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