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