![[BACK]](/icons/back.gif){kind=icon}
Return to aic6360.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to aic6360.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 1: /* $OpenBSD: aic6360.c,v 1.15 2007/08/09 00:03:16 ray Exp $ */
2: /* $NetBSD: aic6360.c,v 1.52 1996/12/10 21:27:51 thorpej Exp $ */
3:
4: #ifdef DDB
5: #define integrate
6: #else
7: #define integrate static inline
8: #endif
9:
10: /*
11: * Copyright (c) 1994, 1995, 1996 Charles Hannum. All rights reserved.
12: *
13: * Redistribution and use in source and binary forms, with or without
14: * modification, are permitted provided that the following conditions
15: * are met:
16: * 1. Redistributions of source code must retain the above copyright
17: * notice, this list of conditions and the following disclaimer.
18: * 2. Redistributions in binary form must reproduce the above copyright
19: * notice, this list of conditions and the following disclaimer in the
20: * documentation and/or other materials provided with the distribution.
21: * 3. All advertising materials mentioning features or use of this software
22: * must display the following acknowledgement:
23: * This product includes software developed by Charles M. Hannum.
24: * 4. The name of the author may not be used to endorse or promote products
25: * derived from this software without specific prior written permission.
26: *
27: * Copyright (c) 1994 Jarle Greipsland
28: * All rights reserved.
29: *
30: * Redistribution and use in source and binary forms, with or without
31: * modification, are permitted provided that the following conditions
32: * are met:
33: * 1. Redistributions of source code must retain the above copyright
34: * notice, this list of conditions and the following disclaimer.
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in the
37: * documentation and/or other materials provided with the distribution.
38: * 3. The name of the author may not be used to endorse or promote products
39: * derived from this software without specific prior written permission.
40: *
41: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
42: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
43: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
44: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
45: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
46: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
47: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
50: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
51: * POSSIBILITY OF SUCH DAMAGE.
52: */
53:
54: /*
55: * Acknowledgements: Many of the algorithms used in this driver are
56: * inspired by the work of Julian Elischer (julian@tfs.com) and
57: * Charles Hannum (mycroft@duality.gnu.ai.mit.edu). Thanks a million!
58: */
59:
60: /* TODO list:
61: * 1) Get the DMA stuff working.
62: * 2) Get the iov/uio stuff working. Is this a good thing ???
63: * 3) Get the synch stuff working.
64: * 4) Rewrite it to use malloc for the acb structs instead of static alloc.?
65: */
66:
67: /*
68: * A few customizable items:
69: */
70:
71: /* Use doubleword transfers to/from SCSI chip. Note: This requires
72: * motherboard support. Basicly, some motherboard chipsets are able to
73: * split a 32 bit I/O operation into two 16 bit I/O operations,
74: * transparently to the processor. This speeds up some things, notably long
75: * data transfers.
76: */
77: #define AIC_USE_DWORDS 0
78:
79: /* Synchronous data transfers? */
80: #define AIC_USE_SYNCHRONOUS 0
81: #define AIC_SYNC_REQ_ACK_OFS 8
82:
83: /* Wide data transfers? */
84: #define AIC_USE_WIDE 0
85: #define AIC_MAX_WIDTH 0
86:
87: /* Max attempts made to transmit a message */
88: #define AIC_MSG_MAX_ATTEMPT 3 /* Not used now XXX */
89:
90: /* Use DMA (else we do programmed I/O using string instructions) (not yet!)*/
91: #define AIC_USE_EISA_DMA 0
92: #define AIC_USE_ISA_DMA 0
93:
94: /* How to behave on the (E)ISA bus when/if DMAing (on<<4) + off in us */
95: #define EISA_BRST_TIM ((15<<4) + 1) /* 15us on, 1us off */
96:
97: /* Some spin loop parameters (essentially how long to wait some places)
98: * The problem(?) is that sometimes we expect either to be able to transmit a
99: * byte or to get a new one from the SCSI bus pretty soon. In order to avoid
100: * returning from the interrupt just to get yanked back for the next byte we
101: * may spin in the interrupt routine waiting for this byte to come. How long?
102: * This is really (SCSI) device and processor dependent. Tuneable, I guess.
103: */
104: #define AIC_MSGIN_SPIN 1 /* Spin upto ?ms for a new msg byte */
105: #define AIC_MSGOUT_SPIN 1
106:
107: /* Include debug functions? At the end of this file there are a bunch of
108: * functions that will print out various information regarding queued SCSI
109: * commands, driver state and chip contents. You can call them from the
110: * kernel debugger. If you set AIC_DEBUG to 0 they are not included (the
111: * kernel uses less memory) but you lose the debugging facilities.
112: */
113: #ifndef SMALL_KERNEL
114: #define AIC_DEBUG 1
115: #endif
116:
117: #define AIC_ABORT_TIMEOUT 2000 /* time to wait for abort */
118:
119: /* End of customizable parameters */
120:
121: #if AIC_USE_EISA_DMA || AIC_USE_ISA_DMA
122: #error "I said not yet! Start paying attention... grumble"
123: #endif
124:
125: #include <sys/types.h>
126: #include <sys/param.h>
127: #include <sys/systm.h>
128: #include <sys/kernel.h>
129: #include <sys/errno.h>
130: #include <sys/ioctl.h>
131: #include <sys/device.h>
132: #include <sys/buf.h>
133: #include <sys/proc.h>
134: #include <sys/user.h>
135: #include <sys/queue.h>
136:
137: #include <machine/bus.h>
138: #include <machine/intr.h>
139:
140: #include <scsi/scsi_all.h>
141: #include <scsi/scsi_message.h>
142: #include <scsi/scsiconf.h>
143:
144: #include <dev/isa/isavar.h>
145:
146: #include <dev/ic/aic6360reg.h>
147: #include <dev/ic/aic6360var.h>
148:
149: #ifndef DDB
150: #define Debugger() panic("should call debugger here (aic6360.c)")
151: #endif /* ! DDB */
152:
153: #ifdef AIC_DEBUG
154: int aic_debug = 0x00; /* AIC_SHOWSTART|AIC_SHOWMISC|AIC_SHOWTRACE; */
155: #endif
156:
157: void aic_minphys(struct buf *);
158: void aic_init(struct aic_softc *);
159: void aic_done(struct aic_softc *, struct aic_acb *);
160: void aic_dequeue(struct aic_softc *, struct aic_acb *);
161: int aic_scsi_cmd(struct scsi_xfer *);
162: int aic_poll(struct aic_softc *, struct scsi_xfer *, int);
163: integrate void aic_sched_msgout(struct aic_softc *, u_char);
164: integrate void aic_setsync(struct aic_softc *, struct aic_tinfo *);
165: void aic_select(struct aic_softc *, struct aic_acb *);
166: void aic_timeout(void *);
167: void aic_sched(struct aic_softc *);
168: void aic_scsi_reset(struct aic_softc *);
169: void aic_reset(struct aic_softc *);
170: void aic_free_acb(struct aic_softc *, struct aic_acb *, int);
171: struct aic_acb* aic_get_acb(struct aic_softc *, int);
172: int aic_reselect(struct aic_softc *, int);
173: void aic_sense(struct aic_softc *, struct aic_acb *);
174: void aic_msgin(struct aic_softc *);
175: void aic_abort(struct aic_softc *, struct aic_acb *);
176: void aic_msgout(struct aic_softc *);
177: int aic_dataout_pio(struct aic_softc *, u_char *, int);
178: int aic_datain_pio(struct aic_softc *, u_char *, int);
179: #ifdef AIC_DEBUG
180: void aic_print_acb(struct aic_acb *);
181: void aic_dump_driver(struct aic_softc *);
182: void aic_dump6360(struct aic_softc *);
183: void aic_show_scsi_cmd(struct aic_acb *);
184: void aic_print_active_acb(void);
185: #endif
186:
187: struct cfdriver aic_cd = {
188: NULL, "aic", DV_DULL
189: };
190:
191: struct scsi_adapter aic_switch = {
192: aic_scsi_cmd,
193: #ifdef notyet
194: aic_minphys,
195: #else
196: minphys,
197: #endif
198: 0,
199: 0,
200: };
201:
202: struct scsi_device aic_dev = {
203: NULL, /* Use default error handler */
204: NULL, /* have a queue, served by this */
205: NULL, /* have no async handler */
206: NULL, /* Use default 'done' routine */
207: };
208:
209:
210: /*
211: * Do the real search-for-device.
212: */
213: int
214: aic_find(bus_space_tag_t iot, bus_space_handle_t ioh)
215: {
216: char chip_id[sizeof(IDSTRING)]; /* For chips that support it */
217: int i;
218:
219: /* Remove aic6360 from possible powerdown mode */
220: bus_space_write_1(iot, ioh, DMACNTRL0, 0);
221:
222: /* Thanks to mark@aggregate.com for the new method for detecting
223: * whether the chip is present or not. Bonus: may also work for
224: * the AIC-6260!
225: */
226: AIC_TRACE(("aic: probing for aic-chip\n"));
227: /*
228: * Linux also init's the stack to 1-16 and then clears it,
229: * 6260's don't appear to have an ID reg - mpg
230: */
231: /* Push the sequence 0,1,..,15 on the stack */
232: #define STSIZE 16
233: bus_space_write_1(iot, ioh, DMACNTRL1, 0); /* Reset stack pointer */
234: for (i = 0; i < STSIZE; i++)
235: bus_space_write_1(iot, ioh, STACK, i);
236:
237: /* See if we can pull out the same sequence */
238: bus_space_write_1(iot, ioh, DMACNTRL1, 0);
239: for (i = 0; i < STSIZE && bus_space_read_1(iot, ioh, STACK) == i; i++)
240: ;
241: if (i != STSIZE) {
242: AIC_START(("STACK futzed at %d.\n", i));
243: return (0);
244: }
245:
246: /* See if we can pull the id string out of the ID register,
247: * now only used for informational purposes.
248: */
249: bzero(chip_id, sizeof(chip_id));
250: bus_space_read_multi_1(iot, ioh, ID, chip_id, sizeof(IDSTRING) - 1);
251: AIC_START(("AIC ID: %s ", chip_id));
252: AIC_START(("chip revision %d\n",
253: (int)bus_space_read_1(iot, ioh, REV)));
254:
255: return (1);
256: }
257:
258: /*
259: * Attach the AIC6360, fill out some high and low level data structures
260: */
261: void
262: aicattach(struct aic_softc *sc)
263: {
264: struct scsibus_attach_args saa;
265: AIC_TRACE(("aicattach "));
266: sc->sc_state = AIC_INIT;
267:
268: sc->sc_initiator = 7;
269: sc->sc_freq = 20; /* XXXX assume 20 MHz. */
270:
271: /*
272: * These are the bounds of the sync period, based on the frequency of
273: * the chip's clock input and the size and offset of the sync period
274: * register.
275: *
276: * For a 20MHz clock, this gives us 25, or 100nS, or 10MB/s, as a
277: * maximum transfer rate, and 112.5, or 450nS, or 2.22MB/s, as a
278: * minimum transfer rate.
279: */
280: sc->sc_minsync = (2 * 250) / sc->sc_freq;
281: sc->sc_maxsync = (9 * 250) / sc->sc_freq;
282:
283: aic_init(sc); /* init chip and driver */
284:
285: /*
286: * Fill in the prototype scsi_link
287: */
288: sc->sc_link.adapter_softc = sc;
289: sc->sc_link.adapter_target = sc->sc_initiator;
290: sc->sc_link.adapter = &aic_switch;
291: sc->sc_link.device = &aic_dev;
292: sc->sc_link.openings = 2;
293:
294: bzero(&saa, sizeof(saa));
295: saa.saa_sc_link = &sc->sc_link;
296:
297: config_found(&sc->sc_dev, &saa, scsiprint);
298: }
299:
300: int
301: aic_detach(struct device *self, int flags)
302: {
303: struct aic_softc *sc = (struct aic_softc *) self;
304: int rv = 0;
305:
306: rv = config_detach_children(&sc->sc_dev, flags);
307:
308: return (rv);
309: }
310:
311: /* Initialize AIC6360 chip itself
312: * The following conditions should hold:
313: * aicprobe should have succeeded, i.e. the ioh handle in aic_softc must
314: * be valid.
315: */
316: void
317: aic_reset(struct aic_softc *sc)
318: {
319: bus_space_tag_t iot = sc->sc_iot;
320: bus_space_handle_t ioh = sc->sc_ioh;
321:
322: /*
323: * Doc. recommends to clear these two registers before operations
324: * commence
325: */
326: bus_space_write_1(iot, ioh, SCSITEST, 0);
327: bus_space_write_1(iot, ioh, TEST, 0);
328:
329: /* Reset SCSI-FIFO and abort any transfers */
330: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN | CLRCH | CLRSTCNT);
331:
332: /* Reset DMA-FIFO */
333: bus_space_write_1(iot, ioh, DMACNTRL0, RSTFIFO);
334: bus_space_write_1(iot, ioh, DMACNTRL1, 0);
335:
336: /* Disable all selection features */
337: bus_space_write_1(iot, ioh, SCSISEQ, 0);
338: bus_space_write_1(iot, ioh, SXFRCTL1, 0);
339:
340: /* Disable some interrupts */
341: bus_space_write_1(iot, ioh, SIMODE0, 0x00);
342: /* Clear a slew of interrupts */
343: bus_space_write_1(iot, ioh, CLRSINT0, 0x7f);
344:
345: /* Disable some more interrupts */
346: bus_space_write_1(iot, ioh, SIMODE1, 0x00);
347: /* Clear another slew of interrupts */
348: bus_space_write_1(iot, ioh, CLRSINT1, 0xef);
349:
350: /* Disable synchronous transfers */
351: bus_space_write_1(iot, ioh, SCSIRATE, 0);
352:
353: /* Haven't seen ant errors (yet) */
354: bus_space_write_1(iot, ioh, CLRSERR, 0x07);
355:
356: /* Set our SCSI-ID */
357: bus_space_write_1(iot, ioh, SCSIID, sc->sc_initiator << OID_S);
358: bus_space_write_1(iot, ioh, BRSTCNTRL, EISA_BRST_TIM);
359: }
360:
361: /* Pull the SCSI RST line for 500 us */
362: void
363: aic_scsi_reset(struct aic_softc *sc)
364: {
365: bus_space_tag_t iot = sc->sc_iot;
366: bus_space_handle_t ioh = sc->sc_ioh;
367:
368: bus_space_write_1(iot, ioh, SCSISEQ, SCSIRSTO);
369: delay(500);
370: bus_space_write_1(iot, ioh, SCSISEQ, 0);
371: delay(50);
372: }
373:
374: /*
375: * Initialize aic SCSI driver.
376: */
377: void
378: aic_init(struct aic_softc *sc)
379: {
380: bus_space_tag_t iot = sc->sc_iot;
381: bus_space_handle_t ioh = sc->sc_ioh;
382: struct aic_acb *acb;
383: int r;
384:
385: aic_reset(sc);
386: aic_scsi_reset(sc);
387: aic_reset(sc);
388:
389: if (sc->sc_state == AIC_INIT) {
390: /* First time through; initialize. */
391: TAILQ_INIT(&sc->ready_list);
392: TAILQ_INIT(&sc->nexus_list);
393: TAILQ_INIT(&sc->free_list);
394: sc->sc_nexus = NULL;
395: acb = sc->sc_acb;
396: bzero(acb, sizeof(sc->sc_acb));
397: for (r = 0; r < sizeof(sc->sc_acb) / sizeof(*acb); r++) {
398: TAILQ_INSERT_TAIL(&sc->free_list, acb, chain);
399: acb++;
400: }
401: bzero(&sc->sc_tinfo, sizeof(sc->sc_tinfo));
402: } else {
403: /* Cancel any active commands. */
404: sc->sc_state = AIC_CLEANING;
405: if ((acb = sc->sc_nexus) != NULL) {
406: acb->xs->error = XS_DRIVER_STUFFUP;
407: timeout_del(&acb->xs->stimeout);
408: aic_done(sc, acb);
409: }
410: while ((acb = TAILQ_FIRST(&sc->nexus_list)) != NULL) {
411: acb->xs->error = XS_DRIVER_STUFFUP;
412: timeout_del(&acb->xs->stimeout);
413: aic_done(sc, acb);
414: }
415: }
416:
417: sc->sc_prevphase = PH_INVALID;
418: for (r = 0; r < 8; r++) {
419: struct aic_tinfo *ti = &sc->sc_tinfo[r];
420:
421: ti->flags = 0;
422: #if AIC_USE_SYNCHRONOUS
423: ti->flags |= DO_SYNC;
424: ti->period = sc->sc_minsync;
425: ti->offset = AIC_SYNC_REQ_ACK_OFS;
426: #else
427: ti->period = ti->offset = 0;
428: #endif
429: #if AIC_USE_WIDE
430: ti->flags |= DO_WIDE;
431: ti->width = AIC_MAX_WIDTH;
432: #else
433: ti->width = 0;
434: #endif
435: }
436:
437: sc->sc_state = AIC_IDLE;
438: bus_space_write_1(iot, ioh, DMACNTRL0, INTEN);
439: }
440:
441: void
442: aic_free_acb(struct aic_softc *sc, struct aic_acb *acb, int flags)
443: {
444: int s;
445:
446: s = splbio();
447:
448: acb->flags = 0;
449: TAILQ_INSERT_HEAD(&sc->free_list, acb, chain);
450:
451: /*
452: * If there were none, wake anybody waiting for one to come free,
453: * starting with queued entries.
454: */
455: if (TAILQ_NEXT(acb, chain) == NULL)
456: wakeup(&sc->free_list);
457:
458: splx(s);
459: }
460:
461: struct aic_acb *
462: aic_get_acb(struct aic_softc *sc, int flags)
463: {
464: struct aic_acb *acb;
465: int s;
466:
467: s = splbio();
468:
469: while ((acb = TAILQ_FIRST(&sc->free_list)) == NULL &&
470: (flags & SCSI_NOSLEEP) == 0)
471: tsleep(&sc->free_list, PRIBIO, "aicacb", 0);
472: if (acb) {
473: TAILQ_REMOVE(&sc->free_list, acb, chain);
474: acb->flags |= ACB_ALLOC;
475: }
476:
477: splx(s);
478: return acb;
479: }
480:
481: /*
482: * DRIVER FUNCTIONS CALLABLE FROM HIGHER LEVEL DRIVERS
483: */
484:
485: /*
486: * Expected sequence:
487: * 1) Command inserted into ready list
488: * 2) Command selected for execution
489: * 3) Command won arbitration and has selected target device
490: * 4) Send message out (identify message, eventually also sync.negotiations)
491: * 5) Send command
492: * 5a) Receive disconnect message, disconnect.
493: * 5b) Reselected by target
494: * 5c) Receive identify message from target.
495: * 6) Send or receive data
496: * 7) Receive status
497: * 8) Receive message (command complete etc.)
498: * 9) If status == SCSI_CHECK construct a synthetic request sense SCSI cmd.
499: * Repeat 2-8 (no disconnects please...)
500: */
501:
502: /*
503: * Start a SCSI-command
504: * This function is called by the higher level SCSI-driver to queue/run
505: * SCSI-commands.
506: */
507: int
508: aic_scsi_cmd(struct scsi_xfer *xs)
509: {
510: struct scsi_link *sc_link = xs->sc_link;
511: struct aic_softc *sc = sc_link->adapter_softc;
512: struct aic_acb *acb;
513: int s, flags;
514:
515: AIC_TRACE(("aic_scsi_cmd "));
516: AIC_CMDS(("[0x%x, %d]->%d ", (int)xs->cmd->opcode, xs->cmdlen,
517: sc_link->target));
518:
519: flags = xs->flags;
520: if ((acb = aic_get_acb(sc, flags)) == NULL) {
521: return TRY_AGAIN_LATER;
522: }
523:
524: /* Initialize acb */
525: acb->xs = xs;
526: acb->timeout = xs->timeout;
527: timeout_set(&xs->stimeout, aic_timeout, acb);
528:
529: if (xs->flags & SCSI_RESET) {
530: acb->flags |= ACB_RESET;
531: acb->scsi_cmd_length = 0;
532: acb->data_length = 0;
533: } else {
534: bcopy(xs->cmd, &acb->scsi_cmd, xs->cmdlen);
535: acb->scsi_cmd_length = xs->cmdlen;
536: acb->data_addr = xs->data;
537: acb->data_length = xs->datalen;
538: }
539: acb->target_stat = 0;
540:
541: s = splbio();
542:
543: TAILQ_INSERT_TAIL(&sc->ready_list, acb, chain);
544: if (sc->sc_state == AIC_IDLE)
545: aic_sched(sc);
546:
547: splx(s);
548:
549: if ((flags & SCSI_POLL) == 0)
550: return SUCCESSFULLY_QUEUED;
551:
552: /* Not allowed to use interrupts, use polling instead */
553: if (aic_poll(sc, xs, acb->timeout)) {
554: aic_timeout(acb);
555: if (aic_poll(sc, xs, acb->timeout))
556: aic_timeout(acb);
557: }
558: return COMPLETE;
559: }
560:
561: #ifdef notyet
562: /*
563: * Adjust transfer size in buffer structure
564: */
565: void
566: aic_minphys(struct buf *bp)
567: {
568:
569: AIC_TRACE(("aic_minphys "));
570: if (bp->b_bcount > (AIC_NSEG << PGSHIFT))
571: bp->b_bcount = (AIC_NSEG << PGSHIFT);
572: minphys(bp);
573: }
574: #endif
575:
576: /*
577: * Used when interrupt driven I/O isn't allowed, e.g. during boot.
578: */
579: int
580: aic_poll(struct aic_softc *sc, struct scsi_xfer *xs, int count)
581: {
582: bus_space_tag_t iot = sc->sc_iot;
583: bus_space_handle_t ioh = sc->sc_ioh;
584:
585: AIC_TRACE(("aic_poll "));
586: while (count) {
587: /*
588: * If we had interrupts enabled, would we
589: * have got an interrupt?
590: */
591: if ((bus_space_read_1(iot, ioh, DMASTAT) & INTSTAT) != 0)
592: aicintr(sc);
593: if ((xs->flags & ITSDONE) != 0)
594: return 0;
595: delay(1000);
596: count--;
597: }
598: return 1;
599: }
600:
601: /*
602: * LOW LEVEL SCSI UTILITIES
603: */
604:
605: integrate void
606: aic_sched_msgout(struct aic_softc *sc, u_char m)
607: {
608: bus_space_tag_t iot = sc->sc_iot;
609: bus_space_handle_t ioh = sc->sc_ioh;
610:
611: if (sc->sc_msgpriq == 0)
612: bus_space_write_1(iot, ioh, SCSISIG, sc->sc_phase | ATNO);
613: sc->sc_msgpriq |= m;
614: }
615:
616: /*
617: * Set synchronous transfer offset and period.
618: */
619: integrate void
620: aic_setsync(struct aic_softc *sc, struct aic_tinfo *ti)
621: {
622: #if AIC_USE_SYNCHRONOUS
623: bus_space_tag_t iot = sc->sc_iot;
624: bus_space_handle_t ioh = sc->sc_ioh;
625:
626: if (ti->offset != 0)
627: bus_space_write_1(iot, ioh, SCSIRATE,
628: ((ti->period * sc->sc_freq) / 250 - 2) << 4 | ti->offset);
629: else
630: bus_space_write_1(iot, ioh, SCSIRATE, 0);
631: #endif
632: }
633:
634: /*
635: * Start a selection. This is used by aic_sched() to select an idle target,
636: * and by aic_done() to immediately reselect a target to get sense information.
637: */
638: void
639: aic_select(struct aic_softc *sc, struct aic_acb *acb)
640: {
641: bus_space_tag_t iot = sc->sc_iot;
642: bus_space_handle_t ioh = sc->sc_ioh;
643: struct scsi_link *sc_link = acb->xs->sc_link;
644: int target = sc_link->target;
645: struct aic_tinfo *ti = &sc->sc_tinfo[target];
646:
647: bus_space_write_1(iot, ioh, SCSIID,
648: sc->sc_initiator << OID_S | target);
649: aic_setsync(sc, ti);
650: bus_space_write_1(iot, ioh, SXFRCTL1, STIMO_256ms | ENSTIMER);
651:
652: /* Always enable reselections. */
653: bus_space_write_1(iot, ioh, SIMODE0, ENSELDI | ENSELDO);
654: bus_space_write_1(iot, ioh, SIMODE1, ENSCSIRST | ENSELTIMO);
655: bus_space_write_1(iot, ioh, SCSISEQ, ENRESELI | ENSELO | ENAUTOATNO);
656:
657: sc->sc_state = AIC_SELECTING;
658: }
659:
660: int
661: aic_reselect(struct aic_softc *sc, int message)
662: {
663: u_char selid, target, lun;
664: struct aic_acb *acb;
665: struct scsi_link *sc_link;
666: struct aic_tinfo *ti;
667:
668: /*
669: * The SCSI chip made a snapshot of the data bus while the reselection
670: * was being negotiated. This enables us to determine which target did
671: * the reselect.
672: */
673: selid = sc->sc_selid & ~(1 << sc->sc_initiator);
674: if (selid & (selid - 1)) {
675: printf("%s: reselect with invalid selid %02x; ",
676: sc->sc_dev.dv_xname, selid);
677: printf("sending DEVICE RESET\n");
678: AIC_BREAK();
679: goto reset;
680: }
681:
682: /* Search wait queue for disconnected cmd
683: * The list should be short, so I haven't bothered with
684: * any more sophisticated structures than a simple
685: * singly linked list.
686: */
687: target = ffs(selid) - 1;
688: lun = message & 0x07;
689: TAILQ_FOREACH(acb, &sc->nexus_list, chain) {
690: sc_link = acb->xs->sc_link;
691: if (sc_link->target == target && sc_link->lun == lun)
692: break;
693: }
694: if (acb == NULL) {
695: printf("%s: reselect from target %d lun %d with no nexus; ",
696: sc->sc_dev.dv_xname, target, lun);
697: printf("sending ABORT\n");
698: AIC_BREAK();
699: goto abort;
700: }
701:
702: /* Make this nexus active again. */
703: TAILQ_REMOVE(&sc->nexus_list, acb, chain);
704: sc->sc_state = AIC_CONNECTED;
705: sc->sc_nexus = acb;
706: ti = &sc->sc_tinfo[target];
707: ti->lubusy |= (1 << lun);
708: aic_setsync(sc, ti);
709:
710: if (acb->flags & ACB_RESET)
711: aic_sched_msgout(sc, SEND_DEV_RESET);
712: else if (acb->flags & ACB_ABORT)
713: aic_sched_msgout(sc, SEND_ABORT);
714:
715: /* Do an implicit RESTORE POINTERS. */
716: sc->sc_dp = acb->data_addr;
717: sc->sc_dleft = acb->data_length;
718: sc->sc_cp = (u_char *)&acb->scsi_cmd;
719: sc->sc_cleft = acb->scsi_cmd_length;
720:
721: return (0);
722:
723: reset:
724: aic_sched_msgout(sc, SEND_DEV_RESET);
725: return (1);
726:
727: abort:
728: aic_sched_msgout(sc, SEND_ABORT);
729: return (1);
730: }
731:
732: /*
733: * Schedule a SCSI operation. This has now been pulled out of the interrupt
734: * handler so that we may call it from aic_scsi_cmd and aic_done. This may
735: * save us an unnecessary interrupt just to get things going. Should only be
736: * called when state == AIC_IDLE and at bio pl.
737: */
738: void
739: aic_sched(struct aic_softc *sc)
740: {
741: bus_space_tag_t iot = sc->sc_iot;
742: bus_space_handle_t ioh = sc->sc_ioh;
743: struct aic_acb *acb;
744: struct scsi_link *sc_link;
745: struct aic_tinfo *ti;
746:
747: /*
748: * Find first acb in ready queue that is for a target/lunit pair that
749: * is not busy.
750: */
751: bus_space_write_1(iot, ioh, CLRSINT1,
752: CLRSELTIMO | CLRBUSFREE | CLRSCSIPERR);
753: TAILQ_FOREACH(acb, &sc->ready_list, chain) {
754: sc_link = acb->xs->sc_link;
755: ti = &sc->sc_tinfo[sc_link->target];
756: if ((ti->lubusy & (1 << sc_link->lun)) == 0) {
757: AIC_MISC(("selecting %d:%d ",
758: sc_link->target, sc_link->lun));
759: TAILQ_REMOVE(&sc->ready_list, acb, chain);
760: sc->sc_nexus = acb;
761: aic_select(sc, acb);
762: return;
763: } else
764: AIC_MISC(("%d:%d busy\n",
765: sc_link->target, sc_link->lun));
766: }
767: AIC_MISC(("idle "));
768: /* Nothing to start; just enable reselections and wait. */
769: bus_space_write_1(iot, ioh, SIMODE0, ENSELDI);
770: bus_space_write_1(iot, ioh, SIMODE1, ENSCSIRST);
771: bus_space_write_1(iot, ioh, SCSISEQ, ENRESELI);
772: }
773:
774: void
775: aic_sense(struct aic_softc *sc, struct aic_acb *acb)
776: {
777: struct scsi_xfer *xs = acb->xs;
778: struct scsi_link *sc_link = xs->sc_link;
779: struct aic_tinfo *ti = &sc->sc_tinfo[sc_link->target];
780: struct scsi_sense *ss = (void *)&acb->scsi_cmd;
781:
782: AIC_MISC(("requesting sense "));
783: /* Next, setup a request sense command block */
784: bzero(ss, sizeof(*ss));
785: ss->opcode = REQUEST_SENSE;
786: ss->byte2 = sc_link->lun << 5;
787: ss->length = sizeof(struct scsi_sense_data);
788: acb->scsi_cmd_length = sizeof(*ss);
789: acb->data_addr = (char *)&xs->sense;
790: acb->data_length = sizeof(struct scsi_sense_data);
791: acb->flags |= ACB_SENSE;
792: ti->senses++;
793: if (acb->flags & ACB_NEXUS)
794: ti->lubusy &= ~(1 << sc_link->lun);
795: if (acb == sc->sc_nexus) {
796: aic_select(sc, acb);
797: } else {
798: aic_dequeue(sc, acb);
799: TAILQ_INSERT_HEAD(&sc->ready_list, acb, chain);
800: if (sc->sc_state == AIC_IDLE)
801: aic_sched(sc);
802: }
803: }
804:
805: /*
806: * POST PROCESSING OF SCSI_CMD (usually current)
807: */
808: void
809: aic_done(struct aic_softc *sc, struct aic_acb *acb)
810: {
811: struct scsi_xfer *xs = acb->xs;
812: struct scsi_link *sc_link = xs->sc_link;
813: struct aic_tinfo *ti = &sc->sc_tinfo[sc_link->target];
814:
815: AIC_TRACE(("aic_done "));
816:
817: /*
818: * Now, if we've come here with no error code, i.e. we've kept the
819: * initial XS_NOERROR, and the status code signals that we should
820: * check sense, we'll need to set up a request sense cmd block and
821: * push the command back into the ready queue *before* any other
822: * commands for this target/lunit, else we lose the sense info.
823: * We don't support chk sense conditions for the request sense cmd.
824: */
825: if (xs->error == XS_NOERROR) {
826: if (acb->flags & ACB_ABORT) {
827: xs->error = XS_DRIVER_STUFFUP;
828: } else if (acb->flags & ACB_SENSE) {
829: xs->error = XS_SENSE;
830: } else if (acb->target_stat == SCSI_CHECK) {
831: /* First, save the return values */
832: xs->resid = acb->data_length;
833: xs->status = acb->target_stat;
834: aic_sense(sc, acb);
835: return;
836: } else {
837: xs->resid = acb->data_length;
838: }
839: }
840:
841: xs->flags |= ITSDONE;
842:
843: #ifdef AIC_DEBUG
844: if ((aic_debug & AIC_SHOWMISC) != 0) {
845: if (xs->resid != 0)
846: printf("resid=%lu ", (u_long)xs->resid);
847: if (xs->error == XS_SENSE)
848: printf("sense=0x%02x\n", xs->sense.error_code);
849: else
850: printf("error=%d\n", xs->error);
851: }
852: #endif
853:
854: /*
855: * Remove the ACB from whatever queue it happens to be on.
856: */
857: if (acb->flags & ACB_NEXUS)
858: ti->lubusy &= ~(1 << sc_link->lun);
859: if (acb == sc->sc_nexus) {
860: sc->sc_nexus = NULL;
861: sc->sc_state = AIC_IDLE;
862: aic_sched(sc);
863: } else
864: aic_dequeue(sc, acb);
865:
866: aic_free_acb(sc, acb, xs->flags);
867: ti->cmds++;
868: scsi_done(xs);
869: }
870:
871: void
872: aic_dequeue(struct aic_softc *sc, struct aic_acb *acb)
873: {
874:
875: if (acb->flags & ACB_NEXUS) {
876: TAILQ_REMOVE(&sc->nexus_list, acb, chain);
877: } else {
878: TAILQ_REMOVE(&sc->ready_list, acb, chain);
879: }
880: }
881:
882: /*
883: * INTERRUPT/PROTOCOL ENGINE
884: */
885:
886: #define IS1BYTEMSG(m) (((m) != 0x01 && (m) < 0x20) || (m) >= 0x80)
887: #define IS2BYTEMSG(m) (((m) & 0xf0) == 0x20)
888: #define ISEXTMSG(m) ((m) == 0x01)
889:
890: /*
891: * Precondition:
892: * The SCSI bus is already in the MSGI phase and there is a message byte
893: * on the bus, along with an asserted REQ signal.
894: */
895: void
896: aic_msgin(struct aic_softc *sc)
897: {
898: bus_space_tag_t iot = sc->sc_iot;
899: bus_space_handle_t ioh = sc->sc_ioh;
900: u_char sstat1;
901: int n;
902:
903: AIC_TRACE(("aic_msgin "));
904:
905: if (sc->sc_prevphase == PH_MSGIN) {
906: /* This is a continuation of the previous message. */
907: n = sc->sc_imp - sc->sc_imess;
908: goto nextbyte;
909: }
910:
911: /* This is a new MESSAGE IN phase. Clean up our state. */
912: sc->sc_flags &= ~AIC_DROP_MSGIN;
913:
914: nextmsg:
915: n = 0;
916: sc->sc_imp = &sc->sc_imess[n];
917:
918: nextbyte:
919: /*
920: * Read a whole message, but don't ack the last byte. If we reject the
921: * message, we have to assert ATN during the message transfer phase
922: * itself.
923: */
924: for (;;) {
925: for (;;) {
926: sstat1 = bus_space_read_1(iot, ioh, SSTAT1);
927: if ((sstat1 & (REQINIT | PHASECHG | BUSFREE)) != 0)
928: break;
929: /* Wait for REQINIT. XXX Need timeout. */
930: }
931: if ((sstat1 & (PHASECHG | BUSFREE)) != 0) {
932: /*
933: * Target left MESSAGE IN, probably because it
934: * a) noticed our ATN signal, or
935: * b) ran out of messages.
936: */
937: goto out;
938: }
939:
940: /* If parity error, just dump everything on the floor. */
941: if ((sstat1 & SCSIPERR) != 0) {
942: sc->sc_flags |= AIC_DROP_MSGIN;
943: aic_sched_msgout(sc, SEND_PARITY_ERROR);
944: }
945:
946: /* Gather incoming message bytes if needed. */
947: if ((sc->sc_flags & AIC_DROP_MSGIN) == 0) {
948: if (n >= AIC_MAX_MSG_LEN) {
949: (void) bus_space_read_1(iot, ioh, SCSIDAT);
950: sc->sc_flags |= AIC_DROP_MSGIN;
951: aic_sched_msgout(sc, SEND_REJECT);
952: } else {
953: *sc->sc_imp++ = bus_space_read_1(iot, ioh,
954: SCSIDAT);
955: n++;
956: /*
957: * This testing is suboptimal, but most
958: * messages will be of the one byte variety, so
959: * it should not affect performance
960: * significantly.
961: */
962: if (n == 1 && IS1BYTEMSG(sc->sc_imess[0]))
963: break;
964: if (n == 2 && IS2BYTEMSG(sc->sc_imess[0]))
965: break;
966: if (n >= 3 && ISEXTMSG(sc->sc_imess[0]) &&
967: n == sc->sc_imess[1] + 2)
968: break;
969: }
970: } else
971: (void) bus_space_read_1(iot, ioh, SCSIDAT);
972:
973: /*
974: * If we reach this spot we're either:
975: * a) in the middle of a multi-byte message, or
976: * b) dropping bytes.
977: */
978: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN | SPIOEN);
979: /* Ack the last byte read. */
980: (void) bus_space_read_1(iot, ioh, SCSIDAT);
981: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN);
982: while ((bus_space_read_1(iot, ioh, SCSISIG) & ACKI) != 0)
983: ;
984: }
985:
986: AIC_MISC(("n=%d imess=0x%02x ", n, sc->sc_imess[0]));
987:
988: /* We now have a complete message. Parse it. */
989: switch (sc->sc_state) {
990: struct aic_acb *acb;
991: struct scsi_link *sc_link;
992: struct aic_tinfo *ti;
993:
994: case AIC_CONNECTED:
995: AIC_ASSERT(sc->sc_nexus != NULL);
996: acb = sc->sc_nexus;
997: ti = &sc->sc_tinfo[acb->xs->sc_link->target];
998:
999: switch (sc->sc_imess[0]) {
1000: case MSG_CMDCOMPLETE:
1001: if ((long)sc->sc_dleft < 0) {
1002: sc_link = acb->xs->sc_link;
1003: printf("%s: %lu extra bytes from %d:%d\n",
1004: sc->sc_dev.dv_xname, (u_long)-sc->sc_dleft,
1005: sc_link->target, sc_link->lun);
1006: acb->data_length = 0;
1007: }
1008: acb->xs->resid = acb->data_length = sc->sc_dleft;
1009: sc->sc_state = AIC_CMDCOMPLETE;
1010: break;
1011:
1012: case MSG_PARITY_ERROR:
1013: /* Resend the last message. */
1014: aic_sched_msgout(sc, sc->sc_lastmsg);
1015: break;
1016:
1017: case MSG_MESSAGE_REJECT:
1018: AIC_MISC(("message rejected %02x ", sc->sc_lastmsg));
1019: switch (sc->sc_lastmsg) {
1020: #if AIC_USE_SYNCHRONOUS + AIC_USE_WIDE
1021: case SEND_IDENTIFY:
1022: ti->flags &= ~(DO_SYNC | DO_WIDE);
1023: ti->period = ti->offset = 0;
1024: aic_setsync(sc, ti);
1025: ti->width = 0;
1026: break;
1027: #endif
1028: #if AIC_USE_SYNCHRONOUS
1029: case SEND_SDTR:
1030: ti->flags &= ~DO_SYNC;
1031: ti->period = ti->offset = 0;
1032: aic_setsync(sc, ti);
1033: break;
1034: #endif
1035: #if AIC_USE_WIDE
1036: case SEND_WDTR:
1037: ti->flags &= ~DO_WIDE;
1038: ti->width = 0;
1039: break;
1040: #endif
1041: case SEND_INIT_DET_ERR:
1042: aic_sched_msgout(sc, SEND_ABORT);
1043: break;
1044: }
1045: break;
1046:
1047: case MSG_NOOP:
1048: break;
1049:
1050: case MSG_DISCONNECT:
1051: ti->dconns++;
1052: sc->sc_state = AIC_DISCONNECT;
1053: break;
1054:
1055: case MSG_SAVEDATAPOINTER:
1056: acb->data_addr = sc->sc_dp;
1057: acb->data_length = sc->sc_dleft;
1058: break;
1059:
1060: case MSG_RESTOREPOINTERS:
1061: sc->sc_dp = acb->data_addr;
1062: sc->sc_dleft = acb->data_length;
1063: sc->sc_cp = (u_char *)&acb->scsi_cmd;
1064: sc->sc_cleft = acb->scsi_cmd_length;
1065: break;
1066:
1067: case MSG_EXTENDED:
1068: switch (sc->sc_imess[2]) {
1069: #if AIC_USE_SYNCHRONOUS
1070: case MSG_EXT_SDTR:
1071: if (sc->sc_imess[1] != 3)
1072: goto reject;
1073: ti->period = sc->sc_imess[3];
1074: ti->offset = sc->sc_imess[4];
1075: ti->flags &= ~DO_SYNC;
1076: if (ti->offset == 0) {
1077: } else if (ti->period < sc->sc_minsync ||
1078: ti->period > sc->sc_maxsync ||
1079: ti->offset > 8) {
1080: ti->period = ti->offset = 0;
1081: aic_sched_msgout(sc, SEND_SDTR);
1082: } else {
1083: sc_print_addr(acb->xs->sc_link);
1084: printf("sync, offset %d, ",
1085: ti->offset);
1086: printf("period %dnsec\n",
1087: ti->period * 4);
1088: }
1089: aic_setsync(sc, ti);
1090: break;
1091: #endif
1092:
1093: #if AIC_USE_WIDE
1094: case MSG_EXT_WDTR:
1095: if (sc->sc_imess[1] != 2)
1096: goto reject;
1097: ti->width = sc->sc_imess[3];
1098: ti->flags &= ~DO_WIDE;
1099: if (ti->width == 0) {
1100: } else if (ti->width > AIC_MAX_WIDTH) {
1101: ti->width = 0;
1102: aic_sched_msgout(sc, SEND_WDTR);
1103: } else {
1104: sc_print_addr(acb->xs->sc_link);
1105: printf("wide, width %d\n",
1106: 1 << (3 + ti->width));
1107: }
1108: break;
1109: #endif
1110:
1111: default:
1112: printf("%s: unrecognized MESSAGE EXTENDED; ",
1113: sc->sc_dev.dv_xname);
1114: printf("sending REJECT\n");
1115: AIC_BREAK();
1116: goto reject;
1117: }
1118: break;
1119:
1120: default:
1121: printf("%s: unrecognized MESSAGE; sending REJECT\n",
1122: sc->sc_dev.dv_xname);
1123: AIC_BREAK();
1124: reject:
1125: aic_sched_msgout(sc, SEND_REJECT);
1126: break;
1127: }
1128: break;
1129:
1130: case AIC_RESELECTED:
1131: if (!MSG_ISIDENTIFY(sc->sc_imess[0])) {
1132: printf("%s: reselect without IDENTIFY; ",
1133: sc->sc_dev.dv_xname);
1134: printf("sending DEVICE RESET\n");
1135: AIC_BREAK();
1136: goto reset;
1137: }
1138:
1139: (void) aic_reselect(sc, sc->sc_imess[0]);
1140: break;
1141:
1142: default:
1143: printf("%s: unexpected MESSAGE IN; sending DEVICE RESET\n",
1144: sc->sc_dev.dv_xname);
1145: AIC_BREAK();
1146: reset:
1147: aic_sched_msgout(sc, SEND_DEV_RESET);
1148: break;
1149:
1150: #ifdef notdef
1151: abort:
1152: aic_sched_msgout(sc, SEND_ABORT);
1153: break;
1154: #endif
1155: }
1156:
1157: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN | SPIOEN);
1158: /* Ack the last message byte. */
1159: (void) bus_space_read_1(iot, ioh, SCSIDAT);
1160: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN);
1161: while ((bus_space_read_1(iot, ioh, SCSISIG) & ACKI) != 0)
1162: ;
1163:
1164: /* Go get the next message, if any. */
1165: goto nextmsg;
1166:
1167: out:
1168: AIC_MISC(("n=%d imess=0x%02x ", n, sc->sc_imess[0]));
1169: }
1170:
1171: /*
1172: * Send the highest priority, scheduled message.
1173: */
1174: void
1175: aic_msgout(struct aic_softc *sc)
1176: {
1177: bus_space_tag_t iot = sc->sc_iot;
1178: bus_space_handle_t ioh = sc->sc_ioh;
1179: #if AIC_USE_SYNCHRONOUS
1180: struct aic_tinfo *ti;
1181: #endif
1182: u_char sstat1;
1183: int n;
1184:
1185: AIC_TRACE(("aic_msgout "));
1186:
1187: /* Reset the FIFO. */
1188: bus_space_write_1(iot, ioh, DMACNTRL0, RSTFIFO);
1189: /* Enable REQ/ACK protocol. */
1190: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN | SPIOEN);
1191:
1192: if (sc->sc_prevphase == PH_MSGOUT) {
1193: if (sc->sc_omp == sc->sc_omess) {
1194: /*
1195: * This is a retransmission.
1196: *
1197: * We get here if the target stayed in MESSAGE OUT
1198: * phase. Section 5.1.9.2 of the SCSI 2 spec indicates
1199: * that all of the previously transmitted messages must
1200: * be sent again, in the same order. Therefore, we
1201: * requeue all the previously transmitted messages, and
1202: * start again from the top. Our simple priority
1203: * scheme keeps the messages in the right order.
1204: */
1205: AIC_MISC(("retransmitting "));
1206: sc->sc_msgpriq |= sc->sc_msgoutq;
1207: /*
1208: * Set ATN. If we're just sending a trivial 1-byte
1209: * message, we'll clear ATN later on anyway.
1210: */
1211: bus_space_write_1(iot, ioh, SCSISIG, PH_MSGOUT | ATNO);
1212: } else {
1213: /* This is a continuation of the previous message. */
1214: n = sc->sc_omp - sc->sc_omess;
1215: goto nextbyte;
1216: }
1217: }
1218:
1219: /* No messages transmitted so far. */
1220: sc->sc_msgoutq = 0;
1221: sc->sc_lastmsg = 0;
1222:
1223: nextmsg:
1224: /* Pick up highest priority message. */
1225: sc->sc_currmsg = sc->sc_msgpriq & -sc->sc_msgpriq;
1226: sc->sc_msgpriq &= ~sc->sc_currmsg;
1227: sc->sc_msgoutq |= sc->sc_currmsg;
1228:
1229: /* Build the outgoing message data. */
1230: switch (sc->sc_currmsg) {
1231: case SEND_IDENTIFY:
1232: AIC_ASSERT(sc->sc_nexus != NULL);
1233: sc->sc_omess[0] =
1234: MSG_IDENTIFY(sc->sc_nexus->xs->sc_link->lun, 1);
1235: n = 1;
1236: break;
1237:
1238: #if AIC_USE_SYNCHRONOUS
1239: case SEND_SDTR:
1240: AIC_ASSERT(sc->sc_nexus != NULL);
1241: ti = &sc->sc_tinfo[sc->sc_nexus->xs->sc_link->target];
1242: sc->sc_omess[4] = MSG_EXTENDED;
1243: sc->sc_omess[3] = 3;
1244: sc->sc_omess[2] = MSG_EXT_SDTR;
1245: sc->sc_omess[1] = ti->period >> 2;
1246: sc->sc_omess[0] = ti->offset;
1247: n = 5;
1248: break;
1249: #endif
1250:
1251: #if AIC_USE_WIDE
1252: case SEND_WDTR:
1253: AIC_ASSERT(sc->sc_nexus != NULL);
1254: ti = &sc->sc_tinfo[sc->sc_nexus->xs->sc_link->target];
1255: sc->sc_omess[3] = MSG_EXTENDED;
1256: sc->sc_omess[2] = 2;
1257: sc->sc_omess[1] = MSG_EXT_WDTR;
1258: sc->sc_omess[0] = ti->width;
1259: n = 4;
1260: break;
1261: #endif
1262:
1263: case SEND_DEV_RESET:
1264: sc->sc_flags |= AIC_ABORTING;
1265: sc->sc_omess[0] = MSG_BUS_DEV_RESET;
1266: n = 1;
1267: break;
1268:
1269: case SEND_REJECT:
1270: sc->sc_omess[0] = MSG_MESSAGE_REJECT;
1271: n = 1;
1272: break;
1273:
1274: case SEND_PARITY_ERROR:
1275: sc->sc_omess[0] = MSG_PARITY_ERROR;
1276: n = 1;
1277: break;
1278:
1279: case SEND_INIT_DET_ERR:
1280: sc->sc_omess[0] = MSG_INITIATOR_DET_ERR;
1281: n = 1;
1282: break;
1283:
1284: case SEND_ABORT:
1285: sc->sc_flags |= AIC_ABORTING;
1286: sc->sc_omess[0] = MSG_ABORT;
1287: n = 1;
1288: break;
1289:
1290: default:
1291: printf("%s: unexpected MESSAGE OUT; sending NOOP\n",
1292: sc->sc_dev.dv_xname);
1293: AIC_BREAK();
1294: sc->sc_omess[0] = MSG_NOOP;
1295: n = 1;
1296: break;
1297: }
1298: sc->sc_omp = &sc->sc_omess[n];
1299:
1300: nextbyte:
1301: /* Send message bytes. */
1302: for (;;) {
1303: for (;;) {
1304: sstat1 = bus_space_read_1(iot, ioh, SSTAT1);
1305: if ((sstat1 & (REQINIT | PHASECHG | BUSFREE)) != 0)
1306: break;
1307: /* Wait for REQINIT. XXX Need timeout. */
1308: }
1309: if ((sstat1 & (PHASECHG | BUSFREE)) != 0) {
1310: /*
1311: * Target left MESSAGE OUT, possibly to reject
1312: * our message.
1313: *
1314: * If this is the last message being sent, then we
1315: * deassert ATN, since either the target is going to
1316: * ignore this message, or it's going to ask for a
1317: * retransmission via MESSAGE PARITY ERROR (in which
1318: * case we reassert ATN anyway).
1319: */
1320: if (sc->sc_msgpriq == 0)
1321: bus_space_write_1(iot, ioh, CLRSINT1, CLRATNO);
1322: goto out;
1323: }
1324:
1325: /* Clear ATN before last byte if this is the last message. */
1326: if (n == 1 && sc->sc_msgpriq == 0)
1327: bus_space_write_1(iot, ioh, CLRSINT1, CLRATNO);
1328: /* Send message byte. */
1329: bus_space_write_1(iot, ioh, SCSIDAT, *--sc->sc_omp);
1330: --n;
1331: /* Keep track of the last message we've sent any bytes of. */
1332: sc->sc_lastmsg = sc->sc_currmsg;
1333: /* Wait for ACK to be negated. XXX Need timeout. */
1334: while ((bus_space_read_1(iot, ioh, SCSISIG) & ACKI) != 0)
1335: ;
1336:
1337: if (n == 0)
1338: break;
1339: }
1340:
1341: /* We get here only if the entire message has been transmitted. */
1342: if (sc->sc_msgpriq != 0) {
1343: /* There are more outgoing messages. */
1344: goto nextmsg;
1345: }
1346:
1347: /*
1348: * The last message has been transmitted. We need to remember the last
1349: * message transmitted (in case the target switches to MESSAGE IN phase
1350: * and sends a MESSAGE REJECT), and the list of messages transmitted
1351: * this time around (in case the target stays in MESSAGE OUT phase to
1352: * request a retransmit).
1353: */
1354:
1355: out:
1356: /* Disable REQ/ACK protocol. */
1357: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN);
1358: }
1359:
1360: /* aic_dataout_pio: perform a data transfer using the FIFO datapath in the aic6360
1361: * Precondition: The SCSI bus should be in the DOUT phase, with REQ asserted
1362: * and ACK deasserted (i.e. waiting for a data byte).
1363: * This new revision has been optimized (I tried) to make the common case fast,
1364: * and the rarer cases (as a result) somewhat more complex.
1365: */
1366: int
1367: aic_dataout_pio(struct aic_softc *sc, u_char *p, int n)
1368: {
1369: bus_space_tag_t iot = sc->sc_iot;
1370: bus_space_handle_t ioh = sc->sc_ioh;
1371: u_char dmastat = 0;
1372: int out = 0;
1373: #define DOUTAMOUNT 128 /* Full FIFO */
1374:
1375: AIC_MISC(("%02x%02x ", bus_space_read_1(iot, ioh, FIFOSTAT),
1376: bus_space_read_1(iot, ioh, SSTAT2)));
1377:
1378: /* Clear host FIFO and counter. */
1379: bus_space_write_1(iot, ioh, DMACNTRL0, RSTFIFO | WRITE);
1380: /* Enable FIFOs. */
1381: bus_space_write_1(iot, ioh, DMACNTRL0, ENDMA | DWORDPIO | WRITE);
1382: bus_space_write_1(iot, ioh, SXFRCTL0, SCSIEN | DMAEN | CHEN);
1383:
1384: /* Turn off ENREQINIT for now. */
1385: bus_space_write_1(iot, ioh, SIMODE1,
1386: ENSCSIRST | ENSCSIPERR | ENBUSFREE | ENPHASECHG);
1387:
1388: /* I have tried to make the main loop as tight as possible. This
1389: * means that some of the code following the loop is a bit more
1390: * complex than otherwise.
1391: */
1392: while (n > 0) {
1393: for (;;) {
1394: dmastat = bus_space_read_1(iot, ioh, DMASTAT);
1395: if ((dmastat & (DFIFOEMP | INTSTAT)) != 0)
1396: break;
1397: }
1398:
1399: if ((dmastat & INTSTAT) != 0)
1400: goto phasechange;
1401:
1402: if (n >= DOUTAMOUNT) {
1403: n -= DOUTAMOUNT;
1404: out += DOUTAMOUNT;
1405:
1406: #if AIC_USE_DWORDS
1407: bus_space_write_multi_4(iot, ioh, DMADATALONG,
1408: (u_int32_t *)p, DOUTAMOUNT >> 2);
1409: #else
1410: bus_space_write_multi_2(iot, ioh, DMADATA,
1411: (u_int16_t *)p, DOUTAMOUNT >> 1);
1412: #endif
1413:
1414: p += DOUTAMOUNT;
1415: } else {
1416: int xfer;
1417:
1418: xfer = n;
1419: AIC_MISC(("%d> ", xfer));
1420:
1421: n -= xfer;
1422: out += xfer;
1423:
1424: #if AIC_USE_DWORDS
1425: if (xfer >= 12) {
1426: bus_space_write_multi_4(iot, ioh, DMADATALONG,
1427: (u_int32_t *)p, xfer >> 2);
1428: p += xfer & ~3;
1429: xfer &= 3;
1430: }
1431: #else
1432: if (xfer >= 8) {
1433: bus_space_write_multi_2(iot, ioh, DMADATA,
1434: (u_int16_t *)p, xfer >> 1);
1435: p += xfer & ~1;
1436: xfer &= 1;
1437: }
1438: #endif
1439:
1440: if (xfer > 0) {
1441: bus_space_write_1(iot, ioh, DMACNTRL0,
1442: ENDMA | B8MODE | WRITE);
1443: bus_space_write_multi_1(iot, ioh, DMADATA, p,
1444: xfer);
1445: p += xfer;
1446: bus_space_write_1(iot, ioh, DMACNTRL0,
1447: ENDMA | DWORDPIO | WRITE);
1448: }
1449: }
1450: }
1451:
1452: if (out == 0) {
1453: bus_space_write_1(iot, ioh, SXFRCTL1, BITBUCKET);
1454: for (;;) {
1455: if ((bus_space_read_1(iot, ioh, DMASTAT) & INTSTAT) !=
1456: 0)
1457: break;
1458: }
1459: bus_space_write_1(iot, ioh, SXFRCTL1, 0);
1460: AIC_MISC(("extra data "));
1461: } else {
1462: /* See the bytes off chip */
1463: for (;;) {
1464: dmastat = bus_space_read_1(iot, ioh, DMASTAT);
1465: if ((dmastat & INTSTAT) != 0)
1466: goto phasechange;
1467: if ((dmastat & DFIFOEMP) != 0 &&
1468: (bus_space_read_1(iot, ioh, SSTAT2) & SEMPTY) != 0)
1469: break;
1470: }
1471: }
1472:
1473: phasechange:
1474: if ((dmastat & INTSTAT) != 0) {
1475: /* Some sort of phase change. */
1476: int amount;
1477:
1478: /* Stop transfers, do some accounting */
1479: amount = bus_space_read_1(iot, ioh, FIFOSTAT) +
1480: (bus_space_read_1(iot, ioh, SSTAT2) & 15);
1481: if (amount > 0) {
1482: out -= amount;
1483: bus_space_write_1(iot, ioh, DMACNTRL0,
1484: RSTFIFO | WRITE);
1485: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN | CLRCH);
1486: AIC_MISC(("+%d ", amount));
1487: }
1488: }
1489:
1490: /* Turn on ENREQINIT again. */
1491: bus_space_write_1(iot, ioh, SIMODE1,
1492: ENSCSIRST | ENSCSIPERR | ENBUSFREE | ENREQINIT | ENPHASECHG);
1493:
1494: /* Stop the FIFO data path. */
1495: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN);
1496: bus_space_write_1(iot, ioh, DMACNTRL0, 0);
1497:
1498: return out;
1499: }
1500:
1501: /* aic_datain_pio: perform data transfers using the FIFO datapath in the aic6360
1502: * Precondition: The SCSI bus should be in the DIN phase, with REQ asserted
1503: * and ACK deasserted (i.e. at least one byte is ready).
1504: * For now, uses a pretty dumb algorithm, hangs around until all data has been
1505: * transferred. This, is OK for fast targets, but not so smart for slow
1506: * targets which don't disconnect or for huge transfers.
1507: */
1508: int
1509: aic_datain_pio(struct aic_softc *sc, u_char *p, int n)
1510: {
1511: bus_space_tag_t iot = sc->sc_iot;
1512: bus_space_handle_t ioh = sc->sc_ioh;
1513: u_char dmastat;
1514: int in = 0;
1515: #define DINAMOUNT 128 /* Full FIFO */
1516:
1517: AIC_MISC(("%02x%02x ", bus_space_read_1(iot, ioh, FIFOSTAT),
1518: bus_space_read_1(iot, ioh, SSTAT2)));
1519:
1520: /* Clear host FIFO and counter. */
1521: bus_space_write_1(iot, ioh, DMACNTRL0, RSTFIFO);
1522: /* Enable FIFOs. */
1523: bus_space_write_1(iot, ioh, DMACNTRL0, ENDMA | DWORDPIO);
1524: bus_space_write_1(iot, ioh, SXFRCTL0, SCSIEN | DMAEN | CHEN);
1525:
1526: /* Turn off ENREQINIT for now. */
1527: bus_space_write_1(iot, ioh, SIMODE1,
1528: ENSCSIRST | ENSCSIPERR | ENBUSFREE | ENPHASECHG);
1529:
1530: /* We leave this loop if one or more of the following is true:
1531: * a) phase != PH_DATAIN && FIFOs are empty
1532: * b) SCSIRSTI is set (a reset has occurred) or busfree is detected.
1533: */
1534: while (n > 0) {
1535: /* Wait for fifo half full or phase mismatch */
1536: for (;;) {
1537: dmastat = bus_space_read_1(iot, ioh, DMASTAT);
1538: if ((dmastat & (DFIFOFULL | INTSTAT)) != 0)
1539: break;
1540: }
1541:
1542: if ((dmastat & DFIFOFULL) != 0) {
1543: n -= DINAMOUNT;
1544: in += DINAMOUNT;
1545:
1546: #if AIC_USE_DWORDS
1547: bus_space_read_multi_4(iot, ioh, DMADATALONG,
1548: (u_int32_t *)p, DINAMOUNT >> 2);
1549: #else
1550: bus_space_read_multi_2(iot, ioh, DMADATA,
1551: (u_int16_t *)p, DINAMOUNT >> 1);
1552: #endif
1553:
1554: p += DINAMOUNT;
1555: } else {
1556: int xfer;
1557:
1558: xfer = min(bus_space_read_1(iot, ioh, FIFOSTAT), n);
1559: AIC_MISC((">%d ", xfer));
1560:
1561: n -= xfer;
1562: in += xfer;
1563:
1564: #if AIC_USE_DWORDS
1565: if (xfer >= 12) {
1566: bus_space_read_multi_4(iot, ioh, DMADATALONG,
1567: (u_int32_t *)p, xfer >> 2);
1568: p += xfer & ~3;
1569: xfer &= 3;
1570: }
1571: #else
1572: if (xfer >= 8) {
1573: bus_space_read_multi_2(iot, ioh, DMADATA,
1574: (u_int16_t *)p, xfer >> 1);
1575: p += xfer & ~1;
1576: xfer &= 1;
1577: }
1578: #endif
1579:
1580: if (xfer > 0) {
1581: bus_space_write_1(iot, ioh, DMACNTRL0,
1582: ENDMA | B8MODE);
1583: bus_space_read_multi_1(iot, ioh, DMADATA, p,
1584: xfer);
1585: p += xfer;
1586: bus_space_write_1(iot, ioh, DMACNTRL0,
1587: ENDMA | DWORDPIO);
1588: }
1589: }
1590:
1591: if ((dmastat & INTSTAT) != 0)
1592: goto phasechange;
1593: }
1594:
1595: /* Some SCSI-devices are rude enough to transfer more data than what
1596: * was requested, e.g. 2048 bytes from a CD-ROM instead of the
1597: * requested 512. Test for progress, i.e. real transfers. If no real
1598: * transfers have been performed (n is probably already zero) and the
1599: * FIFO is not empty, waste some bytes....
1600: */
1601: if (in == 0) {
1602: bus_space_write_1(iot, ioh, SXFRCTL1, BITBUCKET);
1603: for (;;) {
1604: if ((bus_space_read_1(iot, ioh, DMASTAT) & INTSTAT) !=
1605: 0)
1606: break;
1607: }
1608: bus_space_write_1(iot, ioh, SXFRCTL1, 0);
1609: AIC_MISC(("extra data "));
1610: }
1611:
1612: phasechange:
1613: /* Turn on ENREQINIT again. */
1614: bus_space_write_1(iot, ioh, SIMODE1,
1615: ENSCSIRST | ENSCSIPERR | ENBUSFREE | ENREQINIT | ENPHASECHG);
1616:
1617: /* Stop the FIFO data path. */
1618: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN);
1619: bus_space_write_1(iot, ioh, DMACNTRL0, 0);
1620:
1621: return in;
1622: }
1623:
1624: /*
1625: * This is the workhorse routine of the driver.
1626: * Deficiencies (for now):
1627: * 1) always uses programmed I/O
1628: */
1629: int
1630: aicintr(void *arg)
1631: {
1632: struct aic_softc *sc = arg;
1633: bus_space_tag_t iot = sc->sc_iot;
1634: bus_space_handle_t ioh = sc->sc_ioh;
1635: u_char sstat0, sstat1;
1636: struct aic_acb *acb;
1637: struct scsi_link *sc_link;
1638: struct aic_tinfo *ti;
1639: int n;
1640:
1641: /*
1642: * Clear INTEN. We enable it again before returning. This makes the
1643: * interrupt esssentially level-triggered.
1644: */
1645: bus_space_write_1(iot, ioh, DMACNTRL0, 0);
1646:
1647: AIC_TRACE(("aicintr "));
1648:
1649: loop:
1650: /*
1651: * First check for abnormal conditions, such as reset.
1652: */
1653: sstat1 = bus_space_read_1(iot, ioh, SSTAT1);
1654: AIC_MISC(("sstat1:0x%02x ", sstat1));
1655:
1656: if ((sstat1 & SCSIRSTI) != 0) {
1657: printf("%s: SCSI bus reset\n", sc->sc_dev.dv_xname);
1658: goto reset;
1659: }
1660:
1661: /*
1662: * Check for less serious errors.
1663: */
1664: if ((sstat1 & SCSIPERR) != 0) {
1665: printf("%s: SCSI bus parity error\n", sc->sc_dev.dv_xname);
1666: bus_space_write_1(iot, ioh, CLRSINT1, CLRSCSIPERR);
1667: if (sc->sc_prevphase == PH_MSGIN) {
1668: sc->sc_flags |= AIC_DROP_MSGIN;
1669: aic_sched_msgout(sc, SEND_PARITY_ERROR);
1670: } else
1671: aic_sched_msgout(sc, SEND_INIT_DET_ERR);
1672: }
1673:
1674: /*
1675: * If we're not already busy doing something test for the following
1676: * conditions:
1677: * 1) We have been reselected by something
1678: * 2) We have selected something successfully
1679: * 3) Our selection process has timed out
1680: * 4) This is really a bus free interrupt just to get a new command
1681: * going?
1682: * 5) Spurious interrupt?
1683: */
1684: switch (sc->sc_state) {
1685: case AIC_IDLE:
1686: case AIC_SELECTING:
1687: sstat0 = bus_space_read_1(iot, ioh, SSTAT0);
1688: AIC_MISC(("sstat0:0x%02x ", sstat0));
1689:
1690: if ((sstat0 & TARGET) != 0) {
1691: /*
1692: * We don't currently support target mode.
1693: */
1694: printf("%s: target mode selected; going to BUS FREE\n",
1695: sc->sc_dev.dv_xname);
1696: bus_space_write_1(iot, ioh, SCSISIG, 0);
1697:
1698: goto sched;
1699: } else if ((sstat0 & SELDI) != 0) {
1700: AIC_MISC(("reselected "));
1701:
1702: /*
1703: * If we're trying to select a target ourselves,
1704: * push our command back into the ready list.
1705: */
1706: if (sc->sc_state == AIC_SELECTING) {
1707: AIC_MISC(("backoff selector "));
1708: AIC_ASSERT(sc->sc_nexus != NULL);
1709: acb = sc->sc_nexus;
1710: sc->sc_nexus = NULL;
1711: TAILQ_INSERT_HEAD(&sc->ready_list, acb, chain);
1712: }
1713:
1714: /* Save reselection ID. */
1715: sc->sc_selid = bus_space_read_1(iot, ioh, SELID);
1716:
1717: sc->sc_state = AIC_RESELECTED;
1718: } else if ((sstat0 & SELDO) != 0) {
1719: AIC_MISC(("selected "));
1720:
1721: /* We have selected a target. Things to do:
1722: * a) Determine what message(s) to send.
1723: * b) Verify that we're still selecting the target.
1724: * c) Mark device as busy.
1725: */
1726: if (sc->sc_state != AIC_SELECTING) {
1727: printf("%s: selection out while idle; ",
1728: sc->sc_dev.dv_xname);
1729: printf("resetting\n");
1730: AIC_BREAK();
1731: goto reset;
1732: }
1733: AIC_ASSERT(sc->sc_nexus != NULL);
1734: acb = sc->sc_nexus;
1735: sc_link = acb->xs->sc_link;
1736: ti = &sc->sc_tinfo[sc_link->target];
1737:
1738: sc->sc_msgpriq = SEND_IDENTIFY;
1739: if (acb->flags & ACB_RESET)
1740: sc->sc_msgpriq |= SEND_DEV_RESET;
1741: else if (acb->flags & ACB_ABORT)
1742: sc->sc_msgpriq |= SEND_ABORT;
1743: else {
1744: #if AIC_USE_SYNCHRONOUS
1745: if ((ti->flags & DO_SYNC) != 0)
1746: sc->sc_msgpriq |= SEND_SDTR;
1747: #endif
1748: #if AIC_USE_WIDE
1749: if ((ti->flags & DO_WIDE) != 0)
1750: sc->sc_msgpriq |= SEND_WDTR;
1751: #endif
1752: }
1753:
1754: acb->flags |= ACB_NEXUS;
1755: ti->lubusy |= (1 << sc_link->lun);
1756:
1757: /* Do an implicit RESTORE POINTERS. */
1758: sc->sc_dp = acb->data_addr;
1759: sc->sc_dleft = acb->data_length;
1760: sc->sc_cp = (u_char *)&acb->scsi_cmd;
1761: sc->sc_cleft = acb->scsi_cmd_length;
1762:
1763: /* On our first connection, schedule a timeout. */
1764: if ((acb->xs->flags & SCSI_POLL) == 0)
1765: timeout_add(&acb->xs->stimeout,
1766: (acb->timeout * hz) / 1000);
1767:
1768: sc->sc_state = AIC_CONNECTED;
1769: } else if ((sstat1 & SELTO) != 0) {
1770: AIC_MISC(("selection timeout "));
1771:
1772: if (sc->sc_state != AIC_SELECTING) {
1773: printf("%s: selection timeout while idle; ",
1774: sc->sc_dev.dv_xname);
1775: printf("resetting\n");
1776: AIC_BREAK();
1777: goto reset;
1778: }
1779: AIC_ASSERT(sc->sc_nexus != NULL);
1780: acb = sc->sc_nexus;
1781:
1782: bus_space_write_1(iot, ioh, SXFRCTL1, 0);
1783: bus_space_write_1(iot, ioh, SCSISEQ, ENRESELI);
1784: bus_space_write_1(iot, ioh, CLRSINT1, CLRSELTIMO);
1785: delay(250);
1786:
1787: acb->xs->error = XS_SELTIMEOUT;
1788: goto finish;
1789: } else {
1790: if (sc->sc_state != AIC_IDLE) {
1791: printf("%s: BUS FREE while not idle; ",
1792: sc->sc_dev.dv_xname);
1793: printf("state=%d\n", sc->sc_state);
1794: AIC_BREAK();
1795: goto out;
1796: }
1797:
1798: goto sched;
1799: }
1800:
1801: /*
1802: * Turn off selection stuff, and prepare to catch bus free
1803: * interrupts, parity errors, and phase changes.
1804: */
1805: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN | CLRSTCNT | CLRCH);
1806: bus_space_write_1(iot, ioh, SXFRCTL1, 0);
1807: bus_space_write_1(iot, ioh, SCSISEQ, ENAUTOATNP);
1808: bus_space_write_1(iot, ioh, CLRSINT0, CLRSELDI | CLRSELDO);
1809: bus_space_write_1(iot, ioh, CLRSINT1,
1810: CLRBUSFREE | CLRPHASECHG);
1811: bus_space_write_1(iot, ioh, SIMODE0, 0);
1812: bus_space_write_1(iot, ioh, SIMODE1,
1813: ENSCSIRST | ENSCSIPERR | ENBUSFREE | ENREQINIT |
1814: ENPHASECHG);
1815:
1816: sc->sc_flags = 0;
1817: sc->sc_prevphase = PH_INVALID;
1818: goto dophase;
1819: }
1820:
1821: if ((sstat1 & BUSFREE) != 0) {
1822: /* We've gone to BUS FREE phase. */
1823: bus_space_write_1(iot, ioh, CLRSINT1,
1824: CLRBUSFREE | CLRPHASECHG);
1825:
1826: switch (sc->sc_state) {
1827: case AIC_RESELECTED:
1828: goto sched;
1829:
1830: case AIC_CONNECTED:
1831: AIC_ASSERT(sc->sc_nexus != NULL);
1832: acb = sc->sc_nexus;
1833:
1834: #if AIC_USE_SYNCHRONOUS + AIC_USE_WIDE
1835: if (sc->sc_prevphase == PH_MSGOUT) {
1836: /*
1837: * If the target went to BUS FREE phase during
1838: * or immediately after sending a SDTR or WDTR
1839: * message, disable negotiation.
1840: */
1841: sc_link = acb->xs->sc_link;
1842: ti = &sc->sc_tinfo[sc_link->target];
1843: switch (sc->sc_lastmsg) {
1844: #if AIC_USE_SYNCHRONOUS
1845: case SEND_SDTR:
1846: ti->flags &= ~DO_SYNC;
1847: ti->period = ti->offset = 0;
1848: break;
1849: #endif
1850: #if AIC_USE_WIDE
1851: case SEND_WDTR:
1852: ti->flags &= ~DO_WIDE;
1853: ti->width = 0;
1854: break;
1855: #endif
1856: }
1857: }
1858: #endif
1859:
1860: if ((sc->sc_flags & AIC_ABORTING) == 0) {
1861: /*
1862: * Section 5.1.1 of the SCSI 2 spec suggests
1863: * issuing a REQUEST SENSE following an
1864: * unexpected disconnect. Some devices go into
1865: * a contingent allegiance condition when
1866: * disconnecting, and this is necessary to
1867: * clean up their state.
1868: */
1869: printf("%s: unexpected disconnect; ",
1870: sc->sc_dev.dv_xname);
1871: printf("sending REQUEST SENSE\n");
1872: AIC_BREAK();
1873: aic_sense(sc, acb);
1874: goto out;
1875: }
1876:
1877: acb->xs->error = XS_DRIVER_STUFFUP;
1878: goto finish;
1879:
1880: case AIC_DISCONNECT:
1881: AIC_ASSERT(sc->sc_nexus != NULL);
1882: acb = sc->sc_nexus;
1883: #if 1 /* XXXX */
1884: acb->data_addr = sc->sc_dp;
1885: acb->data_length = sc->sc_dleft;
1886: #endif
1887: TAILQ_INSERT_HEAD(&sc->nexus_list, acb, chain);
1888: sc->sc_nexus = NULL;
1889: goto sched;
1890:
1891: case AIC_CMDCOMPLETE:
1892: AIC_ASSERT(sc->sc_nexus != NULL);
1893: acb = sc->sc_nexus;
1894: goto finish;
1895: }
1896: }
1897:
1898: bus_space_write_1(iot, ioh, CLRSINT1, CLRPHASECHG);
1899:
1900: dophase:
1901: if ((sstat1 & REQINIT) == 0) {
1902: /* Wait for REQINIT. */
1903: goto out;
1904: }
1905:
1906: sc->sc_phase = bus_space_read_1(iot, ioh, SCSISIG) & PH_MASK;
1907: bus_space_write_1(iot, ioh, SCSISIG, sc->sc_phase);
1908:
1909: switch (sc->sc_phase) {
1910: case PH_MSGOUT:
1911: if (sc->sc_state != AIC_CONNECTED &&
1912: sc->sc_state != AIC_RESELECTED)
1913: break;
1914: aic_msgout(sc);
1915: sc->sc_prevphase = PH_MSGOUT;
1916: goto loop;
1917:
1918: case PH_MSGIN:
1919: if (sc->sc_state != AIC_CONNECTED &&
1920: sc->sc_state != AIC_RESELECTED)
1921: break;
1922: aic_msgin(sc);
1923: sc->sc_prevphase = PH_MSGIN;
1924: goto loop;
1925:
1926: case PH_CMD:
1927: if (sc->sc_state != AIC_CONNECTED)
1928: break;
1929: #ifdef AIC_DEBUG
1930: if ((aic_debug & AIC_SHOWMISC) != 0) {
1931: AIC_ASSERT(sc->sc_nexus != NULL);
1932: acb = sc->sc_nexus;
1933: printf("cmd=0x%02x+%d ",
1934: acb->scsi_cmd.opcode, acb->scsi_cmd_length-1);
1935: }
1936: #endif
1937: n = aic_dataout_pio(sc, sc->sc_cp, sc->sc_cleft);
1938: sc->sc_cp += n;
1939: sc->sc_cleft -= n;
1940: sc->sc_prevphase = PH_CMD;
1941: goto loop;
1942:
1943: case PH_DATAOUT:
1944: if (sc->sc_state != AIC_CONNECTED)
1945: break;
1946: AIC_MISC(("dataout dleft=%lu ", (u_long)sc->sc_dleft));
1947: n = aic_dataout_pio(sc, sc->sc_dp, sc->sc_dleft);
1948: sc->sc_dp += n;
1949: sc->sc_dleft -= n;
1950: sc->sc_prevphase = PH_DATAOUT;
1951: goto loop;
1952:
1953: case PH_DATAIN:
1954: if (sc->sc_state != AIC_CONNECTED)
1955: break;
1956: AIC_MISC(("datain %lu ", (u_long)sc->sc_dleft));
1957: n = aic_datain_pio(sc, sc->sc_dp, sc->sc_dleft);
1958: sc->sc_dp += n;
1959: sc->sc_dleft -= n;
1960: sc->sc_prevphase = PH_DATAIN;
1961: goto loop;
1962:
1963: case PH_STAT:
1964: if (sc->sc_state != AIC_CONNECTED)
1965: break;
1966: AIC_ASSERT(sc->sc_nexus != NULL);
1967: acb = sc->sc_nexus;
1968: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN | SPIOEN);
1969: acb->target_stat = bus_space_read_1(iot, ioh, SCSIDAT);
1970: bus_space_write_1(iot, ioh, SXFRCTL0, CHEN);
1971: AIC_MISC(("target_stat=0x%02x ", acb->target_stat));
1972: sc->sc_prevphase = PH_STAT;
1973: goto loop;
1974: }
1975:
1976: printf("%s: unexpected bus phase; resetting\n", sc->sc_dev.dv_xname);
1977: AIC_BREAK();
1978: reset:
1979: aic_init(sc);
1980: return 1;
1981:
1982: finish:
1983: timeout_del(&acb->xs->stimeout);
1984: aic_done(sc, acb);
1985: goto out;
1986:
1987: sched:
1988: sc->sc_state = AIC_IDLE;
1989: aic_sched(sc);
1990: goto out;
1991:
1992: out:
1993: bus_space_write_1(iot, ioh, DMACNTRL0, INTEN);
1994: return 1;
1995: }
1996:
1997: void
1998: aic_abort(struct aic_softc *sc, struct aic_acb *acb)
1999: {
2000:
2001: /* 2 secs for the abort */
2002: acb->timeout = AIC_ABORT_TIMEOUT;
2003: acb->flags |= ACB_ABORT;
2004:
2005: if (acb == sc->sc_nexus) {
2006: /*
2007: * If we're still selecting, the message will be scheduled
2008: * after selection is complete.
2009: */
2010: if (sc->sc_state == AIC_CONNECTED)
2011: aic_sched_msgout(sc, SEND_ABORT);
2012: } else {
2013: aic_dequeue(sc, acb);
2014: TAILQ_INSERT_HEAD(&sc->ready_list, acb, chain);
2015: if (sc->sc_state == AIC_IDLE)
2016: aic_sched(sc);
2017: }
2018: }
2019:
2020: void
2021: aic_timeout(void *arg)
2022: {
2023: struct aic_acb *acb = arg;
2024: struct scsi_xfer *xs = acb->xs;
2025: struct scsi_link *sc_link = xs->sc_link;
2026: struct aic_softc *sc = sc_link->adapter_softc;
2027: int s;
2028:
2029: sc_print_addr(sc_link);
2030: printf("timed out");
2031:
2032: s = splbio();
2033:
2034: if (acb->flags & ACB_ABORT) {
2035: /* abort timed out */
2036: printf(" AGAIN\n");
2037: /* XXX Must reset! */
2038: } else {
2039: /* abort the operation that has timed out */
2040: printf("\n");
2041: acb->xs->error = XS_TIMEOUT;
2042: aic_abort(sc, acb);
2043: }
2044:
2045: splx(s);
2046: }
2047:
2048: #ifdef AIC_DEBUG
2049: /*
2050: * The following functions are mostly used for debugging purposes, either
2051: * directly called from the driver or from the kernel debugger.
2052: */
2053:
2054: void
2055: aic_show_scsi_cmd(struct aic_acb *acb)
2056: {
2057: u_char *b = (u_char *)&acb->scsi_cmd;
2058: struct scsi_link *sc_link = acb->xs->sc_link;
2059: int i;
2060:
2061: sc_print_addr(sc_link);
2062: if ((acb->xs->flags & SCSI_RESET) == 0) {
2063: for (i = 0; i < acb->scsi_cmd_length; i++) {
2064: if (i)
2065: printf(",");
2066: printf("%x", b[i]);
2067: }
2068: printf("\n");
2069: } else
2070: printf("RESET\n");
2071: }
2072:
2073: void
2074: aic_print_acb(struct aic_acb *acb)
2075: {
2076:
2077: printf("acb@%p xs=%p flags=%x", acb, acb->xs, acb->flags);
2078: printf(" dp=%p dleft=%d target_stat=%x\n",
2079: acb->data_addr, acb->data_length, acb->target_stat);
2080: aic_show_scsi_cmd(acb);
2081: }
2082:
2083: void
2084: aic_print_active_acb(void)
2085: {
2086: struct aic_acb *acb;
2087: struct aic_softc *sc = aic_cd.cd_devs[0];
2088:
2089: printf("ready list:\n");
2090: TAILQ_FOREACH(acb, &sc->ready_list, chain)
2091: aic_print_acb(acb);
2092: printf("nexus:\n");
2093: if (sc->sc_nexus != NULL)
2094: aic_print_acb(sc->sc_nexus);
2095: printf("nexus list:\n");
2096: TAILQ_FOREACH(acb, &sc->nexus_list, chain)
2097: aic_print_acb(acb);
2098: }
2099:
2100: void
2101: aic_dump6360(struct aic_softc *sc)
2102: {
2103: bus_space_tag_t iot = sc->sc_iot;
2104: bus_space_handle_t ioh = sc->sc_ioh;
2105:
2106: printf("aic6360: SCSISEQ=%x SXFRCTL0=%x SXFRCTL1=%x SCSISIG=%x\n",
2107: bus_space_read_1(iot, ioh, SCSISEQ),
2108: bus_space_read_1(iot, ioh, SXFRCTL0),
2109: bus_space_read_1(iot, ioh, SXFRCTL1),
2110: bus_space_read_1(iot, ioh, SCSISIG));
2111: printf(" SSTAT0=%x SSTAT1=%x SSTAT2=%x SSTAT3=%x SSTAT4=%x\n",
2112: bus_space_read_1(iot, ioh, SSTAT0),
2113: bus_space_read_1(iot, ioh, SSTAT1),
2114: bus_space_read_1(iot, ioh, SSTAT2),
2115: bus_space_read_1(iot, ioh, SSTAT3),
2116: bus_space_read_1(iot, ioh, SSTAT4));
2117: printf(" SIMODE0=%x SIMODE1=%x ",
2118: bus_space_read_1(iot, ioh, SIMODE0),
2119: bus_space_read_1(iot, ioh, SIMODE1));
2120: printf("DMACNTRL0=%x DMACNTRL1=%x DMASTAT=%x\n",
2121: bus_space_read_1(iot, ioh, DMACNTRL0),
2122: bus_space_read_1(iot, ioh, DMACNTRL1),
2123: bus_space_read_1(iot, ioh, DMASTAT));
2124: printf(" FIFOSTAT=%d SCSIBUS=0x%x\n",
2125: bus_space_read_1(iot, ioh, FIFOSTAT),
2126: bus_space_read_1(iot, ioh, SCSIBUS));
2127: }
2128:
2129: void
2130: aic_dump_driver(struct aic_softc *sc)
2131: {
2132: struct aic_tinfo *ti;
2133: int i;
2134:
2135: printf("nexus=%p prevphase=%x\n", sc->sc_nexus, sc->sc_prevphase);
2136: printf("state=%x msgin=%x ", sc->sc_state, sc->sc_imess[0]);
2137: printf("msgpriq=%x msgoutq=%x lastmsg=%x currmsg=%x\n", sc->sc_msgpriq,
2138: sc->sc_msgoutq, sc->sc_lastmsg, sc->sc_currmsg);
2139: for (i = 0; i < 7; i++) {
2140: ti = &sc->sc_tinfo[i];
2141: printf("tinfo%d: %d cmds %d disconnects %d timeouts",
2142: i, ti->cmds, ti->dconns, ti->touts);
2143: printf(" %d senses flags=%x\n", ti->senses, ti->flags);
2144: }
2145: }
2146: #endif