1 /* $NetBSD: ncr5380.c,v 1.79 2023/08/01 21:26:27 andvar Exp $ */
2
3 /*
4 * Copyright (c) 1995 Leo Weppelman.
5 * 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 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include <sys/cdefs.h>
29 __KERNEL_RCSID(0, "$NetBSD: ncr5380.c,v 1.79 2023/08/01 21:26:27 andvar Exp $");
30
31 /*
32 * Bit mask of targets you want debugging to be shown
33 */
34 uint8_t dbg_target_mask = 0x7f;
35
36 /*
37 * Set bit for target when parity checking must be disabled.
38 * My (LWP) Maxtor 7245S seems to generate parity errors on about 50%
39 * of all transfers while the data is correct!?
40 */
41 uint8_t ncr5380_no_parchk = 0xff;
42
43 #ifdef AUTO_SENSE
44
45 /*
46 * Bit masks of targets that accept linked commands, and those
47 * that we've already checked out. Some devices will report
48 * that they support linked commands when they have problems with
49 * them. By default, don't try them on any devices. Allow an
50 * option to override.
51 */
52 #ifdef TRY_SCSI_LINKED_COMMANDS
53 uint8_t ncr_test_link = ((~TRY_SCSI_LINKED_COMMANDS) & 0x7f);
54 #else
55 uint8_t ncr_test_link = 0x7f;
56 #endif
57 uint8_t ncr_will_link = 0x00;
58
59 #endif /* AUTO_SENSE */
60
61 /*
62 * This is the default sense-command we send.
63 */
64 static uint8_t sense_cmd[] = {
65 SCSI_REQUEST_SENSE, 0, 0, 0, sizeof(struct scsi_sense_data), 0
66 };
67
68 /*
69 * True if the main co-routine is running
70 */
71 static volatile int main_running = 0;
72
73 /*
74 * Mask of targets selected
75 */
76 static uint8_t busy;
77
78 static void ncr5380_minphys(struct buf *bp);
79 static void ncr5380_scsi_request(struct scsipi_channel *,
80 scsipi_adapter_req_t, void *);
81 static void ncr5380_show_scsi_cmd(struct scsipi_xfer *xs);
82
83 static SC_REQ req_queue[NREQ];
84 static SC_REQ *free_head = NULL; /* Free request structures */
85
86
87 /*
88 * Inline functions:
89 */
90
91 /*
92 * Wait for request-line to become active. When it doesn't return 0.
93 * Otherwise return != 0.
94 * The timeouts in the 'wait_req_*' functions are arbitrary and rather
95 * large. In 99% of the invocations nearly no timeout is needed but in
96 * some cases (especially when using my tapedrive, a Tandberg 3600) the
97 * device is busy internally and the first SCSI-phase will be delayed.
98 */
99 static inline int
wait_req_true(void)100 wait_req_true(void)
101 {
102 int timeout = 250000;
103
104 while ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_REQ) == 0 && --timeout)
105 delay(1);
106 return GET_5380_REG(NCR5380_IDSTAT) & SC_S_REQ;
107 }
108
109 /*
110 * Wait for request-line to become inactive. When it doesn't return 0.
111 * Otherwise return != 0.
112 */
113 static inline int
wait_req_false(void)114 wait_req_false(void)
115 {
116 int timeout = 250000;
117
118 while ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_REQ) && --timeout)
119 delay(1);
120 return (GET_5380_REG(NCR5380_IDSTAT) & SC_S_REQ) == 0;
121 }
122
123 static inline void
ack_message(void)124 ack_message(void)
125 {
126
127 SET_5380_REG(NCR5380_ICOM, 0);
128 }
129
130 static inline void
nack_message(SC_REQ * reqp,u_char msg)131 nack_message(SC_REQ *reqp, u_char msg)
132 {
133
134 SET_5380_REG(NCR5380_ICOM, SC_A_ATN);
135 reqp->msgout = msg;
136 }
137
138 static inline void
finish_req(SC_REQ * reqp)139 finish_req(SC_REQ *reqp)
140 {
141 int sps;
142 struct scsipi_xfer *xs = reqp->xs;
143
144 #ifdef REAL_DMA
145 /*
146 * If we bounced, free the bounce buffer
147 */
148 if (reqp->dr_flag & DRIVER_BOUNCING)
149 free_bounceb(reqp->bounceb);
150 #endif /* REAL_DMA */
151 #ifdef DBG_REQ
152 if (dbg_target_mask & (1 << reqp->targ_id))
153 show_request(reqp, "DONE");
154 #endif
155 #ifdef DBG_ERR_RET
156 if ((dbg_target_mask & (1 << reqp->targ_id)) && (reqp->xs->error != 0))
157 show_request(reqp, "ERR_RET");
158 #endif
159 /*
160 * Return request to free-q
161 */
162 sps = splbio();
163 reqp->next = free_head;
164 free_head = reqp;
165 splx(sps);
166
167 if ((reqp->dr_flag & DRIVER_LINKCHK) == 0)
168 scsipi_done(xs);
169 }
170
171 /*
172 * Auto config stuff....
173 */
174 static void ncr_attach(device_t, device_t, void *);
175 static int ncr_match(device_t, cfdata_t, void *);
176
177 /*
178 * Tricks to make driver-name configurable
179 */
180 #define CFNAME(n) __CONCAT(n,_cd)
181 #define CANAME(n) __CONCAT(n,_ca)
182 #define CFSTRING(n) __STRING(n)
183 #define CFDRNAME(n) n
184
185 CFATTACH_DECL_NEW(CFDRNAME(DRNAME), sizeof(struct ncr_softc),
186 ncr_match, ncr_attach, NULL, NULL);
187
188 extern struct cfdriver CFNAME(DRNAME);
189
190 static int
ncr_match(device_t parent,cfdata_t cf,void * aux)191 ncr_match(device_t parent, cfdata_t cf, void *aux)
192 {
193
194 return machine_match(parent, cf, aux, &CFNAME(DRNAME));
195 }
196
197 static void
ncr_attach(device_t parent,device_t self,void * aux)198 ncr_attach(device_t parent, device_t self, void *aux)
199 {
200 struct ncr_softc *sc;
201 int i;
202
203 sc = device_private(self);
204 sc->sc_dev = self;
205
206 sc->sc_adapter.adapt_dev = self;
207 sc->sc_adapter.adapt_openings = 7;
208 sc->sc_adapter.adapt_max_periph = 1;
209 sc->sc_adapter.adapt_ioctl = NULL;
210 sc->sc_adapter.adapt_minphys = ncr5380_minphys;
211 sc->sc_adapter.adapt_request = ncr5380_scsi_request;
212
213 sc->sc_channel.chan_adapter = &sc->sc_adapter;
214 sc->sc_channel.chan_bustype = &scsi_bustype;
215 sc->sc_channel.chan_channel = 0;
216 sc->sc_channel.chan_ntargets = 8;
217 sc->sc_channel.chan_nluns = 8;
218 sc->sc_channel.chan_id = 7;
219
220 /*
221 * bitmasks
222 */
223 sc->sc_noselatn = 0;
224 sc->sc_selected = 0;
225
226 /*
227 * Initialize machine-type specific things...
228 */
229 scsi_mach_init(sc);
230 printf("\n");
231
232 /*
233 * Initialize request queue freelist.
234 */
235 for (i = 0; i < NREQ; i++) {
236 req_queue[i].next = free_head;
237 free_head = &req_queue[i];
238 }
239
240 /*
241 * Initialize the host adapter
242 */
243 scsi_idisable();
244 ENABLE_NCR5380(sc);
245 SET_5380_REG(NCR5380_ICOM, 0);
246 SET_5380_REG(NCR5380_MODE, IMODE_BASE);
247 SET_5380_REG(NCR5380_TCOM, 0);
248 SET_5380_REG(NCR5380_IDSTAT, 0);
249 scsi_ienable();
250
251 /*
252 * attach all scsi units on us
253 */
254 config_found(self, &sc->sc_channel, scsiprint, CFARGS_NONE);
255 }
256
257 /*
258 * End of auto config stuff....
259 */
260
261 /*
262 * Carry out a request from the high level driver.
263 */
264 static void
ncr5380_scsi_request(struct scsipi_channel * chan,scsipi_adapter_req_t req,void * arg)265 ncr5380_scsi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
266 void *arg)
267 {
268 struct scsipi_xfer *xs;
269 struct ncr_softc *sc;
270 int sps;
271 SC_REQ *reqp, *link, *tmp;
272 int flags;
273
274 sc = device_private(chan->chan_adapter->adapt_dev);
275
276 switch (req) {
277 case ADAPTER_REQ_RUN_XFER:
278 xs = arg;
279
280 /*
281 * We do not queue RESET commands
282 */
283 flags = xs->xs_control;
284 if (flags & XS_CTL_RESET) {
285 scsi_reset_verbose(sc, "Got reset-command");
286 scsipi_done(xs);
287 return;
288 }
289
290 /*
291 * Get a request block
292 */
293 sps = splbio();
294 if ((reqp = free_head) == 0) {
295 xs->error = XS_RESOURCE_SHORTAGE;
296 scsipi_done(xs);
297 splx(sps);
298 return;
299 }
300 free_head = reqp->next;
301 reqp->next = NULL;
302 splx(sps);
303
304 /*
305 * Initialize our private fields
306 */
307 reqp->dr_flag = (flags & XS_CTL_POLL) ? DRIVER_NOINT : 0;
308 reqp->phase = NR_PHASE;
309 reqp->msgout = MSG_NOOP;
310 reqp->status = SCSGOOD;
311 reqp->message = 0xff;
312 reqp->link = NULL;
313 reqp->xs = xs;
314 reqp->targ_id = xs->xs_periph->periph_target;
315 reqp->targ_lun = xs->xs_periph->periph_lun;
316 reqp->xdata_ptr = (u_char*)xs->data;
317 reqp->xdata_len = xs->datalen;
318 memcpy(&reqp->xcmd, xs->cmd, xs->cmdlen);
319 reqp->xcmd_len = xs->cmdlen;
320 reqp->xcmd.bytes[0] |= reqp->targ_lun << 5;
321
322 #ifdef REAL_DMA
323 /*
324 * Check if DMA can be used on this request
325 */
326 if (scsi_dmaok(reqp))
327 reqp->dr_flag |= DRIVER_DMAOK;
328 #endif /* REAL_DMA */
329
330 /*
331 * Insert the command into the issue queue. Note that
332 * 'REQUEST SENSE' commands are inserted at the head of the
333 * queue since any command will clear the existing contingent
334 * allegience condition and the sense data is only valid while
335 * the condition exists. When possible, link the command to a
336 * previous command to the same target. This is not very
337 * sensible when AUTO_SENSE is not defined! Interrupts are
338 * disabled while we are fiddling with the issue-queue.
339 */
340 sps = splbio();
341 link = NULL;
342 if ((issue_q == NULL) ||
343 (reqp->xcmd.opcode == SCSI_REQUEST_SENSE)) {
344 reqp->next = issue_q;
345 issue_q = reqp;
346 } else {
347 tmp = issue_q;
348 do {
349 if (!link && (tmp->targ_id == reqp->targ_id) &&
350 !tmp->link)
351 link = tmp;
352 } while (tmp->next && (tmp = tmp->next));
353 tmp->next = reqp;
354 #ifdef AUTO_SENSE
355 if (link && (ncr_will_link & (1<<reqp->targ_id))) {
356 link->link = reqp;
357 link->xcmd.bytes[link->xs->cmdlen-2] |= 1;
358 }
359 #endif
360 }
361 #ifdef AUTO_SENSE
362 /*
363 * If we haven't already, check the target for link support.
364 * Do this by prefixing the current command with a dummy
365 * Request_Sense command, link the dummy to the current
366 * command, and insert the dummy command at the head of the
367 * issue queue. Set the DRIVER_LINKCHK flag so that we'll
368 * ignore the results of the dummy command, since we only
369 * care about whether it was accepted or not.
370 */
371 if (!link && (ncr_test_link & (1 << reqp->targ_id)) == 0 &&
372 (tmp = free_head) && (reqp->dr_flag & DRIVER_NOINT) == 0) {
373 free_head = tmp->next;
374 tmp->dr_flag = (reqp->dr_flag & ~DRIVER_DMAOK) |
375 DRIVER_LINKCHK;
376 tmp->phase = NR_PHASE;
377 tmp->msgout = MSG_NOOP;
378 tmp->status = SCSGOOD;
379 tmp->xs = reqp->xs;
380 tmp->targ_id = reqp->targ_id;
381 tmp->targ_lun = reqp->targ_lun;
382 memcpy(&tmp->xcmd, sense_cmd, sizeof(sense_cmd));
383 tmp->xcmd_len = sizeof(sense_cmd);
384 tmp->xdata_ptr = (u_char *)&tmp->xs->sense.scsi_sense;
385 tmp->xdata_len = sizeof(tmp->xs->sense.scsi_sense);
386 ncr_test_link |= 1<<tmp->targ_id;
387 tmp->link = reqp;
388 tmp->xcmd.bytes[sizeof(sense_cmd)-2] |= 1;
389 tmp->next = issue_q;
390 issue_q = tmp;
391 #ifdef DBG_REQ
392 if (dbg_target_mask & (1 << tmp->targ_id))
393 show_request(tmp, "LINKCHK");
394 #endif
395 }
396 #endif
397 splx(sps);
398
399 #ifdef DBG_REQ
400 if (dbg_target_mask & (1 << reqp->targ_id))
401 show_request(reqp,
402 (reqp->xcmd.opcode == SCSI_REQUEST_SENSE) ?
403 "HEAD":"TAIL");
404 #endif
405
406 run_main(sc);
407 return;
408
409 case ADAPTER_REQ_GROW_RESOURCES:
410 /* XXX Not supported. */
411 return;
412
413 case ADAPTER_REQ_SET_XFER_MODE:
414 /* XXX Not supported. */
415 return;
416 }
417 }
418
419 static void
ncr5380_minphys(struct buf * bp)420 ncr5380_minphys(struct buf *bp)
421 {
422
423 if (bp->b_bcount > MIN_PHYS)
424 bp->b_bcount = MIN_PHYS;
425 minphys(bp);
426 }
427 #undef MIN_PHYS
428
429 static void
ncr5380_show_scsi_cmd(struct scsipi_xfer * xs)430 ncr5380_show_scsi_cmd(struct scsipi_xfer *xs)
431 {
432 uint8_t *b = (uint8_t *)xs->cmd;
433 int i = 0;
434
435 scsipi_printaddr(xs->xs_periph);
436 if ((xs->xs_control & XS_CTL_RESET) == 0) {
437 while (i < xs->cmdlen) {
438 if (i)
439 printf(",");
440 printf("%x",b[i++]);
441 }
442 printf("-\n");
443 } else {
444 printf("-RESET-\n");
445 }
446 }
447
448 /*
449 * The body of the driver.
450 */
451 static void
scsi_main(struct ncr_softc * sc)452 scsi_main(struct ncr_softc *sc)
453 {
454 SC_REQ *req, *prev;
455 int itype;
456 int sps;
457
458 /*
459 * While running in the driver SCSI-interrupts are disabled.
460 */
461 scsi_idisable();
462 ENABLE_NCR5380(sc);
463
464 PID("scsi_main1");
465 for (;;) {
466 sps = splbio();
467 if (!connected) {
468 /*
469 * Check if it is fair keep any exclusive access to
470 * DMA claimed. If not, stop queueing new jobs so
471 * the discon_q will be eventually drained and DMA
472 * can be given up.
473 */
474 if (!fair_to_keep_dma())
475 goto main_exit;
476
477 /*
478 * Search through the issue-queue for a command
479 * destined for a target that isn't busy.
480 */
481 prev = NULL;
482 for (req=issue_q; req != NULL;
483 prev = req, req = req->next) {
484 if ((busy & (1 << req->targ_id)) == 0) {
485 /*
486 * Found one, remove it from
487 * the issue queue.
488 */
489 if (prev == NULL)
490 issue_q = req->next;
491 else
492 prev->next = req->next;
493 req->next = NULL;
494 break;
495 }
496 }
497
498 /*
499 * When a request has just ended, we get here
500 * before an other device detects that
501 * the bus is free and that it can reconnect.
502 * The problem is that when this happens,
503 * we always baffle the device because our
504 * (initiator) id is higher. This can cause
505 * a sort of starvation on slow devices.
506 * So we check for a pending reselection here.
507 * Note that 'connected' will be non-null
508 * if the reselection succeeds.
509 */
510 if ((GET_5380_REG(NCR5380_IDSTAT) & (SC_S_SEL|SC_S_IO))
511 == (SC_S_SEL|SC_S_IO)){
512 if (req != NULL) {
513 req->next = issue_q;
514 issue_q = req;
515 }
516 splx(sps);
517
518 reselect(sc);
519 scsi_clr_ipend();
520 goto connected;
521 }
522
523 /*
524 * The host is not connected and there is no request
525 * pending, exit.
526 */
527 if (req == NULL) {
528 PID("scsi_main2");
529 goto main_exit;
530 }
531
532 /*
533 * Re-enable interrupts before handling the request.
534 */
535 splx(sps);
536
537 #ifdef DBG_REQ
538 if (dbg_target_mask & (1 << req->targ_id))
539 show_request(req, "TARGET");
540 #endif
541 /*
542 * We found a request. Try to connect to the target.
543 * If the initiator fails arbitration,
544 * the command is put back in the issue queue.
545 */
546 if (scsi_select(req, 0)) {
547 sps = splbio();
548 req->next = issue_q;
549 issue_q = req;
550 splx(sps);
551 #ifdef DBG_REQ
552 if (dbg_target_mask & (1 << req->targ_id))
553 ncr_tprint(req, "Select failed\n");
554 #endif
555 }
556 } else
557 splx(sps);
558 connected:
559 if (connected) {
560 /*
561 * If the host is currently connected but
562 * a 'real-DMA' transfer is in progress,
563 * the 'end-of-DMA' interrupt restarts main.
564 * So quit.
565 */
566 sps = splbio();
567 if (connected &&
568 (connected->dr_flag & DRIVER_IN_DMA)) {
569 PID("scsi_main3");
570 goto main_exit;
571 }
572 splx(sps);
573
574 /*
575 * Let the target guide us through the bus-phases
576 */
577 while (information_transfer(sc) == -1)
578 continue;
579 }
580 }
581 /* NEVER TO REACH HERE */
582 show_phase(NULL, 0); /* XXX: Get rid of not used warning */
583 panic("ncr5380-SCSI: not designed to come here");
584
585 main_exit:
586 /*
587 * We enter here with interrupts disabled. We are about to exit main
588 * so interrupts should be re-enabled. Because interrupts are edge
589 * triggered, we could already have missed the interrupt. Therefore
590 * we check the IRQ-line here and re-enter when we really missed a
591 * valid interrupt.
592 */
593 PID("scsi_main4");
594 scsi_ienable();
595
596 /*
597 * If we're not currently connected, enable reselection
598 * interrupts.
599 */
600 if (!connected)
601 SET_5380_REG(NCR5380_IDSTAT, SC_HOST_ID);
602
603 if (scsi_ipending()) {
604 if ((itype = check_intr(sc)) != INTR_SPURIOUS) {
605 scsi_idisable();
606 scsi_clr_ipend();
607 splx(sps);
608
609 if (itype == INTR_RESEL)
610 reselect(sc);
611 else {
612 #ifdef REAL_DMA
613 dma_ready();
614 #else
615 if (pdma_ready())
616 goto connected;
617 panic("Got DMA interrupt without DMA");
618 #endif
619 }
620 goto connected;
621 }
622 }
623 reconsider_dma();
624 main_running = 0;
625 splx(sps);
626 PID("scsi_main5");
627 }
628
629 #ifdef REAL_DMA
630 /*
631 * The SCSI-DMA interrupt.
632 * This interrupt can only be triggered when running in non-polled DMA
633 * mode. When DMA is not active, it will be silently ignored, it is usually
634 * to late because the EOP interrupt of the controller happens just a tiny
635 * bit earlier. It might become useful when scatter/gather is implemented,
636 * because in that case only part of the DATAIN/DATAOUT transfer is taken
637 * out of a single buffer.
638 */
639 static void
ncr_dma_intr(struct ncr_softc * sc)640 ncr_dma_intr(struct ncr_softc *sc)
641 {
642 SC_REQ *reqp;
643 int dma_done;
644
645 PID("ncr_dma_intr");
646 if ((reqp = connected) && (reqp->dr_flag & DRIVER_IN_DMA)) {
647 scsi_idisable();
648 if ((dma_done = dma_ready()) == 0) {
649 transfer_dma(reqp, reqp->phase, 0);
650 return;
651 }
652 run_main(sc);
653 }
654 }
655 #endif /* REAL_DMA */
656
657 /*
658 * The SCSI-controller interrupt. This interrupt occurs on reselections and
659 * at the end of non-polled DMA-interrupts. It is assumed to be called from
660 * the machine-dependent hardware interrupt.
661 */
662 static void
ncr_ctrl_intr(struct ncr_softc * sc)663 ncr_ctrl_intr(struct ncr_softc *sc)
664 {
665 int itype;
666
667 if (main_running)
668 return; /* scsi_main() should handle this one */
669
670 while (scsi_ipending()) {
671 scsi_idisable();
672 if ((itype = check_intr(sc)) != INTR_SPURIOUS) {
673 if (itype == INTR_RESEL)
674 reselect(sc);
675 else {
676 #ifdef REAL_DMA
677 int dma_done;
678 if ((dma_done = dma_ready()) == 0) {
679 transfer_dma(connected,
680 connected->phase, 0);
681 return;
682 }
683 #else
684 if (pdma_ready())
685 return;
686 panic("Got DMA interrupt without DMA");
687 #endif
688 }
689 scsi_clr_ipend();
690 }
691 run_main(sc);
692 return;
693 }
694 PID("ncr_ctrl_intr1");
695 }
696
697 /*
698 * Initiate a connection path between the host and the target. The function
699 * first goes into arbitration for the SCSI-bus. When this succeeds, the target
700 * is selected and an 'IDENTIFY' message is send.
701 * Returns -1 when the arbitration failed. Otherwise 0 is returned. When
702 * the target does not respond (to either selection or 'MESSAGE OUT') the
703 * 'done' function is executed.
704 * The result code given by the driver can be influenced by setting 'code'
705 * to a non-zero value. This is the case when 'select' is called by abort.
706 */
707 static int
scsi_select(SC_REQ * reqp,int code)708 scsi_select(SC_REQ *reqp, int code)
709 {
710 uint8_t tmp[1];
711 uint8_t phase;
712 u_long cnt;
713 int sps;
714 uint8_t atn_flag;
715 uint8_t targ_bit;
716 struct ncr_softc *sc;
717
718 sc = device_private(
719 reqp->xs->xs_periph->periph_channel->chan_adapter->adapt_dev);
720 DBG_SELPRINT ("Starting arbitration\n", 0);
721 PID("scsi_select1");
722
723 sps = splbio();
724
725 /*
726 * Prevent a race condition here. If a reselection interrupt occurred
727 * between the decision to pick a new request and the call to select,
728 * we abort the selection.
729 * Interrupts are lowered when the 5380 is setup to arbitrate for the
730 * bus.
731 */
732 if (connected) {
733 splx(sps);
734 PID("scsi_select2");
735 return -1;
736 }
737
738 /*
739 * Set phase bits to 0, otherwise the 5380 won't drive the bus during
740 * selection.
741 */
742 SET_5380_REG(NCR5380_TCOM, 0);
743 SET_5380_REG(NCR5380_ICOM, 0);
744
745 /*
746 * Arbitrate for the bus.
747 */
748 SET_5380_REG(NCR5380_DATA, SC_HOST_ID);
749 SET_5380_REG(NCR5380_MODE, SC_ARBIT);
750
751 splx(sps);
752
753 cnt = 10;
754 while ((GET_5380_REG(NCR5380_ICOM) & SC_AIP) == 0 && --cnt)
755 delay(1);
756
757 if ((GET_5380_REG(NCR5380_ICOM) & SC_AIP) == 0) {
758 SET_5380_REG(NCR5380_MODE, IMODE_BASE);
759 SET_5380_REG(NCR5380_ICOM, 0);
760 DBG_SELPRINT ("Arbitration lost, bus not free\n",0);
761 PID("scsi_select3");
762 return -1;
763 }
764
765 /* The arbitration delay is 2.2 usecs */
766 delay(3);
767
768 /*
769 * Check the result of the arbitration. If we failed, return -1.
770 */
771 if (GET_5380_REG(NCR5380_ICOM) & SC_LA) {
772 SET_5380_REG(NCR5380_MODE, IMODE_BASE);
773 SET_5380_REG(NCR5380_ICOM, 0);
774 PID("scsi_select4");
775 return -1;
776 }
777
778 /*
779 * The spec requires that we should read the data register to
780 * check for higher id's and check the SC_LA again.
781 */
782 tmp[0] = GET_5380_REG(NCR5380_DATA);
783 if (tmp[0] & ~((SC_HOST_ID << 1) - 1)) {
784 SET_5380_REG(NCR5380_MODE, IMODE_BASE);
785 SET_5380_REG(NCR5380_ICOM, 0);
786 DBG_SELPRINT ("Arbitration lost, higher id present\n",0);
787 PID("scsi_select5");
788 return -1;
789 }
790 if (GET_5380_REG(NCR5380_ICOM) & SC_LA) {
791 SET_5380_REG(NCR5380_MODE, IMODE_BASE);
792 SET_5380_REG(NCR5380_ICOM, 0);
793 DBG_SELPRINT ("Arbitration lost,deassert SC_ARBIT\n",0);
794 PID("scsi_select6");
795 return -1;
796 }
797 SET_5380_REG(NCR5380_ICOM, SC_A_SEL | SC_A_BSY);
798 if (GET_5380_REG(NCR5380_ICOM) & SC_LA) {
799 SET_5380_REG(NCR5380_MODE, IMODE_BASE);
800 SET_5380_REG(NCR5380_ICOM, 0);
801 DBG_SELPRINT ("Arbitration lost, deassert SC_A_SEL\n", 0);
802 PID("scsi_select7");
803 return -1;
804 }
805 /* Bus settle delay + Bus clear delay = 1.2 usecs */
806 delay(2);
807 DBG_SELPRINT ("Arbitration complete\n", 0);
808
809 /*
810 * Now that we won the arbitration, start the selection.
811 */
812 targ_bit = 1 << reqp->targ_id;
813 SET_5380_REG(NCR5380_DATA, SC_HOST_ID | targ_bit);
814
815 if (sc->sc_noselatn & targ_bit)
816 atn_flag = 0;
817 else
818 atn_flag = SC_A_ATN;
819
820 /*
821 * Raise ATN while SEL is true before BSY goes false from arbitration,
822 * since this is the only way to guarantee that we'll get a MESSAGE OUT
823 * phase immediately after the selection.
824 */
825 SET_5380_REG(NCR5380_ICOM, SC_A_BSY | SC_A_SEL | atn_flag | SC_ADTB);
826 SET_5380_REG(NCR5380_MODE, IMODE_BASE);
827
828 /*
829 * Turn off reselection interrupts
830 */
831 SET_5380_REG(NCR5380_IDSTAT, 0);
832
833 /*
834 * Reset BSY. The delay following it, surpresses a glitch in the
835 * 5380 which causes us to see our own BSY signal instead of that of
836 * the target.
837 */
838 SET_5380_REG(NCR5380_ICOM, SC_A_SEL | atn_flag | SC_ADTB);
839 delay(1);
840
841 /*
842 * Wait for the target to react, the specs call for a timeout of
843 * 250 ms.
844 */
845 cnt = 25000;
846 while ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_BSY) == 0 && --cnt)
847 delay(10);
848
849 if ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_BSY) == 0) {
850 /*
851 * There is no reaction from the target, start the selection
852 * timeout procedure. We release the databus but keep SEL
853 * asserted. After that we wait a 'selection abort time' (200
854 * usecs) and 2 deskew delays (90 ns) and check BSY again.
855 * When BSY is asserted, we assume the selection succeeded,
856 * otherwise we release the bus.
857 */
858 SET_5380_REG(NCR5380_ICOM, SC_A_SEL | atn_flag);
859 delay(201);
860 if ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_BSY) == 0) {
861 SET_5380_REG(NCR5380_ICOM, 0);
862 reqp->xs->error = code ? code : XS_SELTIMEOUT;
863 DBG_SELPRINT ("Target %d not responding to sel\n",
864 reqp->targ_id);
865 if (reqp->dr_flag & DRIVER_LINKCHK)
866 ncr_test_link &= ~(1<<reqp->targ_id);
867 finish_req(reqp);
868 PID("scsi_select8");
869 return 0;
870 }
871 }
872 SET_5380_REG(NCR5380_ICOM, atn_flag);
873
874 DBG_SELPRINT ("Target %d responding to select.\n", reqp->targ_id);
875
876 /*
877 * The SCSI-interrupts are disabled while a request is being handled.
878 */
879 scsi_idisable();
880
881 /*
882 * If we did not request ATN, then don't try to send IDENTIFY.
883 */
884 if (atn_flag == 0) {
885 reqp->phase = PH_CMD;
886 goto identify_failed;
887 }
888
889 /*
890 * Here we prepare to send an 'IDENTIFY' message.
891 * Allow disconnect only when interrupts are allowed.
892 */
893 tmp[0] = MSG_IDENTIFY(reqp->targ_lun,
894 (reqp->dr_flag & DRIVER_NOINT) ? 0 : 1);
895 cnt = 1;
896 phase = PH_MSGOUT;
897
898 /*
899 * Since we followed the SCSI-spec and raised ATN while SEL was true
900 * but before BSY was false during the selection, a 'MESSAGE OUT'
901 * phase should follow. Unfortunately, this does not happen on
902 * all targets (Asante ethernet devices, for example), so we must
903 * check the actual mode if the message transfer fails--if the
904 * new phase is PH_CMD and has never been successfully selected
905 * w/ATN in the past, then we assume that it is an old device
906 * that doesn't support select w/ATN.
907 */
908 if (transfer_pio(&phase, tmp, &cnt, 0) || cnt) {
909
910 if ((phase == PH_CMD) && (sc->sc_selected & targ_bit) == 0) {
911 DBG_SELPRINT("Target %d: not responding to ATN.\n",
912 reqp->targ_id);
913 sc->sc_noselatn |= targ_bit;
914 reqp->phase = PH_CMD;
915 goto identify_failed;
916 }
917
918 DBG_SELPRINT("Target %d: failed to send identify\n",
919 reqp->targ_id);
920 /*
921 * Try to disconnect from the target. We cannot leave
922 * it just hanging here.
923 */
924 if (!reach_msg_out(sc, sizeof(struct scsipi_generic))) {
925 u_long len = 1;
926 uint8_t phse = PH_MSGOUT;
927 uint8_t msg = MSG_ABORT;
928
929 transfer_pio(&phse, &msg, &len, 0);
930 } else
931 scsi_reset_verbose(sc,
932 "Connected to unidentified target");
933
934 SET_5380_REG(NCR5380_ICOM, 0);
935 reqp->xs->error = code ? code : XS_DRIVER_STUFFUP;
936 finish_req(reqp);
937 PID("scsi_select9");
938 return 0;
939 }
940 reqp->phase = PH_MSGOUT;
941
942 identify_failed:
943 sc->sc_selected |= targ_bit;
944
945 #ifdef notyet /* LWP: Do we need timeouts in the driver? */
946 /*
947 * Command is connected, start timer ticking.
948 */
949 ccb_p->xtimeout = ccb_p->timeout + Lbolt;
950 #endif
951
952 connected = reqp;
953 busy |= targ_bit;
954 PID("scsi_select10");
955 return 0;
956 }
957
958 /*
959 * Return codes:
960 * 0: Job has finished or disconnected, find something else
961 * -1: keep on calling information_transfer() from scsi_main()
962 */
963 static int
information_transfer(struct ncr_softc * sc)964 information_transfer(struct ncr_softc *sc)
965 {
966 SC_REQ *reqp = connected;
967 uint8_t tmp, phase;
968 u_long len;
969
970 PID("info_transf1");
971 /*
972 * Clear pending interrupts from 5380-chip.
973 */
974 scsi_clr_ipend();
975
976 /*
977 * The SCSI-spec requires BSY to be true while connected to a target,
978 * loosing it means we lost the target...
979 * Also REQ needs to be asserted here to indicate that the bus-phase
980 * is valid. When the target does not supply REQ within a 'reasonable'
981 * amount of time, it's probably lost in its own maze of twisting
982 * passages, we have to reset the bus to free it.
983 */
984 if (GET_5380_REG(NCR5380_IDSTAT) & SC_S_BSY)
985 wait_req_true();
986 tmp = GET_5380_REG(NCR5380_IDSTAT);
987
988
989 if ((tmp & (SC_S_BSY|SC_S_REQ)) != (SC_S_BSY|SC_S_REQ)) {
990 busy &= ~(1 << reqp->targ_id);
991 connected = NULL;
992 reqp->xs->error = XS_TIMEOUT;
993 finish_req(reqp);
994 if ((tmp & SC_S_REQ) == 0)
995 scsi_reset_verbose(sc,
996 "Timeout waiting for phase-change");
997 PID("info_transf2");
998 return 0;
999 }
1000
1001 phase = (tmp >> 2) & 7;
1002 if (phase != reqp->phase) {
1003 reqp->phase = phase;
1004 #ifdef DBG_INF
1005 if (dbg_target_mask & (1 << reqp->targ_id))
1006 DBG_INFPRINT(show_phase, reqp, phase);
1007 #endif
1008 } else {
1009 /*
1010 * Same data-phase. If same error give up
1011 */
1012 if ((reqp->msgout == MSG_ABORT) &&
1013 ((phase == PH_DATAOUT) || (phase == PH_DATAIN))) {
1014 busy &= ~(1 << reqp->targ_id);
1015 connected = NULL;
1016 reqp->xs->error = XS_TIMEOUT;
1017 finish_req(reqp);
1018 scsi_reset_verbose(sc, "Failure to abort command");
1019 return 0;
1020 }
1021 }
1022
1023 switch (phase) {
1024 case PH_DATAOUT:
1025 #ifdef DBG_NOWRITE
1026 ncr_tprint(reqp, "NOWRITE set -- write attempt aborted.");
1027 reqp->msgout = MSG_ABORT;
1028 SET_5380_REG(NCR5380_ICOM, SC_A_ATN);
1029 return -1;
1030 #endif /* DBG_NOWRITE */
1031 /*
1032 * If this is the first write using DMA, fill
1033 * the bounce buffer.
1034 */
1035 if (reqp->xdata_ptr == reqp->xs->data) { /* XXX */
1036 if (reqp->dr_flag & DRIVER_BOUNCING)
1037 memcpy(reqp->bounceb, reqp->xdata_ptr,
1038 reqp->xdata_len);
1039 }
1040
1041 case PH_DATAIN:
1042 if (reqp->xdata_len <= 0) {
1043 /*
1044 * Target keeps requesting data. Try to get into
1045 * message-out phase by feeding/taking 100 byte.
1046 */
1047 ncr_tprint(reqp, "Target requests too much data\n");
1048 reqp->msgout = MSG_ABORT;
1049 SET_5380_REG(NCR5380_ICOM, SC_A_ATN);
1050 reach_msg_out(sc, 100);
1051 return -1;
1052 }
1053 #ifdef REAL_DMA
1054 if (reqp->dr_flag & DRIVER_DMAOK) {
1055 int poll = REAL_DMA_POLL|(reqp->dr_flag & DRIVER_NOINT);
1056 transfer_dma(reqp, phase, poll);
1057 if (!poll)
1058 return 0;
1059 } else
1060 #endif
1061 {
1062 PID("info_transf3");
1063 len = reqp->xdata_len;
1064 #ifdef USE_PDMA
1065 if (transfer_pdma(&phase, reqp->xdata_ptr, &len) == 0)
1066 return 0;
1067 #else
1068 transfer_pio(&phase, reqp->xdata_ptr, &len, 0);
1069 #endif
1070 reqp->xdata_ptr += reqp->xdata_len - len;
1071 reqp->xdata_len = len;
1072 }
1073 return -1;
1074 case PH_MSGIN:
1075 /*
1076 * We only expect single byte messages here.
1077 */
1078 len = 1;
1079 transfer_pio(&phase, &tmp, &len, 1);
1080 reqp->message = tmp;
1081 return handle_message(reqp, tmp);
1082 case PH_MSGOUT:
1083 len = 1;
1084 transfer_pio(&phase, &reqp->msgout, &len, 0);
1085 if (reqp->msgout == MSG_ABORT) {
1086 busy &= ~(1 << reqp->targ_id);
1087 connected = NULL;
1088 if (!reqp->xs->error)
1089 reqp->xs->error = XS_DRIVER_STUFFUP;
1090 finish_req(reqp);
1091 PID("info_transf4");
1092 return 0;
1093 }
1094 reqp->msgout = MSG_NOOP;
1095 return -1;
1096 case PH_CMD :
1097 len = reqp->xcmd_len;
1098 transfer_pio(&phase, (uint8_t *)&reqp->xcmd, &len, 0);
1099 PID("info_transf5");
1100 return -1;
1101 case PH_STATUS:
1102 len = 1;
1103 transfer_pio(&phase, &tmp, &len, 0);
1104 reqp->status = tmp;
1105 PID("info_transf6");
1106 return -1;
1107 default:
1108 ncr_tprint(reqp, "Unknown phase\n");
1109 }
1110 PID("info_transf7");
1111 return -1;
1112 }
1113
1114 /*
1115 * Handle the message 'msg' send to us by the target.
1116 * Return values:
1117 * 0 : The current command has completed.
1118 * -1 : Get on to the next phase.
1119 */
1120 static int
handle_message(SC_REQ * reqp,u_int msg)1121 handle_message(SC_REQ *reqp, u_int msg)
1122 {
1123 int sps;
1124 SC_REQ *prev, *req;
1125
1126 PID("hmessage1");
1127 switch (msg) {
1128 /*
1129 * Linking lets us reduce the time required to get
1130 * the next command to the device, skipping the arbitration
1131 * and selection time. In the current implementation,
1132 * we merely have to start the next command pointed
1133 * to by 'next_link'.
1134 */
1135 case MSG_LINK_CMD_COMPLETE:
1136 case MSG_LINK_CMD_COMPLETEF:
1137 if (reqp->link == NULL) {
1138 ncr_tprint(reqp, "No link for linked command");
1139 nack_message(reqp, MSG_ABORT);
1140 PID("hmessage2");
1141 return -1;
1142 }
1143 ack_message();
1144 if ((reqp->dr_flag & DRIVER_AUTOSEN) == 0) {
1145 reqp->xs->resid = reqp->xdata_len;
1146 reqp->xs->error = 0;
1147 }
1148
1149 #ifdef AUTO_SENSE
1150 if (check_autosense(reqp, 1) == -1)
1151 return -1;
1152 #endif /* AUTO_SENSE */
1153
1154 #ifdef DBG_REQ
1155 if (dbg_target_mask & (1 << reqp->targ_id))
1156 show_request(reqp->link, "LINK");
1157 #endif
1158 connected = reqp->link;
1159
1160 /*
1161 * Unlink the 'linked' request from the issue_q
1162 */
1163 sps = splbio();
1164 prev = NULL;
1165 for (req = issue_q; req != NULL; prev = req, req = req->next) {
1166 if (req == connected)
1167 break;
1168 }
1169 if (req == NULL)
1170 panic("Inconsistent issue_q");
1171 if (prev == NULL)
1172 issue_q = req->next;
1173 else
1174 prev->next = req->next;
1175 req->next = NULL;
1176 splx(sps);
1177
1178 finish_req(reqp);
1179 PID("hmessage3");
1180 return -1;
1181 case MSG_ABORT:
1182 case MSG_CMDCOMPLETE:
1183 ack_message();
1184 connected = NULL;
1185 busy &= ~(1 << reqp->targ_id);
1186 if ((reqp->dr_flag & DRIVER_AUTOSEN) == 0) {
1187 reqp->xs->resid = reqp->xdata_len;
1188 reqp->xs->error = 0;
1189 }
1190
1191 #ifdef AUTO_SENSE
1192 if (check_autosense(reqp, 0) == -1) {
1193 PID("hmessage4");
1194 return 0;
1195 }
1196 #endif /* AUTO_SENSE */
1197
1198 finish_req(reqp);
1199 PID("hmessage5");
1200 return 0;
1201 case MSG_MESSAGE_REJECT:
1202 ack_message();
1203 PID("hmessage6");
1204 return -1;
1205 case MSG_DISCONNECT:
1206 ack_message();
1207 #ifdef DBG_REQ
1208 if (dbg_target_mask & (1 << reqp->targ_id))
1209 show_request(reqp, "DISCON");
1210 #endif
1211 sps = splbio();
1212 connected = NULL;
1213 reqp->next = discon_q;
1214 discon_q = reqp;
1215 splx(sps);
1216 PID("hmessage7");
1217 return 0;
1218 case MSG_SAVEDATAPOINTER:
1219 case MSG_RESTOREPOINTERS:
1220 /*
1221 * We save pointers implicitly at disconnect.
1222 * So we can ignore these messages.
1223 */
1224 ack_message();
1225 PID("hmessage8");
1226 return -1;
1227 case MSG_EXTENDED:
1228 nack_message(reqp, MSG_MESSAGE_REJECT);
1229 PID("hmessage9");
1230 return -1;
1231 default:
1232 if ((msg & 0x80) && (msg & 0x18) == 0) { /* IDENTIFY */
1233 PID("hmessage10");
1234 ack_message();
1235 return 0;
1236 } else {
1237 ncr_tprint(reqp, "Unknown message %x. Rejecting.\n",
1238 msg);
1239 nack_message(reqp, MSG_MESSAGE_REJECT);
1240 }
1241 return -1;
1242 }
1243 PID("hmessage11");
1244 return -1;
1245 }
1246
1247 /*
1248 * Handle reselection. If a valid reconnection occurs, connected
1249 * points at the reconnected command. The command is removed from the
1250 * disconnected queue.
1251 */
1252 static void
reselect(struct ncr_softc * sc)1253 reselect(struct ncr_softc *sc)
1254 {
1255 uint8_t phase;
1256 u_long len;
1257 uint8_t msg;
1258 uint8_t target_mask;
1259 int abort = 0;
1260 SC_REQ *tmp, *prev;
1261
1262 PID("reselect1");
1263 target_mask = GET_5380_REG(NCR5380_DATA) & ~SC_HOST_ID;
1264
1265 /*
1266 * At this point, we have detected that our SCSI-id is on the bus,
1267 * SEL is true and BSY was false for at least one bus settle
1268 * delay (400 ns.).
1269 * We must assert BSY ourselves, until the target drops the SEL signal.
1270 * The SCSI-spec specifies no maximum time for this, so we have to
1271 * choose something long enough to suit all targets.
1272 */
1273 SET_5380_REG(NCR5380_ICOM, SC_A_BSY);
1274 len = 250000;
1275 while ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_SEL) && (len > 0)) {
1276 delay(1);
1277 len--;
1278 }
1279 if (GET_5380_REG(NCR5380_IDSTAT) & SC_S_SEL) {
1280 /* Damn SEL isn't dropping */
1281 scsi_reset_verbose(sc, "Target won't drop SEL during Reselect");
1282 return;
1283 }
1284
1285 SET_5380_REG(NCR5380_ICOM, 0);
1286
1287 /*
1288 * Check if the reselection is still valid. Check twice because
1289 * of possible line glitches - cheaper than delay(1) and we need
1290 * only a few nanoseconds.
1291 */
1292 if ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_BSY) == 0) {
1293 if ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_BSY) == 0) {
1294 ncr_aprint(sc,
1295 "Stepped into the reselection timeout\n");
1296 return;
1297 }
1298 }
1299
1300 /*
1301 * Get the expected identify message.
1302 */
1303 phase = PH_MSGIN;
1304 len = 1;
1305 transfer_pio(&phase, &msg, &len, 0);
1306 if (len || !MSG_ISIDENTIFY(msg)) {
1307 ncr_aprint(sc, "Expecting IDENTIFY, got 0x%x\n", msg);
1308 abort = 1;
1309 tmp = NULL;
1310 } else {
1311 /*
1312 * Find the command reconnecting
1313 */
1314 for (tmp = discon_q, prev = NULL; tmp != NULL;
1315 prev = tmp, tmp = tmp->next) {
1316 if (target_mask == (1 << tmp->targ_id)) {
1317 if (prev)
1318 prev->next = tmp->next;
1319 else
1320 discon_q = tmp->next;
1321 tmp->next = NULL;
1322 break;
1323 }
1324 }
1325 if (tmp == NULL) {
1326 ncr_aprint(sc,
1327 "No disconnected job for targetmask %x\n",
1328 target_mask);
1329 abort = 1;
1330 }
1331 }
1332 if (abort) {
1333 msg = MSG_ABORT;
1334 len = 1;
1335 phase = PH_MSGOUT;
1336
1337 SET_5380_REG(NCR5380_ICOM, SC_A_ATN);
1338 if (transfer_pio(&phase, &msg, &len, 0) || len)
1339 scsi_reset_verbose(sc, "Failure to abort reselection");
1340 } else {
1341 connected = tmp;
1342 #ifdef DBG_REQ
1343 if (dbg_target_mask & (1 << tmp->targ_id))
1344 show_request(tmp, "RECON");
1345 #endif
1346 }
1347 PID("reselect2");
1348 }
1349
1350 /*
1351 * Transfer data in a given phase using programmed I/O.
1352 * Returns -1 when a different phase is entered without transferring the
1353 * maximum number of bytes, 0 if all bytes transferred or exit is in the same
1354 * phase.
1355 */
1356 static int
transfer_pio(u_char * phase,u_char * data,u_long * len,int dont_drop_ack)1357 transfer_pio(u_char *phase, u_char *data, u_long *len, int dont_drop_ack)
1358 {
1359 u_int cnt = *len;
1360 uint8_t ph = *phase;
1361 uint8_t tmp, new_icom;
1362
1363 DBG_PIOPRINT("SCSI: transfer_pio start: phase: %d, len: %d\n", ph,cnt);
1364 PID("tpio1");
1365 SET_5380_REG(NCR5380_TCOM, ph);
1366 do {
1367 if (!wait_req_true()) {
1368 DBG_PIOPRINT ("SCSI: transfer_pio: missing REQ\n",
1369 0, 0);
1370 break;
1371 }
1372 if (((GET_5380_REG(NCR5380_IDSTAT) >> 2) & 7) != ph) {
1373 DBG_PIOPRINT("SCSI: transfer_pio: phase mismatch\n",
1374 0, 0);
1375 break;
1376 }
1377 if (PH_IN(ph)) {
1378 *data++ = GET_5380_REG(NCR5380_DATA);
1379 SET_5380_REG(NCR5380_ICOM, SC_A_ACK);
1380 if ((cnt == 1) && dont_drop_ack)
1381 new_icom = SC_A_ACK;
1382 else
1383 new_icom = 0;
1384 } else {
1385 SET_5380_REG(NCR5380_DATA, *data++);
1386
1387 /*
1388 * The SCSI-standard suggests that in the
1389 * 'MESSAGE OUT' phase, the initiator should
1390 * drop ATN on the last byte of the * message phase
1391 * after REQ has been asserted for the handshake
1392 * but before the initiator raises ACK.
1393 */
1394 if (!((ph == PH_MSGOUT) && (cnt > 1) )) {
1395 SET_5380_REG(NCR5380_ICOM, SC_ADTB);
1396 SET_5380_REG(NCR5380_ICOM, SC_ADTB | SC_A_ACK);
1397 new_icom = 0;
1398 } else {
1399 SET_5380_REG(NCR5380_ICOM, SC_ADTB | SC_A_ATN);
1400 SET_5380_REG(NCR5380_ICOM,
1401 SC_ADTB | SC_A_ATN | SC_A_ACK);
1402 new_icom = SC_A_ATN;
1403 }
1404 }
1405 if (!wait_req_false()) {
1406 DBG_PIOPRINT("SCSI: transfer_pio - REQ not dropping\n",
1407 0, 0);
1408 break;
1409 }
1410 SET_5380_REG(NCR5380_ICOM, new_icom);
1411
1412 } while (--cnt);
1413
1414 if ((tmp = GET_5380_REG(NCR5380_IDSTAT)) & SC_S_REQ)
1415 *phase = (tmp >> 2) & 7;
1416 else
1417 *phase = NR_PHASE;
1418 *len = cnt;
1419 DBG_PIOPRINT("SCSI: transfer_pio done: phase: %d, len: %d\n",
1420 *phase, cnt);
1421 PID("tpio2");
1422 if (cnt == 0 || (*phase == ph))
1423 return 0;
1424 return -1;
1425 }
1426
1427 #ifdef REAL_DMA
1428
1429 /*
1430 * Start a DMA-transfer on the device using the current pointers.
1431 * If 'poll' is true, the function busy-waits until DMA has completed.
1432 */
1433 static void
transfer_dma(SC_REQ * reqp,u_int phase,int poll)1434 transfer_dma(SC_REQ *reqp, u_int phase, int poll)
1435 {
1436 int dma_done;
1437 uint8_t mbase = 0;
1438 int sps;
1439
1440 again:
1441 PID("tdma1");
1442
1443 /*
1444 * We should be in phase, otherwise we are not allowed to
1445 * drive the bus.
1446 */
1447 SET_5380_REG(NCR5380_TCOM, phase);
1448
1449 /*
1450 * Defer interrupts until DMA is fully running.
1451 */
1452 sps = splbio();
1453
1454 /*
1455 * Clear pending interrupts and parity errors.
1456 */
1457 scsi_clr_ipend();
1458
1459 if (!poll) {
1460 /*
1461 * Enable SCSI interrupts and set IN_DMA flag, set 'mbase'
1462 * to the interrupts we want enabled.
1463 */
1464 scsi_ienable();
1465 reqp->dr_flag |= DRIVER_IN_DMA;
1466 mbase = SC_E_EOPI | SC_MON_BSY;
1467 } else
1468 scsi_idisable();
1469 mbase |= IMODE_BASE | SC_M_DMA;
1470 scsi_dma_setup(reqp, phase, mbase);
1471
1472 splx(sps);
1473
1474 if (poll) {
1475 /*
1476 * On polled-DMA transfers, we wait here until the
1477 * 'end-of-DMA' condition occurs.
1478 */
1479 poll_edma(reqp);
1480 if ((dma_done = dma_ready()) == 0)
1481 goto again;
1482 }
1483 PID("tdma2");
1484 }
1485
1486 /*
1487 * Check results of a DMA data-transfer.
1488 */
1489 static int
dma_ready(void)1490 dma_ready(void)
1491 {
1492 SC_REQ *reqp = connected;
1493 int dmstat, is_edma;
1494 long bytes_left, bytes_done;
1495
1496 is_edma = get_dma_result(reqp, &bytes_left);
1497 dmstat = GET_5380_REG(NCR5380_DMSTAT);
1498
1499 /*
1500 * Check if the call is sensible and not caused by any spurious
1501 * interrupt.
1502 */
1503 if (!is_edma &&
1504 (dmstat & (SC_END_DMA|SC_BSY_ERR)) == 0 &&
1505 (dmstat & SC_PHS_MTCH) != 0) {
1506 ncr_tprint(reqp, "dma_ready: spurious call "
1507 "(dm:%x,last_hit: %s)\n",
1508 #ifdef DBG_PID
1509 dmstat, last_hit[DBG_PID-1]);
1510 #else
1511 dmstat, "unknown");
1512 #endif
1513 return 0;
1514 }
1515
1516 /*
1517 * Clear all (pending) interrupts.
1518 */
1519 scsi_clr_ipend();
1520
1521 /*
1522 * Update various transfer-pointers/lengths
1523 */
1524 bytes_done = reqp->dm_cur->dm_count - bytes_left;
1525
1526 if ((reqp->dr_flag & DRIVER_BOUNCING) && (PH_IN(reqp->phase))) {
1527 /*
1528 * Copy the bytes read until now from the bounce buffer
1529 * to the 'real' destination. Flush the data-cache
1530 * before copying.
1531 */
1532 PCIA();
1533 memcpy(reqp->xdata_ptr, reqp->bouncerp, bytes_done);
1534 reqp->bouncerp += bytes_done;
1535 }
1536
1537 reqp->xdata_ptr = &reqp->xdata_ptr[bytes_done]; /* XXX */
1538 reqp->xdata_len -= bytes_done; /* XXX */
1539 if ((reqp->dm_cur->dm_count -= bytes_done) == 0)
1540 reqp->dm_cur++;
1541 else
1542 reqp->dm_cur->dm_addr += bytes_done;
1543
1544 if (PH_IN(reqp->phase) && (dmstat & SC_PAR_ERR)) {
1545 if ((ncr5380_no_parchk & (1 << reqp->targ_id)) == 0) {
1546 ncr_tprint(reqp, "parity error in data-phase\n");
1547 reqp->xs->error = XS_TIMEOUT;
1548 }
1549 }
1550
1551 /*
1552 * DMA mode should always be reset even when we will continue with the
1553 * next chain. It is also essential to clear the MON_BUSY because
1554 * when LOST_BUSY is unexpectedly set, we will not be able to drive
1555 * the bus....
1556 */
1557 SET_5380_REG(NCR5380_MODE, IMODE_BASE);
1558
1559
1560 if ((dmstat & SC_BSY_ERR) != 0 || (dmstat & SC_PHS_MTCH) == 0 ||
1561 (reqp->dm_cur > reqp->dm_last) || reqp->xs->error != 0) {
1562
1563 /*
1564 * Tell interrupt functions DMA mode has ended.
1565 */
1566 reqp->dr_flag &= ~DRIVER_IN_DMA;
1567
1568 /*
1569 * Clear mode and icom
1570 */
1571 SET_5380_REG(NCR5380_MODE, IMODE_BASE);
1572 SET_5380_REG(NCR5380_ICOM, 0);
1573
1574 if (dmstat & SC_BSY_ERR) {
1575 if (reqp->xs->error == 0)
1576 reqp->xs->error = XS_TIMEOUT;
1577 finish_req(reqp);
1578 PID("dma_ready1");
1579 return 1;
1580 }
1581
1582 if (reqp->xs->error != 0) {
1583 ncr_tprint(reqp, "dma-ready: code = %d\n",
1584 reqp->xs->error); /* LWP */
1585 reqp->msgout = MSG_ABORT;
1586 SET_5380_REG(NCR5380_ICOM, SC_A_ATN);
1587 }
1588 PID("dma_ready2");
1589 return 1;
1590 }
1591 return 0;
1592 }
1593 #endif /* REAL_DMA */
1594
1595 static int
check_autosense(SC_REQ * reqp,int linked)1596 check_autosense(SC_REQ *reqp, int linked)
1597 {
1598 int sps;
1599
1600 /*
1601 * If this is the driver's Link Check for this target, ignore
1602 * the results of the command. All we care about is whether we
1603 * got here from a LINK_CMD_COMPLETE or CMD_COMPLETE message.
1604 */
1605 PID("linkcheck");
1606 if (reqp->dr_flag & DRIVER_LINKCHK) {
1607 if (linked)
1608 ncr_will_link |= 1<<reqp->targ_id;
1609 else
1610 ncr_tprint(reqp, "Does not support linked commands\n");
1611 return 0;
1612 }
1613 /*
1614 * If we not executing an auto-sense and the status code
1615 * is request-sense, we automatically issue a request
1616 * sense command.
1617 */
1618 PID("cautos1");
1619 if ((reqp->dr_flag & DRIVER_AUTOSEN) == 0) {
1620 switch (reqp->status & SCSMASK) {
1621 case SCSCHKC:
1622 memcpy(&reqp->xcmd, sense_cmd, sizeof(sense_cmd));
1623 reqp->xcmd_len = sizeof(sense_cmd);
1624 reqp->xdata_ptr = (u_char *)&reqp->xs->sense.scsi_sense;
1625 reqp->xdata_len = sizeof(reqp->xs->sense.scsi_sense);
1626 reqp->dr_flag |= DRIVER_AUTOSEN;
1627 reqp->dr_flag &= ~DRIVER_DMAOK;
1628 if (!linked) {
1629 sps = splbio();
1630 reqp->next = issue_q;
1631 issue_q = reqp;
1632 splx(sps);
1633 } else
1634 reqp->xcmd.bytes[sizeof(sense_cmd)-2] |= 1;
1635
1636 #ifdef DBG_REQ
1637 memset(reqp->xdata_ptr, 0, reqp->xdata_len);
1638 if (dbg_target_mask & (1 << reqp->targ_id))
1639 show_request(reqp, "AUTO-SENSE");
1640 #endif
1641 PID("cautos2");
1642 return -1;
1643 case SCSBUSY:
1644 reqp->xs->error = XS_BUSY;
1645 return 0;
1646 }
1647 } else {
1648 /*
1649 * An auto-sense has finished
1650 */
1651 if ((reqp->status & SCSMASK) != SCSGOOD)
1652 reqp->xs->error = XS_DRIVER_STUFFUP; /* SC_E_AUTOSEN; */
1653 else
1654 reqp->xs->error = XS_SENSE;
1655 reqp->status = SCSCHKC;
1656 }
1657 PID("cautos3");
1658 return 0;
1659 }
1660
1661 static int
reach_msg_out(struct ncr_softc * sc,u_long len)1662 reach_msg_out(struct ncr_softc *sc, u_long len)
1663 {
1664 uint8_t phase;
1665 u_long n = len;
1666
1667 ncr_aprint(sc, "Trying to reach Message-out phase\n");
1668 if ((phase = GET_5380_REG(NCR5380_IDSTAT)) & SC_S_REQ)
1669 phase = (phase >> 2) & 7;
1670 else
1671 return -1;
1672 ncr_aprint(sc, "Trying to reach Message-out phase, now: %d\n", phase);
1673 if (phase == PH_MSGOUT)
1674 return 0;
1675
1676 SET_5380_REG(NCR5380_TCOM, phase);
1677
1678 do {
1679 if (!wait_req_true())
1680 break;
1681 if (((GET_5380_REG(NCR5380_IDSTAT) >> 2) & 7) != phase)
1682 break;
1683 if (PH_IN(phase)) {
1684 GET_5380_REG(NCR5380_DATA);
1685 SET_5380_REG(NCR5380_ICOM, SC_A_ACK | SC_A_ATN);
1686 } else {
1687 SET_5380_REG(NCR5380_DATA, 0);
1688 SET_5380_REG(NCR5380_ICOM, SC_ADTB|SC_A_ATN);
1689 SET_5380_REG(NCR5380_ICOM, SC_ADTB|SC_A_ACK|SC_A_ATN);
1690 }
1691 if (!wait_req_false())
1692 break;
1693 SET_5380_REG(NCR5380_ICOM, SC_A_ATN);
1694 } while (--n);
1695
1696 if ((phase = GET_5380_REG(NCR5380_IDSTAT)) & SC_S_REQ) {
1697 phase = (phase >> 2) & 7;
1698 if (phase == PH_MSGOUT) {
1699 ncr_aprint(sc, "Message-out phase reached after "
1700 "%ld bytes.\n", len - n);
1701 return 0;
1702 }
1703 ncr_aprint(sc, "Phase now: %d after %ld bytes.\n",
1704 phase, len - n);
1705
1706 }
1707 return -1;
1708 }
1709
1710 void
scsi_reset(void)1711 scsi_reset(void)
1712 {
1713 SC_REQ *tmp, *next;
1714 int sps;
1715
1716 PID("scsi_reset1");
1717 sps = splbio();
1718 SET_5380_REG(NCR5380_ICOM, SC_A_RST);
1719 delay(100);
1720 SET_5380_REG(NCR5380_ICOM, 0);
1721 scsi_clr_ipend();
1722
1723 /*
1724 * None of the jobs in the discon_q will ever be reconnected,
1725 * notify this to the higher level code.
1726 */
1727 for (tmp = discon_q; tmp ;) {
1728 next = tmp->next;
1729 tmp->next = NULL;
1730 tmp->xs->error = XS_TIMEOUT;
1731 busy &= ~(1 << tmp->targ_id);
1732 finish_req(tmp);
1733 tmp = next;
1734 }
1735 discon_q = NULL;
1736
1737 /*
1738 * The current job will never finish either.
1739 * The problem is that we can't finish the job because an instance
1740 * of main is running on it. Our best guess is that the job is currently
1741 * doing REAL-DMA. In that case 'dma_ready()' should correctly finish
1742 * the job because it detects BSY-loss.
1743 */
1744 if ((tmp = connected) != NULL) {
1745 if (tmp->dr_flag & DRIVER_IN_DMA) {
1746 tmp->xs->error = XS_DRIVER_STUFFUP;
1747 #ifdef REAL_DMA
1748 dma_ready();
1749 #endif
1750 }
1751 }
1752 splx(sps);
1753 PID("scsi_reset2");
1754
1755 /*
1756 * Give the attached devices some time to handle the reset. This
1757 * value is arbitrary but should be relatively long.
1758 */
1759 delay(100000);
1760 }
1761
1762 static void
scsi_reset_verbose(struct ncr_softc * sc,const char * why)1763 scsi_reset_verbose(struct ncr_softc *sc, const char *why)
1764 {
1765
1766 ncr_aprint(sc, "Resetting SCSI-bus (%s)\n", why);
1767
1768 scsi_reset();
1769 }
1770
1771 /*
1772 * Check validity of the IRQ set by the 5380. If the interrupt is valid,
1773 * the appropriate action is carried out (reselection or DMA ready) and
1774 * INTR_RESEL or INTR_DMA is returned. Otherwise a console notice is written
1775 * and INTR_SPURIOUS is returned.
1776 */
1777 static int
check_intr(struct ncr_softc * sc)1778 check_intr(struct ncr_softc *sc)
1779 {
1780 SC_REQ *reqp;
1781
1782 if ((GET_5380_REG(NCR5380_IDSTAT) & (SC_S_SEL|SC_S_IO)) ==
1783 (SC_S_SEL|SC_S_IO))
1784 return INTR_RESEL;
1785 else {
1786 if ((reqp = connected) && (reqp->dr_flag & DRIVER_IN_DMA)){
1787 reqp->dr_flag &= ~DRIVER_IN_DMA;
1788 return INTR_DMA;
1789 }
1790 }
1791 printf("-->");
1792 scsi_show();
1793 scsi_clr_ipend();
1794 ncr_aprint(sc, "Spurious interrupt.\n");
1795 return INTR_SPURIOUS;
1796 }
1797
1798 #ifdef REAL_DMA
1799 /*
1800 * Check if DMA can be used for this request. This function also builds
1801 * the DMA-chain.
1802 */
1803 static int
scsi_dmaok(SC_REQ * reqp)1804 scsi_dmaok(SC_REQ *reqp)
1805 {
1806 u_long phy_buf;
1807 u_long phy_len;
1808 uint8_t *req_addr;
1809 u_long req_len;
1810 struct dma_chain *dm;
1811
1812 /*
1813 * To be safe, do not use DMA for Falcon
1814 */
1815 if (machineid & ATARI_FALCON)
1816 return 0;
1817
1818 /*
1819 * Initialize locals and requests' DMA-chain.
1820 */
1821 req_len = reqp->xdata_len;
1822 req_addr = (uint8_t *)reqp->xdata_ptr;
1823 dm = reqp->dm_cur = reqp->dm_last = reqp->dm_chain;
1824 dm->dm_count = dm->dm_addr = 0;
1825 reqp->dr_flag &= ~DRIVER_BOUNCING;
1826
1827 /*
1828 * Do not accept zero length DMA.
1829 */
1830 if (req_len == 0)
1831 return 0;
1832
1833 /*
1834 * If DMA is emulated in software, we don't have to breakup the
1835 * request. Just build a chain with a single element and stash in
1836 * the KVA and not the KPA.
1837 */
1838 if (emulated_dma()) {
1839 dm->dm_addr = (u_long)req_addr;
1840 dm->dm_count = req_len;
1841 return 1;
1842 }
1843
1844 /*
1845 * LWP: I think that this restriction is not strictly necessary.
1846 */
1847 if ((req_len & 0x1) || ((u_int)req_addr & 0x3))
1848 return 0;
1849
1850 /*
1851 * Build the DMA-chain.
1852 */
1853 dm->dm_addr = phy_buf = kvtop(req_addr);
1854 while (req_len) {
1855 if (req_len <
1856 (phy_len = PAGE_SIZE - ((u_long)req_addr & PGOFSET)))
1857 phy_len = req_len;
1858
1859 req_addr += phy_len;
1860 req_len -= phy_len;
1861 dm->dm_count += phy_len;
1862
1863 if (req_len) {
1864 u_long tmp = kvtop(req_addr);
1865
1866 if ((phy_buf + phy_len) != tmp) {
1867 if (wrong_dma_range(reqp, dm)) {
1868 if (reqp->dr_flag & DRIVER_BOUNCING)
1869 goto bounceit;
1870 return 0;
1871 }
1872
1873 if (++dm >= &reqp->dm_chain[MAXDMAIO]) {
1874 ncr_tprint(reqp,
1875 "dmaok: DMA chain too long!\n");
1876 return 0;
1877 }
1878 dm->dm_count = 0;
1879 dm->dm_addr = tmp;
1880 }
1881 phy_buf = tmp;
1882 }
1883 }
1884 if (wrong_dma_range(reqp, dm)) {
1885 if (reqp->dr_flag & DRIVER_BOUNCING)
1886 goto bounceit;
1887 return 0;
1888 }
1889 reqp->dm_last = dm;
1890 return 1;
1891
1892 bounceit:
1893 if ((reqp->bounceb = alloc_bounceb(reqp->xdata_len)) == NULL) {
1894 /*
1895 * If we can't get a bounce buffer, forget DMA
1896 */
1897 reqp->dr_flag &= ~DRIVER_BOUNCING;
1898 return 0;
1899 }
1900 /*
1901 * Initialize a single DMA-range containing the bounced request
1902 */
1903 dm = reqp->dm_cur = reqp->dm_last = reqp->dm_chain;
1904 dm->dm_addr = kvtop(reqp->bounceb);
1905 dm->dm_count = reqp->xdata_len;
1906 reqp->bouncerp = reqp->bounceb;
1907
1908 return 1;
1909 }
1910 #endif /* REAL_DMA */
1911
1912 static void
run_main(struct ncr_softc * sc)1913 run_main(struct ncr_softc *sc)
1914 {
1915 int sps = splbio();
1916
1917 if (!main_running) {
1918 /*
1919 * If shared resources are required, claim them
1920 * before entering 'scsi_main'. If we can't get them
1921 * now, assume 'run_main' will be called when the resource
1922 * becomes available.
1923 */
1924 if (!claimed_dma()) {
1925 splx(sps);
1926 return;
1927 }
1928 main_running = 1;
1929 splx(sps);
1930 scsi_main(sc);
1931 } else
1932 splx(sps);
1933 }
1934
1935 /*
1936 * Prefix message with full target info.
1937 */
1938 static void
ncr_tprint(SC_REQ * reqp,const char * fmt,...)1939 ncr_tprint(SC_REQ *reqp, const char *fmt, ...)
1940 {
1941 va_list ap;
1942
1943 va_start(ap, fmt);
1944 scsipi_printaddr(reqp->xs->xs_periph);
1945 vprintf(fmt, ap);
1946 va_end(ap);
1947 }
1948
1949 /*
1950 * Prefix message with adapter info.
1951 */
1952 static void
ncr_aprint(struct ncr_softc * sc,const char * fmt,...)1953 ncr_aprint(struct ncr_softc *sc, const char *fmt, ...)
1954 {
1955 va_list ap;
1956 char buf[256];
1957
1958 va_start(ap, fmt);
1959 vsnprintf(buf, sizeof(buf), fmt, ap);
1960 va_end(ap);
1961
1962 printf("%s: %s", device_xname(sc->sc_dev), buf);
1963 }
1964 /****************************************************************************
1965 * Start Debugging Functions *
1966 ****************************************************************************/
1967 static const char *phase_names[] = {
1968 "DATA_OUT", "DATA_IN", "COMMAND", "STATUS", "NONE", "NONE", "MSG_OUT",
1969 "MSG_IN"
1970 };
1971
1972 static void
show_phase(SC_REQ * reqp,int phase)1973 show_phase(SC_REQ *reqp, int phase)
1974 {
1975
1976 printf("INFTRANS: %d Phase = %s\n", reqp->targ_id, phase_names[phase]);
1977 }
1978
1979 static void
show_data_sense(struct scsipi_xfer * xs)1980 show_data_sense(struct scsipi_xfer *xs)
1981 {
1982 uint8_t *p1, *p2;
1983 int i;
1984
1985 p1 = (uint8_t *)xs->cmd;
1986 p2 = (uint8_t *)&xs->sense.scsi_sense;
1987 if (*p2 == 0)
1988 return; /* No(n)sense */
1989 printf("cmd[%d]: ", xs->cmdlen);
1990 for (i = 0; i < xs->cmdlen; i++)
1991 printf("%x ", p1[i]);
1992 printf("\nsense: ");
1993 for (i = 0; i < sizeof(xs->sense.scsi_sense); i++)
1994 printf("%x ", p2[i]);
1995 printf("\n");
1996 }
1997
1998 static void
show_request(SC_REQ * reqp,const char * qtxt)1999 show_request(SC_REQ *reqp, const char *qtxt)
2000 {
2001
2002 printf("REQ-%s: %d %p[%ld] "
2003 "cmd[0]=%x S=%x M=%x R=%x resid=%d dr_flag=%x %s\n",
2004 qtxt, reqp->targ_id, reqp->xdata_ptr, reqp->xdata_len,
2005 reqp->xcmd.opcode, reqp->status, reqp->message,
2006 reqp->xs->error, reqp->xs->resid, reqp->dr_flag,
2007 reqp->link ? "L":"");
2008 if (reqp->status == SCSCHKC)
2009 show_data_sense(reqp->xs);
2010 }
2011
2012 static const char *sig_names[] = {
2013 "PAR", "SEL", "I/O", "C/D", "MSG", "REQ", "BSY", "RST",
2014 "ACK", "ATN", "LBSY", "PMATCH", "IRQ", "EPAR", "DREQ", "EDMA"
2015 };
2016
2017 static void
show_signals(uint8_t dmstat,uint8_t idstat)2018 show_signals(uint8_t dmstat, uint8_t idstat)
2019 {
2020 u_short tmp, mask;
2021 int j, need_pipe;
2022
2023 tmp = idstat | ((dmstat & 3) << 8);
2024 printf("Bus signals (%02x/%02x): ", idstat, dmstat & 3);
2025 for (mask = 1, j = need_pipe = 0; mask <= tmp; mask <<= 1, j++) {
2026 if (tmp & mask)
2027 printf("%s%s", need_pipe++ ? "|" : "", sig_names[j]);
2028 }
2029 printf("\nDma status (%02x): ", dmstat);
2030 for (mask = 4, j = 10, need_pipe = 0; mask <= dmstat; mask <<= 1, j++) {
2031 if (dmstat & mask)
2032 printf("%s%s", need_pipe++ ? "|" : "", sig_names[j]);
2033 }
2034 printf("\n");
2035 }
2036
2037 void
scsi_show(void)2038 scsi_show(void)
2039 {
2040 SC_REQ *tmp;
2041 int sps = splhigh();
2042 uint8_t idstat, dmstat;
2043 int i;
2044
2045 printf("scsi_show: scsi_main is%s running\n",
2046 main_running ? "" : " not");
2047 for (tmp = issue_q; tmp; tmp = tmp->next)
2048 show_request(tmp, "ISSUED");
2049 for (tmp = discon_q; tmp; tmp = tmp->next)
2050 show_request(tmp, "DISCONNECTED");
2051 if (connected)
2052 show_request(connected, "CONNECTED");
2053 if (can_access_5380()) {
2054 idstat = GET_5380_REG(NCR5380_IDSTAT);
2055 dmstat = GET_5380_REG(NCR5380_DMSTAT);
2056 show_signals(dmstat, idstat);
2057 }
2058
2059 if (connected)
2060 printf("phase = %d, ", connected->phase);
2061 printf("busy:%x, spl:%04x\n", busy, sps);
2062 #ifdef DBG_PID
2063 for (i=0; i<DBG_PID; i++)
2064 printf("\t%d\t%s\n", i, last_hit[i]);
2065 #endif
2066
2067 splx(sps);
2068 }
2069