![[BACK]](/icons/back.gif){kind=icon}
Return to aha.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa|
Return to aha.c CVS log | Up to [local] / sys / dev / isa |
1.1 nbrk 1: /* $OpenBSD: aha.c,v 1.57 2007/08/15 02:04:30 krw Exp $ */
2: /* $NetBSD: aha.c,v 1.11 1996/05/12 23:51:23 mycroft Exp $ */
3:
4: #undef AHADIAG
5:
6: /*
7: * Copyright (c) 1994, 1996 Charles M. Hannum. All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Charles M. Hannum.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33: */
34:
35: /*
36: * Originally written by Julian Elischer (julian@tfs.com)
37: * for TRW Financial Systems for use under the MACH(2.5) operating system.
38: *
39: * TRW Financial Systems, in accordance with their agreement with Carnegie
40: * Mellon University, makes this software available to CMU to distribute
41: * or use in any manner that they see fit as long as this message is kept with
42: * the software. For this reason TFS also grants any other persons or
43: * organisations permission to use or modify this software.
44: *
45: * TFS supplies this software to be publicly redistributed
46: * on the understanding that TFS is not responsible for the correct
47: * functioning of this software in any circumstances.
48: */
49:
50: #include <sys/types.h>
51: #include <sys/param.h>
52: #include <sys/systm.h>
53: #include <sys/kernel.h>
54: #include <sys/errno.h>
55: #include <sys/ioctl.h>
56: #include <sys/device.h>
57: #include <sys/malloc.h>
58: #include <sys/buf.h>
59: #include <sys/proc.h>
60: #include <sys/user.h>
61: #include <sys/timeout.h>
62:
63: #include <uvm/uvm.h>
64: #include <uvm/uvm_extern.h>
65:
66: #include <machine/intr.h>
67: #include <machine/bus.h>
68:
69: #include <scsi/scsi_all.h>
70: #include <scsi/scsiconf.h>
71:
72: #include <dev/isa/isavar.h>
73: #include <dev/isa/isadmavar.h>
74: #include <dev/isa/ahareg.h>
75:
76: #ifndef DDB
77: #define Debugger() panic("should call debugger here (aha1542.c)")
78: #endif /* ! DDB */
79:
80: /* XXX fixme:
81: * on i386 at least, xfers to/from user memory
82: * cannot be serviced at interrupt time.
83: */
84: #ifdef i386
85: #define VOLATILE_XS(xs) \
86: ((xs)->datalen > 0 && (xs)->bp == NULL && \
87: ((xs)->flags & SCSI_POLL) == 0)
88: #else
89: #define VOLATILE_XS(xs) 0
90: #endif
91:
92: /*
93: * Mail box defs etc.
94: * these could be bigger but we need the aha_softc to fit on a single page..
95: */
96: #define AHA_MBX_SIZE 16 /* mail box size */
97:
98: #define AHA_CCB_MAX 16 /* store up to 32 CCBs at one time */
99: #define CCB_HASH_SIZE 16 /* hash table size for phystokv */
100: #define CCB_HASH_SHIFT 9
101: #define CCB_HASH(x) ((((long)(x))>>CCB_HASH_SHIFT) & (CCB_HASH_SIZE - 1))
102:
103: #define aha_nextmbx(wmb, mbx, mbio) \
104: if ((wmb) == &(mbx)->mbio[AHA_MBX_SIZE - 1]) \
105: (wmb) = &(mbx)->mbio[0]; \
106: else \
107: (wmb)++;
108:
109: struct aha_mbx {
110: struct aha_mbx_out mbo[AHA_MBX_SIZE];
111: struct aha_mbx_in mbi[AHA_MBX_SIZE];
112: struct aha_mbx_out *cmbo; /* Collection Mail Box out */
113: struct aha_mbx_out *tmbo; /* Target Mail Box out */
114: struct aha_mbx_in *tmbi; /* Target Mail Box in */
115: };
116:
117: struct aha_softc {
118: struct device sc_dev;
119: struct isadev sc_id;
120: void *sc_ih;
121: bus_dma_tag_t sc_dmat;
122:
123: int sc_iobase;
124: int sc_irq, sc_drq;
125:
126: char sc_model[18],
127: sc_firmware[4];
128:
129: struct aha_mbx *sc_mbx; /* all the mailboxes */
130: #define wmbx (sc->sc_mbx)
131: struct aha_ccb *sc_ccbhash[CCB_HASH_SIZE];
132: TAILQ_HEAD(, aha_ccb) sc_free_ccb, sc_waiting_ccb;
133: int sc_numccbs, sc_mbofull;
134: int sc_scsi_dev; /* our scsi id */
135: struct scsi_link sc_link;
136: };
137:
138: #ifdef AHADEBUG
139: int aha_debug = 1;
140: #endif /* AHADEBUG */
141:
142: int aha_cmd(int, struct aha_softc *, int, u_char *, int, u_char *);
143: void aha_finish_ccbs(struct aha_softc *);
144: int ahaintr(void *);
145: void aha_reset_ccb(struct aha_softc *, struct aha_ccb *);
146: void aha_free_ccb(struct aha_softc *, struct aha_ccb *);
147: int aha_init_ccb(struct aha_softc *, struct aha_ccb *, int);
148: struct aha_ccb *aha_get_ccb(struct aha_softc *, int);
149: struct aha_ccb *aha_ccb_phys_kv(struct aha_softc *, u_long);
150: void aha_queue_ccb(struct aha_softc *, struct aha_ccb *);
151: void aha_collect_mbo(struct aha_softc *);
152: void aha_start_ccbs(struct aha_softc *);
153: void aha_done(struct aha_softc *, struct aha_ccb *);
154: int aha_find(struct isa_attach_args *, struct aha_softc *, int);
155: void aha_init(struct aha_softc *);
156: void aha_inquire_setup_information(struct aha_softc *);
157: void ahaminphys(struct buf *);
158: int aha_scsi_cmd(struct scsi_xfer *);
159: int aha_poll(struct aha_softc *, struct scsi_xfer *, int);
160: void aha_timeout(void *arg);
161:
162: struct scsi_adapter aha_switch = {
163: aha_scsi_cmd,
164: ahaminphys,
165: 0,
166: 0,
167: };
168:
169: /* the below structure is so we have a default dev struct for out link struct */
170: struct scsi_device aha_dev = {
171: NULL, /* Use default error handler */
172: NULL, /* have a queue, served by this */
173: NULL, /* have no async handler */
174: NULL, /* Use default 'done' routine */
175: };
176:
177: int aha_isapnp_probe(struct device *, void *, void *);
178: int ahaprobe(struct device *, void *, void *);
179: void ahaattach(struct device *, struct device *, void *);
180:
181: struct cfattach aha_isapnp_ca = {
182: sizeof(struct aha_softc), aha_isapnp_probe, ahaattach
183: };
184:
185: struct cfattach aha_isa_ca = {
186: sizeof(struct aha_softc), ahaprobe, ahaattach
187: };
188:
189: struct cfdriver aha_cd = {
190: NULL, "aha", DV_DULL
191: };
192:
193: #define AHA_RESET_TIMEOUT 2000 /* time to wait for reset (mSec) */
194: #define AHA_ABORT_TIMEOUT 2000 /* time to wait for abort (mSec) */
195:
196: #include "bha.h"
197:
198: /*
199: * aha_cmd(iobase, sc, icnt, ibuf, ocnt, obuf)
200: *
201: * Activate Adapter command
202: * icnt: number of args (outbound bytes including opcode)
203: * ibuf: argument buffer
204: * ocnt: number of expected returned bytes
205: * obuf: result buffer
206: * wait: number of seconds to wait for response
207: *
208: * Performs an adapter command through the ports. Not to be confused with a
209: * scsi command, which is read in via the dma; one of the adapter commands
210: * tells it to read in a scsi command.
211: */
212: int
213: aha_cmd(iobase, sc, icnt, ibuf, ocnt, obuf)
214: int iobase;
215: struct aha_softc *sc;
216: int icnt, ocnt;
217: u_char *ibuf, *obuf;
218: {
219: const char *name;
220: register int i;
221: int wait;
222: u_char sts;
223: u_char opcode = ibuf[0];
224:
225: if (sc != NULL)
226: name = sc->sc_dev.dv_xname;
227: else
228: name = "(aha probe)";
229:
230: /*
231: * Calculate a reasonable timeout for the command.
232: */
233: switch (opcode) {
234: case AHA_INQUIRE_DEVICES:
235: wait = 15 * 20000;
236: break;
237: default:
238: wait = 1 * 20000;
239: break;
240: }
241:
242: /*
243: * Wait for the adapter to go idle, unless it's one of
244: * the commands which don't need this
245: */
246: if (opcode != AHA_MBO_INTR_EN) {
247: for (i = 20000; i; i--) { /* 1 sec? */
248: sts = inb(iobase + AHA_STAT_PORT);
249: if (sts & AHA_STAT_IDLE)
250: break;
251: delay(50);
252: }
253: if (!i) {
254: printf("%s: aha_cmd, host not idle(0x%x)\n",
255: name, sts);
256: return (ENXIO);
257: }
258: }
259: /*
260: * Now that it is idle, if we expect output, preflush the
261: * queue feeding to us.
262: */
263: if (ocnt) {
264: while ((inb(iobase + AHA_STAT_PORT)) & AHA_STAT_DF)
265: inb(iobase + AHA_DATA_PORT);
266: }
267: /*
268: * Output the command and the number of arguments given
269: * for each byte, first check the port is empty.
270: */
271: while (icnt--) {
272: for (i = wait; i; i--) {
273: sts = inb(iobase + AHA_STAT_PORT);
274: if (!(sts & AHA_STAT_CDF))
275: break;
276: delay(50);
277: }
278: if (!i) {
279: if (opcode != AHA_INQUIRE_REVISION)
280: printf("%s: aha_cmd, cmd/data port full\n",
281: name);
282: outb(iobase + AHA_CTRL_PORT, AHA_CTRL_SRST);
283: return (ENXIO);
284: }
285: outb(iobase + AHA_CMD_PORT, *ibuf++);
286: }
287: /*
288: * If we expect input, loop that many times, each time,
289: * looking for the data register to have valid data
290: */
291: while (ocnt--) {
292: for (i = wait; i; i--) {
293: sts = inb(iobase + AHA_STAT_PORT);
294: if (sts & AHA_STAT_DF)
295: break;
296: delay(50);
297: }
298: if (!i) {
299: if (opcode != AHA_INQUIRE_REVISION)
300: printf("%s: aha_cmd, cmd/data port empty %d\n",
301: name, ocnt);
302: outb(iobase + AHA_CTRL_PORT, AHA_CTRL_SRST);
303: return (ENXIO);
304: }
305: *obuf++ = inb(iobase + AHA_DATA_PORT);
306: }
307: /*
308: * Wait for the board to report a finished instruction.
309: * We may get an extra interrupt for the HACC signal, but this is
310: * unimportant.
311: */
312: if (opcode != AHA_MBO_INTR_EN) {
313: for (i = 20000; i; i--) { /* 1 sec? */
314: sts = inb(iobase + AHA_INTR_PORT);
315: /* XXX Need to save this in the interrupt handler? */
316: if (sts & AHA_INTR_HACC)
317: break;
318: delay(50);
319: }
320: if (!i) {
321: printf("%s: aha_cmd, host not finished(0x%x)\n",
322: name, sts);
323: return (ENXIO);
324: }
325: }
326: outb(iobase + AHA_CTRL_PORT, AHA_CTRL_IRST);
327: return (0);
328: }
329:
330: int
331: aha_isapnp_probe(parent, match, aux)
332: struct device *parent;
333: void *match, *aux;
334: {
335: return (1);
336: }
337:
338:
339: /*
340: * Check if the device can be found at the port given
341: * and if so, set it up ready for further work
342: * as an argument, takes the isa_device structure from
343: * autoconf.c
344: */
345: int
346: ahaprobe(parent, match, aux)
347: struct device *parent;
348: void *match, *aux;
349: {
350: register struct isa_attach_args *ia = aux;
351: #if NBHA > 0
352: extern int btports[], nbtports;
353: int i;
354:
355: for (i = 0; i < nbtports; i++)
356: if (btports[i] == ia->ia_iobase)
357: return (0);
358: #endif
359:
360: /* See if there is a unit at this location. */
361: if (aha_find(ia, NULL, 0) != 0)
362: return (0);
363:
364: ia->ia_msize = 0;
365: ia->ia_iosize = 4;
366: /* IRQ and DRQ set by aha_find(). */
367: return (1);
368: }
369:
370: /*
371: * Attach all the sub-devices we can find
372: */
373: void
374: ahaattach(parent, self, aux)
375: struct device *parent, *self;
376: void *aux;
377: {
378: struct isa_attach_args *ia = aux;
379: struct aha_softc *sc = (void *)self;
380: struct scsibus_attach_args saa;
381: int isapnp = !strcmp(parent->dv_cfdata->cf_driver->cd_name, "isapnp");
382:
383: if (isapnp) {
384: ia->ia_iobase = ia->ipa_io[0].base;
385: isadma_cascade(ia->ia_drq);
386: }
387:
388: if (aha_find(ia, sc, isapnp) != 0)
389: panic("ahaattach: aha_find of %s failed", self->dv_xname);
390: sc->sc_iobase = ia->ia_iobase;
391: sc->sc_dmat = ia->ia_dmat;
392:
393: if (sc->sc_drq != DRQUNK && isapnp == 0)
394: isadma_cascade(sc->sc_drq);
395:
396: aha_inquire_setup_information(sc);
397: aha_init(sc);
398: TAILQ_INIT(&sc->sc_free_ccb);
399: TAILQ_INIT(&sc->sc_waiting_ccb);
400:
401: /*
402: * fill in the prototype scsi_link.
403: */
404: sc->sc_link.adapter_softc = sc;
405: sc->sc_link.adapter_target = sc->sc_scsi_dev;
406: sc->sc_link.adapter = &aha_switch;
407: sc->sc_link.device = &aha_dev;
408: sc->sc_link.openings = 2;
409:
410: bzero(&saa, sizeof(saa));
411: saa.saa_sc_link = &sc->sc_link;
412:
413: sc->sc_ih = isa_intr_establish(ia->ia_ic, sc->sc_irq, IST_EDGE,
414: IPL_BIO, ahaintr, sc, sc->sc_dev.dv_xname);
415:
416: /*
417: * ask the adapter what subunits are present
418: */
419: config_found(self, &saa, scsiprint);
420: }
421:
422: void
423: aha_finish_ccbs(sc)
424: struct aha_softc *sc;
425: {
426: struct aha_mbx_in *wmbi;
427: struct aha_ccb *ccb;
428: int i;
429:
430: wmbi = wmbx->tmbi;
431:
432: if (wmbi->stat == AHA_MBI_FREE) {
433: for (i = 0; i < AHA_MBX_SIZE; i++) {
434: if (wmbi->stat != AHA_MBI_FREE) {
435: printf("%s: mbi not in round-robin order\n",
436: sc->sc_dev.dv_xname);
437: goto AGAIN;
438: }
439: aha_nextmbx(wmbi, wmbx, mbi);
440: }
441: #ifdef AHADIAGnot
442: printf("%s: mbi interrupt with no full mailboxes\n",
443: sc->sc_dev.dv_xname);
444: #endif
445: return;
446: }
447:
448: AGAIN:
449: do {
450: ccb = aha_ccb_phys_kv(sc, phystol(wmbi->ccb_addr));
451: if (!ccb) {
452: printf("%s: bad mbi ccb pointer; skipping\n",
453: sc->sc_dev.dv_xname);
454: goto next;
455: }
456:
457: #ifdef AHADEBUG
458: if (aha_debug) {
459: u_char *cp = (u_char *)&ccb->scsi_cmd;
460: printf("op=%x %x %x %x %x %x\n",
461: cp[0], cp[1], cp[2], cp[3], cp[4], cp[5]);
462: printf("stat %x for mbi addr = 0x%08x, ",
463: wmbi->stat, wmbi);
464: printf("ccb addr = 0x%x\n", ccb);
465: }
466: #endif /* AHADEBUG */
467:
468: switch (wmbi->stat) {
469: case AHA_MBI_OK:
470: case AHA_MBI_ERROR:
471: if ((ccb->flags & CCB_ABORT) != 0) {
472: /*
473: * If we already started an abort, wait for it
474: * to complete before clearing the CCB. We
475: * could instead just clear CCB_SENDING, but
476: * what if the mailbox was already received?
477: * The worst that happens here is that we clear
478: * the CCB a bit later than we need to. BFD.
479: */
480: goto next;
481: }
482: break;
483:
484: case AHA_MBI_ABORT:
485: case AHA_MBI_UNKNOWN:
486: /*
487: * Even if the CCB wasn't found, we clear it anyway.
488: * See preceding comment.
489: */
490: break;
491:
492: default:
493: printf("%s: bad mbi status %02x; skipping\n",
494: sc->sc_dev.dv_xname, wmbi->stat);
495: goto next;
496: }
497:
498: if ((ccb->xs->flags & SCSI_POLL) == 0)
499: timeout_del(&ccb->xs->stimeout);
500: bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmam, 0,
501: ccb->ccb_dmam->dm_mapsize, BUS_DMASYNC_POSTREAD);
502: aha_done(sc, ccb);
503:
504: next:
505: wmbi->stat = AHA_MBI_FREE;
506: aha_nextmbx(wmbi, wmbx, mbi);
507: } while (wmbi->stat != AHA_MBI_FREE);
508:
509: wmbx->tmbi = wmbi;
510: }
511:
512: /*
513: * Catch an interrupt from the adaptor
514: */
515: int
516: ahaintr(arg)
517: void *arg;
518: {
519: struct aha_softc *sc = arg;
520: int iobase = sc->sc_iobase;
521: u_char sts;
522:
523: #ifdef AHADEBUG
524: if (aha_debug)
525: printf("%s: ahaintr ", sc->sc_dev.dv_xname);
526: #endif /*AHADEBUG */
527:
528: /*
529: * First acknowlege the interrupt, Then if it's not telling about
530: * a completed operation just return.
531: */
532: sts = inb(iobase + AHA_INTR_PORT);
533: if ((sts & AHA_INTR_ANYINTR) == 0)
534: return (0);
535: outb(iobase + AHA_CTRL_PORT, AHA_CTRL_IRST);
536:
537: #ifdef AHADIAG
538: /* Make sure we clear CCB_SENDING before finishing a CCB. */
539: aha_collect_mbo(sc);
540: #endif
541:
542: /* Mail box out empty? */
543: if (sts & AHA_INTR_MBOA) {
544: struct aha_toggle toggle;
545:
546: toggle.cmd.opcode = AHA_MBO_INTR_EN;
547: toggle.cmd.enable = 0;
548: aha_cmd(iobase, sc, sizeof(toggle.cmd), (u_char *)&toggle.cmd,
549: 0, (u_char *)0);
550: aha_start_ccbs(sc);
551: }
552:
553: /* Mail box in full? */
554: if (sts & AHA_INTR_MBIF)
555: aha_finish_ccbs(sc);
556:
557: return (1);
558: }
559:
560: void
561: aha_reset_ccb(sc, ccb)
562: struct aha_softc *sc;
563: struct aha_ccb *ccb;
564: {
565:
566: ccb->flags = 0;
567: }
568:
569: /*
570: * A ccb is put onto the free list.
571: */
572: void
573: aha_free_ccb(sc, ccb)
574: struct aha_softc *sc;
575: struct aha_ccb *ccb;
576: {
577: int s, hashnum;
578: struct aha_ccb **hashccb;
579:
580: s = splbio();
581:
582: if (ccb->ccb_dmam->dm_segs[0].ds_addr != 0)
583: bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmam);
584:
585: /* remove from hash table */
586:
587: hashnum = CCB_HASH(ccb->ccb_dmam->dm_segs[0].ds_addr);
588: hashccb = &sc->sc_ccbhash[hashnum];
589:
590: while (*hashccb) {
591: if ((*hashccb)->ccb_dmam->dm_segs[0].ds_addr ==
592: ccb->ccb_dmam->dm_segs[0].ds_addr) {
593: *hashccb = (*hashccb)->nexthash;
594: break;
595: }
596: hashccb = &(*hashccb)->nexthash;
597: }
598:
599: aha_reset_ccb(sc, ccb);
600: TAILQ_INSERT_HEAD(&sc->sc_free_ccb, ccb, chain);
601:
602: /*
603: * If there were none, wake anybody waiting for one to come free,
604: * starting with queued entries.
605: */
606: if (TAILQ_NEXT(ccb, chain) == NULL)
607: wakeup(&sc->sc_free_ccb);
608:
609: splx(s);
610: }
611:
612: int
613: aha_init_ccb(sc, ccb, flags)
614: struct aha_softc *sc;
615: struct aha_ccb *ccb;
616: int flags;
617: {
618: int error, wait, state = 0;
619:
620: bzero(ccb, sizeof(struct aha_ccb));
621: aha_reset_ccb(sc, ccb);
622:
623: wait = (flags & SCSI_NOSLEEP) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK;
624: /* Create a DMA map for the data area. */
625: error = bus_dmamap_create(sc->sc_dmat, MAXPHYS, (MAXPHYS / NBPG) + 1,
626: MAXPHYS, 0, wait | BUS_DMA_ALLOCNOW, &ccb->dmam);
627: if (error)
628: goto fail;
629: state++;
630:
631: /* Create a DMA map for the command control block. */
632: error = bus_dmamap_create(sc->sc_dmat, CCB_PHYS_SIZE, 1, CCB_PHYS_SIZE,
633: 0, wait | BUS_DMA_ALLOCNOW, &ccb->ccb_dmam);
634: if (error)
635: goto fail;
636:
637: return (0);
638:
639: fail:
640: if (state > 0)
641: bus_dmamap_destroy(sc->sc_dmat, ccb->dmam);
642: return (error);
643: }
644:
645: /*
646: * Get a free ccb
647: *
648: * If there are none, see if we can allocate a new one. If so, put it in
649: * the hash table too otherwise either return an error or sleep.
650: */
651: struct aha_ccb *
652: aha_get_ccb(sc, flags)
653: struct aha_softc *sc;
654: int flags;
655: {
656: struct aha_ccb *ccb;
657: int hashnum, s;
658:
659: s = splbio();
660:
661: /*
662: * If we can and have to, sleep waiting for one to come free
663: * but only if we can't allocate a new one.
664: */
665: for (;;) {
666: ccb = TAILQ_FIRST(&sc->sc_free_ccb);
667: if (ccb) {
668: TAILQ_REMOVE(&sc->sc_free_ccb, ccb, chain);
669: break;
670: }
671: if (sc->sc_numccbs < AHA_CCB_MAX) {
672: MALLOC(ccb, struct aha_ccb *, sizeof *ccb, M_DEVBUF,
673: (flags & SCSI_NOSLEEP) ? M_NOWAIT : M_WAITOK);
674: if (ccb == NULL) {
675: printf("%s: can't malloc ccb\n",
676: sc->sc_dev.dv_xname);
677: goto out;
678: }
679: if (aha_init_ccb(sc, ccb, flags) == 0) {
680: sc->sc_numccbs++;
681: break;
682: }
683: FREE(ccb, M_DEVBUF);
684: ccb = NULL;
685: }
686: if (flags & SCSI_NOSLEEP)
687: goto out;
688: tsleep(&sc->sc_free_ccb, PRIBIO, "ahaccb", 0);
689: }
690:
691: ccb->flags |= CCB_ALLOC;
692:
693: if (bus_dmamap_load(sc->sc_dmat, ccb->ccb_dmam, ccb, CCB_PHYS_SIZE,
694: NULL, BUS_DMA_NOWAIT) != 0) {
695: aha_free_ccb(sc, ccb);
696: ccb = NULL;
697: } else {
698: hashnum = CCB_HASH(ccb->ccb_dmam->dm_segs[0].ds_addr);
699: ccb->nexthash = sc->sc_ccbhash[hashnum];
700: sc->sc_ccbhash[hashnum] = ccb;
701: }
702: out:
703: splx(s);
704: return (ccb);
705: }
706:
707: /*
708: * Given a physical address, find the ccb that it corresponds to.
709: */
710: struct aha_ccb *
711: aha_ccb_phys_kv(sc, ccb_phys)
712: struct aha_softc *sc;
713: u_long ccb_phys;
714: {
715: int hashnum = CCB_HASH(ccb_phys);
716: struct aha_ccb *ccb = sc->sc_ccbhash[hashnum];
717:
718: while (ccb) {
719: if (ccb->ccb_dmam->dm_segs[0].ds_addr == ccb_phys)
720: break;
721: ccb = ccb->nexthash;
722: }
723: return (ccb);
724: }
725:
726: /*
727: * Queue a CCB to be sent to the controller, and send it if possible.
728: */
729: void
730: aha_queue_ccb(sc, ccb)
731: struct aha_softc *sc;
732: struct aha_ccb *ccb;
733: {
734:
735: TAILQ_INSERT_TAIL(&sc->sc_waiting_ccb, ccb, chain);
736: aha_start_ccbs(sc);
737: }
738:
739: /*
740: * Garbage collect mailboxes that are no longer in use.
741: */
742: void
743: aha_collect_mbo(sc)
744: struct aha_softc *sc;
745: {
746: struct aha_mbx_out *wmbo; /* Mail Box Out pointer */
747: #ifdef AHADIAG
748: struct aha_ccb *ccb;
749: #endif
750:
751: wmbo = wmbx->cmbo;
752:
753: while (sc->sc_mbofull > 0) {
754: if (wmbo->cmd != AHA_MBO_FREE)
755: break;
756:
757: #ifdef AHADIAG
758: ccb = aha_ccb_phys_kv(sc, phystol(wmbo->ccb_addr));
759: if (!ccb) {
760: printf("%s: bad mbo ccb pointer; skipping\n",
761: sc->sc_dev.dv_xname);
762: } else
763: ccb->flags &= ~CCB_SENDING;
764: #endif
765:
766: --sc->sc_mbofull;
767: aha_nextmbx(wmbo, wmbx, mbo);
768: }
769:
770: wmbx->cmbo = wmbo;
771: }
772:
773: /*
774: * Send as many CCBs as we have empty mailboxes for.
775: */
776: void
777: aha_start_ccbs(sc)
778: struct aha_softc *sc;
779: {
780: int iobase = sc->sc_iobase;
781: struct aha_mbx_out *wmbo; /* Mail Box Out pointer */
782: struct aha_ccb *ccb;
783:
784: wmbo = wmbx->tmbo;
785:
786: while ((ccb = TAILQ_FIRST(&sc->sc_waiting_ccb)) != NULL) {
787: if (sc->sc_mbofull >= AHA_MBX_SIZE) {
788: aha_collect_mbo(sc);
789: if (sc->sc_mbofull >= AHA_MBX_SIZE) {
790: struct aha_toggle toggle;
791:
792: toggle.cmd.opcode = AHA_MBO_INTR_EN;
793: toggle.cmd.enable = 1;
794: aha_cmd(iobase, sc, sizeof(toggle.cmd),
795: (u_char *)&toggle.cmd, 0, (u_char *)0);
796: break;
797: }
798: }
799:
800: TAILQ_REMOVE(&sc->sc_waiting_ccb, ccb, chain);
801: #ifdef AHADIAG
802: ccb->flags |= CCB_SENDING;
803: #endif
804:
805: /* Link ccb to mbo. */
806: bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmam, 0,
807: ccb->ccb_dmam->dm_mapsize, BUS_DMASYNC_PREWRITE);
808: ltophys(ccb->ccb_dmam->dm_segs[0].ds_addr, wmbo->ccb_addr);
809: if (ccb->flags & CCB_ABORT)
810: wmbo->cmd = AHA_MBO_ABORT;
811: else
812: wmbo->cmd = AHA_MBO_START;
813:
814: /* Tell the card to poll immediately. */
815: outb(iobase + AHA_CMD_PORT, AHA_START_SCSI);
816:
817: if ((ccb->xs->flags & SCSI_POLL) == 0) {
818: timeout_set(&ccb->xs->stimeout, aha_timeout, ccb);
819: timeout_add(&ccb->xs->stimeout, (ccb->timeout * hz) / 1000);
820: }
821:
822: ++sc->sc_mbofull;
823: aha_nextmbx(wmbo, wmbx, mbo);
824: }
825:
826: wmbx->tmbo = wmbo;
827: }
828:
829: /*
830: * We have a ccb which has been processed by the
831: * adaptor, now we look to see how the operation
832: * went. Wake up the owner if waiting
833: */
834: void
835: aha_done(sc, ccb)
836: struct aha_softc *sc;
837: struct aha_ccb *ccb;
838: {
839: struct scsi_sense_data *s1, *s2;
840: struct scsi_xfer *xs = ccb->xs;
841:
842: SC_DEBUG(xs->sc_link, SDEV_DB2, ("aha_done\n"));
843: /*
844: * Otherwise, put the results of the operation
845: * into the xfer and call whoever started it
846: */
847: #ifdef AHADIAG
848: if (ccb->flags & CCB_SENDING) {
849: printf("%s: exiting ccb still in transit!\n",
850: sc->sc_dev.dv_xname);
851: Debugger();
852: return;
853: }
854: #endif
855: if ((ccb->flags & CCB_ALLOC) == 0) {
856: printf("%s: exiting ccb not allocated!\n",
857: sc->sc_dev.dv_xname);
858: Debugger();
859: return;
860: }
861: if (xs->error == XS_NOERROR) {
862: if (ccb->host_stat != AHA_OK) {
863: switch (ccb->host_stat) {
864: case AHA_SEL_TIMEOUT: /* No response */
865: xs->error = XS_SELTIMEOUT;
866: break;
867: default: /* Other scsi protocol messes */
868: printf("%s: host_stat %x\n",
869: sc->sc_dev.dv_xname, ccb->host_stat);
870: xs->error = XS_DRIVER_STUFFUP;
871: break;
872: }
873: } else if (ccb->target_stat != SCSI_OK) {
874: switch (ccb->target_stat) {
875: case SCSI_CHECK:
876: s1 = (struct scsi_sense_data *)
877: (((char *)(&ccb->scsi_cmd)) +
878: ccb->scsi_cmd_length);
879: s2 = &xs->sense;
880: *s2 = *s1;
881: xs->error = XS_SENSE;
882: break;
883: case SCSI_BUSY:
884: xs->error = XS_BUSY;
885: break;
886: default:
887: printf("%s: target_stat %x\n",
888: sc->sc_dev.dv_xname, ccb->target_stat);
889: xs->error = XS_DRIVER_STUFFUP;
890: break;
891: }
892: } else
893: xs->resid = 0;
894: }
895: xs->flags |= ITSDONE;
896:
897: if (VOLATILE_XS(xs)) {
898: wakeup(ccb);
899: return;
900: }
901:
902: if (ccb->dmam->dm_nsegs > 0) {
903: if (xs->flags & SCSI_DATA_IN)
904: bus_dmamap_sync(sc->sc_dmat, ccb->dmam, 0,
905: ccb->dmam->dm_mapsize, BUS_DMASYNC_POSTREAD);
906: if (xs->flags & SCSI_DATA_OUT)
907: bus_dmamap_sync(sc->sc_dmat, ccb->dmam, 0,
908: ccb->dmam->dm_mapsize, BUS_DMASYNC_POSTWRITE);
909: bus_dmamap_unload(sc->sc_dmat, ccb->dmam);
910: }
911: aha_free_ccb(sc, ccb);
912: scsi_done(xs);
913: }
914:
915: /*
916: * Find the board and find its irq/drq
917: */
918: int
919: aha_find(ia, sc, isapnp)
920: struct isa_attach_args *ia;
921: struct aha_softc *sc;
922: int isapnp;
923: {
924: int iobase = ia->ia_iobase;
925: int i;
926: u_char sts;
927: struct aha_config config;
928: int irq, drq;
929:
930: /*
931: * reset board, If it doesn't respond, assume
932: * that it's not there.. good for the probe
933: */
934:
935: outb(iobase + AHA_CTRL_PORT, AHA_CTRL_HRST | AHA_CTRL_SRST);
936:
937: delay(100);
938: for (i = AHA_RESET_TIMEOUT; i; i--) {
939: sts = inb(iobase + AHA_STAT_PORT);
940: if (sts == (AHA_STAT_IDLE | AHA_STAT_INIT))
941: break;
942: delay(1000); /* calibrated in msec */
943: }
944: if (!i) {
945: #ifdef AHADEBUG
946: if (aha_debug)
947: printf("aha_find: No answer from adaptec board\n");
948: #endif /* AHADEBUG */
949: return (1);
950: }
951:
952: /*
953: * setup dma channel from jumpers and save int
954: * level
955: */
956: delay(1000); /* for Bustek 545 */
957: config.cmd.opcode = AHA_INQUIRE_CONFIG;
958: aha_cmd(iobase, sc, sizeof(config.cmd), (u_char *)&config.cmd,
959: sizeof(config.reply), (u_char *)&config.reply);
960: switch (config.reply.chan) {
961: case EISADMA:
962: drq = DRQUNK; /* for EISA/VLB/PCI clones */
963: break;
964: case CHAN0:
965: drq = 0;
966: break;
967: case CHAN5:
968: drq = 5;
969: break;
970: case CHAN6:
971: drq = 6;
972: break;
973: case CHAN7:
974: drq = 7;
975: break;
976: default:
977: printf("aha_find: illegal drq setting %x\n",
978: config.reply.chan);
979: return (1);
980: }
981: if (isapnp)
982: irq = ia->ia_irq;
983:
984: switch (config.reply.intr) {
985: case INT9:
986: irq = 9;
987: break;
988: case INT10:
989: irq = 10;
990: break;
991: case INT11:
992: irq = 11;
993: break;
994: case INT12:
995: irq = 12;
996: break;
997: case INT14:
998: irq = 14;
999: break;
1000: case INT15:
1001: irq = 15;
1002: break;
1003: default:
1004: printf("aha_find: illegal irq setting %x\n",
1005: config.reply.intr);
1006: return (EIO);
1007: }
1008: if (isapnp)
1009: drq = ia->ia_drq;
1010:
1011: if (sc != NULL) {
1012: /* who are we on the scsi bus? */
1013: sc->sc_scsi_dev = config.reply.scsi_dev;
1014:
1015: sc->sc_iobase = iobase;
1016: sc->sc_irq = irq;
1017: sc->sc_drq = drq;
1018: } else {
1019: if (isapnp)
1020: return (0);
1021: if (ia->ia_irq == IRQUNK)
1022: ia->ia_irq = irq;
1023: else if (ia->ia_irq != irq)
1024: return (1);
1025: if (ia->ia_drq == DRQUNK)
1026: ia->ia_drq = drq;
1027: else if (ia->ia_drq != drq)
1028: return (1);
1029: }
1030:
1031: return (0);
1032: }
1033:
1034: /*
1035: * Start the board, ready for normal operation
1036: */
1037: void
1038: aha_init(sc)
1039: struct aha_softc *sc;
1040: {
1041: int iobase = sc->sc_iobase;
1042: struct aha_devices devices;
1043: struct aha_setup setup;
1044: struct aha_mailbox mailbox;
1045: struct pglist pglist;
1046: struct vm_page *pg;
1047: vaddr_t va;
1048: vsize_t size;
1049: int i;
1050:
1051: /*
1052: * XXX
1053: * If we are a 1542C or later, disable the extended BIOS so that the
1054: * mailbox interface is unlocked.
1055: * No need to check the extended BIOS flags as some of the
1056: * extensions that cause us problems are not flagged in that byte.
1057: */
1058: if (!strncmp(sc->sc_model, "1542C", 5)) {
1059: struct aha_extbios extbios;
1060: struct aha_unlock unlock;
1061:
1062: printf("%s: unlocking mailbox interface\n",
1063: sc->sc_dev.dv_xname);
1064: extbios.cmd.opcode = AHA_EXT_BIOS;
1065: aha_cmd(iobase, sc, sizeof(extbios.cmd),
1066: (u_char *)&extbios.cmd, sizeof(extbios.reply),
1067: (u_char *)&extbios.reply);
1068:
1069: #ifdef AHADEBUG
1070: printf("%s: flags=%02x, mailboxlock=%02x\n",
1071: sc->sc_dev.dv_xname,
1072: extbios.reply.flags, extbios.reply.mailboxlock);
1073: #endif /* AHADEBUG */
1074:
1075: unlock.cmd.opcode = AHA_MBX_ENABLE;
1076: unlock.cmd.junk = 0;
1077: unlock.cmd.magic = extbios.reply.mailboxlock;
1078: aha_cmd(iobase, sc, sizeof(unlock.cmd), (u_char *)&unlock.cmd,
1079: 0, (u_char *)0);
1080: }
1081:
1082: #if 0
1083: /*
1084: * Change the bus on/off times to not clash with other dma users.
1085: */
1086: aha_cmd(sc, 1, 0, 0, 0, AHA_BUS_ON_TIME_SET, 7);
1087: aha_cmd(sc, 1, 0, 0, 0, AHA_BUS_OFF_TIME_SET, 4);
1088: #endif
1089:
1090: /* Inquire Installed Devices (to force synchronous negotiation). */
1091: devices.cmd.opcode = AHA_INQUIRE_DEVICES;
1092: aha_cmd(iobase, sc, sizeof(devices.cmd), (u_char *)&devices.cmd,
1093: sizeof(devices.reply), (u_char *)&devices.reply);
1094:
1095: /* Obtain setup information from. */
1096: setup.cmd.opcode = AHA_INQUIRE_SETUP;
1097: setup.cmd.len = sizeof(setup.reply);
1098: aha_cmd(iobase, sc, sizeof(setup.cmd), (u_char *)&setup.cmd,
1099: sizeof(setup.reply), (u_char *)&setup.reply);
1100:
1101: printf("%s: %s, %s\n",
1102: sc->sc_dev.dv_xname,
1103: setup.reply.sync_neg ? "sync" : "async",
1104: setup.reply.parity ? "parity" : "no parity");
1105:
1106: for (i = 0; i < 8; i++) {
1107: if (!setup.reply.sync[i].valid ||
1108: (!setup.reply.sync[i].offset &&
1109: !setup.reply.sync[i].period))
1110: continue;
1111: printf("%s targ %d: sync, offset %d, period %dnsec\n",
1112: sc->sc_dev.dv_xname, i, setup.reply.sync[i].offset,
1113: setup.reply.sync[i].period * 50 + 200);
1114: }
1115:
1116: /*
1117: * Set up initial mail box for round-robin operation.
1118: */
1119:
1120: /*
1121: * XXX - this vm juggling is so wrong. use bus_dma instead!
1122: */
1123: size = round_page(sizeof(struct aha_mbx));
1124: TAILQ_INIT(&pglist);
1125: if (uvm_pglistalloc(size, 0, 0xffffff, PAGE_SIZE, 0, &pglist, 1, 0) ||
1126: uvm_map(kernel_map, &va, size, NULL, UVM_UNKNOWN_OFFSET, 0,
1127: UVM_MAPFLAG(UVM_PROT_ALL, UVM_PROT_ALL, UVM_INH_NONE,
1128: UVM_ADV_RANDOM, 0)))
1129: panic("aha_init: could not allocate mailbox");
1130:
1131: wmbx = (struct aha_mbx *)va;
1132: for (pg = TAILQ_FIRST(&pglist); pg != NULL;
1133: pg = TAILQ_NEXT(pg, pageq)) {
1134: pmap_kenter_pa(va, VM_PAGE_TO_PHYS(pg),
1135: VM_PROT_READ|VM_PROT_WRITE);
1136: va += PAGE_SIZE;
1137: }
1138: pmap_update(pmap_kernel());
1139: /*
1140: * XXXEND
1141: */
1142:
1143: for (i = 0; i < AHA_MBX_SIZE; i++) {
1144: wmbx->mbo[i].cmd = AHA_MBO_FREE;
1145: wmbx->mbi[i].stat = AHA_MBI_FREE;
1146: }
1147: wmbx->cmbo = wmbx->tmbo = &wmbx->mbo[0];
1148: wmbx->tmbi = &wmbx->mbi[0];
1149: sc->sc_mbofull = 0;
1150:
1151: /* Initialize mail box. */
1152: mailbox.cmd.opcode = AHA_MBX_INIT;
1153: mailbox.cmd.nmbx = AHA_MBX_SIZE;
1154: ltophys(vtophys((vaddr_t)wmbx), mailbox.cmd.addr);
1155: aha_cmd(iobase, sc, sizeof(mailbox.cmd), (u_char *)&mailbox.cmd,
1156: 0, (u_char *)0);
1157: }
1158:
1159: void
1160: aha_inquire_setup_information(sc)
1161: struct aha_softc *sc;
1162: {
1163: int iobase = sc->sc_iobase;
1164: struct aha_revision revision;
1165: u_char sts;
1166: int i;
1167: char *p;
1168:
1169: strlcpy(sc->sc_model, "unknown", sizeof sc->sc_model);
1170:
1171: /*
1172: * Assume we have a board at this stage, do an adapter inquire
1173: * to find out what type of controller it is. If the command
1174: * fails, we assume it's either a crusty board or an old 1542
1175: * clone, and skip the board-specific stuff.
1176: */
1177: revision.cmd.opcode = AHA_INQUIRE_REVISION;
1178: if (aha_cmd(iobase, sc, sizeof(revision.cmd), (u_char *)&revision.cmd,
1179: sizeof(revision.reply), (u_char *)&revision.reply)) {
1180: /*
1181: * aha_cmd() already started the reset. It's not clear we
1182: * even need to bother here.
1183: */
1184: for (i = AHA_RESET_TIMEOUT; i; i--) {
1185: sts = inb(iobase + AHA_STAT_PORT);
1186: if (sts == (AHA_STAT_IDLE | AHA_STAT_INIT))
1187: break;
1188: delay(1000);
1189: }
1190: if (!i) {
1191: #ifdef AHADEBUG
1192: printf("aha_init: soft reset failed\n");
1193: #endif /* AHADEBUG */
1194: return;
1195: }
1196: #ifdef AHADEBUG
1197: printf("aha_init: inquire command failed\n");
1198: #endif /* AHADEBUG */
1199: goto noinquire;
1200: }
1201:
1202: #ifdef AHADEBUG
1203: printf("%s: inquire %x, %x, %x, %x\n",
1204: sc->sc_dev.dv_xname,
1205: revision.reply.boardid, revision.reply.spec_opts,
1206: revision.reply.revision_1, revision.reply.revision_2);
1207: #endif /* AHADEBUG */
1208:
1209: switch (revision.reply.boardid) {
1210: case 0x31:
1211: strlcpy(sc->sc_model, "1540", sizeof sc->sc_model);
1212: break;
1213: case 0x41:
1214: strlcpy(sc->sc_model, "1540A/1542A/1542B", sizeof sc->sc_model);
1215: break;
1216: case 0x42:
1217: strlcpy(sc->sc_model, "1640", sizeof sc->sc_model);
1218: break;
1219: case 0x43:
1220: case 0x44: /* Is this 1542C or -CF? */
1221: strlcpy(sc->sc_model, "1542C", sizeof sc->sc_model);
1222: break;
1223: case 0x45:
1224: strlcpy(sc->sc_model, "1542CF", sizeof sc->sc_model);
1225: break;
1226: case 0x46:
1227: strlcpy(sc->sc_model, "1542CP", sizeof sc->sc_model);
1228: break;
1229: }
1230:
1231: p = sc->sc_firmware;
1232: *p++ = revision.reply.revision_1;
1233: *p++ = '.';
1234: *p++ = revision.reply.revision_2;
1235: *p = '\0';
1236:
1237: noinquire:
1238: printf(": model AHA-%s, firmware %s\n", sc->sc_model, sc->sc_firmware);
1239: }
1240:
1241: void
1242: ahaminphys(bp)
1243: struct buf *bp;
1244: {
1245:
1246: if (bp->b_bcount > ((AHA_NSEG - 1) << PGSHIFT))
1247: bp->b_bcount = ((AHA_NSEG - 1) << PGSHIFT);
1248: minphys(bp);
1249: }
1250:
1251: /*
1252: * start a scsi operation given the command and the data address. Also needs
1253: * the unit, target and lu.
1254: */
1255: int
1256: aha_scsi_cmd(xs)
1257: struct scsi_xfer *xs;
1258: {
1259: struct scsi_link *sc_link = xs->sc_link;
1260: struct aha_softc *sc = sc_link->adapter_softc;
1261: struct aha_ccb *ccb;
1262: struct aha_scat_gath *sg;
1263: int seg, flags;
1264: #ifdef TFS
1265: struct iovec *iovp;
1266: int datalen;
1267: #endif
1268: int s;
1269:
1270: SC_DEBUG(sc_link, SDEV_DB2, ("aha_scsi_cmd\n"));
1271: /*
1272: * get a ccb to use. If the transfer
1273: * is from a buf (possibly from interrupt time)
1274: * then we can't allow it to sleep
1275: */
1276: flags = xs->flags;
1277: if ((ccb = aha_get_ccb(sc, flags)) == NULL) {
1278: return (TRY_AGAIN_LATER);
1279: }
1280: ccb->xs = xs;
1281: ccb->timeout = xs->timeout;
1282:
1283: /*
1284: * Put all the arguments for the xfer in the ccb
1285: */
1286: if (flags & SCSI_RESET) {
1287: ccb->opcode = AHA_RESET_CCB;
1288: ccb->scsi_cmd_length = 0;
1289: } else {
1290: /* can't use S/G if zero length */
1291: ccb->opcode =
1292: (xs->datalen ? AHA_INIT_SCAT_GATH_CCB : AHA_INITIATOR_CCB);
1293: bcopy(xs->cmd, &ccb->scsi_cmd,
1294: ccb->scsi_cmd_length = xs->cmdlen);
1295: }
1296:
1297: if (xs->datalen) {
1298: sg = ccb->scat_gath;
1299: seg = 0;
1300: #ifdef TFS
1301: if (flags & SCSI_DATA_UIO) {
1302: iovp = ((struct uio *)xs->data)->uio_iov;
1303: datalen = ((struct uio *)xs->data)->uio_iovcnt;
1304: xs->datalen = 0;
1305: while (datalen && seg < AHA_NSEG) {
1306: ltophys(iovp->iov_base, sg->seg_addr);
1307: ltophys(iovp->iov_len, sg->seg_len);
1308: xs->datalen += iovp->iov_len;
1309: SC_DEBUGN(sc_link, SDEV_DB4, ("UIO(0x%x@0x%x)",
1310: iovp->iov_len, iovp->iov_base));
1311: sg++;
1312: iovp++;
1313: seg++;
1314: datalen--;
1315: }
1316: } else
1317: #endif /* TFS */
1318: {
1319: /*
1320: * Set up the scatter-gather block.
1321: */
1322: if (bus_dmamap_load(sc->sc_dmat, ccb->dmam, xs->data,
1323: xs->datalen, NULL, BUS_DMA_NOWAIT) != 0) {
1324: aha_free_ccb(sc, ccb);
1325: xs->error = XS_DRIVER_STUFFUP;
1326: return (TRY_AGAIN_LATER);
1327: }
1328: for (seg = 0; seg < ccb->dmam->dm_nsegs; seg++) {
1329: ltophys(ccb->dmam->dm_segs[seg].ds_addr,
1330: sg[seg].seg_addr);
1331: ltophys(ccb->dmam->dm_segs[seg].ds_len,
1332: sg[seg].seg_len);
1333: }
1334: }
1335: if (flags & SCSI_DATA_OUT)
1336: bus_dmamap_sync(sc->sc_dmat, ccb->dmam, 0,
1337: ccb->dmam->dm_mapsize, BUS_DMASYNC_PREWRITE);
1338: if (flags & SCSI_DATA_IN)
1339: bus_dmamap_sync(sc->sc_dmat, ccb->dmam, 0,
1340: ccb->dmam->dm_mapsize, BUS_DMASYNC_PREREAD);
1341: ltophys((unsigned)
1342: ((struct aha_ccb *)(ccb->ccb_dmam->dm_segs[0].ds_addr))->
1343: scat_gath,
1344: ccb->data_addr);
1345: ltophys(ccb->dmam->dm_nsegs * sizeof(struct aha_scat_gath),
1346: ccb->data_length);
1347: } else { /* No data xfer, use non S/G values */
1348: ltophys(0, ccb->data_addr);
1349: ltophys(0, ccb->data_length);
1350: }
1351:
1352: ccb->data_out = 0;
1353: ccb->data_in = 0;
1354: ccb->target = sc_link->target;
1355: ccb->lun = sc_link->lun;
1356: ccb->req_sense_length = sizeof(ccb->scsi_sense);
1357: ccb->host_stat = 0x00;
1358: ccb->target_stat = 0x00;
1359: ccb->link_id = 0;
1360: ltophys(0, ccb->link_addr);
1361:
1362: s = splbio();
1363: aha_queue_ccb(sc, ccb);
1364:
1365: /*
1366: * Usually return SUCCESSFULLY QUEUED
1367: */
1368: SC_DEBUG(sc_link, SDEV_DB3, ("cmd_sent\n"));
1369:
1370: if (VOLATILE_XS(xs)) {
1371: while ((ccb->xs->flags & ITSDONE) == 0) {
1372: tsleep(ccb, PRIBIO, "ahawait", 0);
1373: }
1374: if (ccb->dmam->dm_nsegs > 0) {
1375: if (flags & SCSI_DATA_OUT)
1376: bus_dmamap_sync(sc->sc_dmat, ccb->dmam, 0,
1377: ccb->dmam->dm_mapsize,
1378: BUS_DMASYNC_POSTWRITE);
1379: if (flags & SCSI_DATA_IN)
1380: bus_dmamap_sync(sc->sc_dmat, ccb->dmam, 0,
1381: ccb->dmam->dm_mapsize,
1382: BUS_DMASYNC_POSTREAD);
1383: bus_dmamap_unload(sc->sc_dmat, ccb->dmam);
1384: }
1385: aha_free_ccb(sc, ccb);
1386: scsi_done(xs);
1387: splx(s);
1388: return (COMPLETE);
1389: }
1390: splx(s);
1391:
1392: if ((flags & SCSI_POLL) == 0)
1393: return (SUCCESSFULLY_QUEUED);
1394:
1395: /*
1396: * If we can't use interrupts, poll on completion
1397: */
1398: if (aha_poll(sc, xs, ccb->timeout)) {
1399: aha_timeout(ccb);
1400: if (aha_poll(sc, xs, ccb->timeout))
1401: aha_timeout(ccb);
1402: }
1403: return (COMPLETE);
1404: }
1405:
1406: /*
1407: * Poll a particular unit, looking for a particular xs
1408: */
1409: int
1410: aha_poll(sc, xs, count)
1411: struct aha_softc *sc;
1412: struct scsi_xfer *xs;
1413: int count;
1414: {
1415: int iobase = sc->sc_iobase;
1416: int s;
1417:
1418: /* timeouts are in msec, so we loop in 1000 usec cycles */
1419: while (count) {
1420: /*
1421: * If we had interrupts enabled, would we
1422: * have got an interrupt?
1423: */
1424: if (inb(iobase + AHA_INTR_PORT) & AHA_INTR_ANYINTR) {
1425: s = splbio();
1426: ahaintr(sc);
1427: splx(s);
1428: }
1429: if (xs->flags & ITSDONE)
1430: return (0);
1431: delay(1000); /* only happens in boot so ok */
1432: count--;
1433: }
1434: return (1);
1435: }
1436:
1437: void
1438: aha_timeout(arg)
1439: void *arg;
1440: {
1441: struct aha_ccb *ccb = arg;
1442: struct scsi_xfer *xs;
1443: struct scsi_link *sc_link;
1444: struct aha_softc *sc;
1445: int s;
1446:
1447: s = splbio();
1448: bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmam, 0,
1449: ccb->ccb_dmam->dm_mapsize, BUS_DMASYNC_POSTREAD);
1450: xs = ccb->xs;
1451: sc_link = xs->sc_link;
1452: sc = sc_link->adapter_softc;
1453:
1454: sc_print_addr(sc_link);
1455: printf("timed out");
1456:
1457: #ifdef AHADIAG
1458: /*
1459: * If The ccb's mbx is not free, then the board has gone south?
1460: */
1461: aha_collect_mbo(sc);
1462: if (ccb->flags & CCB_SENDING) {
1463: printf("%s: not taking commands!\n", sc->sc_dev.dv_xname);
1464: Debugger();
1465: }
1466: #endif
1467:
1468: /*
1469: * If it has been through before, then
1470: * a previous abort has failed, don't
1471: * try abort again
1472: */
1473: if (ccb->flags & CCB_ABORT) {
1474: /* abort timed out */
1475: printf(" AGAIN\n");
1476: /* XXX Must reset! */
1477: } else {
1478: /* abort the operation that has timed out */
1479: printf("\n");
1480: ccb->xs->error = XS_TIMEOUT;
1481: ccb->timeout = AHA_ABORT_TIMEOUT;
1482: ccb->flags |= CCB_ABORT;
1483: aha_queue_ccb(sc, ccb);
1484: }
1485:
1486: splx(s);
1487: }
1488: