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