Annotation of sys/dev/ic/cac.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: cac.c,v 1.23 2006/11/28 23:59:45 dlg Exp $ */
2: /* $NetBSD: cac.c,v 1.15 2000/11/08 19:20:35 ad Exp $ */
3:
4: /*
5: * Copyright (c) 2001,2003 Michael Shalayeff
6: * All rights reserved.
7: *
8: * The SCSI emulation layer is derived from gdt(4) driver,
9: * Copyright (c) 1999, 2000 Niklas Hallqvist. All rights reserved.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23: * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
24: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
26: * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
28: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
29: * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30: * THE POSSIBILITY OF SUCH DAMAGE.
31: */
32: /*-
33: * Copyright (c) 2000 The NetBSD Foundation, Inc.
34: * All rights reserved.
35: *
36: * This code is derived from software contributed to The NetBSD Foundation
37: * by Andrew Doran.
38: *
39: * Redistribution and use in source and binary forms, with or without
40: * modification, are permitted provided that the following conditions
41: * are met:
42: * 1. Redistributions of source code must retain the above copyright
43: * notice, this list of conditions and the following disclaimer.
44: * 2. Redistributions in binary form must reproduce the above copyright
45: * notice, this list of conditions and the following disclaimer in the
46: * documentation and/or other materials provided with the distribution.
47: * 3. All advertising materials mentioning features or use of this software
48: * must display the following acknowledgement:
49: * This product includes software developed by the NetBSD
50: * Foundation, Inc. and its contributors.
51: * 4. Neither the name of The NetBSD Foundation nor the names of its
52: * contributors may be used to endorse or promote products derived
53: * from this software without specific prior written permission.
54: *
55: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
56: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
57: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
58: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
59: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
60: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
61: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
62: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
63: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
64: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
65: * POSSIBILITY OF SUCH DAMAGE.
66: */
67:
68: /*
69: * Driver for Compaq array controllers.
70: */
71:
72: /* #define CAC_DEBUG */
73:
74: #include <sys/param.h>
75: #include <sys/systm.h>
76: #include <sys/kernel.h>
77: #include <sys/device.h>
78: #include <sys/queue.h>
79: #include <sys/proc.h>
80: #include <sys/buf.h>
81: #include <sys/endian.h>
82: #include <sys/malloc.h>
83: #include <sys/pool.h>
84:
85: #include <machine/bus.h>
86:
87: #include <scsi/scsi_all.h>
88: #include <scsi/scsi_disk.h>
89: #include <scsi/scsiconf.h>
90:
91: #include <dev/ic/cacreg.h>
92: #include <dev/ic/cacvar.h>
93:
94: struct cfdriver cac_cd = {
95: NULL, "cac", DV_DULL
96: };
97:
98: int cac_scsi_cmd(struct scsi_xfer *);
99: void cacminphys(struct buf *bp);
100:
101: struct scsi_adapter cac_switch = {
102: cac_scsi_cmd, cacminphys, 0, 0,
103: };
104:
105: struct scsi_device cac_dev = {
106: NULL, NULL, NULL, NULL
107: };
108:
109: struct cac_ccb *cac_ccb_alloc(struct cac_softc *, int);
110: void cac_ccb_done(struct cac_softc *, struct cac_ccb *);
111: void cac_ccb_free(struct cac_softc *, struct cac_ccb *);
112: int cac_ccb_poll(struct cac_softc *, struct cac_ccb *, int);
113: int cac_ccb_start(struct cac_softc *, struct cac_ccb *);
114: int cac_cmd(struct cac_softc *sc, int command, void *data, int datasize,
115: int drive, int blkno, int flags, struct scsi_xfer *xs);
116: int cac_get_dinfo(struct cac_softc *sc, int target);
117: int cac_flush(struct cac_softc *sc);
118: void cac_shutdown(void *);
119: void cac_copy_internal_data(struct scsi_xfer *xs, void *v, size_t size);
120:
121: struct cac_ccb *cac_l0_completed(struct cac_softc *);
122: int cac_l0_fifo_full(struct cac_softc *);
123: void cac_l0_intr_enable(struct cac_softc *, int);
124: int cac_l0_intr_pending(struct cac_softc *);
125: void cac_l0_submit(struct cac_softc *, struct cac_ccb *);
126:
127: void *cac_sdh; /* shutdown hook */
128:
129: const
130: struct cac_linkage cac_l0 = {
131: cac_l0_completed,
132: cac_l0_fifo_full,
133: cac_l0_intr_enable,
134: cac_l0_intr_pending,
135: cac_l0_submit
136: };
137:
138: /*
139: * Initialise our interface to the controller.
140: */
141: int
142: cac_init(struct cac_softc *sc, int startfw)
143: {
144: struct scsibus_attach_args saa;
145: struct cac_controller_info cinfo;
146: int error, rseg, size, i;
147: bus_dma_segment_t seg[1];
148: struct cac_ccb *ccb;
149:
150: SIMPLEQ_INIT(&sc->sc_ccb_free);
151: SIMPLEQ_INIT(&sc->sc_ccb_queue);
152:
153: size = sizeof(struct cac_ccb) * CAC_MAX_CCBS;
154:
155: if ((error = bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, seg, 1,
156: &rseg, BUS_DMA_NOWAIT)) != 0) {
157: printf("%s: unable to allocate CCBs, error = %d\n",
158: sc->sc_dv.dv_xname, error);
159: return (-1);
160: }
161:
162: if ((error = bus_dmamem_map(sc->sc_dmat, seg, rseg, size,
163: &sc->sc_ccbs, BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
164: printf("%s: unable to map CCBs, error = %d\n",
165: sc->sc_dv.dv_xname, error);
166: return (-1);
167: }
168:
169: if ((error = bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
170: BUS_DMA_NOWAIT, &sc->sc_dmamap)) != 0) {
171: printf("%s: unable to create CCB DMA map, error = %d\n",
172: sc->sc_dv.dv_xname, error);
173: return (-1);
174: }
175:
176: if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_dmamap, sc->sc_ccbs,
177: size, NULL, BUS_DMA_NOWAIT)) != 0) {
178: printf("%s: unable to load CCB DMA map, error = %d\n",
179: sc->sc_dv.dv_xname, error);
180: return (-1);
181: }
182:
183: sc->sc_ccbs_paddr = sc->sc_dmamap->dm_segs[0].ds_addr;
184: memset(sc->sc_ccbs, 0, size);
185: ccb = (struct cac_ccb *)sc->sc_ccbs;
186:
187: for (i = 0; i < CAC_MAX_CCBS; i++, ccb++) {
188: /* Create the DMA map for this CCB's data */
189: error = bus_dmamap_create(sc->sc_dmat, CAC_MAX_XFER,
190: CAC_SG_SIZE, CAC_MAX_XFER, 0,
191: BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
192: &ccb->ccb_dmamap_xfer);
193:
194: if (error) {
195: printf("%s: can't create ccb dmamap (%d)\n",
196: sc->sc_dv.dv_xname, error);
197: break;
198: }
199:
200: ccb->ccb_paddr = sc->sc_ccbs_paddr + i * sizeof(struct cac_ccb);
201: SIMPLEQ_INSERT_TAIL(&sc->sc_ccb_free, ccb, ccb_chain);
202: }
203:
204: /* Start firmware background tasks, if needed. */
205: if (startfw) {
206: if (cac_cmd(sc, CAC_CMD_START_FIRMWARE, &cinfo, sizeof(cinfo),
207: 0, 0, CAC_CCB_DATA_IN, NULL)) {
208: printf("%s: CAC_CMD_START_FIRMWARE failed\n",
209: sc->sc_dv.dv_xname);
210: return (-1);
211: }
212: }
213:
214: if (cac_cmd(sc, CAC_CMD_GET_CTRL_INFO, &cinfo, sizeof(cinfo), 0, 0,
215: CAC_CCB_DATA_IN, NULL)) {
216: printf("%s: CAC_CMD_GET_CTRL_INFO failed\n",
217: sc->sc_dv.dv_xname);
218: return (-1);
219: }
220:
221: if (!cinfo.num_drvs) {
222: printf("%s: no volumes defined\n", sc->sc_dv.dv_xname);
223: return (-1);
224: }
225:
226: sc->sc_nunits = cinfo.num_drvs;
227: sc->sc_dinfos = malloc(cinfo.num_drvs * sizeof(struct cac_drive_info),
228: M_DEVBUF, M_NOWAIT);
229: if (sc->sc_dinfos == NULL) {
230: printf("%s: cannot allocate memory for drive_info\n",
231: sc->sc_dv.dv_xname);
232: return (-1);
233: }
234: bzero(sc->sc_dinfos, cinfo.num_drvs * sizeof(struct cac_drive_info));
235:
236: sc->sc_link.adapter_softc = sc;
237: sc->sc_link.adapter = &cac_switch;
238: sc->sc_link.adapter_target = cinfo.num_drvs;
239: sc->sc_link.adapter_buswidth = cinfo.num_drvs;
240: sc->sc_link.device = &cac_dev;
241: sc->sc_link.openings = CAC_MAX_CCBS / sc->sc_nunits;
242: if (sc->sc_link.openings < 4 )
243: sc->sc_link.openings = 4;
244:
245: bzero(&saa, sizeof(saa));
246: saa.saa_sc_link = &sc->sc_link;
247:
248: config_found(&sc->sc_dv, &saa, scsiprint);
249:
250: /* Set our `shutdownhook' before we start any device activity. */
251: if (cac_sdh == NULL)
252: cac_sdh = shutdownhook_establish(cac_shutdown, NULL);
253:
254: (*sc->sc_cl->cl_intr_enable)(sc, 1);
255:
256: return (0);
257: }
258:
259: int
260: cac_flush(sc)
261: struct cac_softc *sc;
262: {
263: u_int8_t buf[512];
264:
265: memset(buf, 0, sizeof(buf));
266: buf[0] = 1;
267: return cac_cmd(sc, CAC_CMD_FLUSH_CACHE, buf, sizeof(buf), 0, 0,
268: CAC_CCB_DATA_OUT, NULL);
269: }
270:
271: /*
272: * Shut down all `cac' controllers.
273: */
274: void
275: cac_shutdown(void *cookie)
276: {
277: extern struct cfdriver cac_cd;
278: struct cac_softc *sc;
279: int i;
280:
281: for (i = 0; i < cac_cd.cd_ndevs; i++) {
282: if ((sc = (struct cac_softc *)device_lookup(&cac_cd, i)) == NULL)
283: continue;
284: cac_flush(sc);
285: }
286: }
287:
288: /*
289: * Handle an interrupt from the controller: process finished CCBs and
290: * dequeue any waiting CCBs.
291: */
292: int
293: cac_intr(v)
294: void *v;
295: {
296: struct cac_softc *sc = v;
297: struct cac_ccb *ccb;
298: int istat, ret = 0;
299:
300: if (!(istat = (sc->sc_cl->cl_intr_pending)(sc)))
301: return 0;
302:
303: if (istat & CAC_INTR_FIFO_NEMPTY)
304: while ((ccb = (*sc->sc_cl->cl_completed)(sc)) != NULL) {
305: ret = 1;
306: cac_ccb_done(sc, ccb);
307: }
308: cac_ccb_start(sc, NULL);
309:
310: return (ret);
311: }
312:
313: /*
314: * Execute a [polled] command.
315: */
316: int
317: cac_cmd(struct cac_softc *sc, int command, void *data, int datasize,
318: int drive, int blkno, int flags, struct scsi_xfer *xs)
319: {
320: struct cac_ccb *ccb;
321: struct cac_sgb *sgb;
322: int i, rv, size, nsegs;
323:
324: #ifdef CAC_DEBUG
325: printf("cac_cmd op=%x drv=%d blk=%d data=%p[%x] fl=%x xs=%p ",
326: command, drive, blkno, data, datasize, flags, xs);
327: #endif
328:
329: if ((ccb = cac_ccb_alloc(sc, 0)) == NULL) {
330: printf("%s: unable to alloc CCB\n", sc->sc_dv.dv_xname);
331: return (ENOMEM);
332: }
333:
334: if ((flags & (CAC_CCB_DATA_IN | CAC_CCB_DATA_OUT)) != 0) {
335: bus_dmamap_load(sc->sc_dmat, ccb->ccb_dmamap_xfer,
336: (void *)data, datasize, NULL, BUS_DMA_NOWAIT);
337:
338: bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap_xfer, 0,
339: ccb->ccb_dmamap_xfer->dm_mapsize,
340: (flags & CAC_CCB_DATA_IN) != 0 ? BUS_DMASYNC_PREREAD :
341: BUS_DMASYNC_PREWRITE);
342:
343: sgb = ccb->ccb_seg;
344: nsegs = ccb->ccb_dmamap_xfer->dm_nsegs;
345: if (nsegs > CAC_SG_SIZE)
346: panic("cac_cmd: nsegs botch");
347:
348: size = 0;
349: for (i = 0; i < nsegs; i++, sgb++) {
350: size += ccb->ccb_dmamap_xfer->dm_segs[i].ds_len;
351: sgb->length =
352: htole32(ccb->ccb_dmamap_xfer->dm_segs[i].ds_len);
353: sgb->addr =
354: htole32(ccb->ccb_dmamap_xfer->dm_segs[i].ds_addr);
355: }
356: } else {
357: size = datasize;
358: nsegs = 0;
359: }
360:
361: ccb->ccb_hdr.drive = drive;
362: ccb->ccb_hdr.priority = 0;
363: ccb->ccb_hdr.size = htole16((sizeof(struct cac_req) +
364: sizeof(struct cac_sgb) * CAC_SG_SIZE) >> 2);
365:
366: ccb->ccb_req.next = 0;
367: ccb->ccb_req.command = command;
368: ccb->ccb_req.error = 0;
369: ccb->ccb_req.blkno = htole32(blkno);
370: ccb->ccb_req.bcount = htole16(howmany(size, DEV_BSIZE));
371: ccb->ccb_req.sgcount = nsegs;
372: ccb->ccb_req.reserved = 0;
373:
374: ccb->ccb_flags = flags;
375: ccb->ccb_datasize = size;
376: ccb->ccb_xs = xs;
377:
378: if (!xs || xs->flags & SCSI_POLL) {
379:
380: /* Synchronous commands musn't wait. */
381: if ((*sc->sc_cl->cl_fifo_full)(sc)) {
382: cac_ccb_free(sc, ccb);
383: rv = -1;
384: } else {
385: ccb->ccb_flags |= CAC_CCB_ACTIVE;
386: (*sc->sc_cl->cl_submit)(sc, ccb);
387: rv = cac_ccb_poll(sc, ccb, 2000);
388: }
389: } else
390: rv = cac_ccb_start(sc, ccb);
391:
392: return (rv);
393: }
394:
395: /*
396: * Wait for the specified CCB to complete. Must be called at splbio.
397: */
398: int
399: cac_ccb_poll(struct cac_softc *sc, struct cac_ccb *wantccb, int timo)
400: {
401: struct cac_ccb *ccb;
402: int t = timo * 10;
403:
404: do {
405: for (; t--; DELAY(100))
406: if ((ccb = (*sc->sc_cl->cl_completed)(sc)) != NULL)
407: break;
408: if (t < 0) {
409: printf("%s: timeout\n", sc->sc_dv.dv_xname);
410: return (EBUSY);
411: }
412: cac_ccb_done(sc, ccb);
413: } while (ccb != wantccb);
414:
415: return (0);
416: }
417:
418: /*
419: * Enqueue the specified command (if any) and attempt to start all enqueued
420: * commands. Must be called at splbio.
421: */
422: int
423: cac_ccb_start(struct cac_softc *sc, struct cac_ccb *ccb)
424: {
425: if (ccb != NULL)
426: SIMPLEQ_INSERT_TAIL(&sc->sc_ccb_queue, ccb, ccb_chain);
427:
428: while ((ccb = SIMPLEQ_FIRST(&sc->sc_ccb_queue)) != NULL &&
429: !(*sc->sc_cl->cl_fifo_full)(sc)) {
430: SIMPLEQ_REMOVE_HEAD(&sc->sc_ccb_queue, ccb_chain);
431: ccb->ccb_flags |= CAC_CCB_ACTIVE;
432: (*sc->sc_cl->cl_submit)(sc, ccb);
433: }
434:
435: return (0);
436: }
437:
438: /*
439: * Process a finished CCB.
440: */
441: void
442: cac_ccb_done(struct cac_softc *sc, struct cac_ccb *ccb)
443: {
444: struct scsi_xfer *xs = ccb->ccb_xs;
445: int error = 0;
446:
447: if ((ccb->ccb_flags & CAC_CCB_ACTIVE) == 0) {
448: printf("%s: CCB not active, xs=%p\n", sc->sc_dv.dv_xname, xs);
449: if (xs) {
450: xs->error = XS_DRIVER_STUFFUP;
451: scsi_done(xs);
452: }
453: return;
454: }
455:
456: if ((ccb->ccb_flags & (CAC_CCB_DATA_IN | CAC_CCB_DATA_OUT)) != 0) {
457: bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap_xfer, 0,
458: ccb->ccb_dmamap_xfer->dm_mapsize,
459: ccb->ccb_flags & CAC_CCB_DATA_IN ?
460: BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
461: bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap_xfer);
462: }
463:
464: if ((ccb->ccb_req.error & CAC_RET_SOFT_ERROR) != 0)
465: printf("%s: soft error; corrected\n", sc->sc_dv.dv_xname);
466: if ((ccb->ccb_req.error & CAC_RET_HARD_ERROR) != 0) {
467: error = 1;
468: printf("%s: hard error\n", sc->sc_dv.dv_xname);
469: }
470: if ((ccb->ccb_req.error & CAC_RET_CMD_REJECTED) != 0) {
471: error = 1;
472: printf("%s: invalid request\n", sc->sc_dv.dv_xname);
473: }
474:
475: cac_ccb_free(sc, ccb);
476: if (xs) {
477: if (error)
478: xs->error = XS_DRIVER_STUFFUP;
479: else
480: xs->resid = 0;
481:
482: xs->flags |= ITSDONE;
483: scsi_done(xs);
484: }
485: }
486:
487: /*
488: * Allocate a CCB.
489: */
490: struct cac_ccb *
491: cac_ccb_alloc(struct cac_softc *sc, int nosleep)
492: {
493: struct cac_ccb *ccb;
494:
495: if ((ccb = SIMPLEQ_FIRST(&sc->sc_ccb_free)) != NULL)
496: SIMPLEQ_REMOVE_HEAD(&sc->sc_ccb_free, ccb_chain);
497: else
498: ccb = NULL;
499: return (ccb);
500: }
501:
502: /*
503: * Put a CCB onto the freelist.
504: */
505: void
506: cac_ccb_free(struct cac_softc *sc, struct cac_ccb *ccb)
507: {
508:
509: ccb->ccb_flags = 0;
510: SIMPLEQ_INSERT_HEAD(&sc->sc_ccb_free, ccb, ccb_chain);
511: }
512:
513: int
514: cac_get_dinfo(sc, target)
515: struct cac_softc *sc;
516: int target;
517: {
518: if (sc->sc_dinfos[target].ncylinders)
519: return (0);
520:
521: if (cac_cmd(sc, CAC_CMD_GET_LOG_DRV_INFO, &sc->sc_dinfos[target],
522: sizeof(*sc->sc_dinfos), target, 0, CAC_CCB_DATA_IN, NULL)) {
523: printf("%s: CMD_GET_LOG_DRV_INFO failed\n",
524: sc->sc_dv.dv_xname);
525: return (-1);
526: }
527:
528: return (0);
529: }
530:
531: void
532: cacminphys(bp)
533: struct buf *bp;
534: {
535: if (bp->b_bcount > CAC_MAX_XFER)
536: bp->b_bcount = CAC_MAX_XFER;
537: minphys(bp);
538: }
539:
540: void
541: cac_copy_internal_data(xs, v, size)
542: struct scsi_xfer *xs;
543: void *v;
544: size_t size;
545: {
546: size_t copy_cnt;
547:
548: if (!xs->datalen)
549: printf("uio move is not yet supported\n");
550: else {
551: copy_cnt = MIN(size, xs->datalen);
552: bcopy(v, xs->data, copy_cnt);
553: }
554: }
555:
556: int
557: cac_scsi_cmd(xs)
558: struct scsi_xfer *xs;
559: {
560: struct scsi_link *link = xs->sc_link;
561: struct cac_softc *sc = link->adapter_softc;
562: struct cac_drive_info *dinfo;
563: struct scsi_inquiry_data inq;
564: struct scsi_sense_data sd;
565: struct scsi_read_cap_data rcd;
566: u_int8_t target = link->target;
567: u_int32_t blockno, blockcnt, size;
568: struct scsi_rw *rw;
569: struct scsi_rw_big *rwb;
570: int op, flags, s, error, poll;
571: const char *p;
572:
573: if (target >= sc->sc_nunits || link->lun != 0) {
574: xs->error = XS_DRIVER_STUFFUP;
575: return (COMPLETE);
576: }
577:
578: s = splbio();
579: xs->error = XS_NOERROR;
580: xs->free_list.le_next = NULL;
581: dinfo = &sc->sc_dinfos[target];
582:
583: switch (xs->cmd->opcode) {
584: case TEST_UNIT_READY:
585: case START_STOP:
586: #if 0
587: case VERIFY:
588: #endif
589: break;
590:
591: case REQUEST_SENSE:
592: bzero(&sd, sizeof sd);
593: sd.error_code = 0x70;
594: sd.segment = 0;
595: sd.flags = SKEY_NO_SENSE;
596: *(u_int32_t*)sd.info = htole32(0);
597: sd.extra_len = 0;
598: cac_copy_internal_data(xs, &sd, sizeof sd);
599: break;
600:
601: case INQUIRY:
602: if (cac_get_dinfo(sc, target)) {
603: xs->error = XS_DRIVER_STUFFUP;
604: break;
605: }
606: bzero(&inq, sizeof inq);
607: inq.device = T_DIRECT;
608: inq.dev_qual2 = 0;
609: inq.version = 2;
610: inq.response_format = 2;
611: inq.additional_length = 32;
612: strlcpy(inq.vendor, "Compaq ", sizeof inq.vendor);
613: switch (CAC_GET1(dinfo->mirror)) {
614: case 0: p = "RAID0"; break;
615: case 1: p = "RAID4"; break;
616: case 2: p = "RAID1"; break;
617: case 3: p = "RAID5"; break;
618: default:p = "<UNK>"; break;
619: }
620: snprintf(inq.product, sizeof inq.product, "%s vol #%02d",
621: p, target);
622: strlcpy(inq.revision, " ", sizeof inq.revision);
623: cac_copy_internal_data(xs, &inq, sizeof inq);
624: break;
625:
626: case READ_CAPACITY:
627: if (cac_get_dinfo(sc, target)) {
628: xs->error = XS_DRIVER_STUFFUP;
629: break;
630: }
631: bzero(&rcd, sizeof rcd);
632: _lto4b( CAC_GET2(dinfo->ncylinders) * CAC_GET1(dinfo->nheads) *
633: CAC_GET1(dinfo->nsectors) - 1, rcd.addr);
634: _lto4b(CAC_SECTOR_SIZE, rcd.length);
635: cac_copy_internal_data(xs, &rcd, sizeof rcd);
636: break;
637:
638: case PREVENT_ALLOW:
639: break;
640:
641: case SYNCHRONIZE_CACHE:
642: if (cac_flush(sc))
643: xs->error = XS_DRIVER_STUFFUP;
644: break;
645:
646: case READ_COMMAND:
647: case READ_BIG:
648: case WRITE_COMMAND:
649: case WRITE_BIG:
650:
651: flags = 0;
652: /* A read or write operation. */
653: if (xs->cmdlen == 6) {
654: rw = (struct scsi_rw *)xs->cmd;
655: blockno = _3btol(rw->addr) &
656: (SRW_TOPADDR << 16 | 0xffff);
657: blockcnt = rw->length ? rw->length : 0x100;
658: } else {
659: rwb = (struct scsi_rw_big *)xs->cmd;
660: blockno = _4btol(rwb->addr);
661: blockcnt = _2btol(rwb->length);
662: }
663: size = CAC_GET2(dinfo->ncylinders) *
664: CAC_GET1(dinfo->nheads) * CAC_GET1(dinfo->nsectors);
665: if (blockno >= size || blockno + blockcnt > size) {
666: printf("%s: out of bounds %u-%u >= %u\n",
667: sc->sc_dv.dv_xname, blockno, blockcnt, size);
668: xs->error = XS_DRIVER_STUFFUP;
669: scsi_done(xs);
670: break;
671: }
672:
673: switch (xs->cmd->opcode) {
674: case READ_COMMAND:
675: case READ_BIG:
676: op = CAC_CMD_READ;
677: flags = CAC_CCB_DATA_IN;
678: break;
679: case WRITE_COMMAND:
680: case WRITE_BIG:
681: op = CAC_CMD_WRITE;
682: flags = CAC_CCB_DATA_OUT;
683: break;
684: }
685:
686: poll = xs->flags & SCSI_POLL;
687: if ((error = cac_cmd(sc, op, xs->data, blockcnt * DEV_BSIZE,
688: target, blockno, flags, xs))) {
689:
690: if (error == ENOMEM) {
691: splx(s);
692: return (TRY_AGAIN_LATER);
693: } else if (poll) {
694: splx(s);
695: return (TRY_AGAIN_LATER);
696: } else {
697: xs->error = XS_DRIVER_STUFFUP;
698: scsi_done(xs);
699: break;
700: }
701: }
702:
703: splx(s);
704:
705: if (poll)
706: return (COMPLETE);
707: else
708: return (SUCCESSFULLY_QUEUED);
709:
710: default:
711: SC_DEBUG(link, SDEV_DB1, ("unsupported scsi command %#x "
712: "tgt %d ", xs->cmd->opcode, target));
713: xs->error = XS_DRIVER_STUFFUP;
714: }
715: splx(s);
716:
717: return (COMPLETE);
718: }
719:
720: /*
721: * Board specific linkage shared between multiple bus types.
722: */
723:
724: int
725: cac_l0_fifo_full(struct cac_softc *sc)
726: {
727:
728: return (cac_inl(sc, CAC_REG_CMD_FIFO) == 0);
729: }
730:
731: void
732: cac_l0_submit(struct cac_softc *sc, struct cac_ccb *ccb)
733: {
734: #ifdef CAC_DEBUG
735: printf("submit-%x ", ccb->ccb_paddr);
736: #endif
737: bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap, 0,
738: sc->sc_dmamap->dm_mapsize,
739: BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
740: cac_outl(sc, CAC_REG_CMD_FIFO, ccb->ccb_paddr);
741: }
742:
743: struct cac_ccb *
744: cac_l0_completed(sc)
745: struct cac_softc *sc;
746: {
747: struct cac_ccb *ccb;
748: paddr_t off;
749:
750: if (!(off = cac_inl(sc, CAC_REG_DONE_FIFO)))
751: return NULL;
752: #ifdef CAC_DEBUG
753: printf("compl-%x ", off);
754: #endif
755: if (off & 3 && ccb->ccb_req.error == 0)
756: ccb->ccb_req.error = CAC_RET_CMD_INVALID;
757:
758: off = (off & ~3) - sc->sc_ccbs_paddr;
759: ccb = (struct cac_ccb *)(sc->sc_ccbs + off);
760:
761: bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap, 0,
762: sc->sc_dmamap->dm_mapsize,
763: BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
764:
765: return (ccb);
766: }
767:
768: int
769: cac_l0_intr_pending(struct cac_softc *sc)
770: {
771:
772: return (cac_inl(sc, CAC_REG_INTR_PENDING));
773: }
774:
775: void
776: cac_l0_intr_enable(struct cac_softc *sc, int state)
777: {
778:
779: cac_outl(sc, CAC_REG_INTR_MASK,
780: state ? CAC_INTR_ENABLE : CAC_INTR_DISABLE);
781: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to cac.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic