![[BACK]](/icons/back.gif){kind=icon}
Return to gdt_common.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to gdt_common.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 1: /* $OpenBSD: gdt_common.c,v 1.39 2007/04/28 00:35:16 deraadt Exp $ */
2:
3: /*
4: * Copyright (c) 1999, 2000, 2003 Niklas Hallqvist. All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: * 1. Redistributions of source code must retain the above copyright
10: * notice, this list of conditions and the following disclaimer.
11: * 2. Redistributions in binary form must reproduce the above copyright
12: * notice, this list of conditions and the following disclaimer in the
13: * documentation and/or other materials provided with the distribution.
14: *
15: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25: */
26:
27: /*
28: * This driver would not have written if it was not for the hardware donations
29: * from both ICP-Vortex and Öko.neT. I want to thank them for their support.
30: */
31:
32: #include <sys/param.h>
33: #include <sys/buf.h>
34: #include <sys/device.h>
35: #include <sys/ioctl.h>
36: #include <sys/kernel.h>
37: #include <sys/malloc.h>
38: #include <sys/systm.h>
39:
40: #include <machine/bus.h>
41:
42: #include <uvm/uvm_extern.h>
43:
44: #include <scsi/scsi_all.h>
45: #include <scsi/scsi_disk.h>
46: #include <scsi/scsiconf.h>
47:
48: #include <dev/biovar.h>
49: #include <dev/ic/gdtreg.h>
50: #include <dev/ic/gdtvar.h>
51:
52: #include "bio.h"
53:
54: #ifdef GDT_DEBUG
55: int gdt_maxcmds = GDT_MAXCMDS;
56: #undef GDT_MAXCMDS
57: #define GDT_MAXCMDS gdt_maxcmds
58: #endif
59:
60: #define GDT_DRIVER_VERSION 1
61: #define GDT_DRIVER_SUBVERSION 2
62:
63: int gdt_async_event(struct gdt_softc *, int);
64: void gdt_chain(struct gdt_softc *);
65: void gdt_clear_events(struct gdt_softc *);
66: void gdt_copy_internal_data(struct scsi_xfer *, u_int8_t *, size_t);
67: struct scsi_xfer *gdt_dequeue(struct gdt_softc *);
68: void gdt_enqueue(struct gdt_softc *, struct scsi_xfer *, int);
69: void gdt_enqueue_ccb(struct gdt_softc *, struct gdt_ccb *);
70: void gdt_eval_mapping(u_int32_t, int *, int *, int *);
71: int gdt_exec_ccb(struct gdt_ccb *);
72: void gdt_free_ccb(struct gdt_softc *, struct gdt_ccb *);
73: struct gdt_ccb *gdt_get_ccb(struct gdt_softc *, int);
74: void gdt_internal_cache_cmd(struct scsi_xfer *);
75: int gdt_internal_cmd(struct gdt_softc *, u_int8_t, u_int16_t,
76: u_int32_t, u_int32_t, u_int32_t);
77: #if NBIO > 0
78: int gdt_ioctl(struct device *, u_long, caddr_t);
79: int gdt_ioctl_inq(struct gdt_softc *, struct bioc_inq *);
80: int gdt_ioctl_vol(struct gdt_softc *, struct bioc_vol *);
81: int gdt_ioctl_disk(struct gdt_softc *, struct bioc_disk *);
82: int gdt_ioctl_alarm(struct gdt_softc *, struct bioc_alarm *);
83: int gdt_ioctl_setstate(struct gdt_softc *, struct bioc_setstate *);
84: #endif /* NBIO > 0 */
85: int gdt_raw_scsi_cmd(struct scsi_xfer *);
86: int gdt_scsi_cmd(struct scsi_xfer *);
87: void gdt_start_ccbs(struct gdt_softc *);
88: int gdt_sync_event(struct gdt_softc *, int, u_int8_t,
89: struct scsi_xfer *);
90: void gdt_timeout(void *);
91: int gdt_wait(struct gdt_softc *, struct gdt_ccb *, int);
92: void gdt_watchdog(void *);
93:
94: struct cfdriver gdt_cd = {
95: NULL, "gdt", DV_DULL
96: };
97:
98: struct scsi_adapter gdt_switch = {
99: gdt_scsi_cmd, gdtminphys, 0, 0,
100: };
101:
102: struct scsi_adapter gdt_raw_switch = {
103: gdt_raw_scsi_cmd, gdtminphys, 0, 0,
104: };
105:
106: struct scsi_device gdt_dev = {
107: NULL, NULL, NULL, NULL
108: };
109:
110: int gdt_cnt = 0;
111: u_int8_t gdt_polling;
112: u_int8_t gdt_from_wait;
113: struct gdt_softc *gdt_wait_gdt;
114: int gdt_wait_index;
115: #ifdef GDT_DEBUG
116: int gdt_debug = GDT_DEBUG;
117: #endif
118:
119: int
120: gdt_attach(gdt)
121: struct gdt_softc *gdt;
122: {
123: struct scsibus_attach_args saa;
124: u_int16_t cdev_cnt;
125: int i, id, drv_cyls, drv_hds, drv_secs, error, nsegs;
126:
127: gdt_polling = 1;
128: gdt_from_wait = 0;
129:
130: if (bus_dmamem_alloc(gdt->sc_dmat, GDT_SCRATCH_SZ, PAGE_SIZE, 0,
131: &gdt->sc_scratch_seg, 1, &nsegs, BUS_DMA_NOWAIT))
132: panic("%s: bus_dmamem_alloc failed", DEVNAME(gdt));
133: if (bus_dmamem_map(gdt->sc_dmat, &gdt->sc_scratch_seg, 1,
134: GDT_SCRATCH_SZ, &gdt->sc_scratch, BUS_DMA_NOWAIT))
135: panic("%s: bus_dmamem_map failed", DEVNAME(gdt));
136:
137: gdt_clear_events(gdt);
138:
139: TAILQ_INIT(&gdt->sc_free_ccb);
140: TAILQ_INIT(&gdt->sc_ccbq);
141: TAILQ_INIT(&gdt->sc_ucmdq);
142: LIST_INIT(&gdt->sc_queue);
143:
144: /* Initialize the ccbs */
145: for (i = 0; i < GDT_MAXCMDS; i++) {
146: gdt->sc_ccbs[i].gc_cmd_index = i + 2;
147: error = bus_dmamap_create(gdt->sc_dmat,
148: (GDT_MAXOFFSETS - 1) << PGSHIFT, GDT_MAXOFFSETS,
149: (GDT_MAXOFFSETS - 1) << PGSHIFT, 0,
150: BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
151: &gdt->sc_ccbs[i].gc_dmamap_xfer);
152: if (error) {
153: printf("%s: cannot create ccb dmamap (%d)",
154: DEVNAME(gdt), error);
155: return (1);
156: }
157: (void)gdt_ccb_set_cmd(gdt->sc_ccbs + i, GDT_GCF_UNUSED);
158: TAILQ_INSERT_TAIL(&gdt->sc_free_ccb, &gdt->sc_ccbs[i],
159: gc_chain);
160: }
161:
162: /* Fill in the prototype scsi_link. */
163: gdt->sc_link.adapter_softc = gdt;
164: gdt->sc_link.adapter = &gdt_switch;
165: gdt->sc_link.device = &gdt_dev;
166: /* openings will be filled in later. */
167: gdt->sc_link.adapter_buswidth =
168: (gdt->sc_class & GDT_FC) ? GDT_MAXID : GDT_MAX_HDRIVES;
169: gdt->sc_link.adapter_target = gdt->sc_link.adapter_buswidth;
170:
171: if (!gdt_internal_cmd(gdt, GDT_SCREENSERVICE, GDT_INIT, 0, 0, 0)) {
172: printf("screen service initialization error %d\n",
173: gdt->sc_status);
174: return (1);
175: }
176:
177: if (!gdt_internal_cmd(gdt, GDT_CACHESERVICE, GDT_INIT, GDT_LINUX_OS, 0,
178: 0)) {
179: printf("cache service initialization error %d\n",
180: gdt->sc_status);
181: return (1);
182: }
183:
184: cdev_cnt = (u_int16_t)gdt->sc_info;
185:
186: /* Detect number of busses */
187: gdt_enc32(gdt->sc_scratch + GDT_IOC_VERSION, GDT_IOC_NEWEST);
188: gdt->sc_scratch[GDT_IOC_LIST_ENTRIES] = GDT_MAXBUS;
189: gdt->sc_scratch[GDT_IOC_FIRST_CHAN] = 0;
190: gdt->sc_scratch[GDT_IOC_LAST_CHAN] = GDT_MAXBUS - 1;
191: gdt_enc32(gdt->sc_scratch + GDT_IOC_LIST_OFFSET, GDT_IOC_HDR_SZ);
192: if (gdt_internal_cmd(gdt, GDT_CACHESERVICE, GDT_IOCTL,
193: GDT_IOCHAN_RAW_DESC, GDT_INVALID_CHANNEL,
194: GDT_IOC_HDR_SZ + GDT_RAWIOC_SZ)) {
195: gdt->sc_bus_cnt = gdt->sc_scratch[GDT_IOC_CHAN_COUNT];
196: for (i = 0; i < gdt->sc_bus_cnt; i++) {
197: id = gdt->sc_scratch[GDT_IOC_HDR_SZ +
198: i * GDT_RAWIOC_SZ + GDT_RAWIOC_PROC_ID];
199: gdt->sc_bus_id[id] = id < GDT_MAXBUS ? id : 0xff;
200: }
201:
202: } else {
203: /* New method failed, use fallback. */
204: gdt_enc32(gdt->sc_scratch + GDT_GETCH_CHANNEL_NO, i);
205: for (i = 0; i < GDT_MAXBUS; i++) {
206: if (!gdt_internal_cmd(gdt, GDT_CACHESERVICE, GDT_IOCTL,
207: GDT_SCSI_CHAN_CNT | GDT_L_CTRL_PATTERN,
208: GDT_IO_CHANNEL | GDT_INVALID_CHANNEL,
209: GDT_GETCH_SZ)) {
210: if (i == 0) {
211: printf("cannot get channel count, "
212: "error %d\n", gdt->sc_status);
213: return (1);
214: }
215: break;
216: }
217: gdt->sc_bus_id[i] =
218: (gdt->sc_scratch[GDT_GETCH_SIOP_ID] < GDT_MAXID) ?
219: gdt->sc_scratch[GDT_GETCH_SIOP_ID] : 0xff;
220: }
221: gdt->sc_bus_cnt = i;
222: }
223:
224: /* Read cache configuration */
225: if (!gdt_internal_cmd(gdt, GDT_CACHESERVICE, GDT_IOCTL, GDT_CACHE_INFO,
226: GDT_INVALID_CHANNEL, GDT_CINFO_SZ)) {
227: printf("cannot get cache info, error %d\n", gdt->sc_status);
228: return (1);
229: }
230: gdt->sc_cpar.cp_version =
231: gdt_dec32(gdt->sc_scratch + GDT_CPAR_VERSION);
232: gdt->sc_cpar.cp_state = gdt_dec16(gdt->sc_scratch + GDT_CPAR_STATE);
233: gdt->sc_cpar.cp_strategy =
234: gdt_dec16(gdt->sc_scratch + GDT_CPAR_STRATEGY);
235: gdt->sc_cpar.cp_write_back =
236: gdt_dec16(gdt->sc_scratch + GDT_CPAR_WRITE_BACK);
237: gdt->sc_cpar.cp_block_size =
238: gdt_dec16(gdt->sc_scratch + GDT_CPAR_BLOCK_SIZE);
239:
240: /* Read board information and features */
241: gdt->sc_more_proc = 0;
242: if (gdt_internal_cmd(gdt, GDT_CACHESERVICE, GDT_IOCTL, GDT_BOARD_INFO,
243: GDT_INVALID_CHANNEL, GDT_BINFO_SZ)) {
244: /* XXX A lot of these assignments can probably go later */
245: gdt->sc_binfo.bi_ser_no =
246: gdt_dec32(gdt->sc_scratch + GDT_BINFO_SER_NO);
247: bcopy(gdt->sc_scratch + GDT_BINFO_OEM_ID,
248: gdt->sc_binfo.bi_oem_id, sizeof gdt->sc_binfo.bi_oem_id);
249: gdt->sc_binfo.bi_ep_flags =
250: gdt_dec16(gdt->sc_scratch + GDT_BINFO_EP_FLAGS);
251: gdt->sc_binfo.bi_proc_id =
252: gdt_dec32(gdt->sc_scratch + GDT_BINFO_PROC_ID);
253: gdt->sc_binfo.bi_memsize =
254: gdt_dec32(gdt->sc_scratch + GDT_BINFO_MEMSIZE);
255: gdt->sc_binfo.bi_mem_banks =
256: gdt->sc_scratch[GDT_BINFO_MEM_BANKS];
257: gdt->sc_binfo.bi_chan_type =
258: gdt->sc_scratch[GDT_BINFO_CHAN_TYPE];
259: gdt->sc_binfo.bi_chan_count =
260: gdt->sc_scratch[GDT_BINFO_CHAN_COUNT];
261: gdt->sc_binfo.bi_rdongle_pres =
262: gdt->sc_scratch[GDT_BINFO_RDONGLE_PRES];
263: gdt->sc_binfo.bi_epr_fw_ver =
264: gdt_dec32(gdt->sc_scratch + GDT_BINFO_EPR_FW_VER);
265: gdt->sc_binfo.bi_upd_fw_ver =
266: gdt_dec32(gdt->sc_scratch + GDT_BINFO_UPD_FW_VER);
267: gdt->sc_binfo.bi_upd_revision =
268: gdt_dec32(gdt->sc_scratch + GDT_BINFO_UPD_REVISION);
269: bcopy(gdt->sc_scratch + GDT_BINFO_TYPE_STRING,
270: gdt->sc_binfo.bi_type_string,
271: sizeof gdt->sc_binfo.bi_type_string);
272: bcopy(gdt->sc_scratch + GDT_BINFO_RAID_STRING,
273: gdt->sc_binfo.bi_raid_string,
274: sizeof gdt->sc_binfo.bi_raid_string);
275: gdt->sc_binfo.bi_update_pres =
276: gdt->sc_scratch[GDT_BINFO_UPDATE_PRES];
277: gdt->sc_binfo.bi_xor_pres =
278: gdt->sc_scratch[GDT_BINFO_XOR_PRES];
279: gdt->sc_binfo.bi_prom_type =
280: gdt->sc_scratch[GDT_BINFO_PROM_TYPE];
281: gdt->sc_binfo.bi_prom_count =
282: gdt->sc_scratch[GDT_BINFO_PROM_COUNT];
283: gdt->sc_binfo.bi_dup_pres =
284: gdt_dec32(gdt->sc_scratch + GDT_BINFO_DUP_PRES);
285: gdt->sc_binfo.bi_chan_pres =
286: gdt_dec32(gdt->sc_scratch + GDT_BINFO_CHAN_PRES);
287: gdt->sc_binfo.bi_mem_pres =
288: gdt_dec32(gdt->sc_scratch + GDT_BINFO_MEM_PRES);
289: gdt->sc_binfo.bi_ft_bus_system =
290: gdt->sc_scratch[GDT_BINFO_FT_BUS_SYSTEM];
291: gdt->sc_binfo.bi_subtype_valid =
292: gdt->sc_scratch[GDT_BINFO_SUBTYPE_VALID];
293: gdt->sc_binfo.bi_board_subtype =
294: gdt->sc_scratch[GDT_BINFO_BOARD_SUBTYPE];
295: gdt->sc_binfo.bi_rampar_pres =
296: gdt->sc_scratch[GDT_BINFO_RAMPAR_PRES];
297:
298: if (gdt_internal_cmd(gdt, GDT_CACHESERVICE, GDT_IOCTL,
299: GDT_BOARD_FEATURES, GDT_INVALID_CHANNEL, GDT_BFEAT_SZ)) {
300: gdt->sc_bfeat.bf_chaining =
301: gdt->sc_scratch[GDT_BFEAT_CHAINING];
302: gdt->sc_bfeat.bf_striping =
303: gdt->sc_scratch[GDT_BFEAT_STRIPING];
304: gdt->sc_bfeat.bf_mirroring =
305: gdt->sc_scratch[GDT_BFEAT_MIRRORING];
306: gdt->sc_bfeat.bf_raid =
307: gdt->sc_scratch[GDT_BFEAT_RAID];
308: gdt->sc_more_proc = 1;
309: }
310: } else {
311: /* XXX Not implemented yet */
312: }
313:
314: /* Read more information */
315: if (gdt->sc_more_proc) {
316: int bus, j;
317: /* physical drives, channel addresses */
318: /* step 1: get magical bus number from firmware */
319: gdt_enc32(gdt->sc_scratch + GDT_IOC_VERSION, GDT_IOC_NEWEST);
320: gdt->sc_scratch[GDT_IOC_LIST_ENTRIES] = GDT_MAXBUS;
321: gdt->sc_scratch[GDT_IOC_FIRST_CHAN] = 0;
322: gdt->sc_scratch[GDT_IOC_LAST_CHAN] = GDT_MAXBUS - 1;
323: gdt_enc32(gdt->sc_scratch + GDT_IOC_LIST_OFFSET, GDT_IOC_HDR_SZ);
324: if (gdt_internal_cmd(gdt, GDT_CACHESERVICE, GDT_IOCTL,
325: GDT_IOCHAN_DESC, GDT_INVALID_CHANNEL,
326: GDT_IOC_HDR_SZ + GDT_IOC_SZ * GDT_MAXBUS)) {
327: GDT_DPRINTF(GDT_D_INFO, ("method 1\n"));
328: for (bus = 0; bus < gdt->sc_bus_cnt; bus++) {
329: gdt->sc_raw[bus].ra_address =
330: gdt_dec32(gdt->sc_scratch +
331: GDT_IOC_HDR_SZ +
332: GDT_IOC_SZ * bus +
333: GDT_IOC_ADDRESS);
334: gdt->sc_raw[bus].ra_local_no =
335: gdt_dec8(gdt->sc_scratch +
336: GDT_IOC_HDR_SZ +
337: GDT_IOC_SZ * bus +
338: GDT_IOC_LOCAL_NO);
339: GDT_DPRINTF(GDT_D_INFO, (
340: "bus: %d address: %x local: %x\n",
341: bus,
342: gdt->sc_raw[bus].ra_address,
343: gdt->sc_raw[bus].ra_local_no));
344: }
345: } else {
346: GDT_DPRINTF(GDT_D_INFO, ("method 2\n"));
347: for (bus = 0; bus < gdt->sc_bus_cnt; bus++) {
348: gdt->sc_raw[bus].ra_address = GDT_IO_CHANNEL;
349: gdt->sc_raw[bus].ra_local_no = bus;
350: GDT_DPRINTF(GDT_D_INFO, (
351: "bus: %d address: %x local: %x\n",
352: bus,
353: gdt->sc_raw[bus].ra_address,
354: gdt->sc_raw[bus].ra_local_no));
355: }
356: }
357: /* step 2: use magical bus number to get nr of phys disks */
358: for (bus = 0; bus < gdt->sc_bus_cnt; bus++) {
359: gdt_enc32(gdt->sc_scratch + GDT_GETCH_CHANNEL_NO,
360: gdt->sc_raw[bus].ra_local_no);
361: if (gdt_internal_cmd(gdt, GDT_CACHESERVICE, GDT_IOCTL,
362: GDT_SCSI_CHAN_CNT | GDT_L_CTRL_PATTERN,
363: gdt->sc_raw[bus].ra_address | GDT_INVALID_CHANNEL,
364: GDT_GETCH_SZ)) {
365: gdt->sc_raw[bus].ra_phys_cnt =
366: gdt_dec32(gdt->sc_scratch +
367: GDT_GETCH_DRIVE_CNT);
368: GDT_DPRINTF(GDT_D_INFO, ("chan: %d disks: %d\n",
369: bus, gdt->sc_raw[bus].ra_phys_cnt));
370: }
371:
372: /* step 3: get scsi disk nr */
373: if (gdt->sc_raw[bus].ra_phys_cnt > 0) {
374: gdt_enc32(gdt->sc_scratch +
375: GDT_GETSCSI_CHAN,
376: gdt->sc_raw[bus].ra_local_no);
377: gdt_enc32(gdt->sc_scratch +
378: GDT_GETSCSI_CNT,
379: gdt->sc_raw[bus].ra_phys_cnt);
380: if (gdt_internal_cmd(gdt, GDT_CACHESERVICE,
381: GDT_IOCTL,
382: GDT_SCSI_DR_LIST | GDT_L_CTRL_PATTERN,
383: gdt->sc_raw[bus].ra_address |
384: GDT_INVALID_CHANNEL,
385: GDT_GETSCSI_SZ))
386: for (j = 0;
387: j < gdt->sc_raw[bus].ra_phys_cnt;
388: j++) {
389: gdt->sc_raw[bus].ra_id_list[j] =
390: gdt_dec32(gdt->sc_scratch +
391: GDT_GETSCSI_LIST +
392: GDT_GETSCSI_LIST_SZ * j);
393: GDT_DPRINTF(GDT_D_INFO,
394: (" diskid: %d\n",
395: gdt->sc_raw[bus].ra_id_list[j]));
396: }
397: else
398: gdt->sc_raw[bus].ra_phys_cnt = 0;
399: }
400: /* add found disks to grand total */
401: gdt->sc_total_disks += gdt->sc_raw[bus].ra_phys_cnt;
402: }
403: } /* if (gdt->sc_more_proc) */
404:
405: if (!gdt_internal_cmd(gdt, GDT_SCSIRAWSERVICE, GDT_INIT, 0, 0, 0)) {
406: printf("raw service initialization error %d\n",
407: gdt->sc_status);
408: return (1);
409: }
410:
411: /* Set/get features raw service (scatter/gather) */
412: gdt->sc_raw_feat = 0;
413: if (gdt_internal_cmd(gdt, GDT_SCSIRAWSERVICE, GDT_SET_FEAT,
414: GDT_SCATTER_GATHER, 0, 0))
415: if (gdt_internal_cmd(gdt, GDT_SCSIRAWSERVICE, GDT_GET_FEAT, 0,
416: 0, 0))
417: gdt->sc_raw_feat = gdt->sc_info;
418:
419: /* Set/get features cache service (scatter/gather) */
420: gdt->sc_cache_feat = 0;
421: if (gdt_internal_cmd(gdt, GDT_CACHESERVICE, GDT_SET_FEAT, 0,
422: GDT_SCATTER_GATHER, 0))
423: if (gdt_internal_cmd(gdt, GDT_CACHESERVICE, GDT_GET_FEAT, 0, 0,
424: 0))
425: gdt->sc_cache_feat = gdt->sc_info;
426:
427: /* XXX Linux reserve drives here, potentially */
428:
429: gdt->sc_ndevs = 0;
430: /* Scan for cache devices */
431: for (i = 0; i < cdev_cnt && i < GDT_MAX_HDRIVES; i++)
432: if (gdt_internal_cmd(gdt, GDT_CACHESERVICE, GDT_INFO, i, 0,
433: 0)) {
434: gdt->sc_hdr[i].hd_present = 1;
435: gdt->sc_hdr[i].hd_size = gdt->sc_info;
436:
437: if (gdt->sc_hdr[i].hd_size > 0)
438: gdt->sc_ndevs++;
439:
440: /*
441: * Evaluate mapping (sectors per head, heads per cyl)
442: */
443: gdt->sc_hdr[i].hd_size &= ~GDT_SECS32;
444: if (gdt->sc_info2 == 0)
445: gdt_eval_mapping(gdt->sc_hdr[i].hd_size,
446: &drv_cyls, &drv_hds, &drv_secs);
447: else {
448: drv_hds = gdt->sc_info2 & 0xff;
449: drv_secs = (gdt->sc_info2 >> 8) & 0xff;
450: drv_cyls = gdt->sc_hdr[i].hd_size / drv_hds /
451: drv_secs;
452: }
453: gdt->sc_hdr[i].hd_heads = drv_hds;
454: gdt->sc_hdr[i].hd_secs = drv_secs;
455: /* Round the size */
456: gdt->sc_hdr[i].hd_size = drv_cyls * drv_hds * drv_secs;
457:
458: if (gdt_internal_cmd(gdt, GDT_CACHESERVICE,
459: GDT_DEVTYPE, i, 0, 0))
460: gdt->sc_hdr[i].hd_devtype = gdt->sc_info;
461: }
462:
463: if (gdt->sc_ndevs == 0)
464: gdt->sc_link.openings = 0;
465: else
466: gdt->sc_link.openings = (GDT_MAXCMDS - GDT_CMD_RESERVE) /
467: gdt->sc_ndevs;
468:
469: printf("dpmem %llx %d-bus %d cache device%s\n",
470: (long long)gdt->sc_dpmembase,
471: gdt->sc_bus_cnt, cdev_cnt, cdev_cnt == 1 ? "" : "s");
472: printf("%s: ver %x, cache %s, strategy %d, writeback %s, blksz %d\n",
473: DEVNAME(gdt), gdt->sc_cpar.cp_version,
474: gdt->sc_cpar.cp_state ? "on" : "off", gdt->sc_cpar.cp_strategy,
475: gdt->sc_cpar.cp_write_back ? "on" : "off",
476: gdt->sc_cpar.cp_block_size);
477: #if 1
478: printf("%s: raw feat %x cache feat %x\n", DEVNAME(gdt),
479: gdt->sc_raw_feat, gdt->sc_cache_feat);
480: #endif
481:
482: #if NBIO > 0
483: if (bio_register(&gdt->sc_dev, gdt_ioctl) != 0)
484: panic("%s: controller registration failed", DEVNAME(gdt));
485: #endif
486: gdt_cnt++;
487:
488: bzero(&saa, sizeof(saa));
489: saa.saa_sc_link = &gdt->sc_link;
490:
491: config_found(&gdt->sc_dev, &saa, scsiprint);
492:
493: gdt->sc_raw_link = malloc(gdt->sc_bus_cnt * sizeof (struct scsi_link),
494: M_DEVBUF, M_NOWAIT);
495: if (gdt->sc_raw_link == NULL)
496: panic("gdt_attach");
497: bzero(gdt->sc_raw_link, gdt->sc_bus_cnt * sizeof (struct scsi_link));
498:
499: for (i = 0; i < gdt->sc_bus_cnt; i++) {
500: /* Fill in the prototype scsi_link. */
501: gdt->sc_raw_link[i].adapter_softc = gdt;
502: gdt->sc_raw_link[i].adapter = &gdt_raw_switch;
503: gdt->sc_raw_link[i].adapter_target = 7;
504: gdt->sc_raw_link[i].device = &gdt_dev;
505: gdt->sc_raw_link[i].openings = 4; /* XXX a guess */
506: gdt->sc_raw_link[i].adapter_buswidth =
507: (gdt->sc_class & GDT_FC) ? GDT_MAXID : 16; /* XXX */
508:
509: bzero(&saa, sizeof(saa));
510: saa.saa_sc_link = &gdt->sc_raw_link[i];
511:
512: config_found(&gdt->sc_dev, &saa, scsiprint);
513: }
514:
515: gdt_polling = 0;
516: return (0);
517: }
518:
519: void
520: gdt_eval_mapping(size, cyls, heads, secs)
521: u_int32_t size;
522: int *cyls, *heads, *secs;
523: {
524: *cyls = size / GDT_HEADS / GDT_SECS;
525: if (*cyls < GDT_MAXCYLS) {
526: *heads = GDT_HEADS;
527: *secs = GDT_SECS;
528: } else {
529: /* Too high for 64 * 32 */
530: *cyls = size / GDT_MEDHEADS / GDT_MEDSECS;
531: if (*cyls < GDT_MAXCYLS) {
532: *heads = GDT_MEDHEADS;
533: *secs = GDT_MEDSECS;
534: } else {
535: /* Too high for 127 * 63 */
536: *cyls = size / GDT_BIGHEADS / GDT_BIGSECS;
537: *heads = GDT_BIGHEADS;
538: *secs = GDT_BIGSECS;
539: }
540: }
541: }
542:
543: /*
544: * Insert a command into the driver queue, either at the front or at the tail.
545: * It's ok to overload the freelist link as these structures are never on
546: * the freelist at this time.
547: */
548: void
549: gdt_enqueue(gdt, xs, infront)
550: struct gdt_softc *gdt;
551: struct scsi_xfer *xs;
552: int infront;
553: {
554: if (infront || LIST_FIRST(&gdt->sc_queue) == NULL) {
555: if (LIST_FIRST(&gdt->sc_queue) == NULL)
556: gdt->sc_queuelast = xs;
557: LIST_INSERT_HEAD(&gdt->sc_queue, xs, free_list);
558: return;
559: }
560: LIST_INSERT_AFTER(gdt->sc_queuelast, xs, free_list);
561: gdt->sc_queuelast = xs;
562: }
563:
564: /*
565: * Pull a command off the front of the driver queue.
566: */
567: struct scsi_xfer *
568: gdt_dequeue(gdt)
569: struct gdt_softc *gdt;
570: {
571: struct scsi_xfer *xs;
572:
573: xs = LIST_FIRST(&gdt->sc_queue);
574: if (xs == NULL)
575: return (NULL);
576: LIST_REMOVE(xs, free_list);
577:
578: if (LIST_FIRST(&gdt->sc_queue) == NULL)
579: gdt->sc_queuelast = NULL;
580:
581: return (xs);
582: }
583:
584: /*
585: * Start a SCSI operation on a cache device.
586: * XXX Polled operation is not yet complete. What kind of locking do we need?
587: */
588: int
589: gdt_scsi_cmd(xs)
590: struct scsi_xfer *xs;
591: {
592: struct scsi_link *link = xs->sc_link;
593: struct gdt_softc *gdt = link->adapter_softc;
594: u_int8_t target = link->target;
595: struct gdt_ccb *ccb;
596: #if 0
597: struct gdt_ucmd *ucmd;
598: #endif
599: u_int32_t blockno, blockcnt;
600: struct scsi_rw *rw;
601: struct scsi_rw_big *rwb;
602: bus_dmamap_t xfer;
603: int error, retval = SUCCESSFULLY_QUEUED;
604: int s;
605:
606: GDT_DPRINTF(GDT_D_CMD, ("gdt_scsi_cmd "));
607:
608: xs->error = XS_NOERROR;
609:
610: if (target >= GDT_MAX_HDRIVES || !gdt->sc_hdr[target].hd_present ||
611: link->lun != 0) {
612: /*
613: * XXX Should be XS_SENSE but that would require setting up a
614: * faked sense too.
615: */
616: xs->error = XS_DRIVER_STUFFUP;
617: xs->flags |= ITSDONE;
618: s = splbio();
619: scsi_done(xs);
620: splx(s);
621: return (COMPLETE);
622: }
623:
624: s = splbio();
625:
626: /* Don't double enqueue if we came from gdt_chain. */
627: if (xs != LIST_FIRST(&gdt->sc_queue))
628: gdt_enqueue(gdt, xs, 0);
629:
630: while ((xs = gdt_dequeue(gdt)) != NULL) {
631: xs->error = XS_NOERROR;
632: ccb = NULL;
633: link = xs->sc_link;
634: target = link->target;
635:
636: if (!gdt_polling && !(xs->flags & SCSI_POLL) &&
637: gdt->sc_test_busy(gdt)) {
638: /*
639: * Put it back in front. XXX Should we instead
640: * set xs->error to XS_BUSY?
641: */
642: gdt_enqueue(gdt, xs, 1);
643: break;
644: }
645:
646: switch (xs->cmd->opcode) {
647: case TEST_UNIT_READY:
648: case REQUEST_SENSE:
649: case INQUIRY:
650: case MODE_SENSE:
651: case START_STOP:
652: case READ_CAPACITY:
653: #if 0
654: case VERIFY:
655: #endif
656: gdt_internal_cache_cmd(xs);
657: xs->flags |= ITSDONE;
658: scsi_done(xs);
659: goto ready;
660:
661: case PREVENT_ALLOW:
662: GDT_DPRINTF(GDT_D_CMD, ("PREVENT/ALLOW "));
663: /* XXX Not yet implemented */
664: xs->error = XS_NOERROR;
665: xs->flags |= ITSDONE;
666: scsi_done(xs);
667: goto ready;
668:
669: default:
670: GDT_DPRINTF(GDT_D_CMD,
671: ("unknown opc %d ", xs->cmd->opcode));
672: /* XXX Not yet implemented */
673: xs->error = XS_DRIVER_STUFFUP;
674: xs->flags |= ITSDONE;
675: scsi_done(xs);
676: goto ready;
677:
678: case READ_COMMAND:
679: case READ_BIG:
680: case WRITE_COMMAND:
681: case WRITE_BIG:
682: case SYNCHRONIZE_CACHE:
683: /*
684: * A new command chain, start from the beginning.
685: */
686: gdt->sc_cmd_off = 0;
687:
688: if (xs->cmd->opcode != SYNCHRONIZE_CACHE) {
689: /* A read or write operation. */
690: if (xs->cmdlen == 6) {
691: rw = (struct scsi_rw *)xs->cmd;
692: blockno = _3btol(rw->addr) &
693: (SRW_TOPADDR << 16 | 0xffff);
694: blockcnt =
695: rw->length ? rw->length : 0x100;
696: } else {
697: rwb = (struct scsi_rw_big *)xs->cmd;
698: blockno = _4btol(rwb->addr);
699: blockcnt = _2btol(rwb->length);
700: }
701: if (blockno >= gdt->sc_hdr[target].hd_size ||
702: blockno + blockcnt >
703: gdt->sc_hdr[target].hd_size) {
704: printf(
705: "%s: out of bounds %u-%u >= %u\n",
706: DEVNAME(gdt), blockno,
707: blockcnt,
708: gdt->sc_hdr[target].hd_size);
709: /*
710: * XXX Should be XS_SENSE but that
711: * would require setting up a faked
712: * sense too.
713: */
714: xs->error = XS_DRIVER_STUFFUP;
715: xs->flags |= ITSDONE;
716: scsi_done(xs);
717: goto ready;
718: }
719: }
720:
721: ccb = gdt_get_ccb(gdt, xs->flags);
722: /*
723: * We are out of commands, try again in a little while.
724: */
725: if (ccb == NULL) {
726: splx(s);
727: return (TRY_AGAIN_LATER);
728: }
729:
730: ccb->gc_blockno = blockno;
731: ccb->gc_blockcnt = blockcnt;
732: ccb->gc_xs = xs;
733: ccb->gc_timeout = xs->timeout;
734: ccb->gc_service = GDT_CACHESERVICE;
735: gdt_ccb_set_cmd(ccb, GDT_GCF_SCSI);
736:
737: if (xs->cmd->opcode != SYNCHRONIZE_CACHE) {
738: xfer = ccb->gc_dmamap_xfer;
739: error = bus_dmamap_load(gdt->sc_dmat, xfer,
740: xs->data, xs->datalen, NULL,
741: (xs->flags & SCSI_NOSLEEP) ?
742: BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
743: if (error) {
744: printf("%s: gdt_scsi_cmd: ",
745: DEVNAME(gdt));
746: if (error == EFBIG)
747: printf(
748: "more than %d dma segs\n",
749: GDT_MAXOFFSETS);
750: else
751: printf("error %d "
752: "loading dma map\n",
753: error);
754:
755: gdt_free_ccb(gdt, ccb);
756: xs->error = XS_DRIVER_STUFFUP;
757: xs->flags |= ITSDONE;
758: scsi_done(xs);
759: goto ready;
760: }
761: bus_dmamap_sync(gdt->sc_dmat, xfer, 0,
762: xfer->dm_mapsize,
763: (xs->flags & SCSI_DATA_IN) ?
764: BUS_DMASYNC_PREREAD :
765: BUS_DMASYNC_PREWRITE);
766: }
767:
768: gdt_enqueue_ccb(gdt, ccb);
769: /* XXX what if enqueue did not start a transfer? */
770: if (gdt_polling || (xs->flags & SCSI_POLL)) {
771: if (!gdt_wait(gdt, ccb, ccb->gc_timeout)) {
772: splx(s);
773: printf("%s: command %d timed out\n",
774: DEVNAME(gdt),
775: ccb->gc_cmd_index);
776: return (TRY_AGAIN_LATER);
777: }
778: xs->flags |= ITSDONE;
779: scsi_done(xs);
780: }
781: }
782:
783: ready:
784: /*
785: * Don't process the queue if we are polling.
786: */
787: if (xs->flags & SCSI_POLL) {
788: retval = COMPLETE;
789: break;
790: }
791: }
792:
793: splx(s);
794: return (retval);
795: }
796:
797: /* XXX Currently only for cacheservice, returns 0 if busy */
798: int
799: gdt_exec_ccb(ccb)
800: struct gdt_ccb *ccb;
801: {
802: struct scsi_xfer *xs = ccb->gc_xs;
803: struct scsi_link *link = xs->sc_link;
804: struct gdt_softc *gdt = link->adapter_softc;
805: u_int8_t target = link->target;
806: u_int32_t sg_canz;
807: bus_dmamap_t xfer;
808: int i;
809: #if 1 /* XXX */
810: static int __level = 0;
811:
812: if (__level++ > 0)
813: panic("level > 0");
814: #endif
815: GDT_DPRINTF(GDT_D_CMD, ("gdt_exec_ccb(%p, %p) ", xs, ccb));
816:
817: gdt->sc_cmd_cnt = 0;
818:
819: /*
820: * XXX Yeah I know it's an always-true condition, but that may change
821: * later.
822: */
823: if (gdt->sc_cmd_cnt == 0)
824: gdt->sc_set_sema0(gdt);
825:
826: gdt_enc32(gdt->sc_cmd + GDT_CMD_COMMANDINDEX, ccb->gc_cmd_index);
827: gdt_enc32(gdt->sc_cmd + GDT_CMD_BOARDNODE, GDT_LOCALBOARD);
828: gdt_enc16(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_DEVICENO,
829: target);
830:
831: switch (xs->cmd->opcode) {
832: case PREVENT_ALLOW:
833: case SYNCHRONIZE_CACHE:
834: if (xs->cmd->opcode == PREVENT_ALLOW) {
835: /* XXX PREVENT_ALLOW support goes here */
836: } else {
837: GDT_DPRINTF(GDT_D_CMD,
838: ("SYNCHRONIZE CACHE tgt %d ", target));
839: gdt->sc_cmd[GDT_CMD_OPCODE] = GDT_FLUSH;
840: }
841: gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_BLOCKNO,
842: 1);
843: sg_canz = 0;
844: break;
845:
846: case WRITE_COMMAND:
847: case WRITE_BIG:
848: /* XXX WRITE_THR could be supported too */
849: gdt->sc_cmd[GDT_CMD_OPCODE] = GDT_WRITE;
850: break;
851:
852: case READ_COMMAND:
853: case READ_BIG:
854: gdt->sc_cmd[GDT_CMD_OPCODE] = GDT_READ;
855: break;
856: }
857:
858: if (xs->cmd->opcode != PREVENT_ALLOW &&
859: xs->cmd->opcode != SYNCHRONIZE_CACHE) {
860: gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_BLOCKNO,
861: ccb->gc_blockno);
862: gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_BLOCKCNT,
863: ccb->gc_blockcnt);
864:
865: xfer = ccb->gc_dmamap_xfer;
866: if (gdt->sc_cache_feat & GDT_SCATTER_GATHER) {
867: gdt_enc32(
868: gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_DESTADDR,
869: 0xffffffff);
870: for (i = 0; i < xfer->dm_nsegs; i++) {
871: gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION +
872: GDT_CACHE_SG_LST + i * GDT_SG_SZ +
873: GDT_SG_PTR,
874: xfer->dm_segs[i].ds_addr);
875: gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION +
876: GDT_CACHE_SG_LST + i * GDT_SG_SZ +
877: GDT_SG_LEN,
878: xfer->dm_segs[i].ds_len);
879: GDT_DPRINTF(GDT_D_IO,
880: ("#%d va %p pa %p len %x\n", i, buf,
881: xfer->dm_segs[i].ds_addr,
882: xfer->dm_segs[i].ds_len));
883: }
884: sg_canz = xfer->dm_nsegs;
885: gdt_enc32(
886: gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_SG_LST +
887: sg_canz * GDT_SG_SZ + GDT_SG_LEN, 0);
888: } else {
889: /* XXX Hardly correct */
890: gdt_enc32(
891: gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_DESTADDR,
892: xfer->dm_segs[0].ds_addr);
893: sg_canz = 0;
894: }
895: }
896: gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_SG_CANZ, sg_canz);
897:
898: gdt->sc_cmd_len =
899: roundup(GDT_CMD_UNION + GDT_CACHE_SG_LST + sg_canz * GDT_SG_SZ,
900: sizeof (u_int32_t));
901:
902: if (gdt->sc_cmd_cnt > 0 &&
903: gdt->sc_cmd_off + gdt->sc_cmd_len + GDT_DPMEM_COMMAND_OFFSET >
904: gdt->sc_ic_all_size) {
905: printf("%s: DPMEM overflow\n", DEVNAME(gdt));
906: gdt_free_ccb(gdt, ccb);
907: xs->error = XS_BUSY;
908: #if 1 /* XXX */
909: __level--;
910: #endif
911: return (0);
912: }
913:
914: gdt->sc_copy_cmd(gdt, ccb);
915: gdt->sc_release_event(gdt, ccb);
916:
917: xs->error = XS_NOERROR;
918: xs->resid = 0;
919: #if 1 /* XXX */
920: __level--;
921: #endif
922: return (1);
923: }
924:
925: void
926: gdt_copy_internal_data(xs, data, size)
927: struct scsi_xfer *xs;
928: u_int8_t *data;
929: size_t size;
930: {
931: size_t copy_cnt;
932:
933: GDT_DPRINTF(GDT_D_MISC, ("gdt_copy_internal_data "));
934:
935: if (!xs->datalen)
936: printf("uio move not yet supported\n");
937: else {
938: copy_cnt = MIN(size, xs->datalen);
939: bcopy(data, xs->data, copy_cnt);
940: }
941: }
942:
943: /* Emulated SCSI operation on cache device */
944: void
945: gdt_internal_cache_cmd(xs)
946: struct scsi_xfer *xs;
947: {
948: struct scsi_link *link = xs->sc_link;
949: struct gdt_softc *gdt = link->adapter_softc;
950: struct scsi_inquiry_data inq;
951: struct scsi_sense_data sd;
952: struct scsi_read_cap_data rcd;
953: u_int8_t target = link->target;
954:
955: GDT_DPRINTF(GDT_D_CMD, ("gdt_internal_cache_cmd "));
956:
957: switch (xs->cmd->opcode) {
958: case TEST_UNIT_READY:
959: case START_STOP:
960: #if 0
961: case VERIFY:
962: #endif
963: GDT_DPRINTF(GDT_D_CMD, ("opc %d tgt %d ", xs->cmd->opcode,
964: target));
965: break;
966:
967: case REQUEST_SENSE:
968: GDT_DPRINTF(GDT_D_CMD, ("REQUEST SENSE tgt %d ", target));
969: bzero(&sd, sizeof sd);
970: sd.error_code = 0x70;
971: sd.segment = 0;
972: sd.flags = SKEY_NO_SENSE;
973: gdt_enc32(sd.info, 0);
974: sd.extra_len = 0;
975: gdt_copy_internal_data(xs, (u_int8_t *)&sd, sizeof sd);
976: break;
977:
978: case INQUIRY:
979: GDT_DPRINTF(GDT_D_CMD, ("INQUIRY tgt %d devtype %x ", target,
980: gdt->sc_hdr[target].hd_devtype));
981: bzero(&inq, sizeof inq);
982: inq.device =
983: (gdt->sc_hdr[target].hd_devtype & 4) ? T_CDROM : T_DIRECT;
984: inq.dev_qual2 =
985: (gdt->sc_hdr[target].hd_devtype & 1) ? SID_REMOVABLE : 0;
986: inq.version = 2;
987: inq.response_format = 2;
988: inq.additional_length = 32;
989: strlcpy(inq.vendor, "ICP ", sizeof inq.vendor);
990: snprintf(inq.product, sizeof inq.product, "Host drive #%02d",
991: target);
992: strlcpy(inq.revision, " ", sizeof inq.revision);
993: gdt_copy_internal_data(xs, (u_int8_t *)&inq, sizeof inq);
994: break;
995:
996: case READ_CAPACITY:
997: GDT_DPRINTF(GDT_D_CMD, ("READ CAPACITY tgt %d ", target));
998: bzero(&rcd, sizeof rcd);
999: _lto4b(gdt->sc_hdr[target].hd_size - 1, rcd.addr);
1000: _lto4b(GDT_SECTOR_SIZE, rcd.length);
1001: gdt_copy_internal_data(xs, (u_int8_t *)&rcd, sizeof rcd);
1002: break;
1003:
1004: default:
1005: GDT_DPRINTF(GDT_D_CMD, ("unsupported scsi command %#x tgt %d ",
1006: xs->cmd->opcode, target));
1007: xs->error = XS_DRIVER_STUFFUP;
1008: return;
1009: }
1010:
1011: xs->error = XS_NOERROR;
1012: }
1013:
1014: /* Start a raw SCSI operation */
1015: int
1016: gdt_raw_scsi_cmd(xs)
1017: struct scsi_xfer *xs;
1018: {
1019: struct scsi_link *link = xs->sc_link;
1020: struct gdt_softc *gdt = link->adapter_softc;
1021: struct gdt_ccb *ccb;
1022: int s;
1023:
1024: GDT_DPRINTF(GDT_D_CMD, ("gdt_raw_scsi_cmd "));
1025:
1026: if (xs->cmdlen > 12 /* XXX create #define */) {
1027: GDT_DPRINTF(GDT_D_CMD, ("CDB too big %p ", xs));
1028: bzero(&xs->sense, sizeof(xs->sense));
1029: xs->sense.error_code = SSD_ERRCODE_VALID | 0x70;
1030: xs->sense.flags = SKEY_ILLEGAL_REQUEST;
1031: xs->sense.add_sense_code = 0x20; /* illcmd, 0x24 illfield */
1032: xs->error = XS_SENSE;
1033: s = splbio();
1034: scsi_done(xs);
1035: splx(s);
1036: return (COMPLETE);
1037: }
1038:
1039: if ((ccb = gdt_get_ccb(gdt, xs->flags)) == NULL) {
1040: GDT_DPRINTF(GDT_D_CMD, ("no ccb available for %p ", xs));
1041: xs->error = XS_DRIVER_STUFFUP;
1042: s = splbio();
1043: scsi_done(xs);
1044: splx(s);
1045: return (COMPLETE);
1046: }
1047:
1048: xs->error = XS_DRIVER_STUFFUP;
1049: xs->flags |= ITSDONE;
1050: s = splbio();
1051: scsi_done(xs);
1052: gdt_free_ccb(gdt, ccb);
1053:
1054: splx(s);
1055:
1056: return (COMPLETE);
1057: }
1058:
1059: void
1060: gdt_clear_events(gdt)
1061: struct gdt_softc *gdt;
1062: {
1063: GDT_DPRINTF(GDT_D_MISC, ("gdt_clear_events(%p) ", gdt));
1064:
1065: /* XXX To be implemented */
1066: }
1067:
1068: int
1069: gdt_async_event(gdt, service)
1070: struct gdt_softc *gdt;
1071: int service;
1072: {
1073: GDT_DPRINTF(GDT_D_INTR, ("gdt_async_event(%p, %d) ", gdt, service));
1074:
1075: if (service == GDT_SCREENSERVICE) {
1076: /* XXX To be implemented */
1077: } else {
1078: /* XXX To be implemented */
1079: }
1080:
1081: return (0);
1082: }
1083:
1084: int
1085: gdt_sync_event(gdt, service, index, xs)
1086: struct gdt_softc *gdt;
1087: int service;
1088: u_int8_t index;
1089: struct scsi_xfer *xs;
1090: {
1091: GDT_DPRINTF(GDT_D_INTR,
1092: ("gdt_sync_event(%p, %d, %d, %p) ", gdt, service, index, xs));
1093:
1094: if (service == GDT_SCREENSERVICE) {
1095: GDT_DPRINTF(GDT_D_INTR, ("service == GDT_SCREENSERVICE "));
1096: /* XXX To be implemented */
1097: return (0);
1098: } else {
1099: switch (gdt->sc_status) {
1100: case GDT_S_OK:
1101: GDT_DPRINTF(GDT_D_INTR, ("sc_status == GDT_S_OK "));
1102: /* XXX To be implemented */
1103: break;
1104: case GDT_S_BSY:
1105: GDT_DPRINTF(GDT_D_INTR, ("sc_status == GDT_S_BSY "));
1106: /* XXX To be implemented */
1107: return (2);
1108: default:
1109: GDT_DPRINTF(GDT_D_INTR, ("sc_status is %d ",
1110: gdt->sc_status));
1111: /* XXX To be implemented */
1112: return (0);
1113: }
1114: }
1115:
1116: return (1);
1117: }
1118:
1119: int
1120: gdt_intr(arg)
1121: void *arg;
1122: {
1123: struct gdt_softc *gdt = arg;
1124: struct gdt_intr_ctx ctx;
1125: int chain = 1;
1126: int sync_val = 0;
1127: struct scsi_xfer *xs;
1128: int prev_cmd;
1129: struct gdt_ccb *ccb;
1130: int s;
1131:
1132: GDT_DPRINTF(GDT_D_INTR, ("gdt_intr(%p) ", gdt));
1133:
1134: /* If polling and we were not called from gdt_wait, just return */
1135: if (gdt_polling && !gdt_from_wait)
1136: return (0);
1137:
1138: if (!gdt_polling)
1139: s = splbio();
1140:
1141: ctx.istatus = gdt->sc_get_status(gdt);
1142: if (!ctx.istatus) {
1143: if (!gdt_polling)
1144: splx(s);
1145: gdt->sc_status = GDT_S_NO_STATUS;
1146: return (0);
1147: }
1148:
1149: gdt_wait_index = 0;
1150: ctx.service = ctx.info2 = 0;
1151:
1152: gdt->sc_intr(gdt, &ctx);
1153:
1154: gdt->sc_status = ctx.cmd_status;
1155: gdt->sc_info = ctx.info;
1156: gdt->sc_info2 = ctx.info2;
1157:
1158: if (gdt_from_wait) {
1159: gdt_wait_gdt = gdt;
1160: gdt_wait_index = ctx.istatus;
1161: }
1162:
1163: switch (ctx.istatus) {
1164: case GDT_ASYNCINDEX:
1165: gdt_async_event(gdt, ctx.service);
1166: goto finish;
1167:
1168: case GDT_SPEZINDEX:
1169: printf("%s: uninitialized or unknown service (%d %d)\n",
1170: DEVNAME(gdt), ctx.info, ctx.info2);
1171: chain = 0;
1172: goto finish;
1173: }
1174:
1175: ccb = &gdt->sc_ccbs[ctx.istatus - 2];
1176: xs = ccb->gc_xs;
1177: if (!gdt_polling)
1178: timeout_del(&xs->stimeout);
1179: ctx.service = ccb->gc_service;
1180: prev_cmd = ccb->gc_flags & GDT_GCF_CMD_MASK;
1181: if (xs && xs->cmd->opcode != PREVENT_ALLOW &&
1182: xs->cmd->opcode != SYNCHRONIZE_CACHE) {
1183: bus_dmamap_sync(gdt->sc_dmat, ccb->gc_dmamap_xfer, 0,
1184: ccb->gc_dmamap_xfer->dm_mapsize,
1185: (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_POSTREAD :
1186: BUS_DMASYNC_POSTWRITE);
1187: bus_dmamap_unload(gdt->sc_dmat, ccb->gc_dmamap_xfer);
1188: }
1189: gdt_free_ccb(gdt, ccb);
1190: switch (prev_cmd) {
1191: case GDT_GCF_UNUSED:
1192: /* XXX Not yet implemented */
1193: chain = 0;
1194: goto finish;
1195: case GDT_GCF_INTERNAL:
1196: chain = 0;
1197: goto finish;
1198: }
1199:
1200: sync_val = gdt_sync_event(gdt, ctx.service, ctx.istatus, xs);
1201:
1202: finish:
1203: if (!gdt_polling)
1204: splx(s);
1205:
1206: switch (sync_val) {
1207: case 1:
1208: xs->flags |= ITSDONE;
1209: scsi_done(xs);
1210: break;
1211:
1212: case 2:
1213: gdt_enqueue(gdt, xs, 0);
1214: }
1215:
1216: if (chain)
1217: gdt_chain(gdt);
1218: return (1);
1219: }
1220:
1221: void
1222: gdtminphys(bp)
1223: struct buf *bp;
1224: {
1225: GDT_DPRINTF(GDT_D_MISC, ("gdtminphys(0x%x) ", bp));
1226:
1227: /* As this is way more than MAXPHYS it's really not necessary. */
1228: if ((GDT_MAXOFFSETS - 1) * PAGE_SIZE < MAXPHYS &&
1229: bp->b_bcount > ((GDT_MAXOFFSETS - 1) * PAGE_SIZE))
1230: bp->b_bcount = ((GDT_MAXOFFSETS - 1) * PAGE_SIZE);
1231:
1232: minphys(bp);
1233: }
1234:
1235: int
1236: gdt_wait(gdt, ccb, timeout)
1237: struct gdt_softc *gdt;
1238: struct gdt_ccb *ccb;
1239: int timeout;
1240: {
1241: int rv = 0;
1242:
1243: GDT_DPRINTF(GDT_D_MISC,
1244: ("gdt_wait(%p, %p, %d) ", gdt, ccb, timeout));
1245:
1246: gdt_from_wait = 1;
1247: do {
1248: if (gdt_intr(gdt) && gdt == gdt_wait_gdt &&
1249: ccb->gc_cmd_index == gdt_wait_index) {
1250: rv = 1;
1251: break;
1252: }
1253: DELAY(1);
1254: } while (--timeout);
1255: gdt_from_wait = 0;
1256:
1257: while (gdt->sc_test_busy(gdt))
1258: DELAY(0); /* XXX correct? */
1259:
1260: return (rv);
1261: }
1262:
1263: int
1264: gdt_internal_cmd(gdt, service, opcode, arg1, arg2, arg3)
1265: struct gdt_softc *gdt;
1266: u_int8_t service;
1267: u_int16_t opcode;
1268: u_int32_t arg1, arg2, arg3;
1269: {
1270: int retries;
1271: struct gdt_ccb *ccb;
1272:
1273: GDT_DPRINTF(GDT_D_CMD, ("gdt_internal_cmd(%p, %d, %d, %d, %d, %d) ",
1274: gdt, service, opcode, arg1, arg2, arg3));
1275:
1276: bzero(gdt->sc_cmd, GDT_CMD_SZ);
1277:
1278: for (retries = GDT_RETRIES; ; ) {
1279: ccb = gdt_get_ccb(gdt, SCSI_NOSLEEP);
1280: if (ccb == NULL) {
1281: printf("%s: no free command index found\n",
1282: DEVNAME(gdt));
1283: return (0);
1284: }
1285: ccb->gc_service = service;
1286: gdt_ccb_set_cmd(ccb, GDT_GCF_INTERNAL);
1287:
1288: gdt->sc_set_sema0(gdt);
1289: gdt_enc32(gdt->sc_cmd + GDT_CMD_COMMANDINDEX,
1290: ccb->gc_cmd_index);
1291: gdt_enc16(gdt->sc_cmd + GDT_CMD_OPCODE, opcode);
1292: gdt_enc32(gdt->sc_cmd + GDT_CMD_BOARDNODE, GDT_LOCALBOARD);
1293:
1294: switch (service) {
1295: case GDT_CACHESERVICE:
1296: if (opcode == GDT_IOCTL) {
1297: gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION +
1298: GDT_IOCTL_SUBFUNC, arg1);
1299: gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION +
1300: GDT_IOCTL_CHANNEL, arg2);
1301: gdt_enc16(gdt->sc_cmd + GDT_CMD_UNION +
1302: GDT_IOCTL_PARAM_SIZE, (u_int16_t)arg3);
1303: gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION +
1304: GDT_IOCTL_P_PARAM,
1305: gdt->sc_scratch_seg.ds_addr);
1306: } else {
1307: gdt_enc16(gdt->sc_cmd + GDT_CMD_UNION +
1308: GDT_CACHE_DEVICENO, (u_int16_t)arg1);
1309: gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION +
1310: GDT_CACHE_BLOCKNO, arg2);
1311: }
1312: break;
1313:
1314: case GDT_SCSIRAWSERVICE:
1315: gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION +
1316: GDT_RAW_DIRECTION, arg1);
1317: gdt->sc_cmd[GDT_CMD_UNION + GDT_RAW_BUS] =
1318: (u_int8_t)arg2;
1319: gdt->sc_cmd[GDT_CMD_UNION + GDT_RAW_TARGET] =
1320: (u_int8_t)arg3;
1321: gdt->sc_cmd[GDT_CMD_UNION + GDT_RAW_LUN] =
1322: (u_int8_t)(arg3 >> 8);
1323: }
1324:
1325: gdt->sc_cmd_len = GDT_CMD_SZ;
1326: gdt->sc_cmd_off = 0;
1327: gdt->sc_cmd_cnt = 0;
1328: gdt->sc_copy_cmd(gdt, ccb);
1329: gdt->sc_release_event(gdt, ccb);
1330: DELAY(20);
1331: if (!gdt_wait(gdt, ccb, GDT_POLL_TIMEOUT))
1332: return (0);
1333: if (gdt->sc_status != GDT_S_BSY || --retries == 0)
1334: break;
1335: DELAY(1);
1336: }
1337: return (gdt->sc_status == GDT_S_OK);
1338: }
1339:
1340: struct gdt_ccb *
1341: gdt_get_ccb(gdt, flags)
1342: struct gdt_softc *gdt;
1343: int flags;
1344: {
1345: struct gdt_ccb *ccb;
1346: int s;
1347:
1348: GDT_DPRINTF(GDT_D_QUEUE, ("gdt_get_ccb(%p, 0x%x) ", gdt, flags));
1349:
1350: s = splbio();
1351:
1352: for (;;) {
1353: ccb = TAILQ_FIRST(&gdt->sc_free_ccb);
1354: if (ccb != NULL)
1355: break;
1356: if (flags & SCSI_NOSLEEP)
1357: goto bail_out;
1358: tsleep(&gdt->sc_free_ccb, PRIBIO, "gdt_ccb", 0);
1359: }
1360:
1361: TAILQ_REMOVE(&gdt->sc_free_ccb, ccb, gc_chain);
1362:
1363: bail_out:
1364: splx(s);
1365: return (ccb);
1366: }
1367:
1368: void
1369: gdt_free_ccb(gdt, ccb)
1370: struct gdt_softc *gdt;
1371: struct gdt_ccb *ccb;
1372: {
1373: int s;
1374:
1375: GDT_DPRINTF(GDT_D_QUEUE, ("gdt_free_ccb(%p, %p) ", gdt, ccb));
1376:
1377: s = splbio();
1378:
1379: TAILQ_INSERT_HEAD(&gdt->sc_free_ccb, ccb, gc_chain);
1380:
1381: /* If the free list was empty, wake up potential waiters. */
1382: if (TAILQ_NEXT(ccb, gc_chain) == NULL)
1383: wakeup(&gdt->sc_free_ccb);
1384:
1385: splx(s);
1386: }
1387:
1388: void
1389: gdt_enqueue_ccb(gdt, ccb)
1390: struct gdt_softc *gdt;
1391: struct gdt_ccb *ccb;
1392: {
1393: GDT_DPRINTF(GDT_D_QUEUE, ("gdt_enqueue_ccb(%p, %p) ", gdt, ccb));
1394:
1395: timeout_set(&ccb->gc_xs->stimeout, gdt_timeout, ccb);
1396: TAILQ_INSERT_TAIL(&gdt->sc_ccbq, ccb, gc_chain);
1397: gdt_start_ccbs(gdt);
1398: }
1399:
1400: void
1401: gdt_start_ccbs(gdt)
1402: struct gdt_softc *gdt;
1403: {
1404: struct gdt_ccb *ccb;
1405: struct scsi_xfer *xs;
1406:
1407: GDT_DPRINTF(GDT_D_QUEUE, ("gdt_start_ccbs(%p) ", gdt));
1408:
1409: while ((ccb = TAILQ_FIRST(&gdt->sc_ccbq)) != NULL) {
1410:
1411: xs = ccb->gc_xs;
1412: if (ccb->gc_flags & GDT_GCF_WATCHDOG)
1413: timeout_del(&xs->stimeout);
1414:
1415: if (gdt_exec_ccb(ccb) == 0) {
1416: ccb->gc_flags |= GDT_GCF_WATCHDOG;
1417: timeout_set(&ccb->gc_xs->stimeout, gdt_watchdog, ccb);
1418: timeout_add(&xs->stimeout,
1419: (GDT_WATCH_TIMEOUT * hz) / 1000);
1420: break;
1421: }
1422: TAILQ_REMOVE(&gdt->sc_ccbq, ccb, gc_chain);
1423:
1424: if ((xs->flags & SCSI_POLL) == 0) {
1425: timeout_set(&ccb->gc_xs->stimeout, gdt_timeout, ccb);
1426: timeout_add(&xs->stimeout,
1427: (ccb->gc_timeout * hz) / 1000);
1428: }
1429: }
1430: }
1431:
1432: void
1433: gdt_chain(gdt)
1434: struct gdt_softc *gdt;
1435: {
1436: GDT_DPRINTF(GDT_D_INTR, ("gdt_chain(%p) ", gdt));
1437:
1438: if (LIST_FIRST(&gdt->sc_queue))
1439: gdt_scsi_cmd(LIST_FIRST(&gdt->sc_queue));
1440: }
1441:
1442: void
1443: gdt_timeout(arg)
1444: void *arg;
1445: {
1446: struct gdt_ccb *ccb = arg;
1447: struct scsi_link *link = ccb->gc_xs->sc_link;
1448: struct gdt_softc *gdt = link->adapter_softc;
1449: int s;
1450:
1451: sc_print_addr(link);
1452: printf("timed out\n");
1453:
1454: /* XXX Test for multiple timeouts */
1455:
1456: ccb->gc_xs->error = XS_TIMEOUT;
1457: s = splbio();
1458: gdt_enqueue_ccb(gdt, ccb);
1459: splx(s);
1460: }
1461:
1462: void
1463: gdt_watchdog(arg)
1464: void *arg;
1465: {
1466: struct gdt_ccb *ccb = arg;
1467: struct scsi_link *link = ccb->gc_xs->sc_link;
1468: struct gdt_softc *gdt = link->adapter_softc;
1469: int s;
1470:
1471: s = splbio();
1472: ccb->gc_flags &= ~GDT_GCF_WATCHDOG;
1473: gdt_start_ccbs(gdt);
1474: splx(s);
1475: }
1476:
1477: #if NBIO > 0
1478: int
1479: gdt_ioctl(struct device *dev, u_long cmd, caddr_t addr)
1480: {
1481: struct gdt_softc *sc = (struct gdt_softc *)dev;
1482: int error = 0;
1483:
1484: GDT_DPRINTF(GDT_D_IOCTL, ("%s: ioctl ", DEVNAME(sc)));
1485:
1486: switch (cmd) {
1487: case BIOCINQ:
1488: GDT_DPRINTF(GDT_D_IOCTL, ("inq "));
1489: error = gdt_ioctl_inq(sc, (struct bioc_inq *)addr);
1490: break;
1491:
1492: case BIOCVOL:
1493: GDT_DPRINTF(GDT_D_IOCTL, ("vol "));
1494: error = gdt_ioctl_vol(sc, (struct bioc_vol *)addr);
1495: break;
1496:
1497: case BIOCDISK:
1498: GDT_DPRINTF(GDT_D_IOCTL, ("disk "));
1499: error = gdt_ioctl_disk(sc, (struct bioc_disk *)addr);
1500: break;
1501:
1502: case BIOCALARM:
1503: GDT_DPRINTF(GDT_D_IOCTL, ("alarm "));
1504: error = gdt_ioctl_alarm(sc, (struct bioc_alarm *)addr);
1505: break;
1506:
1507: case BIOCSETSTATE:
1508: GDT_DPRINTF(GDT_D_IOCTL, ("setstate "));
1509: error = gdt_ioctl_setstate(sc, (struct bioc_setstate *)addr);
1510: break;
1511:
1512: default:
1513: GDT_DPRINTF(GDT_D_IOCTL, (" invalid ioctl\n"));
1514: error = EINVAL;
1515: }
1516:
1517: return (error);
1518: }
1519:
1520: int
1521: gdt_ioctl_inq(struct gdt_softc *sc, struct bioc_inq *bi)
1522: {
1523: bi->bi_novol = sc->sc_ndevs;
1524: bi->bi_nodisk = sc->sc_total_disks;
1525:
1526: strlcpy(bi->bi_dev, DEVNAME(sc), sizeof(bi->bi_dev));
1527:
1528: return (0);
1529: }
1530:
1531: int
1532: gdt_ioctl_vol(struct gdt_softc *sc, struct bioc_vol *bv)
1533: {
1534: return (1); /* XXX not yet */
1535: }
1536:
1537: int
1538: gdt_ioctl_disk(struct gdt_softc *sc, struct bioc_disk *bd)
1539: {
1540: return (1); /* XXX not yet */
1541: }
1542:
1543: int
1544: gdt_ioctl_alarm(struct gdt_softc *sc, struct bioc_alarm *ba)
1545: {
1546: return (1); /* XXX not yet */
1547: }
1548:
1549: int
1550: gdt_ioctl_setstate(struct gdt_softc *sc, struct bioc_setstate *bs)
1551: {
1552: return (1); /* XXX not yet */
1553: }
1554:
1555: #if 0
1556: int
1557: gdt_ioctl(dev, cmd, addr)
1558: struct device *dev;
1559: u_long cmd;
1560: caddr_t addr;
1561: {
1562: int error = 0;
1563: struct gdt_dummy *dummy;
1564:
1565: switch (cmd) {
1566: case GDT_IOCTL_DUMMY:
1567: dummy = (struct gdt_dummy *)addr;
1568: printf("%s: GDT_IOCTL_DUMMY %d\n", dev->dv_xname, dummy->x++);
1569: break;
1570:
1571: case GDT_IOCTL_GENERAL: {
1572: gdt_ucmd_t *ucmd;
1573: struct gdt_softc *gdt = (struct gdt_softc *)dev;
1574: int s;
1575:
1576: ucmd = (gdt_ucmd_t *)addr;
1577: s = splbio();
1578: TAILQ_INSERT_TAIL(&gdt->sc_ucmdq, ucmd, links);
1579: ucmd->complete_flag = FALSE;
1580: splx(s);
1581: gdt_chain(gdt);
1582: if (!ucmd->complete_flag)
1583: (void)tsleep((void *)ucmd, PCATCH | PRIBIO, "gdtucw",
1584: 0);
1585: break;
1586: }
1587:
1588: case GDT_IOCTL_DRVERS:
1589: ((gdt_drvers_t *)addr)->vers =
1590: (GDT_DRIVER_VERSION << 8) | GDT_DRIVER_SUBVERSION;
1591: break;
1592:
1593: case GDT_IOCTL_CTRCNT:
1594: ((gdt_ctrcnt_t *)addr)->cnt = gdt_cnt;
1595: break;
1596:
1597: #ifdef notyet
1598: case GDT_IOCTL_CTRTYPE: {
1599: gdt_ctrt_t *p;
1600: struct gdt_softc *gdt = (struct gdt_softc *)dev;
1601:
1602: p = (gdt_ctrt_t *)addr;
1603: p->oem_id = 0x8000;
1604: p->type = 0xfd;
1605: p->info = (gdt->sc_bus << 8) | (gdt->sc_slot << 3);
1606: p->ext_type = 0x6000 | gdt->sc_subdevice;
1607: p->device_id = gdt->sc_device;
1608: p->sub_device_id = gdt->sc_subdevice;
1609: break;
1610: }
1611: #endif
1612:
1613: case GDT_IOCTL_OSVERS: {
1614: gdt_osv_t *p;
1615:
1616: p = (gdt_osv_t *)addr;
1617: p->oscode = 10;
1618: p->version = osrelease[0] - '0';
1619: if (osrelease[1] == '.')
1620: p->subversion = osrelease[2] - '0';
1621: else
1622: p->subversion = 0;
1623: if (osrelease[3] == '.')
1624: p->revision = osrelease[4] - '0';
1625: else
1626: p->revision = 0;
1627: strlcpy(p->name, ostype, sizeof p->name);
1628: break;
1629: }
1630:
1631: #ifdef notyet
1632: case GDT_IOCTL_EVENT: {
1633: gdt_event_t *p;
1634: int s;
1635:
1636: p = (gdt_event_t *)addr;
1637: if (p->erase == 0xff) {
1638: if (p->dvr.event_source == GDT_ES_TEST)
1639: p->dvr.event_data.size =
1640: sizeof(p->dvr.event_data.eu.test);
1641: else if (p->dvr.event_source == GDT_ES_DRIVER)
1642: p->dvr.event_data.size =
1643: sizeof(p->dvr.event_data.eu.driver);
1644: else if (p->dvr.event_source == GDT_ES_SYNC)
1645: p->dvr.event_data.size =
1646: sizeof(p->dvr.event_data.eu.sync);
1647: else
1648: p->dvr.event_data.size =
1649: sizeof(p->dvr.event_data.eu.async);
1650: s = splbio();
1651: gdt_store_event(p->dvr.event_source, p->dvr.event_idx,
1652: &p->dvr.event_data);
1653: splx(s);
1654: } else if (p->erase == 0xfe) {
1655: s = splbio();
1656: gdt_clear_events();
1657: splx(s);
1658: } else if (p->erase == 0) {
1659: p->handle = gdt_read_event(p->handle, &p->dvr);
1660: } else {
1661: gdt_readapp_event((u_int8_t)p->erase, &p->dvr);
1662: }
1663: break;
1664: }
1665: #endif
1666:
1667: case GDT_IOCTL_STATIST:
1668: #if 0
1669: bcopy(&gdt_stat, (gdt_statist_t *)addr, sizeof gdt_stat);
1670: #else
1671: error = EOPNOTSUPP;
1672: #endif
1673: break;
1674:
1675: default:
1676: error = EINVAL;
1677: }
1678: return (error);
1679: }
1680: #endif /* 0 */
1681: #endif /* NBIO > 0 */