![[BACK]](/icons/back.gif){kind=icon}
Return to adv.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to adv.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 1: /* $OpenBSD: adv.c,v 1.17 2006/11/29 01:00:47 grange Exp $ */
2: /* $NetBSD: adv.c,v 1.6 1998/10/28 20:39:45 dante Exp $ */
3:
4: /*
5: * Generic driver for the Advanced Systems Inc. Narrow SCSI controllers
6: *
7: * Copyright (c) 1998 The NetBSD Foundation, Inc.
8: * All rights reserved.
9: *
10: * Author: Baldassare Dante Profeta <dante@mclink.it>
11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: * 3. All advertising materials mentioning features or use of this software
21: * must display the following acknowledgement:
22: * This product includes software developed by the NetBSD
23: * Foundation, Inc. and its contributors.
24: * 4. Neither the name of The NetBSD Foundation nor the names of its
25: * contributors may be used to endorse or promote products derived
26: * from this software without specific prior written permission.
27: *
28: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
29: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
30: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
31: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
32: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
34: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
36: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38: * POSSIBILITY OF SUCH DAMAGE.
39: */
40:
41: #include <sys/types.h>
42: #include <sys/param.h>
43: #include <sys/systm.h>
44: #include <sys/kernel.h>
45: #include <sys/errno.h>
46: #include <sys/ioctl.h>
47: #include <sys/device.h>
48: #include <sys/malloc.h>
49: #include <sys/buf.h>
50: #include <sys/proc.h>
51: #include <sys/user.h>
52:
53: #include <machine/bus.h>
54: #include <machine/intr.h>
55:
56: #include <scsi/scsi_all.h>
57: #include <scsi/scsiconf.h>
58:
59: #include <dev/ic/adv.h>
60: #include <dev/ic/advlib.h>
61:
62: #ifndef DDB
63: #define Debugger() panic("should call debugger here (adv.c)")
64: #endif /* ! DDB */
65:
66:
67: /* #define ASC_DEBUG */
68:
69: /******************************************************************************/
70:
71:
72: static void adv_enqueue(ASC_SOFTC *, struct scsi_xfer *, int);
73: static struct scsi_xfer *adv_dequeue(ASC_SOFTC *);
74:
75: static int adv_alloc_ccbs(ASC_SOFTC *);
76: static int adv_create_ccbs(ASC_SOFTC *, ADV_CCB *, int);
77: static void adv_free_ccb(ASC_SOFTC *, ADV_CCB *);
78: static void adv_reset_ccb(ADV_CCB *);
79: static int adv_init_ccb(ASC_SOFTC *, ADV_CCB *);
80: static ADV_CCB *adv_get_ccb(ASC_SOFTC *, int);
81: static void adv_queue_ccb(ASC_SOFTC *, ADV_CCB *);
82: static void adv_start_ccbs(ASC_SOFTC *);
83:
84: static u_int8_t *adv_alloc_overrunbuf(char *dvname, bus_dma_tag_t);
85:
86: static int adv_scsi_cmd(struct scsi_xfer *);
87: static void advminphys(struct buf *);
88: static void adv_narrow_isr_callback(ASC_SOFTC *, ASC_QDONE_INFO *);
89:
90: static int adv_poll(ASC_SOFTC *, struct scsi_xfer *, int);
91: static void adv_timeout(void *);
92: static void adv_watchdog(void *);
93:
94:
95: /******************************************************************************/
96:
97:
98: struct cfdriver adv_cd = {
99: NULL, "adv", DV_DULL
100: };
101:
102:
103: struct scsi_adapter adv_switch =
104: {
105: adv_scsi_cmd, /* called to start/enqueue a SCSI command */
106: advminphys, /* to limit the transfer to max device can do */
107: 0, /* IT SEEMS IT IS NOT USED YET */
108: 0, /* as above... */
109: };
110:
111:
112: /* the below structure is so we have a default dev struct for out link struct */
113: struct scsi_device adv_dev =
114: {
115: NULL, /* Use default error handler */
116: NULL, /* have a queue, served by this */
117: NULL, /* have no async handler */
118: NULL, /* Use default 'done' routine */
119: };
120:
121:
122: #define ADV_ABORT_TIMEOUT 2000 /* time to wait for abort (mSec) */
123: #define ADV_WATCH_TIMEOUT 1000 /* time to wait for watchdog (mSec) */
124:
125:
126: /******************************************************************************/
127: /* scsi_xfer queue routines */
128: /******************************************************************************/
129:
130:
131: /*
132: * Insert a scsi_xfer into the software queue. We overload xs->free_list
133: * to avoid having to allocate additional resources (since we're used
134: * only during resource shortages anyhow.
135: */
136: static void
137: adv_enqueue(sc, xs, infront)
138: ASC_SOFTC *sc;
139: struct scsi_xfer *xs;
140: int infront;
141: {
142:
143: if (infront || LIST_EMPTY(&sc->sc_queue)) {
144: if (LIST_EMPTY(&sc->sc_queue))
145: sc->sc_queuelast = xs;
146: LIST_INSERT_HEAD(&sc->sc_queue, xs, free_list);
147: return;
148: }
149: LIST_INSERT_AFTER(sc->sc_queuelast, xs, free_list);
150: sc->sc_queuelast = xs;
151: }
152:
153:
154: /*
155: * Pull a scsi_xfer off the front of the software queue.
156: */
157: static struct scsi_xfer *
158: adv_dequeue(sc)
159: ASC_SOFTC *sc;
160: {
161: struct scsi_xfer *xs;
162:
163: xs = LIST_FIRST(&sc->sc_queue);
164: LIST_REMOVE(xs, free_list);
165:
166: if (LIST_EMPTY(&sc->sc_queue))
167: sc->sc_queuelast = NULL;
168:
169: return (xs);
170: }
171:
172:
173: /******************************************************************************/
174: /* Control Blocks routines */
175: /******************************************************************************/
176:
177:
178: static int
179: adv_alloc_ccbs(sc)
180: ASC_SOFTC *sc;
181: {
182: bus_dma_segment_t seg;
183: int error, rseg;
184:
185: /*
186: * Allocate the control blocks.
187: */
188: if ((error = bus_dmamem_alloc(sc->sc_dmat, sizeof(struct adv_control),
189: NBPG, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT)) != 0) {
190: printf("%s: unable to allocate control structures,"
191: " error = %d\n", sc->sc_dev.dv_xname, error);
192: return (error);
193: }
194: if ((error = bus_dmamem_map(sc->sc_dmat, &seg, rseg,
195: sizeof(struct adv_control), (caddr_t *) & sc->sc_control,
196: BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
197: printf("%s: unable to map control structures, error = %d\n",
198: sc->sc_dev.dv_xname, error);
199: return (error);
200: }
201: /*
202: * Create and load the DMA map used for the control blocks.
203: */
204: if ((error = bus_dmamap_create(sc->sc_dmat, sizeof(struct adv_control),
205: 1, sizeof(struct adv_control), 0, BUS_DMA_NOWAIT,
206: &sc->sc_dmamap_control)) != 0) {
207: printf("%s: unable to create control DMA map, error = %d\n",
208: sc->sc_dev.dv_xname, error);
209: return (error);
210: }
211: if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_dmamap_control,
212: sc->sc_control, sizeof(struct adv_control), NULL,
213: BUS_DMA_NOWAIT)) != 0) {
214: printf("%s: unable to load control DMA map, error = %d\n",
215: sc->sc_dev.dv_xname, error);
216: return (error);
217: }
218: return (0);
219: }
220:
221:
222: /*
223: * Create a set of ccbs and add them to the free list. Called once
224: * by adv_init(). We return the number of CCBs successfully created.
225: */
226: static int
227: adv_create_ccbs(sc, ccbstore, count)
228: ASC_SOFTC *sc;
229: ADV_CCB *ccbstore;
230: int count;
231: {
232: ADV_CCB *ccb;
233: int i, error;
234:
235: bzero(ccbstore, sizeof(ADV_CCB) * count);
236: for (i = 0; i < count; i++) {
237: ccb = &ccbstore[i];
238: if ((error = adv_init_ccb(sc, ccb)) != 0) {
239: printf("%s: unable to initialize ccb, error = %d\n",
240: sc->sc_dev.dv_xname, error);
241: return (i);
242: }
243: TAILQ_INSERT_TAIL(&sc->sc_free_ccb, ccb, chain);
244: }
245:
246: return (i);
247: }
248:
249:
250: /*
251: * A ccb is put onto the free list.
252: */
253: static void
254: adv_free_ccb(sc, ccb)
255: ASC_SOFTC *sc;
256: ADV_CCB *ccb;
257: {
258: int s;
259:
260: s = splbio();
261:
262: adv_reset_ccb(ccb);
263: TAILQ_INSERT_HEAD(&sc->sc_free_ccb, ccb, chain);
264:
265: /*
266: * If there were none, wake anybody waiting for one to come free,
267: * starting with queued entries.
268: */
269: if (TAILQ_NEXT(ccb, chain) == NULL)
270: wakeup(&sc->sc_free_ccb);
271:
272: splx(s);
273: }
274:
275:
276: static void
277: adv_reset_ccb(ccb)
278: ADV_CCB *ccb;
279: {
280:
281: ccb->flags = 0;
282: }
283:
284:
285: static int
286: adv_init_ccb(sc, ccb)
287: ASC_SOFTC *sc;
288: ADV_CCB *ccb;
289: {
290: int error;
291:
292: /*
293: * Create the DMA map for this CCB.
294: */
295: error = bus_dmamap_create(sc->sc_dmat,
296: (ASC_MAX_SG_LIST - 1) * PAGE_SIZE,
297: ASC_MAX_SG_LIST, (ASC_MAX_SG_LIST - 1) * PAGE_SIZE,
298: 0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &ccb->dmamap_xfer);
299: if (error) {
300: printf("%s: unable to create DMA map, error = %d\n",
301: sc->sc_dev.dv_xname, error);
302: return (error);
303: }
304: adv_reset_ccb(ccb);
305: return (0);
306: }
307:
308:
309: /*
310: * Get a free ccb
311: *
312: * If there are none, see if we can allocate a new one
313: */
314: static ADV_CCB *
315: adv_get_ccb(sc, flags)
316: ASC_SOFTC *sc;
317: int flags;
318: {
319: ADV_CCB *ccb = 0;
320: int s;
321:
322: s = splbio();
323:
324: /*
325: * If we can and have to, sleep waiting for one to come free
326: * but only if we can't allocate a new one.
327: */
328: for (;;) {
329: ccb = TAILQ_FIRST(&sc->sc_free_ccb);
330: if (ccb) {
331: TAILQ_REMOVE(&sc->sc_free_ccb, ccb, chain);
332: break;
333: }
334: if ((flags & SCSI_NOSLEEP) != 0)
335: goto out;
336:
337: tsleep(&sc->sc_free_ccb, PRIBIO, "advccb", 0);
338: }
339:
340: ccb->flags |= CCB_ALLOC;
341:
342: out:
343: splx(s);
344: return (ccb);
345: }
346:
347:
348: /*
349: * Queue a CCB to be sent to the controller, and send it if possible.
350: */
351: static void
352: adv_queue_ccb(sc, ccb)
353: ASC_SOFTC *sc;
354: ADV_CCB *ccb;
355: {
356:
357: timeout_set(&ccb->xs->stimeout, adv_timeout, ccb);
358: TAILQ_INSERT_TAIL(&sc->sc_waiting_ccb, ccb, chain);
359:
360: adv_start_ccbs(sc);
361: }
362:
363:
364: static void
365: adv_start_ccbs(sc)
366: ASC_SOFTC *sc;
367: {
368: ADV_CCB *ccb;
369: struct scsi_xfer *xs;
370:
371: while ((ccb = TAILQ_FIRST(&sc->sc_waiting_ccb)) != NULL) {
372:
373: xs = ccb->xs;
374: if (ccb->flags & CCB_WATCHDOG)
375: timeout_del(&xs->stimeout);
376:
377: if (AscExeScsiQueue(sc, &ccb->scsiq) == ASC_BUSY) {
378: ccb->flags |= CCB_WATCHDOG;
379: timeout_set(&xs->stimeout, adv_watchdog, ccb);
380: timeout_add(&xs->stimeout,
381: (ADV_WATCH_TIMEOUT * hz) / 1000);
382: break;
383: }
384: TAILQ_REMOVE(&sc->sc_waiting_ccb, ccb, chain);
385:
386: if ((ccb->xs->flags & SCSI_POLL) == 0) {
387: timeout_set(&xs->stimeout, adv_timeout, ccb);
388: timeout_add(&xs->stimeout, (ccb->timeout * hz) / 1000);
389: }
390: }
391: }
392:
393:
394: /******************************************************************************/
395: /* DMA able memory allocation routines */
396: /******************************************************************************/
397:
398:
399: /*
400: * Allocate a DMA able memory for overrun_buffer.
401: * This memory can be safely shared among all the AdvanSys boards.
402: */
403: u_int8_t *
404: adv_alloc_overrunbuf(dvname, dmat)
405: char *dvname;
406: bus_dma_tag_t dmat;
407: {
408: static u_int8_t *overrunbuf = NULL;
409:
410: bus_dmamap_t ovrbuf_dmamap;
411: bus_dma_segment_t seg;
412: int rseg, error;
413:
414:
415: /*
416: * if an overrun buffer has been already allocated don't allocate it
417: * again. Instead return the address of the allocated buffer.
418: */
419: if (overrunbuf)
420: return (overrunbuf);
421:
422:
423: if ((error = bus_dmamem_alloc(dmat, ASC_OVERRUN_BSIZE,
424: NBPG, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT)) != 0) {
425: printf("%s: unable to allocate overrun buffer, error = %d\n",
426: dvname, error);
427: return (0);
428: }
429: if ((error = bus_dmamem_map(dmat, &seg, rseg, ASC_OVERRUN_BSIZE,
430: (caddr_t *) & overrunbuf, BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
431: printf("%s: unable to map overrun buffer, error = %d\n",
432: dvname, error);
433:
434: bus_dmamem_free(dmat, &seg, 1);
435: return (0);
436: }
437: if ((error = bus_dmamap_create(dmat, ASC_OVERRUN_BSIZE, 1,
438: ASC_OVERRUN_BSIZE, 0, BUS_DMA_NOWAIT, &ovrbuf_dmamap)) != 0) {
439: printf("%s: unable to create overrun buffer DMA map,"
440: " error = %d\n", dvname, error);
441:
442: bus_dmamem_unmap(dmat, overrunbuf, ASC_OVERRUN_BSIZE);
443: bus_dmamem_free(dmat, &seg, 1);
444: return (0);
445: }
446: if ((error = bus_dmamap_load(dmat, ovrbuf_dmamap, overrunbuf,
447: ASC_OVERRUN_BSIZE, NULL, BUS_DMA_NOWAIT)) != 0) {
448: printf("%s: unable to load overrun buffer DMA map,"
449: " error = %d\n", dvname, error);
450:
451: bus_dmamap_destroy(dmat, ovrbuf_dmamap);
452: bus_dmamem_unmap(dmat, overrunbuf, ASC_OVERRUN_BSIZE);
453: bus_dmamem_free(dmat, &seg, 1);
454: return (0);
455: }
456: return (overrunbuf);
457: }
458:
459:
460: /******************************************************************************/
461: /* SCSI layer interfacing routines */
462: /******************************************************************************/
463:
464:
465: int
466: adv_init(sc)
467: ASC_SOFTC *sc;
468: {
469: int warn;
470:
471: if (!AscFindSignature(sc->sc_iot, sc->sc_ioh))
472: panic("adv_init: adv_find_signature failed");
473:
474: /*
475: * Read the board configuration
476: */
477: AscInitASC_SOFTC(sc);
478: warn = AscInitFromEEP(sc);
479: if (warn) {
480: printf("%s -get: ", sc->sc_dev.dv_xname);
481: switch (warn) {
482: case -1:
483: printf("Chip is not halted\n");
484: break;
485:
486: case -2:
487: printf("Couldn't get MicroCode Start"
488: " address\n");
489: break;
490:
491: case ASC_WARN_IO_PORT_ROTATE:
492: printf("I/O port address modified\n");
493: break;
494:
495: case ASC_WARN_AUTO_CONFIG:
496: printf("I/O port increment switch enabled\n");
497: break;
498:
499: case ASC_WARN_EEPROM_CHKSUM:
500: printf("EEPROM checksum error\n");
501: break;
502:
503: case ASC_WARN_IRQ_MODIFIED:
504: printf("IRQ modified\n");
505: break;
506:
507: case ASC_WARN_CMD_QNG_CONFLICT:
508: printf("tag queuing enabled w/o disconnects\n");
509: break;
510:
511: default:
512: printf("unknown warning %d\n", warn);
513: }
514: }
515: if (sc->scsi_reset_wait > ASC_MAX_SCSI_RESET_WAIT)
516: sc->scsi_reset_wait = ASC_MAX_SCSI_RESET_WAIT;
517:
518: /*
519: * Modify the board configuration
520: */
521: warn = AscInitFromASC_SOFTC(sc);
522: if (warn) {
523: printf("%s -set: ", sc->sc_dev.dv_xname);
524: switch (warn) {
525: case ASC_WARN_CMD_QNG_CONFLICT:
526: printf("tag queuing enabled w/o disconnects\n");
527: break;
528:
529: case ASC_WARN_AUTO_CONFIG:
530: printf("I/O port increment switch enabled\n");
531: break;
532:
533: default:
534: printf("unknown warning %d\n", warn);
535: }
536: }
537: sc->isr_callback = (ulong) adv_narrow_isr_callback;
538:
539: if (!(sc->overrun_buf = adv_alloc_overrunbuf(sc->sc_dev.dv_xname,
540: sc->sc_dmat))) {
541: return (1);
542: }
543:
544: return (0);
545: }
546:
547:
548: void
549: adv_attach(sc)
550: ASC_SOFTC *sc;
551: {
552: struct scsibus_attach_args saa;
553: int i, error;
554:
555: /*
556: * Initialize board RISC chip and enable interrupts.
557: */
558: switch (AscInitDriver(sc)) {
559: case 0:
560: /* AllOK */
561: break;
562:
563: case 1:
564: panic("%s: bad signature", sc->sc_dev.dv_xname);
565: break;
566:
567: case 2:
568: panic("%s: unable to load MicroCode",
569: sc->sc_dev.dv_xname);
570: break;
571:
572: case 3:
573: panic("%s: unable to initialize MicroCode",
574: sc->sc_dev.dv_xname);
575: break;
576:
577: default:
578: panic("%s: unable to initialize board RISC chip",
579: sc->sc_dev.dv_xname);
580: }
581:
582:
583: /*
584: * fill in the prototype scsi_link.
585: */
586: sc->sc_link.adapter_softc = sc;
587: sc->sc_link.adapter_target = sc->chip_scsi_id;
588: sc->sc_link.adapter = &adv_switch;
589: sc->sc_link.device = &adv_dev;
590: sc->sc_link.openings = 4;
591: sc->sc_link.adapter_buswidth = 7;
592:
593:
594: TAILQ_INIT(&sc->sc_free_ccb);
595: TAILQ_INIT(&sc->sc_waiting_ccb);
596: LIST_INIT(&sc->sc_queue);
597:
598:
599: /*
600: * Allocate the Control Blocks.
601: */
602: error = adv_alloc_ccbs(sc);
603: if (error)
604: return; /* (error) */ ;
605:
606: /*
607: * Create and initialize the Control Blocks.
608: */
609: i = adv_create_ccbs(sc, sc->sc_control->ccbs, ADV_MAX_CCB);
610: if (i == 0) {
611: printf("%s: unable to create control blocks\n",
612: sc->sc_dev.dv_xname);
613: return; /* (ENOMEM) */ ;
614: } else if (i != ADV_MAX_CCB) {
615: printf("%s: WARNING: only %d of %d control blocks created\n",
616: sc->sc_dev.dv_xname, i, ADV_MAX_CCB);
617: }
618:
619: bzero(&saa, sizeof(saa));
620: saa.saa_sc_link = &sc->sc_link;
621: config_found(&sc->sc_dev, &saa, scsiprint);
622: }
623:
624:
625: static void
626: advminphys(bp)
627: struct buf *bp;
628: {
629:
630: if (bp->b_bcount > ((ASC_MAX_SG_LIST - 1) * PAGE_SIZE))
631: bp->b_bcount = ((ASC_MAX_SG_LIST - 1) * PAGE_SIZE);
632: minphys(bp);
633: }
634:
635:
636: /*
637: * start a scsi operation given the command and the data address. Also needs
638: * the unit, target and lu.
639: */
640: static int
641: adv_scsi_cmd(xs)
642: struct scsi_xfer *xs;
643: {
644: struct scsi_link *sc_link = xs->sc_link;
645: ASC_SOFTC *sc = sc_link->adapter_softc;
646: bus_dma_tag_t dmat = sc->sc_dmat;
647: ADV_CCB *ccb;
648: int s, flags, error, nsegs;
649: int fromqueue = 1, dontqueue = 0;
650:
651:
652: s = splbio(); /* protect the queue */
653:
654: /*
655: * If we're running the queue from adv_done(), we've been
656: * called with the first queue entry as our argument.
657: */
658: if (xs == LIST_FIRST(&sc->sc_queue)) {
659: xs = adv_dequeue(sc);
660: fromqueue = 1;
661: } else {
662:
663: /* Polled requests can't be queued for later. */
664: dontqueue = xs->flags & SCSI_POLL;
665:
666: /*
667: * If there are jobs in the queue, run them first.
668: */
669: if (!LIST_EMPTY(&sc->sc_queue)) {
670: /*
671: * If we can't queue, we have to abort, since
672: * we have to preserve order.
673: */
674: if (dontqueue) {
675: splx(s);
676: return (TRY_AGAIN_LATER);
677: }
678: /*
679: * Swap with the first queue entry.
680: */
681: adv_enqueue(sc, xs, 0);
682: xs = adv_dequeue(sc);
683: fromqueue = 1;
684: }
685: }
686:
687:
688: /*
689: * get a ccb to use. If the transfer
690: * is from a buf (possibly from interrupt time)
691: * then we can't allow it to sleep
692: */
693:
694: flags = xs->flags;
695: if ((ccb = adv_get_ccb(sc, flags)) == NULL) {
696: /*
697: * If we can't queue, we lose.
698: */
699: if (dontqueue) {
700: splx(s);
701: return (TRY_AGAIN_LATER);
702: }
703: /*
704: * Stuff ourselves into the queue, in front
705: * if we came off in the first place.
706: */
707: adv_enqueue(sc, xs, fromqueue);
708: splx(s);
709: return (SUCCESSFULLY_QUEUED);
710: }
711: splx(s); /* done playing with the queue */
712:
713: ccb->xs = xs;
714: ccb->timeout = xs->timeout;
715:
716: /*
717: * Build up the request
718: */
719: memset(&ccb->scsiq, 0, sizeof(ASC_SCSI_Q));
720:
721: ccb->scsiq.q2.ccb_ptr = (ulong) ccb;
722:
723: ccb->scsiq.cdbptr = &xs->cmd->opcode;
724: ccb->scsiq.q2.cdb_len = xs->cmdlen;
725: ccb->scsiq.q1.target_id = ASC_TID_TO_TARGET_ID(sc_link->target);
726: ccb->scsiq.q1.target_lun = sc_link->lun;
727: ccb->scsiq.q2.target_ix = ASC_TIDLUN_TO_IX(sc_link->target,
728: sc_link->lun);
729: ccb->scsiq.q1.sense_addr = sc->sc_dmamap_control->dm_segs[0].ds_addr +
730: ADV_CCB_OFF(ccb) + offsetof(struct adv_ccb, scsi_sense);
731: ccb->scsiq.q1.sense_len = sizeof(struct scsi_sense_data);
732:
733: /*
734: * If there are any outstanding requests for the current target,
735: * then every 255th request send an ORDERED request. This heuristic
736: * tries to retain the benefit of request sorting while preventing
737: * request starvation. 255 is the max number of tags or pending commands
738: * a device may have outstanding.
739: */
740: sc->reqcnt[sc_link->target]++;
741: if ((sc->reqcnt[sc_link->target] > 0) &&
742: (sc->reqcnt[sc_link->target] % 255) == 0) {
743: ccb->scsiq.q2.tag_code = M2_QTAG_MSG_ORDERED;
744: } else {
745: ccb->scsiq.q2.tag_code = M2_QTAG_MSG_SIMPLE;
746: }
747:
748:
749: if (xs->datalen) {
750: /*
751: * Map the DMA transfer.
752: */
753: #ifdef TFS
754: if (flags & SCSI_DATA_UIO) {
755: error = bus_dmamap_load_uio(dmat,
756: ccb->dmamap_xfer, (struct uio *) xs->data,
757: (flags & SCSI_NOSLEEP) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
758: } else
759: #endif /* TFS */
760: {
761: error = bus_dmamap_load(dmat,
762: ccb->dmamap_xfer, xs->data, xs->datalen, NULL,
763: (flags & SCSI_NOSLEEP) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
764: }
765:
766: if (error) {
767: if (error == EFBIG) {
768: printf("%s: adv_scsi_cmd, more than %d dma"
769: " segments\n",
770: sc->sc_dev.dv_xname, ASC_MAX_SG_LIST);
771: } else {
772: printf("%s: adv_scsi_cmd, error %d loading"
773: " dma map\n",
774: sc->sc_dev.dv_xname, error);
775: }
776:
777: xs->error = XS_DRIVER_STUFFUP;
778: adv_free_ccb(sc, ccb);
779: return (COMPLETE);
780: }
781: bus_dmamap_sync(dmat, ccb->dmamap_xfer,
782: 0, ccb->dmamap_xfer->dm_mapsize,
783: ((flags & SCSI_DATA_IN) ? BUS_DMASYNC_PREREAD :
784: BUS_DMASYNC_PREWRITE));
785:
786:
787: memset(&ccb->sghead, 0, sizeof(ASC_SG_HEAD));
788:
789: for (nsegs = 0; nsegs < ccb->dmamap_xfer->dm_nsegs; nsegs++) {
790:
791: ccb->sghead.sg_list[nsegs].addr =
792: ccb->dmamap_xfer->dm_segs[nsegs].ds_addr;
793: ccb->sghead.sg_list[nsegs].bytes =
794: ccb->dmamap_xfer->dm_segs[nsegs].ds_len;
795: }
796:
797: ccb->sghead.entry_cnt = ccb->scsiq.q1.sg_queue_cnt =
798: ccb->dmamap_xfer->dm_nsegs;
799:
800: ccb->scsiq.q1.cntl |= ASC_QC_SG_HEAD;
801: ccb->scsiq.sg_head = &ccb->sghead;
802: ccb->scsiq.q1.data_addr = 0;
803: ccb->scsiq.q1.data_cnt = 0;
804: } else {
805: /*
806: * No data xfer, use non S/G values.
807: */
808: ccb->scsiq.q1.data_addr = 0;
809: ccb->scsiq.q1.data_cnt = 0;
810: }
811:
812: #ifdef ASC_DEBUG
813: printf("id = %d, lun = %d, cmd = %d, ccb = 0x%lX \n",
814: sc_link->scsipi_scsi.target,
815: sc_link->scsipi_scsi.lun, xs->cmd->opcode,
816: (unsigned long)ccb);
817: #endif
818: s = splbio();
819: adv_queue_ccb(sc, ccb);
820: splx(s);
821:
822: /*
823: * Usually return SUCCESSFULLY QUEUED
824: */
825: if ((flags & SCSI_POLL) == 0)
826: return (SUCCESSFULLY_QUEUED);
827:
828: /*
829: * If we can't use interrupts, poll on completion
830: */
831: if (adv_poll(sc, xs, ccb->timeout)) {
832: adv_timeout(ccb);
833: if (adv_poll(sc, xs, ccb->timeout))
834: adv_timeout(ccb);
835: }
836: return (COMPLETE);
837: }
838:
839:
840: int
841: adv_intr(arg)
842: void *arg;
843: {
844: ASC_SOFTC *sc = arg;
845: struct scsi_xfer *xs;
846:
847: #ifdef ASC_DEBUG
848: int int_pend = FALSE;
849:
850: if(ASC_IS_INT_PENDING(sc->sc_iot, sc->sc_ioh))
851: {
852: int_pend = TRUE;
853: printf("ISR - ");
854: }
855: #endif
856: AscISR(sc);
857: #ifdef ASC_DEBUG
858: if(int_pend)
859: printf("\n");
860: #endif
861:
862: /*
863: * If there are queue entries in the software queue, try to
864: * run the first one. We should be more or less guaranteed
865: * to succeed, since we just freed a CCB.
866: *
867: * NOTE: adv_scsi_cmd() relies on our calling it with
868: * the first entry in the queue.
869: */
870: if ((xs = LIST_FIRST(&sc->sc_queue)) != NULL)
871: (void) adv_scsi_cmd(xs);
872:
873: return (1);
874: }
875:
876:
877: /*
878: * Poll a particular unit, looking for a particular xs
879: */
880: static int
881: adv_poll(sc, xs, count)
882: ASC_SOFTC *sc;
883: struct scsi_xfer *xs;
884: int count;
885: {
886:
887: /* timeouts are in msec, so we loop in 1000 usec cycles */
888: while (count) {
889: adv_intr(sc);
890: if (xs->flags & ITSDONE)
891: return (0);
892: delay(1000); /* only happens in boot so ok */
893: count--;
894: }
895: return (1);
896: }
897:
898:
899: static void
900: adv_timeout(arg)
901: void *arg;
902: {
903: ADV_CCB *ccb = arg;
904: struct scsi_xfer *xs = ccb->xs;
905: struct scsi_link *sc_link = xs->sc_link;
906: ASC_SOFTC *sc = sc_link->adapter_softc;
907: int s;
908:
909: sc_print_addr(sc_link);
910: printf("timed out");
911:
912: s = splbio();
913:
914: /*
915: * If it has been through before, then a previous abort has failed,
916: * don't try abort again, reset the bus instead.
917: */
918: if (ccb->flags & CCB_ABORT) {
919: /* abort timed out */
920: printf(" AGAIN. Resetting Bus\n");
921: /* Lets try resetting the bus! */
922: if (AscResetBus(sc) == ASC_ERROR) {
923: ccb->timeout = sc->scsi_reset_wait;
924: adv_queue_ccb(sc, ccb);
925: }
926: } else {
927: /* abort the operation that has timed out */
928: printf("\n");
929: AscAbortCCB(sc, (u_int32_t) ccb);
930: ccb->xs->error = XS_TIMEOUT;
931: ccb->timeout = ADV_ABORT_TIMEOUT;
932: ccb->flags |= CCB_ABORT;
933: adv_queue_ccb(sc, ccb);
934: }
935:
936: splx(s);
937: }
938:
939:
940: static void
941: adv_watchdog(arg)
942: void *arg;
943: {
944: ADV_CCB *ccb = arg;
945: struct scsi_xfer *xs = ccb->xs;
946: struct scsi_link *sc_link = xs->sc_link;
947: ASC_SOFTC *sc = sc_link->adapter_softc;
948: int s;
949:
950: s = splbio();
951:
952: ccb->flags &= ~CCB_WATCHDOG;
953: adv_start_ccbs(sc);
954:
955: splx(s);
956: }
957:
958:
959: /******************************************************************************/
960: /* NARROW and WIDE boards Interrupt callbacks */
961: /******************************************************************************/
962:
963:
964: /*
965: * adv_narrow_isr_callback() - Second Level Interrupt Handler called by AscISR()
966: *
967: * Interrupt callback function for the Narrow SCSI Asc Library.
968: */
969: static void
970: adv_narrow_isr_callback(sc, qdonep)
971: ASC_SOFTC *sc;
972: ASC_QDONE_INFO *qdonep;
973: {
974: bus_dma_tag_t dmat = sc->sc_dmat;
975: ADV_CCB *ccb = (ADV_CCB *) qdonep->d2.ccb_ptr;
976: struct scsi_xfer *xs = ccb->xs;
977: struct scsi_sense_data *s1, *s2;
978:
979:
980: #ifdef ASC_DEBUG
981: printf(" - ccb=0x%lx, id=%d, lun=%d, cmd=%d, ",
982: (unsigned long)ccb,
983: xs->sc_link->scsipi_scsi.target,
984: xs->sc_link->scsipi_scsi.lun, xs->cmd->opcode);
985: #endif
986: timeout_del(&xs->stimeout);
987:
988: /*
989: * If we were a data transfer, unload the map that described
990: * the data buffer.
991: */
992: if (xs->datalen) {
993: bus_dmamap_sync(dmat, ccb->dmamap_xfer,
994: 0, ccb->dmamap_xfer->dm_mapsize,
995: ((xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_POSTREAD :
996: BUS_DMASYNC_POSTWRITE));
997: bus_dmamap_unload(dmat, ccb->dmamap_xfer);
998: }
999: if ((ccb->flags & CCB_ALLOC) == 0) {
1000: printf("%s: exiting ccb not allocated!\n", sc->sc_dev.dv_xname);
1001: Debugger();
1002: return;
1003: }
1004: /*
1005: * 'qdonep' contains the command's ending status.
1006: */
1007: #ifdef ASC_DEBUG
1008: printf("d_s=%d, h_s=%d", qdonep->d3.done_stat, qdonep->d3.host_stat);
1009: #endif
1010: switch (qdonep->d3.done_stat) {
1011: case ASC_QD_NO_ERROR:
1012: switch (qdonep->d3.host_stat) {
1013: case ASC_QHSTA_NO_ERROR:
1014: xs->error = XS_NOERROR;
1015: xs->resid = 0;
1016: break;
1017:
1018: default:
1019: /* QHSTA error occurred */
1020: xs->error = XS_DRIVER_STUFFUP;
1021: break;
1022: }
1023:
1024: /*
1025: * If an INQUIRY command completed successfully, then call
1026: * the AscInquiryHandling() function to patch bugged boards.
1027: */
1028: if ((xs->cmd->opcode == SCSICMD_Inquiry) &&
1029: (xs->sc_link->lun == 0) &&
1030: (xs->datalen - qdonep->remain_bytes) >= 8) {
1031: AscInquiryHandling(sc,
1032: xs->sc_link->target & 0x7,
1033: (ASC_SCSI_INQUIRY *) xs->data);
1034: }
1035: break;
1036:
1037: case ASC_QD_WITH_ERROR:
1038: switch (qdonep->d3.host_stat) {
1039: case ASC_QHSTA_NO_ERROR:
1040: if (qdonep->d3.scsi_stat == SS_CHK_CONDITION) {
1041: s1 = &ccb->scsi_sense;
1042: s2 = &xs->sense;
1043: *s2 = *s1;
1044: xs->error = XS_SENSE;
1045: } else {
1046: xs->error = XS_DRIVER_STUFFUP;
1047: }
1048: break;
1049:
1050: default:
1051: /* QHSTA error occurred */
1052: xs->error = XS_DRIVER_STUFFUP;
1053: break;
1054: }
1055: break;
1056:
1057: case ASC_QD_ABORTED_BY_HOST:
1058: default:
1059: xs->error = XS_DRIVER_STUFFUP;
1060: break;
1061: }
1062:
1063:
1064: adv_free_ccb(sc, ccb);
1065: xs->flags |= ITSDONE;
1066: scsi_done(xs);
1067: }