![[BACK]](/icons/back.gif){kind=icon}
Return to osiop.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to osiop.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 1: /* $OpenBSD: osiop.c,v 1.29 2007/06/20 18:02:39 miod Exp $ */
2: /* $NetBSD: osiop.c,v 1.9 2002/04/05 18:27:54 bouyer Exp $ */
3:
4: /*
5: * Copyright (c) 2001 Izumi Tsutsui. All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. The name of the author may not be used to endorse or promote products
16: * derived from this software without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28: */
29:
30: /*
31: * Copyright (c) 1994 Michael L. Hitch
32: * Copyright (c) 1990 The Regents of the University of California.
33: * All rights reserved.
34: *
35: * This code is derived from software contributed to Berkeley by
36: * Van Jacobson of Lawrence Berkeley Laboratory.
37: *
38: * Redistribution and use in source and binary forms, with or without
39: * modification, are permitted provided that the following conditions
40: * are met:
41: * 1. Redistributions of source code must retain the above copyright
42: * notice, this list of conditions and the following disclaimer.
43: * 2. Redistributions in binary form must reproduce the above copyright
44: * notice, this list of conditions and the following disclaimer in the
45: * documentation and/or other materials provided with the distribution.
46: * 3. Neither the name of the University nor the names of its contributors
47: * may be used to endorse or promote products derived from this software
48: * without specific prior written permission.
49: *
50: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
51: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
52: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
53: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
54: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
59: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60: * SUCH DAMAGE.
61: *
62: * @(#)siop.c 7.5 (Berkeley) 5/4/91
63: */
64:
65: /*
66: * MI NCR53C710 scsi adaptor driver; based on arch/amiga/dev/siop.c:
67: * NetBSD: siop.c,v 1.43 1999/09/30 22:59:53 thorpej Exp
68: *
69: * bus_space/bus_dma'fied by Izumi Tsutsui <tsutsui@ceres.dti.ne.jp>
70: */
71:
72: #include <sys/cdefs.h>
73: /* __KERNEL_RCSID(0, "$NetBSD: osiop.c,v 1.9 2002/04/05 18:27:54 bouyer Exp $"); */
74:
75: #include <sys/param.h>
76: #include <sys/systm.h>
77: #include <sys/device.h>
78: #include <sys/malloc.h>
79: #include <sys/buf.h>
80: #include <sys/kernel.h>
81:
82: #include <scsi/scsi_all.h>
83: #include <scsi/scsiconf.h>
84: #include <scsi/scsi_message.h>
85:
86: #include <machine/cpu.h>
87: #include <machine/bus.h>
88:
89: #include <dev/ic/osiopreg.h>
90: #include <dev/ic/osiopvar.h>
91:
92: /* 53C710 script */
93: #include <dev/microcode/siop/osiop.out>
94:
95: void osiop_attach(struct osiop_softc *);
96: void osiop_minphys(struct buf *);
97: int osiop_scsicmd(struct scsi_xfer *xs);
98: void osiop_poll(struct osiop_softc *, struct osiop_acb *);
99: void osiop_sched(struct osiop_softc *);
100: void osiop_scsidone(struct osiop_acb *, int);
101: void osiop_abort(struct osiop_softc *, const char *);
102: void osiop_init(struct osiop_softc *);
103: void osiop_reset(struct osiop_softc *);
104: void osiop_resetbus(struct osiop_softc *);
105: void osiop_start(struct osiop_softc *);
106: int osiop_checkintr(struct osiop_softc *, u_int8_t, u_int8_t, u_int8_t, int *);
107: void osiop_select(struct osiop_softc *);
108: void osiop_update_xfer_mode(struct osiop_softc *, int);
109: void scsi_period_to_osiop(struct osiop_softc *, int);
110: void osiop_timeout(void *);
111:
112: int osiop_reset_delay = 250; /* delay after reset, in milliseconds */
113:
114: /* #define OSIOP_DEBUG */
115: #ifdef OSIOP_DEBUG
116: #define DEBUG_DMA 0x0001
117: #define DEBUG_INT 0x0002
118: #define DEBUG_PHASE 0x0004
119: #define DEBUG_DISC 0x0008
120: #define DEBUG_CMD 0x0010
121: #define DEBUG_SYNC 0x0020
122: #define DEBUG_SCHED 0x0040
123: #define DEBUG_ALL 0xffff
124: int osiop_debug = 0; /*DEBUG_ALL;*/
125: int osiopstarts = 0;
126: int osiopints = 0;
127: int osiopphmm = 0;
128: int osiop_trix = 0;
129: #define OSIOP_TRACE_SIZE 128
130: #define OSIOP_TRACE(a,b,c,d) do { \
131: osiop_trbuf[osiop_trix + 0] = (a); \
132: osiop_trbuf[osiop_trix + 1] = (b); \
133: osiop_trbuf[osiop_trix + 2] = (c); \
134: osiop_trbuf[osiop_trix + 3] = (d); \
135: osiop_trix = (osiop_trix + 4) & (OSIOP_TRACE_SIZE - 1); \
136: } while (0)
137: u_int8_t osiop_trbuf[OSIOP_TRACE_SIZE];
138: void osiop_dump_trace(void);
139: void osiop_dump_acb(struct osiop_acb *);
140: void osiop_dump(struct osiop_softc *);
141: #else
142: #define OSIOP_TRACE(a,b,c,d)
143: #endif
144:
145: #ifdef OSIOP_DEBUG
146: /*
147: * sync period transfer lookup - only valid for 66MHz clock
148: */
149: static struct {
150: u_int8_t p; /* period from sync request message */
151: u_int8_t r; /* siop_period << 4 | sbcl */
152: } sync_tab[] = {
153: { 60/4, 0<<4 | 1},
154: { 76/4, 1<<4 | 1},
155: { 92/4, 2<<4 | 1},
156: { 92/4, 0<<4 | 2},
157: {108/4, 3<<4 | 1},
158: {116/4, 1<<4 | 2},
159: {120/4, 4<<4 | 1},
160: {120/4, 0<<4 | 3},
161: {136/4, 5<<4 | 1},
162: {140/4, 2<<4 | 2},
163: {152/4, 6<<4 | 1},
164: {152/4, 1<<4 | 3},
165: {164/4, 3<<4 | 2},
166: {168/4, 7<<4 | 1},
167: {180/4, 2<<4 | 3},
168: {184/4, 4<<4 | 2},
169: {208/4, 5<<4 | 2},
170: {212/4, 3<<4 | 3},
171: {232/4, 6<<4 | 2},
172: {240/4, 4<<4 | 3},
173: {256/4, 7<<4 | 2},
174: {272/4, 5<<4 | 3},
175: {300/4, 6<<4 | 3},
176: {332/4, 7<<4 | 3}
177: };
178: #endif
179:
180: struct cfdriver osiop_cd = {
181: NULL, "osiop", DV_DULL
182: };
183:
184: struct scsi_adapter osiop_adapter = {
185: osiop_scsicmd,
186: osiop_minphys,
187: NULL,
188: NULL,
189: };
190:
191: struct scsi_device osiop_dev = {
192: NULL,
193: NULL,
194: NULL,
195: NULL,
196: };
197:
198: void
199: osiop_attach(sc)
200: struct osiop_softc *sc;
201: {
202: struct scsibus_attach_args saa;
203: struct osiop_acb *acb;
204: bus_dma_segment_t seg;
205: int nseg;
206: int i, err;
207:
208: /*
209: * Allocate and map DMA-safe memory for the script.
210: */
211: err = bus_dmamem_alloc(sc->sc_dmat, PAGE_SIZE, PAGE_SIZE, 0,
212: &seg, 1, &nseg, BUS_DMA_NOWAIT);
213: if (err) {
214: printf(": failed to allocate script memory, err=%d\n", err);
215: return;
216: }
217: err = bus_dmamem_map(sc->sc_dmat, &seg, nseg, PAGE_SIZE,
218: (caddr_t *)&sc->sc_script, BUS_DMA_NOWAIT | BUS_DMA_COHERENT);
219: if (err) {
220: printf(": failed to map script memory, err=%d\n", err);
221: return;
222: }
223: err = bus_dmamap_create(sc->sc_dmat, PAGE_SIZE, 1, PAGE_SIZE, 0,
224: BUS_DMA_NOWAIT, &sc->sc_scrdma);
225: if (err) {
226: printf(": failed to create script map, err=%d\n", err);
227: return;
228: }
229: err = bus_dmamap_load_raw(sc->sc_dmat, sc->sc_scrdma,
230: &seg, nseg, PAGE_SIZE, BUS_DMA_NOWAIT);
231: if (err) {
232: printf(": failed to load script map, err=%d\n", err);
233: return;
234: }
235: bzero(sc->sc_script, PAGE_SIZE);
236:
237: /*
238: * Copy and sync script
239: */
240: memcpy(sc->sc_script, osiop_script, sizeof(osiop_script));
241: bus_dmamap_sync(sc->sc_dmat, sc->sc_scrdma, 0, sizeof(osiop_script),
242: BUS_DMASYNC_PREWRITE);
243:
244: /*
245: * Allocate and map DMA-safe memory for the script data structure.
246: */
247: err = bus_dmamem_alloc(sc->sc_dmat,
248: sizeof(struct osiop_ds) * OSIOP_NACB, PAGE_SIZE, 0,
249: &seg, 1, &nseg, BUS_DMA_NOWAIT);
250: if (err) {
251: printf(": failed to allocate ds memory, err=%d\n", err);
252: return;
253: }
254: err = bus_dmamem_map(sc->sc_dmat, &seg, nseg,
255: sizeof(struct osiop_ds) * OSIOP_NACB, (caddr_t *)&sc->sc_ds,
256: BUS_DMA_NOWAIT | BUS_DMA_COHERENT);
257: if (err) {
258: printf(": failed to map ds memory, err=%d\n", err);
259: return;
260: }
261: err = bus_dmamap_create(sc->sc_dmat,
262: sizeof(struct osiop_ds) * OSIOP_NACB, 1,
263: sizeof(struct osiop_ds) * OSIOP_NACB, 0,
264: BUS_DMA_NOWAIT, &sc->sc_dsdma);
265: if (err) {
266: printf(": failed to create ds map, err=%d\n", err);
267: return;
268: }
269: err = bus_dmamap_load_raw(sc->sc_dmat, sc->sc_dsdma,
270: &seg, nseg, sizeof(struct osiop_ds) * OSIOP_NACB, BUS_DMA_NOWAIT);
271: if (err) {
272: printf(": failed to load ds map, err=%d\n", err);
273: return;
274: }
275: bzero(sc->sc_ds, sizeof(struct osiop_ds) * OSIOP_NACB);
276:
277: /*
278: * Allocate (malloc) memory for acb's.
279: */
280: acb = malloc(sizeof(struct osiop_acb) * OSIOP_NACB,
281: M_DEVBUF, M_NOWAIT);
282: if (acb == NULL) {
283: printf(": can't allocate memory for acb\n");
284: return;
285: }
286: bzero(acb, sizeof(struct osiop_acb) * OSIOP_NACB);
287: sc->sc_acb = acb;
288:
289: sc->sc_cfflags = sc->sc_dev.dv_cfdata->cf_flags;
290: sc->sc_nexus = NULL;
291: sc->sc_active = 0;
292:
293: bzero(sc->sc_tinfo, sizeof(sc->sc_tinfo));
294:
295: /* Initialize command block queue */
296: TAILQ_INIT(&sc->ready_list);
297: TAILQ_INIT(&sc->nexus_list);
298: TAILQ_INIT(&sc->free_list);
299:
300: /* Initialize each command block */
301: for (i = 0; i < OSIOP_NACB; i++, acb++) {
302: bus_addr_t dsa;
303:
304: err = bus_dmamap_create(sc->sc_dmat, OSIOP_MAX_XFER, OSIOP_NSG,
305: OSIOP_MAX_XFER, 0, BUS_DMA_NOWAIT, &acb->datadma);
306: if (err) {
307: printf(": failed to create datadma map, err=%d\n",
308: err);
309: return;
310: }
311:
312: acb->sc = sc;
313: acb->ds = &sc->sc_ds[i];
314: acb->dsoffset = sizeof(struct osiop_ds) * i;
315:
316: dsa = sc->sc_dsdma->dm_segs[0].ds_addr + acb->dsoffset;
317: acb->ds->id.addr = dsa + OSIOP_DSIDOFF;
318: acb->ds->cmd.addr = dsa + OSIOP_DSCMDOFF;
319: acb->ds->status.count = 1;
320: acb->ds->status.addr = dsa + OSIOP_DSSTATOFF;
321: acb->ds->msg.count = 1;
322: acb->ds->msg.addr = dsa + OSIOP_DSMSGOFF;
323: acb->ds->msgin.count = 1;
324: acb->ds->msgin.addr = dsa + OSIOP_DSMSGINOFF;
325: acb->ds->extmsg.count = 1;
326: acb->ds->extmsg.addr = dsa + OSIOP_DSEXTMSGOFF;
327: acb->ds->synmsg.count = 3;
328: acb->ds->synmsg.addr = dsa + OSIOP_DSSYNMSGOFF;
329: TAILQ_INSERT_TAIL(&sc->free_list, acb, chain);
330: }
331:
332: printf(": NCR53C710 rev %d, %dMHz, SCSI ID %d\n",
333: osiop_read_1(sc, OSIOP_CTEST8) >> 4, sc->sc_clock_freq, sc->sc_id);
334:
335: /*
336: * Initialize all
337: */
338: osiop_init(sc);
339:
340: /*
341: * Fill in the sc_link.
342: */
343: sc->sc_link.adapter = &osiop_adapter;
344: sc->sc_link.adapter_softc = sc;
345: sc->sc_link.device = &osiop_dev;
346: sc->sc_link.openings = 4;
347: sc->sc_link.adapter_buswidth = OSIOP_NTGT;
348: sc->sc_link.adapter_target = sc->sc_id;
349:
350: bzero(&saa, sizeof(saa));
351: saa.saa_sc_link = &sc->sc_link;
352:
353: /*
354: * Now try to attach all the sub devices.
355: */
356: config_found(&sc->sc_dev, &saa, scsiprint);
357: }
358:
359: /*
360: * default minphys routine for osiop based controllers
361: */
362: void
363: osiop_minphys(bp)
364: struct buf *bp;
365: {
366:
367: if (bp->b_bcount > OSIOP_MAX_XFER)
368: bp->b_bcount = OSIOP_MAX_XFER;
369: minphys(bp);
370: }
371:
372: /*
373: * used by specific osiop controller
374: *
375: */
376: int
377: osiop_scsicmd(xs)
378: struct scsi_xfer *xs;
379: {
380: struct scsi_link *periph = xs->sc_link;
381: struct osiop_acb *acb;
382: struct osiop_softc *sc = periph->adapter_softc;
383: int err, s;
384:
385: /* XXXX ?? */
386: if (xs->flags & SCSI_DATA_UIO)
387: panic("osiop: scsi data uio requested");
388:
389: /* XXXX ?? */
390: if (sc->sc_nexus && (xs->flags & SCSI_POLL))
391: #if 0
392: panic("osiop_scsicmd: busy");
393: #else
394: printf("osiop_scsicmd: busy\n");
395: #endif
396:
397: s = splbio();
398: acb = TAILQ_FIRST(&sc->free_list);
399: if (acb != NULL) {
400: TAILQ_REMOVE(&sc->free_list, acb, chain);
401: }
402: else {
403: #ifdef DIAGNOSTIC
404: sc_print_addr(periph);
405: printf("unable to allocate acb\n");
406: panic("osiop_scsipi_request");
407: #endif
408: splx(s);
409: return (TRY_AGAIN_LATER);
410: }
411:
412: acb->flags = 0;
413: acb->status = ACB_S_READY;
414: acb->xs = xs;
415: acb->xsflags = xs->flags;
416: bcopy(xs->cmd, &acb->ds->scsi_cmd, xs->cmdlen);
417: acb->ds->cmd.count = xs->cmdlen;
418: acb->datalen = 0;
419: #ifdef OSIOP_DEBUG
420: acb->data = xs->data;
421: #endif
422:
423: /* Setup DMA map for data buffer */
424: if (acb->xsflags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
425: acb->datalen = xs->datalen;
426: err = bus_dmamap_load(sc->sc_dmat, acb->datadma,
427: xs->data, acb->datalen, NULL,
428: BUS_DMA_NOWAIT | BUS_DMA_STREAMING |
429: ((acb->xsflags & SCSI_DATA_IN) ?
430: BUS_DMA_READ : BUS_DMA_WRITE));
431: if (err) {
432: printf("%s: unable to load data DMA map: %d",
433: sc->sc_dev.dv_xname, err);
434: xs->error = XS_DRIVER_STUFFUP;
435: scsi_done(xs);
436: TAILQ_INSERT_TAIL(&sc->free_list, acb, chain);
437: splx(s);
438: return (COMPLETE);
439: }
440: bus_dmamap_sync(sc->sc_dmat, acb->datadma,
441: 0, acb->datalen, (acb->xsflags & SCSI_DATA_IN) ?
442: BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
443: }
444:
445: /*
446: * Always initialize timeout so it does not contain trash
447: * that could confuse timeout_del().
448: */
449: timeout_set(&xs->stimeout, osiop_timeout, acb);
450:
451: TAILQ_INSERT_TAIL(&sc->ready_list, acb, chain);
452:
453: osiop_sched(sc);
454:
455: splx(s);
456:
457: if ((acb->xsflags & SCSI_POLL) || (sc->sc_flags & OSIOP_NODMA))
458: osiop_poll(sc, acb);
459: else
460: /* start expire timer */
461: timeout_add(&xs->stimeout, (xs->timeout/1000) * hz);
462:
463: if ((xs->flags & ITSDONE) == 0)
464: return (SUCCESSFULLY_QUEUED);
465: else
466: return (COMPLETE);
467: }
468:
469: void
470: osiop_poll(sc, acb)
471: struct osiop_softc *sc;
472: struct osiop_acb *acb;
473: {
474: struct scsi_xfer *xs = acb->xs;
475: int status, i, s, to;
476: u_int8_t istat, dstat, sstat0;
477:
478: s = splbio();
479: to = xs->timeout / 1000;
480: if (!TAILQ_EMPTY(&sc->nexus_list))
481: printf("%s: osiop_poll called with disconnected device\n",
482: sc->sc_dev.dv_xname);
483: for (;;) {
484: i = 1000;
485: while (((istat = osiop_read_1(sc, OSIOP_ISTAT)) &
486: (OSIOP_ISTAT_SIP | OSIOP_ISTAT_DIP)) == 0) {
487: if (i <= 0) {
488: #ifdef OSIOP_DEBUG
489: printf("waiting: tgt %d cmd %02x sbcl %02x"
490: " dsp %x (+%lx) dcmd %x"
491: " ds %p timeout %d\n",
492: xs->sc_link->target,
493: acb->ds->scsi_cmd.opcode,
494: osiop_read_1(sc, OSIOP_SBCL),
495: osiop_read_4(sc, OSIOP_DSP),
496: osiop_read_4(sc, OSIOP_DSP) -
497: sc->sc_scrdma->dm_segs[0].ds_addr,
498: osiop_read_1(sc, OSIOP_DCMD),
499: acb->ds, acb->xs->timeout);
500: #endif
501: i = 1000;
502: to--;
503: if (to <= 0) {
504: osiop_reset(sc);
505: splx(s);
506: return;
507: }
508: }
509: delay(1000);
510: i--;
511: }
512: sstat0 = osiop_read_1(sc, OSIOP_SSTAT0);
513: delay(25); /* Need delay between SSTAT0 and DSTAT reads */
514: dstat = osiop_read_1(sc, OSIOP_DSTAT);
515: if (osiop_checkintr(sc, istat, dstat, sstat0, &status)) {
516: if (acb != sc->sc_nexus)
517: printf("%s: osiop_poll disconnected device"
518: " completed\n", sc->sc_dev.dv_xname);
519: else if ((sc->sc_flags & OSIOP_INTDEFER) == 0) {
520: sc->sc_flags &= ~OSIOP_INTSOFF;
521: osiop_write_1(sc, OSIOP_SIEN, sc->sc_sien);
522: osiop_write_1(sc, OSIOP_DIEN, sc->sc_dien);
523: }
524: osiop_scsidone(sc->sc_nexus, status);
525: }
526:
527: if (xs->flags & ITSDONE)
528: break;
529: }
530:
531: splx(s);
532: return;
533: }
534:
535: /*
536: * start next command that's ready
537: */
538: void
539: osiop_sched(sc)
540: struct osiop_softc *sc;
541: {
542: struct osiop_tinfo *ti;
543: struct scsi_link *periph;
544: struct osiop_acb *acb;
545:
546: if ((sc->sc_nexus != NULL) || TAILQ_EMPTY(&sc->ready_list)) {
547: #ifdef OSIOP_DEBUG
548: if (osiop_debug & DEBUG_SCHED)
549: printf("%s: osiop_sched->nexus %p/%d ready %p/%d\n",
550: sc->sc_dev.dv_xname, sc->sc_nexus,
551: sc->sc_nexus != NULL ?
552: sc->sc_nexus->xs->sc_link->target : 0,
553: TAILQ_FIRST(&sc->ready_list),
554: TAILQ_FIRST(&sc->ready_list) != NULL ?
555: TAILQ_FIRST(&sc->ready_list)->xs->sc_link->target :
556: 0);
557: #endif
558: return;
559: }
560: TAILQ_FOREACH(acb, &sc->ready_list, chain) {
561: periph = acb->xs->sc_link;
562: ti = &sc->sc_tinfo[periph->target];
563: if ((ti->lubusy & (1 << periph->lun)) == 0) {
564: TAILQ_REMOVE(&sc->ready_list, acb, chain);
565: sc->sc_nexus = acb;
566: ti->lubusy |= (1 << periph->lun);
567: break;
568: }
569: }
570:
571: if (acb == NULL) {
572: #ifdef OSIOP_DEBUG
573: if (osiop_debug & DEBUG_SCHED)
574: printf("%s: osiop_sched didn't find ready command\n",
575: sc->sc_dev.dv_xname);
576: #endif
577: return;
578: }
579:
580: if (acb->xsflags & SCSI_RESET)
581: osiop_reset(sc);
582:
583: sc->sc_active++;
584: osiop_select(sc);
585: }
586:
587: void
588: osiop_scsidone(acb, status)
589: struct osiop_acb *acb;
590: int status;
591: {
592: struct scsi_xfer *xs;
593: struct scsi_link *periph;
594: struct osiop_softc *sc;
595: int autosense;
596:
597: #ifdef DIAGNOSTIC
598: if (acb == NULL || acb->xs == NULL) {
599: printf("osiop_scsidone: NULL acb or scsi_xfer\n");
600: #if defined(OSIOP_DEBUG) && defined(DDB)
601: Debugger();
602: #endif
603: return;
604: }
605: #endif
606: xs = acb->xs;
607: sc = acb->sc;
608: periph = xs->sc_link;
609:
610: /*
611: * Record if this is the completion of an auto sense
612: * scsi command, and then reset the flag so we don't loop
613: * when such a command fails or times out.
614: */
615: autosense = acb->flags & ACB_F_AUTOSENSE;
616: acb->flags &= ~ACB_F_AUTOSENSE;
617:
618: #ifdef OSIOP_DEBUG
619: if (acb->status != ACB_S_DONE)
620: printf("%s: acb not done (status %d)\n",
621: sc->sc_dev.dv_xname, acb->status);
622: #endif
623:
624: if (acb->xsflags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
625: bus_dmamap_sync(sc->sc_dmat, acb->datadma, 0, acb->datalen,
626: (acb->xsflags & SCSI_DATA_IN) ?
627: BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
628: bus_dmamap_unload(sc->sc_dmat, acb->datadma);
629: }
630:
631: timeout_del(&xs->stimeout);
632: xs->status = status;
633:
634: switch (status) {
635: case SCSI_OK:
636: if (autosense == 0)
637: xs->error = XS_NOERROR;
638: else
639: xs->error = XS_SENSE;
640: break;
641: case SCSI_BUSY:
642: xs->error = XS_BUSY;
643: break;
644: case SCSI_CHECK:
645: if (autosense == 0)
646: acb->flags |= ACB_F_AUTOSENSE;
647: else
648: xs->error = XS_DRIVER_STUFFUP;
649: break;
650: case SCSI_OSIOP_NOCHECK:
651: /*
652: * don't check status, xs->error is already valid
653: */
654: break;
655: case SCSI_OSIOP_NOSTATUS:
656: /*
657: * the status byte was not updated, cmd was
658: * aborted
659: */
660: xs->error = XS_SELTIMEOUT;
661: break;
662: default:
663: #ifdef OSIOP_DEBUG
664: printf("%s: osiop_scsidone: unknown status code (0x%02x)\n",
665: sc->sc_dev.dv_xname, status);
666: #endif
667: xs->error = XS_DRIVER_STUFFUP;
668: break;
669: }
670:
671: /*
672: * Remove the ACB from whatever queue it's on. We have to do a bit of
673: * a hack to figure out which queue it's on. Note that it is *not*
674: * necessary to cdr down the ready queue, but we must cdr down the
675: * nexus queue and see if it's there, so we can mark the unit as no
676: * longer busy. This code is sickening, but it works.
677: */
678: if (acb == sc->sc_nexus) {
679: sc->sc_nexus = NULL;
680: sc->sc_tinfo[periph->target].lubusy &=
681: ~(1 << periph->lun);
682: sc->sc_active--;
683: OSIOP_TRACE('d', 'a', status, 0);
684: } else if (sc->ready_list.tqh_last == &TAILQ_NEXT(acb, chain)) {
685: TAILQ_REMOVE(&sc->ready_list, acb, chain);
686: OSIOP_TRACE('d', 'r', status, 0);
687: } else {
688: struct osiop_acb *acb2;
689: TAILQ_FOREACH(acb2, &sc->nexus_list, chain) {
690: if (acb2 == acb) {
691: TAILQ_REMOVE(&sc->nexus_list, acb, chain);
692: sc->sc_tinfo[periph->target].lubusy &=
693: ~(1 << periph->lun);
694: sc->sc_active--;
695: break;
696: }
697: }
698: if (acb2 == NULL) {
699: if (TAILQ_NEXT(acb, chain) != NULL) {
700: TAILQ_REMOVE(&sc->ready_list, acb, chain);
701: sc->sc_active--;
702: } else {
703: printf("%s: can't find matching acb\n",
704: sc->sc_dev.dv_xname);
705: #ifdef DDB
706: #if 0
707: Debugger();
708: #endif
709: #endif
710: }
711: }
712: OSIOP_TRACE('d', 'n', status, 0);
713: }
714:
715: if ((acb->flags & ACB_F_AUTOSENSE) == 0) {
716: /* Put it on the free list. */
717: FREE:
718: acb->status = ACB_S_FREE;
719: TAILQ_INSERT_TAIL(&sc->free_list, acb, chain);
720: sc->sc_tinfo[periph->target].cmds++;
721:
722: xs->resid = 0;
723: xs->flags |= ITSDONE;
724: scsi_done(xs);
725: } else {
726: /* Set up REQUEST_SENSE command */
727: struct scsi_sense *cmd = (struct scsi_sense *)&acb->ds->scsi_cmd;
728: int err;
729:
730: bzero(cmd, sizeof(*cmd));
731: acb->ds->cmd.count = sizeof(*cmd);
732: cmd->opcode = REQUEST_SENSE;
733: cmd->byte2 = xs->sc_link->lun << 5;
734: cmd->length = sizeof(xs->sense);
735:
736: /* Setup DMA map for data buffer */
737: acb->xsflags &= SCSI_POLL | SCSI_NOSLEEP;
738: acb->xsflags |= SCSI_DATA_IN;
739: acb->datalen = sizeof xs->sense;
740: #ifdef OSIOP_DEBUG
741: acb->data = &xs->sense;
742: #endif
743: err = bus_dmamap_load(sc->sc_dmat, acb->datadma,
744: &xs->sense, sizeof(xs->sense), NULL,
745: BUS_DMA_NOWAIT | BUS_DMA_STREAMING | BUS_DMA_READ);
746: if (err) {
747: printf("%s: unable to load REQUEST_SENSE data DMA map: %d",
748: sc->sc_dev.dv_xname, err);
749: xs->error = XS_DRIVER_STUFFUP;
750: goto FREE;
751: }
752: bus_dmamap_sync(sc->sc_dmat, acb->datadma,
753: 0, sizeof(xs->sense), BUS_DMASYNC_PREREAD);
754:
755: sc->sc_tinfo[periph->target].senses++;
756: acb->status = ACB_S_READY;
757: TAILQ_INSERT_HEAD(&sc->ready_list, acb, chain);
758: if (((acb->xsflags & SCSI_POLL) == 0) && ((sc->sc_flags & OSIOP_NODMA) == 0))
759: /* start expire timer */
760: timeout_add(&xs->stimeout, (xs->timeout/1000) * hz);
761: }
762:
763: osiop_sched(sc);
764: }
765:
766: void
767: osiop_abort(sc, where)
768: struct osiop_softc *sc;
769: const char *where;
770: {
771: u_int8_t dstat, sstat0;
772:
773: sstat0 = osiop_read_1(sc, OSIOP_SSTAT0);
774: delay(25); /* Need delay between SSTAT0 and DSTAT reads */
775: dstat = osiop_read_1(sc, OSIOP_DSTAT);
776:
777: printf("%s: abort %s: dstat %02x, sstat0 %02x sbcl %02x\n",
778: sc->sc_dev.dv_xname, where,
779: dstat, sstat0,
780: osiop_read_1(sc, OSIOP_SBCL));
781:
782: /* XXX XXX XXX */
783: if (sc->sc_active > 0) {
784: sc->sc_active = 0;
785: }
786: }
787:
788: void
789: osiop_init(sc)
790: struct osiop_softc *sc;
791: {
792: int i, inhibit_sync, inhibit_disc;
793:
794: sc->sc_tcp[1] = 1000 / sc->sc_clock_freq;
795: sc->sc_tcp[2] = 1500 / sc->sc_clock_freq;
796: sc->sc_tcp[3] = 2000 / sc->sc_clock_freq;
797: sc->sc_minsync = sc->sc_tcp[1]; /* in 4ns units */
798:
799: if (sc->sc_minsync < 25)
800: sc->sc_minsync = 25;
801:
802: if (sc->sc_clock_freq <= 25) {
803: sc->sc_dcntl |= OSIOP_DCNTL_CF_1; /* SCLK/1 */
804: sc->sc_tcp[0] = sc->sc_tcp[1];
805: } else if (sc->sc_clock_freq <= 37) {
806: sc->sc_dcntl |= OSIOP_DCNTL_CF_1_5; /* SCLK/1.5 */
807: sc->sc_tcp[0] = sc->sc_tcp[2];
808: } else if (sc->sc_clock_freq <= 50) {
809: sc->sc_dcntl |= OSIOP_DCNTL_CF_2; /* SCLK/2 */
810: sc->sc_tcp[0] = sc->sc_tcp[3];
811: } else {
812: sc->sc_dcntl |= OSIOP_DCNTL_CF_3; /* SCLK/3 */
813: sc->sc_tcp[0] = 3000 / sc->sc_clock_freq;
814: }
815:
816: if ((sc->sc_cfflags & 0x10000) != 0) {
817: sc->sc_flags |= OSIOP_NODMA;
818: #ifdef OSIOP_DEBUG
819: printf("%s: DMA disabled; use polling\n",
820: sc->sc_dev.dv_xname);
821: #endif
822: }
823:
824: inhibit_sync = (sc->sc_cfflags & 0xff00) >> 8; /* XXX */
825: inhibit_disc = sc->sc_cfflags & 0x00ff; /* XXX */
826: #ifdef OSIOP_DEBUG
827: if (inhibit_sync != 0)
828: printf("%s: Inhibiting synchronous transfer: 0x%02x\n",
829: sc->sc_dev.dv_xname, inhibit_sync);
830: if (inhibit_disc != 0)
831: printf("%s: Inhibiting disconnect: 0x%02x\n",
832: sc->sc_dev.dv_xname, inhibit_disc);
833: #endif
834: for (i = 0; i < OSIOP_NTGT; i++) {
835: if (inhibit_sync & (1 << i))
836: sc->sc_tinfo[i].flags |= TI_NOSYNC;
837: if (inhibit_disc & (1 << i))
838: sc->sc_tinfo[i].flags |= TI_NODISC;
839: }
840:
841: osiop_resetbus(sc);
842: osiop_reset(sc);
843: }
844:
845: void
846: osiop_reset(sc)
847: struct osiop_softc *sc;
848: {
849: struct osiop_acb *acb;
850: int i, s;
851: u_int8_t stat;
852:
853: #ifdef OSIOP_DEBUG
854: printf("%s: resetting chip\n", sc->sc_dev.dv_xname);
855: #endif
856: if (sc->sc_flags & OSIOP_ALIVE)
857: osiop_abort(sc, "reset");
858:
859: s = splbio();
860:
861: /*
862: * Reset the chip
863: * XXX - is this really needed?
864: */
865:
866: /* abort current script */
867: osiop_write_1(sc, OSIOP_ISTAT,
868: osiop_read_1(sc, OSIOP_ISTAT) | OSIOP_ISTAT_ABRT);
869: /* reset chip */
870: osiop_write_1(sc, OSIOP_ISTAT,
871: osiop_read_1(sc, OSIOP_ISTAT) | OSIOP_ISTAT_RST);
872: delay(100);
873: osiop_write_1(sc, OSIOP_ISTAT,
874: osiop_read_1(sc, OSIOP_ISTAT) & ~OSIOP_ISTAT_RST);
875: delay(100);
876:
877: /*
878: * Set up various chip parameters
879: */
880: osiop_write_1(sc, OSIOP_SCNTL0,
881: OSIOP_ARB_FULL | OSIOP_SCNTL0_EPC | OSIOP_SCNTL0_EPG);
882: osiop_write_1(sc, OSIOP_SCNTL1, OSIOP_SCNTL1_ESR);
883: osiop_write_1(sc, OSIOP_DCNTL, sc->sc_dcntl);
884: osiop_write_1(sc, OSIOP_DMODE, sc->sc_dmode);
885: /* don't enable interrupts yet */
886: osiop_write_1(sc, OSIOP_SIEN, 0x00);
887: osiop_write_1(sc, OSIOP_DIEN, 0x00);
888: osiop_write_1(sc, OSIOP_SCID, OSIOP_SCID_VALUE(sc->sc_id));
889: osiop_write_1(sc, OSIOP_DWT, 0x00);
890: osiop_write_1(sc, OSIOP_CTEST0, osiop_read_1(sc, OSIOP_CTEST0)
891: | OSIOP_CTEST0_BTD | OSIOP_CTEST0_EAN);
892: osiop_write_1(sc, OSIOP_CTEST7,
893: osiop_read_1(sc, OSIOP_CTEST7) | sc->sc_ctest7);
894:
895: /* will need to re-negotiate sync xfers */
896: for (i = 0; i < OSIOP_NTGT; i++) {
897: sc->sc_tinfo[i].state = NEG_INIT;
898: sc->sc_tinfo[i].period = 0;
899: sc->sc_tinfo[i].offset = 0;
900: }
901:
902: stat = osiop_read_1(sc, OSIOP_ISTAT);
903: if (stat & OSIOP_ISTAT_SIP)
904: osiop_read_1(sc, OSIOP_SSTAT0);
905: if (stat & OSIOP_ISTAT_DIP) {
906: if (stat & OSIOP_ISTAT_SIP)
907: /* Need delay between SSTAT0 and DSTAT reads */
908: delay(25);
909: osiop_read_1(sc, OSIOP_DSTAT);
910: }
911:
912: splx(s);
913:
914: delay(osiop_reset_delay * 1000);
915:
916: s = splbio();
917: if (sc->sc_nexus != NULL) {
918: sc->sc_nexus->xs->error =
919: (sc->sc_nexus->flags & ACB_F_TIMEOUT) ?
920: XS_TIMEOUT : XS_RESET;
921: sc->sc_nexus->status = ACB_S_DONE;
922: osiop_scsidone(sc->sc_nexus, SCSI_OSIOP_NOCHECK);
923: }
924: while ((acb = TAILQ_FIRST(&sc->nexus_list)) != NULL) {
925: acb->xs->error = (acb->flags & ACB_F_TIMEOUT) ?
926: XS_TIMEOUT : XS_RESET;
927: acb->status = ACB_S_DONE;
928: osiop_scsidone(acb, SCSI_OSIOP_NOCHECK);
929: }
930: splx(s);
931:
932: sc->sc_flags &= ~(OSIOP_INTDEFER | OSIOP_INTSOFF);
933: /* enable SCSI and DMA interrupts */
934: sc->sc_sien = OSIOP_SIEN_M_A | OSIOP_SIEN_STO | /*OSIOP_SIEN_SEL |*/
935: OSIOP_SIEN_SGE | OSIOP_SIEN_UDC | OSIOP_SIEN_RST | OSIOP_SIEN_PAR;
936: sc->sc_dien = OSIOP_DIEN_BF | OSIOP_DIEN_ABRT | OSIOP_DIEN_SIR |
937: /*OSIOP_DIEN_WTD |*/ OSIOP_DIEN_IID;
938: osiop_write_1(sc, OSIOP_SIEN, sc->sc_sien);
939: osiop_write_1(sc, OSIOP_DIEN, sc->sc_dien);
940: }
941:
942: void
943: osiop_resetbus(sc)
944: struct osiop_softc *sc;
945: {
946:
947: osiop_write_1(sc, OSIOP_SIEN, 0);
948: osiop_write_1(sc, OSIOP_SCNTL1,
949: osiop_read_1(sc, OSIOP_SCNTL1) | OSIOP_SCNTL1_RST);
950: delay(25);
951: osiop_write_1(sc, OSIOP_SCNTL1,
952: osiop_read_1(sc, OSIOP_SCNTL1) & ~OSIOP_SCNTL1_RST);
953: }
954:
955: /*
956: * Setup Data Storage for 53C710 and start SCRIPTS processing
957: */
958:
959: void
960: osiop_start(sc)
961: struct osiop_softc *sc;
962: {
963: struct osiop_acb *acb = sc->sc_nexus;
964: struct osiop_ds *ds = acb->ds;
965: struct scsi_xfer *xs = acb->xs;
966: bus_dmamap_t dsdma = sc->sc_dsdma, datadma = acb->datadma;
967: struct osiop_tinfo *ti;
968: int target = xs->sc_link->target;
969: int lun = xs->sc_link->lun;
970: int disconnect, i;
971:
972: #ifdef OSIOP_DEBUG
973: if (osiop_debug & DEBUG_DISC &&
974: osiop_read_1(sc, OSIOP_SBCL) & OSIOP_BSY) {
975: printf("ACK! osiop was busy: script %p dsa %p active %d\n",
976: sc->sc_script, acb->ds, sc->sc_active);
977: printf("istat %02x sfbr %02x lcrc %02x sien %02x dien %02x\n",
978: osiop_read_1(sc, OSIOP_ISTAT),
979: osiop_read_1(sc, OSIOP_SFBR),
980: osiop_read_1(sc, OSIOP_LCRC),
981: osiop_read_1(sc, OSIOP_SIEN),
982: osiop_read_1(sc, OSIOP_DIEN));
983: #ifdef DDB
984: #if 0
985: Debugger();
986: #endif
987: #endif
988: }
989: #endif
990:
991: #ifdef OSIOP_DEBUG
992: if (acb->status != ACB_S_READY)
993: panic("osiop_start: non-ready cmd in acb");
994: #endif
995:
996: acb->intstat = 0;
997:
998: ti = &sc->sc_tinfo[target];
999: ds->scsi_addr = ((1 << 16) << target) | (ti->sxfer << 8);
1000:
1001: disconnect = (ds->scsi_cmd.opcode != REQUEST_SENSE) &&
1002: (ti->flags & TI_NODISC) == 0;
1003:
1004: ds->msgout[0] = MSG_IDENTIFY(lun, disconnect);
1005: ds->id.count = 1;
1006: ds->stat[0] = SCSI_OSIOP_NOSTATUS; /* set invalid status */
1007: ds->msgbuf[0] = ds->msgbuf[1] = MSG_INVALID;
1008: bzero(&ds->data, sizeof(ds->data));
1009:
1010: /*
1011: * Negotiate wide is the initial negotiation state; since the 53c710
1012: * doesn't do wide transfers, just begin the synchronous transfer
1013: * negotiation here.
1014: */
1015: if (ti->state == NEG_INIT) {
1016: if ((ti->flags & TI_NOSYNC) != 0) {
1017: ti->state = NEG_DONE;
1018: ti->period = 0;
1019: ti->offset = 0;
1020: osiop_update_xfer_mode(sc, target);
1021: #ifdef OSIOP_DEBUG
1022: if (osiop_debug & DEBUG_SYNC)
1023: printf("Forcing target %d asynchronous\n",
1024: target);
1025: #endif
1026: } else {
1027: ds->msgbuf[2] = MSG_INVALID;
1028: ds->msgout[1] = MSG_EXTENDED;
1029: ds->msgout[2] = MSG_EXT_SDTR_LEN;
1030: ds->msgout[3] = MSG_EXT_SDTR;
1031: ds->msgout[4] = sc->sc_minsync;
1032: ds->msgout[5] = OSIOP_MAX_OFFSET;
1033: ds->id.count = MSG_EXT_SDTR_LEN + 3;
1034: ti->state = NEG_WAITS;
1035: #ifdef OSIOP_DEBUG
1036: if (osiop_debug & DEBUG_SYNC)
1037: printf("Sending sync request to target %d\n",
1038: target);
1039: #endif
1040: }
1041: }
1042:
1043: acb->curaddr = 0;
1044: acb->curlen = 0;
1045:
1046: /*
1047: * Build physical DMA addresses for scatter/gather I/O
1048: */
1049: if (acb->xsflags & (SCSI_DATA_IN | SCSI_DATA_OUT)) {
1050: for (i = 0; i < datadma->dm_nsegs; i++) {
1051: ds->data[i].count = datadma->dm_segs[i].ds_len;
1052: ds->data[i].addr = datadma->dm_segs[i].ds_addr;
1053: }
1054: }
1055:
1056: /* sync script data structure */
1057: bus_dmamap_sync(sc->sc_dmat, dsdma,
1058: acb->dsoffset, sizeof(struct osiop_ds),
1059: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1060:
1061: acb->status = ACB_S_ACTIVE;
1062:
1063: #ifdef OSIOP_DEBUG
1064: if (osiop_debug & DEBUG_DISC &&
1065: osiop_read_1(sc, OSIOP_SBCL) & OSIOP_BSY) {
1066: printf("ACK! osiop was busy at start: "
1067: "script %p dsa %p active %d\n",
1068: sc->sc_script, acb->ds, sc->sc_active);
1069: #ifdef DDB
1070: #if 0
1071: Debugger();
1072: #endif
1073: #endif
1074: }
1075: #endif
1076: if (TAILQ_EMPTY(&sc->nexus_list)) {
1077: if (osiop_read_1(sc, OSIOP_ISTAT) & OSIOP_ISTAT_CON)
1078: printf("%s: osiop_select while connected?\n",
1079: sc->sc_dev.dv_xname);
1080: osiop_write_4(sc, OSIOP_TEMP, 0);
1081: osiop_write_1(sc, OSIOP_SBCL, ti->sbcl);
1082: osiop_write_4(sc, OSIOP_DSA,
1083: dsdma->dm_segs[0].ds_addr + acb->dsoffset);
1084: osiop_write_4(sc, OSIOP_DSP,
1085: sc->sc_scrdma->dm_segs[0].ds_addr + Ent_scripts);
1086: OSIOP_TRACE('s', 1, 0, 0);
1087: } else {
1088: if ((osiop_read_1(sc, OSIOP_ISTAT) & OSIOP_ISTAT_CON) == 0) {
1089: osiop_write_1(sc, OSIOP_ISTAT, OSIOP_ISTAT_SIGP);
1090: OSIOP_TRACE('s', 2, 0, 0);
1091: } else {
1092: OSIOP_TRACE('s', 3,
1093: osiop_read_1(sc, OSIOP_ISTAT), 0);
1094: }
1095: }
1096: #ifdef OSIOP_DEBUG
1097: osiopstarts++;
1098: #endif
1099: }
1100:
1101: /*
1102: * Process a DMA or SCSI interrupt from the 53C710 SIOP
1103: */
1104:
1105: int
1106: osiop_checkintr(sc, istat, dstat, sstat0, status)
1107: struct osiop_softc *sc;
1108: u_int8_t istat;
1109: u_int8_t dstat;
1110: u_int8_t sstat0;
1111: int *status;
1112: {
1113: struct osiop_acb *acb = sc->sc_nexus;
1114: struct osiop_ds *ds;
1115: bus_dmamap_t dsdma = sc->sc_dsdma;
1116: bus_addr_t scraddr = sc->sc_scrdma->dm_segs[0].ds_addr;
1117: int target = 0;
1118: int dfifo, dbc, intcode, sstat1;
1119:
1120: dfifo = osiop_read_1(sc, OSIOP_DFIFO);
1121: dbc = osiop_read_4(sc, OSIOP_DBC) & 0x00ffffff;
1122: sstat1 = osiop_read_1(sc, OSIOP_SSTAT1);
1123: osiop_write_1(sc, OSIOP_CTEST8,
1124: osiop_read_1(sc, OSIOP_CTEST8) | OSIOP_CTEST8_CLF);
1125: while ((osiop_read_1(sc, OSIOP_CTEST1) & OSIOP_CTEST1_FMT) !=
1126: OSIOP_CTEST1_FMT)
1127: ;
1128: osiop_write_1(sc, OSIOP_CTEST8,
1129: osiop_read_1(sc, OSIOP_CTEST8) & ~OSIOP_CTEST8_CLF);
1130: intcode = osiop_read_4(sc, OSIOP_DSPS);
1131: #ifdef OSIOP_DEBUG
1132: osiopints++;
1133: if (osiop_read_4(sc, OSIOP_DSP) != 0 &&
1134: (osiop_read_4(sc, OSIOP_DSP) < scraddr ||
1135: osiop_read_4(sc, OSIOP_DSP) >= scraddr + sizeof(osiop_script))) {
1136: printf("%s: dsp not within script dsp %x scripts %lx:%lx",
1137: sc->sc_dev.dv_xname,
1138: osiop_read_4(sc, OSIOP_DSP),
1139: scraddr, scraddr + sizeof(osiop_script));
1140: printf(" istat %x dstat %x sstat0 %x\n", istat, dstat, sstat0);
1141: #ifdef DDB
1142: Debugger();
1143: #endif
1144: }
1145: #endif
1146: OSIOP_TRACE('i', dstat, istat, (istat & OSIOP_ISTAT_DIP) ?
1147: intcode & 0xff : sstat0);
1148:
1149: ds = NULL;
1150: if (acb != NULL) { /* XXX */
1151: ds = acb->ds;
1152: bus_dmamap_sync(sc->sc_dmat, dsdma,
1153: acb->dsoffset, sizeof(struct osiop_ds),
1154: BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1155: #ifdef OSIOP_DEBUG
1156: if (acb->status != ACB_S_ACTIVE)
1157: printf("osiop_checkintr: acb not active (status %d)\n",
1158: acb->status);
1159: #endif
1160: }
1161:
1162: if (dstat & OSIOP_DSTAT_SIR && intcode == A_ok) {
1163: /* Normal completion status, or check condition */
1164: struct osiop_tinfo *ti;
1165: if (acb == NULL) {
1166: printf("%s: COMPLETE with no active command?\n",
1167: sc->sc_dev.dv_xname);
1168: return (0);
1169: }
1170: #ifdef OSIOP_DEBUG
1171: if (osiop_read_4(sc, OSIOP_DSA) !=
1172: dsdma->dm_segs[0].ds_addr + acb->dsoffset) {
1173: printf("osiop: invalid dsa: %x %lx\n",
1174: osiop_read_4(sc, OSIOP_DSA),
1175: dsdma->dm_segs[0].ds_addr + acb->dsoffset);
1176: panic("*** osiop DSA invalid ***");
1177: }
1178: #endif
1179: target = acb->xs->sc_link->target;
1180: ti = &sc->sc_tinfo[target];
1181: if (ti->state == NEG_WAITS) {
1182: if (ds->msgbuf[1] == MSG_INVALID)
1183: printf("%s: target %d ignored sync request\n",
1184: sc->sc_dev.dv_xname, target);
1185: else if (ds->msgbuf[1] == MSG_MESSAGE_REJECT)
1186: printf("%s: target %d rejected sync request\n",
1187: sc->sc_dev.dv_xname, target);
1188: ti->period = 0;
1189: ti->offset = 0;
1190: osiop_update_xfer_mode(sc, target);
1191: ti->state = NEG_DONE;
1192: }
1193: #ifdef OSIOP_DEBUG
1194: if (osiop_read_1(sc, OSIOP_SBCL) & OSIOP_BSY) {
1195: #if 0
1196: printf("ACK! osiop was busy at end: "
1197: "script %p dsa %p\n", &osiop_script, ds);
1198: #ifdef DDB
1199: Debugger();
1200: #endif
1201: #endif
1202: }
1203: if (ds->msgbuf[0] != MSG_CMDCOMPLETE)
1204: printf("%s: message was not COMMAND COMPLETE: %02x\n",
1205: sc->sc_dev.dv_xname, ds->msgbuf[0]);
1206: #endif
1207: if (!TAILQ_EMPTY(&sc->nexus_list))
1208: osiop_write_1(sc, OSIOP_DCNTL,
1209: osiop_read_1(sc, OSIOP_DCNTL) | OSIOP_DCNTL_STD);
1210: *status = ds->stat[0];
1211: acb->status = ACB_S_DONE;
1212: return (1);
1213: }
1214: if (dstat & OSIOP_DSTAT_SIR && intcode == A_int_syncmsg) {
1215: if (acb == NULL) {
1216: printf("%s: Sync message with no active command?\n",
1217: sc->sc_dev.dv_xname);
1218: return (0);
1219: }
1220: target = acb->xs->sc_link->target;
1221: if (ds->msgbuf[1] == MSG_EXTENDED &&
1222: ds->msgbuf[2] == MSG_EXT_SDTR_LEN &&
1223: ds->msgbuf[3] == MSG_EXT_SDTR) {
1224: struct osiop_tinfo *ti = &sc->sc_tinfo[target];
1225: #ifdef OSIOP_DEBUG
1226: if (osiop_debug & DEBUG_SYNC)
1227: printf("sync msg in: "
1228: "%02x %02x %02x %02x %02x %02x\n",
1229: ds->msgbuf[0], ds->msgbuf[1],
1230: ds->msgbuf[2], ds->msgbuf[3],
1231: ds->msgbuf[4], ds->msgbuf[5]);
1232: #endif
1233: ti->period = ds->msgbuf[4];
1234: ti->offset = ds->msgbuf[5];
1235: osiop_update_xfer_mode(sc, target);
1236:
1237: bus_dmamap_sync(sc->sc_dmat, dsdma,
1238: acb->dsoffset, sizeof(struct osiop_ds),
1239: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1240: osiop_write_1(sc, OSIOP_SXFER, ti->sxfer);
1241: osiop_write_1(sc, OSIOP_SBCL, ti->sbcl);
1242: if (ti->state == NEG_WAITS) {
1243: ti->state = NEG_DONE;
1244: osiop_write_4(sc, OSIOP_DSP,
1245: scraddr + Ent_clear_ack);
1246: return (0);
1247: }
1248: osiop_write_1(sc, OSIOP_DCNTL,
1249: osiop_read_1(sc, OSIOP_DCNTL) | OSIOP_DCNTL_STD);
1250: ti->state = NEG_DONE;
1251: return (0);
1252: }
1253: /* XXX - not SDTR message */
1254: }
1255: if (sstat0 & OSIOP_SSTAT0_M_A) {
1256: /* Phase mismatch */
1257: #ifdef OSIOP_DEBUG
1258: osiopphmm++;
1259: #endif
1260: if (acb == NULL) {
1261: printf("%s: Phase mismatch with no active command?\n",
1262: sc->sc_dev.dv_xname);
1263: return (0);
1264: }
1265: if (acb->datalen > 0) {
1266: int adjust = (dfifo - (dbc & 0x7f)) & 0x7f;
1267: if (sstat1 & OSIOP_SSTAT1_ORF)
1268: adjust++;
1269: if (sstat1 & OSIOP_SSTAT1_OLF)
1270: adjust++;
1271: acb->curaddr = osiop_read_4(sc, OSIOP_DNAD) - adjust;
1272: acb->curlen = dbc + adjust;
1273: #ifdef OSIOP_DEBUG
1274: if (osiop_debug & DEBUG_DISC) {
1275: printf("Phase mismatch: curaddr %lx "
1276: "curlen %lx dfifo %x dbc %x sstat1 %x "
1277: "adjust %x sbcl %x starts %d acb %p\n",
1278: acb->curaddr, acb->curlen, dfifo,
1279: dbc, sstat1, adjust,
1280: osiop_read_1(sc, OSIOP_SBCL),
1281: osiopstarts, acb);
1282: if (ds->data[1].count != 0) {
1283: int i;
1284: for (i = 0; ds->data[i].count != 0; i++)
1285: printf("chain[%d] "
1286: "addr %x len %x\n", i,
1287: ds->data[i].addr,
1288: ds->data[i].count);
1289: }
1290: bus_dmamap_sync(sc->sc_dmat, dsdma,
1291: acb->dsoffset, sizeof(struct osiop_ds),
1292: BUS_DMASYNC_PREREAD |
1293: BUS_DMASYNC_PREWRITE);
1294: }
1295: #endif
1296: }
1297: #ifdef OSIOP_DEBUG
1298: OSIOP_TRACE('m', osiop_read_1(sc, OSIOP_SBCL),
1299: osiop_read_4(sc, OSIOP_DSP) >> 8,
1300: osiop_read_4(sc, OSIOP_DSP));
1301: if (osiop_debug & DEBUG_PHASE)
1302: printf("Phase mismatch: %x dsp +%lx dcmd %x\n",
1303: osiop_read_1(sc, OSIOP_SBCL),
1304: osiop_read_4(sc, OSIOP_DSP) - scraddr,
1305: osiop_read_4(sc, OSIOP_DBC));
1306: #endif
1307: if ((osiop_read_1(sc, OSIOP_SBCL) & OSIOP_REQ) == 0) {
1308: printf("Phase mismatch: "
1309: "REQ not asserted! %02x dsp %x\n",
1310: osiop_read_1(sc, OSIOP_SBCL),
1311: osiop_read_4(sc, OSIOP_DSP));
1312: #if defined(OSIOP_DEBUG) && defined(DDB)
1313: /*Debugger(); XXX is*/
1314: #endif
1315: }
1316: switch (OSIOP_PHASE(osiop_read_1(sc, OSIOP_SBCL))) {
1317: case DATA_OUT_PHASE:
1318: case DATA_IN_PHASE:
1319: case STATUS_PHASE:
1320: case COMMAND_PHASE:
1321: case MSG_IN_PHASE:
1322: case MSG_OUT_PHASE:
1323: osiop_write_4(sc, OSIOP_DSP, scraddr + Ent_switch);
1324: break;
1325: default:
1326: printf("%s: invalid phase\n", sc->sc_dev.dv_xname);
1327: goto bad_phase;
1328: }
1329: return (0);
1330: }
1331: if (sstat0 & OSIOP_SSTAT0_STO) {
1332: /* Select timed out */
1333: if (acb == NULL) {
1334: printf("%s: Select timeout with no active command?\n",
1335: sc->sc_dev.dv_xname);
1336: #if 0
1337: return (0);
1338: #else
1339: goto bad_phase;
1340: #endif
1341: }
1342: #ifdef OSIOP_DEBUG
1343: if (osiop_read_1(sc, OSIOP_SBCL) & OSIOP_BSY) {
1344: printf("ACK! osiop was busy at timeout: "
1345: "script %p dsa %lx\n", sc->sc_script,
1346: dsdma->dm_segs[0].ds_addr + acb->dsoffset);
1347: printf(" sbcl %x sdid %x "
1348: "istat %x dstat %x sstat0 %x\n",
1349: osiop_read_1(sc, OSIOP_SBCL),
1350: osiop_read_1(sc, OSIOP_SDID),
1351: istat, dstat, sstat0);
1352: if ((osiop_read_1(sc, OSIOP_SBCL) & OSIOP_BSY) == 0) {
1353: printf("Yikes, it's not busy now!\n");
1354: #if 0
1355: *status = SCSI_OSIOP_NOSTATUS;
1356: if (!TAILQ_EMPTY(&sc->nexus_list))
1357: osiop_write_4(sc, OSIOP_DSP,
1358: scraddr + Ent_wait_reselect);
1359: return (1);
1360: #endif
1361: }
1362: #if 0
1363: osiop_write_1(sc, OSIOP_DCNTL,
1364: osiop_read_1(sc, OSIOP_DCNTL) | OSIOP_DCNTL_STD);
1365: #endif
1366: #ifdef DDB
1367: Debugger();
1368: #endif
1369: return (0);
1370: }
1371: #endif
1372: acb->status = ACB_S_DONE;
1373: *status = SCSI_OSIOP_NOSTATUS;
1374: acb->xs->error = XS_SELTIMEOUT;
1375: if (!TAILQ_EMPTY(&sc->nexus_list))
1376: osiop_write_4(sc, OSIOP_DSP,
1377: scraddr + Ent_wait_reselect);
1378: return (1);
1379: }
1380: if (acb != NULL)
1381: target = acb->xs->sc_link->target;
1382: else
1383: target = sc->sc_id;
1384: if (sstat0 & OSIOP_SSTAT0_UDC) {
1385: #ifdef OSIOP_DEBUG
1386: if (acb == NULL)
1387: printf("%s: Unexpected disconnect "
1388: "with no active command?\n", sc->sc_dev.dv_xname);
1389: printf("%s: target %d disconnected unexpectedly\n",
1390: sc->sc_dev.dv_xname, target);
1391: #endif
1392: #if 0
1393: osiop_abort(sc, "osiop_chkintr");
1394: #endif
1395: *status = SCSI_CHECK;
1396: if (!TAILQ_EMPTY(&sc->nexus_list))
1397: osiop_write_4(sc, OSIOP_DSP,
1398: scraddr + Ent_wait_reselect);
1399: return (acb != NULL);
1400: }
1401: if (dstat & OSIOP_DSTAT_SIR &&
1402: (intcode == A_int_disc || intcode == A_int_disc_wodp)) {
1403: /* Disconnect */
1404: if (acb == NULL) {
1405: printf("%s: Disconnect with no active command?\n",
1406: sc->sc_dev.dv_xname);
1407: return (0);
1408: }
1409: #ifdef OSIOP_DEBUG
1410: if (osiop_debug & DEBUG_DISC) {
1411: printf("%s: ID %02x disconnected TEMP %x (+%lx) "
1412: "curaddr %lx curlen %lx buf %x len %x dfifo %x "
1413: "dbc %x sstat1 %x starts %d acb %p\n",
1414: sc->sc_dev.dv_xname, 1 << target,
1415: osiop_read_4(sc, OSIOP_TEMP),
1416: (osiop_read_4(sc, OSIOP_TEMP) != 0) ?
1417: osiop_read_4(sc, OSIOP_TEMP) - scraddr : 0,
1418: acb->curaddr, acb->curlen,
1419: ds->data[0].addr, ds->data[0].count,
1420: dfifo, dbc, sstat1, osiopstarts, acb);
1421: bus_dmamap_sync(sc->sc_dmat, dsdma,
1422: acb->dsoffset, sizeof(struct osiop_ds),
1423: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1424: }
1425: #endif
1426: /*
1427: * XXXX need to update curaddr/curlen to reflect
1428: * current data transferred. If device disconnected in
1429: * the middle of a DMA block, they should already be set
1430: * by the phase change interrupt. If the disconnect
1431: * occurs on a DMA block boundary, we have to figure out
1432: * which DMA block it was.
1433: */
1434: if (acb->datalen > 0 &&
1435: osiop_read_4(sc, OSIOP_TEMP) != 0) {
1436: long n = osiop_read_4(sc, OSIOP_TEMP) - scraddr;
1437:
1438: if (acb->curlen != 0 &&
1439: acb->curlen != ds->data[0].count)
1440: printf("%s: curaddr/curlen already set? "
1441: "n %lx iob %lx/%lx chain[0] %x/%x\n",
1442: sc->sc_dev.dv_xname, n,
1443: acb->curaddr, acb->curlen,
1444: ds->data[0].addr, ds->data[0].count);
1445: if (n < Ent_datain)
1446: n = (n - Ent_dataout) / 16;
1447: else
1448: n = (n - Ent_datain) / 16;
1449: if (n < 0 || n >= OSIOP_NSG)
1450: printf("TEMP invalid %ld\n", n);
1451: else {
1452: acb->curaddr = ds->data[n].addr;
1453: acb->curlen = ds->data[n].count;
1454: }
1455: #ifdef OSIOP_DEBUG
1456: if (osiop_debug & DEBUG_DISC) {
1457: printf("%s: TEMP offset %ld",
1458: sc->sc_dev.dv_xname, n);
1459: printf(" curaddr %lx curlen %lx\n",
1460: acb->curaddr, acb->curlen);
1461: }
1462: #endif
1463: }
1464: /*
1465: * If data transfer was interrupted by disconnect, curaddr
1466: * and curlen should reflect the point of interruption.
1467: * Adjust the DMA chain so that the data transfer begins
1468: * at the appropriate place upon reselection.
1469: * XXX This should only be done on save data pointer message?
1470: */
1471: if (acb->curlen > 0) {
1472: int i, j;
1473: #ifdef OSIOP_DEBUG
1474: if (osiop_debug & DEBUG_DISC)
1475: printf("%s: adjusting DMA chain\n",
1476: sc->sc_dev.dv_xname);
1477: if (intcode == A_int_disc_wodp)
1478: printf("%s: ID %02x disconnected "
1479: "without Save Data Pointers\n",
1480: sc->sc_dev.dv_xname, 1 << target);
1481: #endif
1482: for (i = 0; i < OSIOP_NSG; i++) {
1483: if (ds->data[i].count == 0)
1484: break;
1485: if (acb->curaddr >= ds->data[i].addr &&
1486: acb->curaddr <
1487: (ds->data[i].addr + ds->data[i].count))
1488: break;
1489: }
1490: if (i >= OSIOP_NSG || ds->data[i].count == 0) {
1491: printf("couldn't find saved data pointer: "
1492: "curaddr %lx curlen %lx i %d\n",
1493: acb->curaddr, acb->curlen, i);
1494: #if defined(OSIOP_DEBUG) && defined(DDB)
1495: Debugger();
1496: #endif
1497: }
1498: #ifdef OSIOP_DEBUG
1499: if (osiop_debug & DEBUG_DISC)
1500: printf(" chain[0]: %x/%x -> %lx/%lx\n",
1501: ds->data[0].addr, ds->data[0].count,
1502: acb->curaddr, acb->curlen);
1503: #endif
1504: ds->data[0].addr = acb->curaddr;
1505: ds->data[0].count = acb->curlen;
1506: for (j = 1, i = i + 1;
1507: i < OSIOP_NSG && ds->data[i].count > 0;
1508: i++, j++) {
1509: #ifdef OSIOP_DEBUG
1510: if (osiop_debug & DEBUG_DISC)
1511: printf(" chain[%d]: %x/%x -> %x/%x\n",
1512: j,
1513: ds->data[j].addr, ds->data[j].count,
1514: ds->data[i].addr, ds->data[i].count);
1515: #endif
1516: ds->data[j].addr = ds->data[i].addr;
1517: ds->data[j].count = ds->data[i].count;
1518: }
1519: if (j < OSIOP_NSG) {
1520: ds->data[j].addr = 0;
1521: ds->data[j].count = 0;
1522: }
1523: bus_dmamap_sync(sc->sc_dmat, dsdma,
1524: acb->dsoffset, sizeof(struct osiop_ds),
1525: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1526: }
1527: sc->sc_tinfo[target].dconns++;
1528: /*
1529: * add nexus to waiting list
1530: * clear nexus
1531: * try to start another command for another target/lun
1532: */
1533: acb->intstat = sc->sc_flags & OSIOP_INTSOFF;
1534: TAILQ_INSERT_TAIL(&sc->nexus_list, acb, chain);
1535: sc->sc_nexus = NULL; /* no current device */
1536: osiop_write_4(sc, OSIOP_DSP, scraddr + Ent_wait_reselect);
1537: /* XXXX start another command ? */
1538: osiop_sched(sc);
1539: return (0);
1540: }
1541: if (dstat & OSIOP_DSTAT_SIR && intcode == A_int_reconnect) {
1542: int reselid = ffs(osiop_read_4(sc, OSIOP_SCRATCH) & 0xff) - 1;
1543: int reselun = osiop_read_1(sc, OSIOP_SFBR) & 0x07;
1544: #ifdef OSIOP_DEBUG
1545: u_int8_t resmsg;
1546: #endif
1547:
1548: /* Reconnect */
1549: /* XXXX save current SBCL */
1550: sc->sc_sstat1 = osiop_read_1(sc, OSIOP_SBCL);
1551: #ifdef OSIOP_DEBUG
1552: if (osiop_debug & DEBUG_DISC)
1553: printf("%s: target ID %02x reselected dsps %x\n",
1554: sc->sc_dev.dv_xname, reselid, intcode);
1555: resmsg = osiop_read_1(sc, OSIOP_SFBR);
1556: if (!MSG_ISIDENTIFY(resmsg))
1557: printf("%s: Reselect message in was not identify: "
1558: "%02x\n", sc->sc_dev.dv_xname, resmsg);
1559: #endif
1560: if (sc->sc_nexus != NULL) {
1561: struct scsi_link *periph =
1562: sc->sc_nexus->xs->sc_link;
1563: #ifdef OSIOP_DEBUG
1564: if (osiop_debug & DEBUG_DISC)
1565: printf("%s: reselect ID %02x w/active\n",
1566: sc->sc_dev.dv_xname, reselid);
1567: #endif
1568: TAILQ_INSERT_HEAD(&sc->ready_list,
1569: sc->sc_nexus, chain);
1570: sc->sc_tinfo[periph->target].lubusy
1571: &= ~(1 << periph->lun);
1572: sc->sc_active--;
1573: }
1574: /*
1575: * locate acb of reselecting device
1576: * set sc->sc_nexus to acb
1577: */
1578: TAILQ_FOREACH(acb, &sc->nexus_list, chain) {
1579: struct scsi_link *periph = acb->xs->sc_link;
1580: if (reselid != periph->target ||
1581: reselun != periph->lun) {
1582: continue;
1583: }
1584: TAILQ_REMOVE(&sc->nexus_list, acb, chain);
1585: sc->sc_nexus = acb;
1586: sc->sc_flags |= acb->intstat;
1587: acb->intstat = 0;
1588: osiop_write_4(sc, OSIOP_DSA,
1589: dsdma->dm_segs[0].ds_addr + acb->dsoffset);
1590: osiop_write_1(sc, OSIOP_SXFER,
1591: sc->sc_tinfo[reselid].sxfer);
1592: osiop_write_1(sc, OSIOP_SBCL,
1593: sc->sc_tinfo[reselid].sbcl);
1594: break;
1595: }
1596: if (acb == NULL) {
1597: printf("%s: target ID %02x reselect nexus_list %p\n",
1598: sc->sc_dev.dv_xname, reselid,
1599: TAILQ_FIRST(&sc->nexus_list));
1600: panic("unable to find reselecting device");
1601: }
1602:
1603: osiop_write_4(sc, OSIOP_TEMP, 0);
1604: osiop_write_1(sc, OSIOP_DCNTL,
1605: osiop_read_1(sc, OSIOP_DCNTL) | OSIOP_DCNTL_STD);
1606: return (0);
1607: }
1608: if (dstat & OSIOP_DSTAT_SIR && intcode == A_int_connect) {
1609: #ifdef OSIOP_DEBUG
1610: u_int8_t ctest2 = osiop_read_1(sc, OSIOP_CTEST2);
1611:
1612: /* reselect was interrupted (by Sig_P or select) */
1613: if (osiop_debug & DEBUG_DISC ||
1614: (ctest2 & OSIOP_CTEST2_SIGP) == 0)
1615: printf("%s: reselect interrupted (Sig_P?) "
1616: "scntl1 %x ctest2 %x sfbr %x istat %x/%x\n",
1617: sc->sc_dev.dv_xname,
1618: osiop_read_1(sc, OSIOP_SCNTL1), ctest2,
1619: osiop_read_1(sc, OSIOP_SFBR), istat,
1620: osiop_read_1(sc, OSIOP_ISTAT));
1621: #endif
1622: /* XXX assumes it was not select */
1623: if (sc->sc_nexus == NULL) {
1624: #ifdef OSIOP_DEBUG
1625: printf("%s: reselect interrupted, sc_nexus == NULL\n",
1626: sc->sc_dev.dv_xname);
1627: #if 0
1628: osiop_dump(sc);
1629: #ifdef DDB
1630: Debugger();
1631: #endif
1632: #endif
1633: #endif
1634: osiop_write_1(sc, OSIOP_DCNTL,
1635: osiop_read_1(sc, OSIOP_DCNTL) | OSIOP_DCNTL_STD);
1636: return (0);
1637: }
1638: target = sc->sc_nexus->xs->sc_link->target;
1639: osiop_write_4(sc, OSIOP_TEMP, 0);
1640: osiop_write_4(sc, OSIOP_DSA,
1641: dsdma->dm_segs[0].ds_addr + sc->sc_nexus->dsoffset);
1642: osiop_write_1(sc, OSIOP_SXFER, sc->sc_tinfo[target].sxfer);
1643: osiop_write_1(sc, OSIOP_SBCL, sc->sc_tinfo[target].sbcl);
1644: osiop_write_4(sc, OSIOP_DSP, scraddr + Ent_scripts);
1645: return (0);
1646: }
1647: if (dstat & OSIOP_DSTAT_SIR && intcode == A_int_msgin) {
1648: /* Unrecognized message in byte */
1649: if (acb == NULL) {
1650: printf("%s: Bad message-in with no active command?\n",
1651: sc->sc_dev.dv_xname);
1652: return (0);
1653: }
1654: printf("%s: Unrecognized message in data "
1655: "sfbr %x msg %x sbcl %x\n", sc->sc_dev.dv_xname,
1656: osiop_read_1(sc, OSIOP_SFBR), ds->msgbuf[1],
1657: osiop_read_1(sc, OSIOP_SBCL));
1658: /* what should be done here? */
1659: osiop_write_4(sc, OSIOP_DSP, scraddr + Ent_switch);
1660: bus_dmamap_sync(sc->sc_dmat, dsdma,
1661: acb->dsoffset, sizeof(struct osiop_ds),
1662: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1663: return (0);
1664: }
1665: if (dstat & OSIOP_DSTAT_SIR && intcode == A_int_status) {
1666: /* Status phase wasn't followed by message in phase? */
1667: printf("%s: Status phase not followed by message in phase? "
1668: "sbcl %x sbdl %x\n", sc->sc_dev.dv_xname,
1669: osiop_read_1(sc, OSIOP_SBCL),
1670: osiop_read_1(sc, OSIOP_SBDL));
1671: if (osiop_read_1(sc, OSIOP_SBCL) == 0xa7) {
1672: /* It is now, just continue the script? */
1673: osiop_write_1(sc, OSIOP_DCNTL,
1674: osiop_read_1(sc, OSIOP_DCNTL) | OSIOP_DCNTL_STD);
1675: return (0);
1676: }
1677: }
1678: if (dstat & OSIOP_DSTAT_SIR && sstat0 == 0) {
1679: printf("OSIOP interrupt: %x sts %x msg %x %x sbcl %x\n",
1680: intcode, ds->stat[0], ds->msgbuf[0], ds->msgbuf[1],
1681: osiop_read_1(sc, OSIOP_SBCL));
1682: osiop_reset(sc);
1683: *status = SCSI_OSIOP_NOSTATUS;
1684: return (0); /* osiop_reset has cleaned up */
1685: }
1686: if (sstat0 & OSIOP_SSTAT0_SGE)
1687: printf("%s: SCSI Gross Error\n", sc->sc_dev.dv_xname);
1688: if (sstat0 & OSIOP_SSTAT0_PAR)
1689: printf("%s: Parity Error\n", sc->sc_dev.dv_xname);
1690: if (dstat & OSIOP_DSTAT_IID)
1691: printf("%s: Invalid instruction detected\n",
1692: sc->sc_dev.dv_xname);
1693: bad_phase:
1694: /*
1695: * temporary panic for unhandled conditions
1696: * displays various things about the 53C710 status and registers
1697: * then panics.
1698: * XXXX need to clean this up to print out the info, reset, and continue
1699: */
1700: printf("osiop_chkintr: target %x ds %p\n", target, ds);
1701: printf("scripts %lx ds %lx dsp %x dcmd %x\n", scraddr,
1702: sc->sc_dsdma->dm_segs[0].ds_addr + acb->dsoffset,
1703: osiop_read_4(sc, OSIOP_DSP),
1704: osiop_read_4(sc, OSIOP_DBC));
1705: printf("osiop_chkintr: istat %x dstat %x sstat0 %x "
1706: "dsps %x dsa %x sbcl %x sts %x msg %x %x sfbr %x\n",
1707: istat, dstat, sstat0, intcode,
1708: osiop_read_4(sc, OSIOP_DSA),
1709: osiop_read_1(sc, OSIOP_SBCL),
1710: ds->stat[0], ds->msgbuf[0], ds->msgbuf[1],
1711: osiop_read_1(sc, OSIOP_SFBR));
1712: #ifdef OSIOP_DEBUG
1713: if (osiop_debug & DEBUG_DMA)
1714: panic("osiop_chkintr: **** temp ****");
1715: #if 0
1716: #ifdef DDB
1717: Debugger();
1718: #endif
1719: #endif
1720: #endif
1721: osiop_reset(sc); /* hard reset */
1722: *status = SCSI_OSIOP_NOSTATUS;
1723: if (acb != NULL)
1724: acb->status = ACB_S_DONE;
1725: return (0); /* osiop_reset cleaned up */
1726: }
1727:
1728: void
1729: osiop_select(sc)
1730: struct osiop_softc *sc;
1731: {
1732: struct osiop_acb *acb = sc->sc_nexus;
1733:
1734: #ifdef OSIOP_DEBUG
1735: if (osiop_debug & DEBUG_CMD)
1736: printf("%s: select ", sc->sc_dev.dv_xname);
1737: #endif
1738:
1739: if (acb->xsflags & SCSI_POLL || sc->sc_flags & OSIOP_NODMA) {
1740: sc->sc_flags |= OSIOP_INTSOFF;
1741: sc->sc_flags &= ~OSIOP_INTDEFER;
1742: if ((osiop_read_1(sc, OSIOP_ISTAT) & OSIOP_ISTAT_CON) == 0) {
1743: osiop_write_1(sc, OSIOP_SIEN, 0);
1744: osiop_write_1(sc, OSIOP_DIEN, 0);
1745: }
1746: #if 0
1747: } else if ((sc->sc_flags & OSIOP_INTDEFER) == 0) {
1748: sc->sc_flags &= ~OSIOP_INTSOFF;
1749: if ((osiop_read_1(sc, OSIOP_ISTAT) & OSIOP_ISTAT_CON) == 0) {
1750: osiop_write_1(sc, OSIOP_SIEN, sc->sc_sien);
1751: osiop_write_1(sc, OSIOP_DIEN, sc->sc_dien);
1752: }
1753: #endif
1754: }
1755: #ifdef OSIOP_DEBUG
1756: if (osiop_debug & DEBUG_CMD)
1757: printf("osiop_select: target %x cmd %02x ds %p\n",
1758: acb->xs->sc_link->target,
1759: acb->ds->scsi_cmd.opcode, sc->sc_nexus->ds);
1760: #endif
1761:
1762: osiop_start(sc);
1763:
1764: return;
1765: }
1766:
1767: /*
1768: * 53C710 interrupt handler
1769: */
1770:
1771: void
1772: osiop_intr(sc)
1773: struct osiop_softc *sc;
1774: {
1775: int status, s;
1776: u_int8_t istat, dstat, sstat0;
1777:
1778: s = splbio();
1779:
1780: istat = sc->sc_istat;
1781: if ((istat & (OSIOP_ISTAT_SIP | OSIOP_ISTAT_DIP)) == 0) {
1782: splx(s);
1783: return;
1784: }
1785:
1786: /* Got a valid interrupt on this device; set by MD handler */
1787: dstat = sc->sc_dstat;
1788: sstat0 = sc->sc_sstat0;
1789: sc->sc_istat = 0;
1790: #ifdef OSIOP_DEBUG
1791: if (!sc->sc_active) {
1792: /* XXX needs sync */
1793: printf("%s: spurious interrupt? "
1794: "istat %x dstat %x sstat0 %x nexus %p status %x\n",
1795: sc->sc_dev.dv_xname, istat, dstat, sstat0, sc->sc_nexus,
1796: (sc->sc_nexus != NULL) ? sc->sc_nexus->ds->stat[0] : 0);
1797: }
1798: #endif
1799:
1800: #ifdef OSIOP_DEBUG
1801: if (osiop_debug & (DEBUG_INT|DEBUG_CMD)) {
1802: /* XXX needs sync */
1803: printf("%s: intr istat %x dstat %x sstat0 %x dsps %x "
1804: "sbcl %x dsp %x dcmd %x sts %x msg %x\n",
1805: sc->sc_dev.dv_xname,
1806: istat, dstat, sstat0,
1807: osiop_read_4(sc, OSIOP_DSPS),
1808: osiop_read_1(sc, OSIOP_SBCL),
1809: osiop_read_4(sc, OSIOP_DSP),
1810: osiop_read_4(sc, OSIOP_DBC),
1811: (sc->sc_nexus != NULL) ? sc->sc_nexus->ds->stat[0] : 0,
1812: (sc->sc_nexus != NULL) ? sc->sc_nexus->ds->msgbuf[0] : 0);
1813: }
1814: #endif
1815: if (sc->sc_flags & OSIOP_INTDEFER) {
1816: sc->sc_flags &= ~(OSIOP_INTDEFER | OSIOP_INTSOFF);
1817: osiop_write_1(sc, OSIOP_SIEN, sc->sc_sien);
1818: osiop_write_1(sc, OSIOP_DIEN, sc->sc_dien);
1819: }
1820: if (osiop_checkintr(sc, istat, dstat, sstat0, &status)) {
1821: #if 0
1822: if (status == SCSI_OSIOP_NOSTATUS)
1823: printf("osiop_intr: no valid status \n");
1824: #endif
1825: if ((sc->sc_flags & (OSIOP_INTSOFF | OSIOP_INTDEFER)) !=
1826: OSIOP_INTSOFF) {
1827: #if 0
1828: if (osiop_read_1(sc, OSIOP_SBCL) & OSIOP_BSY) {
1829: struct scsi_link *periph;
1830:
1831: periph = sc->sc_nexus->xs->sc_link;
1832: printf("%s: SCSI bus busy at completion"
1833: " targ %d sbcl %02x sfbr %x lcrc "
1834: "%02x dsp +%x\n", sc->sc_dev.dv_xname,
1835: periph->periphtarget,
1836: osiop_read_1(sc, OSIOP_SBCL),
1837: osiop_read_1(sc, OSIOP_SFBR),
1838: osiop_read_1(sc, OSIOP_LCRC),
1839: osiop_read_4(sc, OSIOP_DSP) -
1840: sc->sc_scrdma->dm_segs[0].ds_addr);
1841: }
1842: #endif
1843: osiop_scsidone(sc->sc_nexus, status);
1844: }
1845: }
1846: splx(s);
1847: }
1848:
1849: void
1850: osiop_update_xfer_mode(sc, target)
1851: struct osiop_softc *sc;
1852: int target;
1853: {
1854: struct osiop_tinfo *ti = &sc->sc_tinfo[target];
1855:
1856: printf("%s: target %d now using 8 bit ", sc->sc_dev.dv_xname, target);
1857:
1858: ti->sxfer = 0;
1859: ti->sbcl = 0;
1860: if (ti->offset != 0) {
1861: scsi_period_to_osiop(sc, target);
1862: switch (ti->period) {
1863: case 0x00:
1864: case 0x01:
1865: case 0x02:
1866: case 0x03:
1867: case 0x04:
1868: case 0x05:
1869: case 0x06:
1870: case 0x07:
1871: case 0x08:
1872: /* Reserved transfer period factor */
1873: printf("??");
1874: break;
1875: case 0x09:
1876: /* Transfer period = 12.5 ns */
1877: printf("80");
1878: break;
1879: case 0x0a:
1880: /* Transfer period = 25 ns */
1881: printf("40");
1882: break;
1883: case 0x0b:
1884: /* Transfer period = 30.3 ns */
1885: printf("33");
1886: break;
1887: case 0x0c:
1888: /* Transfer period = 50 ns */
1889: printf("20");
1890: break;
1891: default:
1892: /* Transfer period = ti->period*4 ns */
1893: printf("%d", 1000/(ti->period*4));
1894: break;
1895: }
1896: printf(" MHz %d REQ/ACK offset", ti->offset);
1897: } else
1898: printf("asynch");
1899:
1900: printf(" xfers\n");
1901: }
1902:
1903: /*
1904: * This is based on the Progressive Peripherals 33MHz Zeus driver and will
1905: * not be correct for other 53c710 boards.
1906: *
1907: */
1908: void
1909: scsi_period_to_osiop(sc, target)
1910: struct osiop_softc *sc;
1911: int target;
1912: {
1913: int period, offset, sxfer, sbcl;
1914: #ifdef OSIOP_DEBUG
1915: int i;
1916: #endif
1917:
1918: period = sc->sc_tinfo[target].period;
1919: offset = sc->sc_tinfo[target].offset;
1920: #ifdef OSIOP_DEBUG
1921: if (osiop_debug & DEBUG_SYNC) {
1922: sxfer = 0;
1923: if (offset <= OSIOP_MAX_OFFSET)
1924: sxfer = offset;
1925: for (i = 0; i < sizeof(sync_tab) / sizeof(sync_tab[0]); i++) {
1926: if (period <= sync_tab[i].p) {
1927: sxfer |= sync_tab[i].r & 0x70;
1928: sbcl = sync_tab[i].r & 0x03;
1929: break;
1930: }
1931: }
1932: printf("osiop sync old: osiop_sxfr %02x, osiop_sbcl %02x\n",
1933: sxfer, sbcl);
1934: }
1935: #endif
1936: for (sbcl = 1; sbcl < 4; sbcl++) {
1937: sxfer = (period * 4 - 1) / sc->sc_tcp[sbcl] - 3;
1938: if (sxfer >= 0 && sxfer <= 7)
1939: break;
1940: }
1941: if (sbcl > 3) {
1942: printf("osiop sync: unable to compute sync params "
1943: "for period %d ns\n", period * 4);
1944: /*
1945: * XXX need to pick a value we can do and renegotiate
1946: */
1947: sxfer = sbcl = 0;
1948: } else {
1949: sxfer = (sxfer << 4) | ((offset <= OSIOP_MAX_OFFSET) ?
1950: offset : OSIOP_MAX_OFFSET);
1951: #ifdef OSIOP_DEBUG
1952: if (osiop_debug & DEBUG_SYNC) {
1953: printf("osiop sync: params for period %dns: sxfer %x sbcl %x",
1954: period * 4, sxfer, sbcl);
1955: printf(" actual period %dns\n",
1956: sc->sc_tcp[sbcl] * ((sxfer >> 4) + 4));
1957: }
1958: #endif
1959: }
1960: sc->sc_tinfo[target].sxfer = sxfer;
1961: sc->sc_tinfo[target].sbcl = sbcl;
1962: #ifdef OSIOP_DEBUG
1963: if (osiop_debug & DEBUG_SYNC)
1964: printf("osiop sync: osiop_sxfr %02x, osiop_sbcl %02x\n",
1965: sxfer, sbcl);
1966: #endif
1967: }
1968:
1969: void
1970: osiop_timeout(arg)
1971: void *arg;
1972: {
1973: struct osiop_acb *acb = arg;
1974: struct scsi_xfer *xs = acb->xs;
1975: struct osiop_softc *sc = acb->sc;
1976: int s;
1977:
1978: sc_print_addr(xs->sc_link);
1979: printf("command 0x%02x timeout on xs %p\n", xs->cmd->opcode, xs);
1980:
1981: s = splbio();
1982: /* reset the scsi bus */
1983: osiop_resetbus(sc);
1984:
1985: acb->flags |= ACB_F_TIMEOUT;
1986: osiop_reset(sc);
1987: splx(s);
1988: return;
1989: }
1990:
1991: #ifdef OSIOP_DEBUG
1992:
1993: #if OSIOP_TRACE_SIZE
1994: void
1995: osiop_dump_trace()
1996: {
1997: int i;
1998:
1999: printf("osiop trace: next index %d\n", osiop_trix);
2000: i = osiop_trix;
2001: do {
2002: printf("%3d: '%c' %02x %02x %02x\n", i,
2003: osiop_trbuf[i], osiop_trbuf[i + 1],
2004: osiop_trbuf[i + 2], osiop_trbuf[i + 3]);
2005: i = (i + 4) & (OSIOP_TRACE_SIZE - 1);
2006: } while (i != osiop_trix);
2007: }
2008: #endif
2009:
2010: void
2011: osiop_dump_acb(acb)
2012: struct osiop_acb *acb;
2013: {
2014: u_int8_t *b;
2015: int i;
2016:
2017: printf("acb@%p ", acb);
2018: if (acb->xs == NULL) {
2019: printf("<unused>\n");
2020: return;
2021: }
2022:
2023: b = (u_int8_t *)&acb->ds->scsi_cmd;
2024: printf("(%d:%d) status %2x cmdlen %2ld cmd ",
2025: acb->xs->sc_link->target,
2026: acb->xs->sc_link->lun,
2027: acb->status,
2028: acb->ds->cmd.count);
2029: for (i = acb->ds->cmd.count; i > 0; i--)
2030: printf(" %02x", *b++);
2031: printf("\n");
2032: printf(" xs: %p data %p:%04x ", acb->xs, acb->data,
2033: acb->datalen);
2034: printf("cur %lx:%lx\n", acb->curaddr, acb->curlen);
2035: }
2036:
2037: void
2038: osiop_dump(sc)
2039: struct osiop_softc *sc;
2040: {
2041: struct osiop_acb *acb;
2042: int i, s;
2043:
2044: s = splbio();
2045: #if OSIOP_TRACE_SIZE
2046: osiop_dump_trace();
2047: #endif
2048: printf("%s@%p istat %02x\n",
2049: sc->sc_dev.dv_xname, sc, osiop_read_1(sc, OSIOP_ISTAT));
2050: if ((acb = TAILQ_FIRST(&sc->free_list)) != NULL) {
2051: printf("Free list:\n");
2052: while (acb) {
2053: osiop_dump_acb(acb);
2054: acb = TAILQ_NEXT(acb, chain);
2055: }
2056: }
2057: if ((acb = TAILQ_FIRST(&sc->ready_list)) != NULL) {
2058: printf("Ready list:\n");
2059: while (acb) {
2060: osiop_dump_acb(acb);
2061: acb = TAILQ_NEXT(acb, chain);
2062: }
2063: }
2064: if ((acb = TAILQ_FIRST(&sc->nexus_list)) != NULL) {
2065: printf("Nexus list:\n");
2066: while (acb) {
2067: osiop_dump_acb(acb);
2068: acb = TAILQ_NEXT(acb, chain);
2069: }
2070: }
2071: if (sc->sc_nexus) {
2072: printf("Nexus:\n");
2073: osiop_dump_acb(sc->sc_nexus);
2074: }
2075: for (i = 0; i < OSIOP_NTGT; i++) {
2076: if (sc->sc_tinfo[i].cmds > 2) {
2077: printf("tgt %d: cmds %d disc %d lubusy %x\n",
2078: i, sc->sc_tinfo[i].cmds,
2079: sc->sc_tinfo[i].dconns,
2080: sc->sc_tinfo[i].lubusy);
2081: }
2082: }
2083: splx(s);
2084: }
2085: #endif