Annotation of sys/dev/ic/ncr5380sbc.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ncr5380sbc.c,v 1.19 2006/12/10 16:15:37 miod Exp $ */
! 2: /* $NetBSD: ncr5380sbc.c,v 1.13 1996/10/13 01:37:25 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 David Jones, Gordon W. Ross
! 6: * Copyright (c) 1994 Jarle Greipsland
! 7: * All rights reserved.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above copyright
! 15: * notice, this list of conditions and the following disclaimer in the
! 16: * documentation and/or other materials provided with the distribution.
! 17: * 3. The name of the authors may not be used to endorse or promote products
! 18: * derived from this software without specific prior written permission.
! 19: * 4. All advertising materials mentioning features or use of this software
! 20: * must display the following acknowledgement:
! 21: * This product includes software developed by
! 22: * David Jones and Gordon Ross
! 23: *
! 24: * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
! 25: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 26: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 27: * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
! 28: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 29: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 30: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 31: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 32: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 33: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 34: */
! 35:
! 36: /*
! 37: * This is a machine-independent driver for the NCR5380
! 38: * SCSI Bus Controller (SBC), also known as the Am5380.
! 39: *
! 40: * This code should work with any memory-mapped 5380,
! 41: * and can be shared by multiple adapters that address
! 42: * the 5380 with different register offset spacings.
! 43: * (This can happen on the atari, for example.)
! 44: * For porting/design info. see: ncr5380.doc
! 45: *
! 46: * Credits, history:
! 47: *
! 48: * David Jones is the author of most of the code that now
! 49: * appears in this file, and was the architect of the
! 50: * current overall structure (MI/MD code separation, etc.)
! 51: *
! 52: * Gordon Ross integrated the message phase code, added lots of
! 53: * comments about what happens when and why (re. SCSI spec.),
! 54: * debugged some reentrance problems, and added several new
! 55: * "hooks" needed for the Sun3 "si" adapters.
! 56: *
! 57: * The message in/out code was taken nearly verbatim from
! 58: * the aic6360 driver by Jarle Greipsland.
! 59: *
! 60: * Several other NCR5380 drivers were used for reference
! 61: * while developing this driver, including work by:
! 62: * The Alice Group (mac68k port) namely:
! 63: * Allen K. Briggs, Chris P. Caputo, Michael L. Finch,
! 64: * Bradley A. Grantham, and Lawrence A. Kesteloot
! 65: * Michael L. Hitch (amiga drivers: sci.c)
! 66: * Leo Weppelman (atari driver: ncr5380.c)
! 67: * There are others too. Thanks, everyone.
! 68: */
! 69:
! 70: #include <sys/types.h>
! 71: #include <sys/param.h>
! 72: #include <sys/systm.h>
! 73: #include <sys/kernel.h>
! 74: #include <sys/errno.h>
! 75: #include <sys/device.h>
! 76: #include <sys/buf.h>
! 77: #include <sys/proc.h>
! 78: #include <sys/user.h>
! 79:
! 80: #include <scsi/scsi_all.h>
! 81: #include <scsi/scsi_debug.h>
! 82: #include <scsi/scsi_message.h>
! 83: #include <scsi/scsiconf.h>
! 84:
! 85: #ifdef DDB
! 86: #include <ddb/db_output.h>
! 87: #endif
! 88:
! 89: #include <dev/ic/ncr5380reg.h>
! 90: #include <dev/ic/ncr5380var.h>
! 91:
! 92: static void ncr5380_sched(struct ncr5380_softc *);
! 93: static void ncr5380_done(struct ncr5380_softc *);
! 94:
! 95: static int ncr5380_select(struct ncr5380_softc *, struct sci_req *);
! 96: static void ncr5380_reselect(struct ncr5380_softc *);
! 97:
! 98: static int ncr5380_msg_in(struct ncr5380_softc *);
! 99: static int ncr5380_msg_out(struct ncr5380_softc *);
! 100: static int ncr5380_data_xfer(struct ncr5380_softc *, int);
! 101: static int ncr5380_command(struct ncr5380_softc *);
! 102: static int ncr5380_status(struct ncr5380_softc *);
! 103: static void ncr5380_machine(struct ncr5380_softc *);
! 104:
! 105: void ncr5380_abort(struct ncr5380_softc *);
! 106: void ncr5380_cmd_timeout(void *);
! 107: /*
! 108: * Action flags returned by the info_transfer functions:
! 109: * (These determine what happens next.)
! 110: */
! 111: #define ACT_CONTINUE 0x00 /* No flags: expect another phase */
! 112: #define ACT_DISCONNECT 0x01 /* Target is disconnecting */
! 113: #define ACT_CMD_DONE 0x02 /* Need to call scsi_done() */
! 114: #define ACT_RESET_BUS 0x04 /* Need bus reset (cmd timeout) */
! 115: #define ACT_WAIT_DMA 0x10 /* Wait for DMA to complete */
! 116:
! 117: /*****************************************************************
! 118: * Debugging stuff
! 119: *****************************************************************/
! 120:
! 121: #ifndef DDB
! 122: /* This is used only in recoverable places. */
! 123: #define Debugger() printf("Debug: ncr5380.c:%d\n", __LINE__)
! 124: #endif
! 125:
! 126: #ifdef NCR5380_DEBUG
! 127:
! 128: #define NCR_DBG_BREAK 1
! 129: #define NCR_DBG_CMDS 2
! 130: int ncr5380_debug = NCR_DBG_BREAK|NCR_DBG_CMDS;
! 131: struct ncr5380_softc *ncr5380_debug_sc;
! 132:
! 133: #define NCR_BREAK() \
! 134: do { if (ncr5380_debug & NCR_DBG_BREAK) Debugger(); } while (0)
! 135:
! 136: static void ncr5380_show_scsi_cmd(struct scsi_xfer *);
! 137: static void ncr5380_show_sense(struct scsi_xfer *);
! 138:
! 139: #ifdef DDB
! 140: void ncr5380_trace(char *, long);
! 141: void ncr5380_clear_trace(void);
! 142: void ncr5380_show_trace(void);
! 143: void ncr5380_show_req(struct sci_req *);
! 144: void ncr5380_show_req(struct sci_req *);
! 145: void ncr5380_show_state(void);
! 146: #endif /* DDB */
! 147: #else /* NCR5380_DEBUG */
! 148:
! 149: #define NCR_BREAK() /* nada */
! 150: #define ncr5380_show_scsi_cmd(xs) /* nada */
! 151: #define ncr5380_show_sense(xs) /* nada */
! 152:
! 153: #endif /* NCR5380_DEBUG */
! 154:
! 155: static char *
! 156: phase_names[8] = {
! 157: "DATA_OUT",
! 158: "DATA_IN",
! 159: "COMMAND",
! 160: "STATUS",
! 161: "UNSPEC1",
! 162: "UNSPEC2",
! 163: "MSG_OUT",
! 164: "MSG_IN",
! 165: };
! 166:
! 167: /*****************************************************************
! 168: * Actual chip control
! 169: *****************************************************************/
! 170:
! 171: /*
! 172: * XXX: These timeouts might need to be tuned...
! 173: */
! 174:
! 175: /* This one is used when waiting for a phase change. (X100uS.) */
! 176: int ncr5380_wait_phase_timo = 1000 * 10 * 300; /* 5 min. */
! 177:
! 178: /* These are used in the following inline functions. */
! 179: int ncr5380_wait_req_timo = 1000 * 50; /* X2 = 100 mS. */
! 180: int ncr5380_wait_nrq_timo = 1000 * 25; /* X2 = 50 mS. */
! 181:
! 182: static __inline int ncr5380_wait_req(struct ncr5380_softc *);
! 183: static __inline int ncr5380_wait_not_req(struct ncr5380_softc *);
! 184: static __inline void ncr_sched_msgout(struct ncr5380_softc *, int);
! 185:
! 186: /* Return zero on success. */
! 187: static __inline int ncr5380_wait_req(sc)
! 188: struct ncr5380_softc *sc;
! 189: {
! 190: register int timo = ncr5380_wait_req_timo;
! 191: for (;;) {
! 192: if (*sc->sci_bus_csr & SCI_BUS_REQ) {
! 193: timo = 0; /* return 0 */
! 194: break;
! 195: }
! 196: if (--timo < 0)
! 197: break; /* return -1 */
! 198: delay(2);
! 199: }
! 200: return (timo);
! 201: }
! 202:
! 203: /* Return zero on success. */
! 204: static __inline int ncr5380_wait_not_req(sc)
! 205: struct ncr5380_softc *sc;
! 206: {
! 207: register int timo = ncr5380_wait_nrq_timo;
! 208: for (;;) {
! 209: if ((*sc->sci_bus_csr & SCI_BUS_REQ) == 0) {
! 210: timo = 0; /* return 0 */
! 211: break;
! 212: }
! 213: if (--timo < 0)
! 214: break; /* return -1 */
! 215: delay(2);
! 216: }
! 217: return (timo);
! 218: }
! 219:
! 220: /* Ask the target for a MSG_OUT phase. */
! 221: static __inline void
! 222: ncr_sched_msgout(sc, msg_code)
! 223: struct ncr5380_softc *sc;
! 224: int msg_code;
! 225: {
! 226: /* First time, raise ATN line. */
! 227: if (sc->sc_msgpriq == 0) {
! 228: register u_char icmd;
! 229: icmd = *sc->sci_icmd & SCI_ICMD_RMASK;
! 230: *sc->sci_icmd = icmd | SCI_ICMD_ATN;
! 231: delay(2);
! 232: }
! 233: sc->sc_msgpriq |= msg_code;
! 234: }
! 235:
! 236:
! 237: int
! 238: ncr5380_pio_out(sc, phase, count, data)
! 239: struct ncr5380_softc *sc;
! 240: int phase, count;
! 241: unsigned char *data;
! 242: {
! 243: register u_char icmd;
! 244: register int resid;
! 245: register int error;
! 246:
! 247: icmd = *(sc->sci_icmd) & SCI_ICMD_RMASK;
! 248:
! 249: icmd |= SCI_ICMD_DATA;
! 250: *sc->sci_icmd = icmd;
! 251:
! 252: resid = count;
! 253: while (resid > 0) {
! 254: if (!SCI_BUSY(sc)) {
! 255: NCR_TRACE("pio_out: lost BSY, resid=%d\n", resid);
! 256: break;
! 257: }
! 258: if (ncr5380_wait_req(sc)) {
! 259: NCR_TRACE("pio_out: no REQ, resid=%d\n", resid);
! 260: break;
! 261: }
! 262: if (SCI_BUS_PHASE(*sc->sci_bus_csr) != phase)
! 263: break;
! 264:
! 265: /* Put the data on the bus. */
! 266: if (data)
! 267: *sc->sci_odata = *data++;
! 268: else
! 269: *sc->sci_odata = 0;
! 270:
! 271: /* Tell the target it's there. */
! 272: icmd |= SCI_ICMD_ACK;
! 273: *sc->sci_icmd = icmd;
! 274:
! 275: /* Wait for target to get it. */
! 276: error = ncr5380_wait_not_req(sc);
! 277:
! 278: /* OK, it's got it (or we gave up waiting). */
! 279: icmd &= ~SCI_ICMD_ACK;
! 280: *sc->sci_icmd = icmd;
! 281:
! 282: if (error) {
! 283: NCR_TRACE("pio_out: stuck REQ, resid=%d\n", resid);
! 284: break;
! 285: }
! 286:
! 287: --resid;
! 288: }
! 289:
! 290: /* Stop driving the data bus. */
! 291: icmd &= ~SCI_ICMD_DATA;
! 292: *sc->sci_icmd = icmd;
! 293:
! 294: return (count - resid);
! 295: }
! 296:
! 297:
! 298: int
! 299: ncr5380_pio_in(sc, phase, count, data)
! 300: struct ncr5380_softc *sc;
! 301: int phase, count;
! 302: unsigned char *data;
! 303: {
! 304: register u_char icmd;
! 305: register int resid;
! 306: register int error;
! 307:
! 308: icmd = *(sc->sci_icmd) & SCI_ICMD_RMASK;
! 309:
! 310: resid = count;
! 311: while (resid > 0) {
! 312: if (!SCI_BUSY(sc)) {
! 313: NCR_TRACE("pio_in: lost BSY, resid=%d\n", resid);
! 314: break;
! 315: }
! 316: if (ncr5380_wait_req(sc)) {
! 317: NCR_TRACE("pio_in: no REQ, resid=%d\n", resid);
! 318: break;
! 319: }
! 320: /* A phase change is not valid until AFTER REQ rises! */
! 321: if (SCI_BUS_PHASE(*sc->sci_bus_csr) != phase)
! 322: break;
! 323:
! 324: /* Read the data bus. */
! 325: if (data)
! 326: *data++ = *sc->sci_data;
! 327: else
! 328: (void) *sc->sci_data;
! 329:
! 330: /* Tell target we got it. */
! 331: icmd |= SCI_ICMD_ACK;
! 332: *sc->sci_icmd = icmd;
! 333:
! 334: /* Wait for target to drop REQ... */
! 335: error = ncr5380_wait_not_req(sc);
! 336:
! 337: /* OK, we can drop ACK. */
! 338: icmd &= ~SCI_ICMD_ACK;
! 339: *sc->sci_icmd = icmd;
! 340:
! 341: if (error) {
! 342: NCR_TRACE("pio_in: stuck REQ, resid=%d\n", resid);
! 343: break;
! 344: }
! 345:
! 346: --resid;
! 347: }
! 348:
! 349: return (count - resid);
! 350: }
! 351:
! 352:
! 353: void
! 354: ncr5380_init(sc)
! 355: struct ncr5380_softc *sc;
! 356: {
! 357: int i, j;
! 358: struct sci_req *sr;
! 359:
! 360: #ifdef NCR5380_DEBUG
! 361: ncr5380_debug_sc = sc;
! 362: #endif
! 363:
! 364: for (i = 0; i < SCI_OPENINGS; i++) {
! 365: sr = &sc->sc_ring[i];
! 366: sr->sr_xs = NULL;
! 367: timeout_set(&sr->sr_timeout, ncr5380_cmd_timeout, sr);
! 368: }
! 369: for (i = 0; i < 8; i++)
! 370: for (j = 0; j < 8; j++)
! 371: sc->sc_matrix[i][j] = NULL;
! 372:
! 373: sc->sc_link.openings = 2; /* XXX - Not SCI_OPENINGS */
! 374: sc->sc_prevphase = PHASE_INVALID;
! 375: sc->sc_state = NCR_IDLE;
! 376:
! 377: *sc->sci_tcmd = PHASE_INVALID;
! 378: *sc->sci_icmd = 0;
! 379: *sc->sci_mode = 0;
! 380: *sc->sci_sel_enb = 0;
! 381: SCI_CLR_INTR(sc);
! 382:
! 383: /* XXX: Enable reselect interrupts... */
! 384: *sc->sci_sel_enb = 0x80;
! 385:
! 386: /* Another hack (Er.. hook!) for the sun3 si: */
! 387: if (sc->sc_intr_on) {
! 388: NCR_TRACE("init: intr ON\n", 0);
! 389: sc->sc_intr_on(sc);
! 390: }
! 391: }
! 392:
! 393:
! 394: void
! 395: ncr5380_reset_scsibus(sc)
! 396: struct ncr5380_softc *sc;
! 397: {
! 398:
! 399: NCR_TRACE("reset_scsibus, cur=0x%x\n",
! 400: (long) sc->sc_current);
! 401:
! 402: *sc->sci_icmd = SCI_ICMD_RST;
! 403: delay(500);
! 404: *sc->sci_icmd = 0;
! 405:
! 406: *sc->sci_mode = 0;
! 407: *sc->sci_tcmd = PHASE_INVALID;
! 408:
! 409: SCI_CLR_INTR(sc);
! 410: /* XXX - Need long delay here! */
! 411: delay(100000);
! 412:
! 413: /* XXX - Need to cancel disconnected requests. */
! 414: }
! 415:
! 416:
! 417: /*
! 418: * Interrupt handler for the SCSI Bus Controller (SBC)
! 419: * This may also called for a DMA timeout (at splbio).
! 420: */
! 421: int
! 422: ncr5380_intr(sc)
! 423: struct ncr5380_softc *sc;
! 424: {
! 425: int claimed = 0;
! 426:
! 427: /*
! 428: * Do not touch SBC regs here unless sc_current == NULL
! 429: * or it will complain about "register conflict" errors.
! 430: * Instead, just let ncr5380_machine() deal with it.
! 431: */
! 432: NCR_TRACE("intr: top, state=%d\n", sc->sc_state);
! 433:
! 434: if (sc->sc_state == NCR_IDLE) {
! 435: /*
! 436: * Might be reselect. ncr5380_reselect() will check,
! 437: * and set up the connection if so. This will verify
! 438: * that sc_current == NULL at the beginning...
! 439: */
! 440:
! 441: /* Another hack (Er.. hook!) for the sun3 si: */
! 442: if (sc->sc_intr_off) {
! 443: NCR_TRACE("intr: for reselect, intr off\n", 0);
! 444: sc->sc_intr_off(sc);
! 445: }
! 446:
! 447: ncr5380_reselect(sc);
! 448: }
! 449:
! 450: /*
! 451: * The remaining documented interrupt causes are phase mismatch and
! 452: * disconnect. In addition, the sunsi controller may produce a state
! 453: * where SCI_CSR_DONE is false, yet DMA is complete.
! 454: *
! 455: * The procedure in all these cases is to let ncr5380_machine()
! 456: * figure out what to do next.
! 457: */
! 458: if (sc->sc_state & NCR_WORKING) {
! 459: NCR_TRACE("intr: call machine, cur=0x%x\n",
! 460: (long) sc->sc_current);
! 461: /* This will usually free-up the nexus. */
! 462: ncr5380_machine(sc);
! 463: NCR_TRACE("intr: machine done, cur=0x%x\n",
! 464: (long) sc->sc_current);
! 465: claimed = 1;
! 466: }
! 467:
! 468: /* Maybe we can run some commands now... */
! 469: if (sc->sc_state == NCR_IDLE) {
! 470: NCR_TRACE("intr: call sched, cur=0x%x\n",
! 471: (long) sc->sc_current);
! 472: ncr5380_sched(sc);
! 473: NCR_TRACE("intr: sched done, cur=0x%x\n",
! 474: (long) sc->sc_current);
! 475: }
! 476:
! 477: return claimed;
! 478: }
! 479:
! 480:
! 481: /*
! 482: * Abort the current command (i.e. due to timeout)
! 483: */
! 484: void
! 485: ncr5380_abort(sc)
! 486: struct ncr5380_softc *sc;
! 487: {
! 488:
! 489: /*
! 490: * Finish it now. If DMA is in progress, we
! 491: * can not call ncr_sched_msgout() because
! 492: * that hits the SBC (avoid DMA conflict).
! 493: */
! 494:
! 495: /* Another hack (Er.. hook!) for the sun3 si: */
! 496: if (sc->sc_intr_off) {
! 497: NCR_TRACE("abort: intr off\n", 0);
! 498: sc->sc_intr_off(sc);
! 499: }
! 500:
! 501: sc->sc_state |= NCR_ABORTING;
! 502: if ((sc->sc_state & NCR_DOINGDMA) == 0) {
! 503: ncr_sched_msgout(sc, SEND_ABORT);
! 504: }
! 505: NCR_TRACE("abort: call machine, cur=0x%x\n",
! 506: (long) sc->sc_current);
! 507: ncr5380_machine(sc);
! 508: NCR_TRACE("abort: machine done, cur=0x%x\n",
! 509: (long) sc->sc_current);
! 510:
! 511: /* Another hack (Er.. hook!) for the sun3 si: */
! 512: if (sc->sc_intr_on) {
! 513: NCR_TRACE("abort: intr ON\n", 0);
! 514: sc->sc_intr_on(sc);
! 515: }
! 516: }
! 517:
! 518: /*
! 519: * Timeout handler, scheduled for each SCSI command.
! 520: */
! 521: void
! 522: ncr5380_cmd_timeout(arg)
! 523: void *arg;
! 524: {
! 525: struct sci_req *sr = arg;
! 526: struct scsi_xfer *xs;
! 527: struct scsi_link *sc_link;
! 528: struct ncr5380_softc *sc;
! 529: int s;
! 530:
! 531: s = splbio();
! 532:
! 533: /* Get all our variables... */
! 534: xs = sr->sr_xs;
! 535: if (xs == NULL) {
! 536: printf("ncr5380_cmd_timeout: no scsi_xfer\n");
! 537: goto out;
! 538: }
! 539: sc_link = xs->sc_link;
! 540: sc = sc_link->adapter_softc;
! 541:
! 542: printf("%s: cmd timeout, targ=%d, lun=%d\n",
! 543: sc->sc_dev.dv_xname,
! 544: sr->sr_target, sr->sr_lun);
! 545:
! 546: /*
! 547: * Mark the overdue job as failed, and arrange for
! 548: * ncr5380_machine to terminate it. If the victim
! 549: * is the current job, call ncr5380_machine() now.
! 550: * Otherwise arrange for ncr5380_sched() to do it.
! 551: */
! 552: sr->sr_flags |= SR_OVERDUE;
! 553: if (sc->sc_current == sr) {
! 554: NCR_TRACE("cmd_tmo: call abort, sr=0x%x\n", (long) sr);
! 555: ncr5380_abort(sc);
! 556: } else {
! 557: /*
! 558: * The driver may be idle, or busy with another job.
! 559: * Arrange for ncr5380_sched() to do the deed.
! 560: */
! 561: NCR_TRACE("cmd_tmo: clear matrix, t/l=0x%02x\n",
! 562: (sr->sr_target << 4) | sr->sr_lun);
! 563: sc->sc_matrix[sr->sr_target][sr->sr_lun] = NULL;
! 564: }
! 565:
! 566: /*
! 567: * We may have aborted the current job, or may have
! 568: * already been idle. In either case, we should now
! 569: * be idle, so try to start another job.
! 570: */
! 571: if (sc->sc_state == NCR_IDLE) {
! 572: NCR_TRACE("cmd_tmo: call sched, cur=0x%x\n",
! 573: (long) sc->sc_current);
! 574: ncr5380_sched(sc);
! 575: NCR_TRACE("cmd_tmo: sched done, cur=0x%x\n",
! 576: (long) sc->sc_current);
! 577: }
! 578:
! 579: out:
! 580: splx(s);
! 581: }
! 582:
! 583:
! 584: /*****************************************************************
! 585: * Interface to higher level
! 586: *****************************************************************/
! 587:
! 588:
! 589: /*
! 590: * Enter a new SCSI command into the "issue" queue, and
! 591: * if there is work to do, start it going.
! 592: *
! 593: * WARNING: This can be called recursively!
! 594: * (see comment in ncr5380_done)
! 595: */
! 596: int
! 597: ncr5380_scsi_cmd(xs)
! 598: struct scsi_xfer *xs;
! 599: {
! 600: struct ncr5380_softc *sc;
! 601: struct sci_req *sr;
! 602: int s, rv, i, flags;
! 603:
! 604: sc = xs->sc_link->adapter_softc;
! 605: flags = xs->flags;
! 606:
! 607: if (sc->sc_flags & NCR5380_FORCE_POLLING)
! 608: flags |= SCSI_POLL;
! 609:
! 610: if (flags & SCSI_DATA_UIO)
! 611: panic("ncr5380: scsi data uio requested");
! 612:
! 613: s = splbio();
! 614:
! 615: if (flags & SCSI_POLL) {
! 616: /* Terminate any current command. */
! 617: sr = sc->sc_current;
! 618: if (sr) {
! 619: printf("%s: polled request aborting %d/%d\n",
! 620: sc->sc_dev.dv_xname,
! 621: sr->sr_target, sr->sr_lun);
! 622: ncr5380_abort(sc);
! 623: }
! 624: if (sc->sc_state != NCR_IDLE) {
! 625: panic("ncr5380_scsi_cmd: polled request, abort failed");
! 626: }
! 627: }
! 628:
! 629: /*
! 630: * Find lowest empty slot in ring buffer.
! 631: * XXX: What about "fairness" and cmd order?
! 632: */
! 633: for (i = 0; i < SCI_OPENINGS; i++)
! 634: if (sc->sc_ring[i].sr_xs == NULL)
! 635: goto new;
! 636:
! 637: rv = TRY_AGAIN_LATER;
! 638: NCR_TRACE("scsi_cmd: no openings, rv=%d\n", rv);
! 639: goto out;
! 640:
! 641: new:
! 642: /* Create queue entry */
! 643: sr = &sc->sc_ring[i];
! 644: sr->sr_xs = xs;
! 645: sr->sr_target = xs->sc_link->target;
! 646: sr->sr_lun = xs->sc_link->lun;
! 647: sr->sr_dma_hand = NULL;
! 648: sr->sr_dataptr = xs->data;
! 649: sr->sr_datalen = xs->datalen;
! 650: sr->sr_flags = (flags & SCSI_POLL) ? SR_IMMED : 0;
! 651: sr->sr_status = -1; /* no value */
! 652: sc->sc_ncmds++;
! 653: rv = SUCCESSFULLY_QUEUED;
! 654:
! 655: NCR_TRACE("scsi_cmd: new sr=0x%x\n", (long)sr);
! 656:
! 657: if (flags & SCSI_POLL) {
! 658: /* Force this new command to be next. */
! 659: sc->sc_rr = i;
! 660: }
! 661:
! 662: /*
! 663: * If we were idle, run some commands...
! 664: */
! 665: if (sc->sc_state == NCR_IDLE) {
! 666: NCR_TRACE("scsi_cmd: call sched, cur=0x%x\n",
! 667: (long) sc->sc_current);
! 668: ncr5380_sched(sc);
! 669: NCR_TRACE("scsi_cmd: sched done, cur=0x%x\n",
! 670: (long) sc->sc_current);
! 671: }
! 672:
! 673: if (flags & SCSI_POLL) {
! 674: #ifdef DIAGNOSTIC
! 675: /* Make sure ncr5380_sched() finished it. */
! 676: if (sc->sc_state != NCR_IDLE)
! 677: panic("ncr5380_scsi_cmd: poll didn't finish");
! 678: #endif
! 679: rv = COMPLETE;
! 680: }
! 681:
! 682: out:
! 683: splx(s);
! 684: return (rv);
! 685: }
! 686:
! 687:
! 688: /*
! 689: * POST PROCESSING OF SCSI_CMD (usually current)
! 690: * Called by ncr5380_sched(), ncr5380_machine()
! 691: */
! 692: static void
! 693: ncr5380_done(sc)
! 694: struct ncr5380_softc *sc;
! 695: {
! 696: struct sci_req *sr;
! 697: struct scsi_xfer *xs;
! 698:
! 699: #ifdef DIAGNOSTIC
! 700: if (sc->sc_state == NCR_IDLE)
! 701: panic("ncr5380_done: state=idle");
! 702: if (sc->sc_current == NULL)
! 703: panic("ncr5380_done: current=0");
! 704: #endif
! 705:
! 706: sr = sc->sc_current;
! 707: xs = sr->sr_xs;
! 708:
! 709: NCR_TRACE("done: top, cur=0x%x\n", (long) sc->sc_current);
! 710:
! 711: /*
! 712: * Clean up DMA resources for this command.
! 713: */
! 714: if (sr->sr_dma_hand) {
! 715: NCR_TRACE("done: dma_free, dh=0x%x\n",
! 716: (long) sr->sr_dma_hand);
! 717: (*sc->sc_dma_free)(sc);
! 718: }
! 719: #ifdef DIAGNOSTIC
! 720: if (sr->sr_dma_hand)
! 721: panic("ncr5380_done: dma free did not");
! 722: #endif
! 723:
! 724: if (sc->sc_state & NCR_ABORTING) {
! 725: NCR_TRACE("done: aborting, error=%d\n", xs->error);
! 726: if (xs->error == XS_NOERROR)
! 727: xs->error = XS_TIMEOUT;
! 728: }
! 729:
! 730: NCR_TRACE("done: check error=%d\n", (long) xs->error);
! 731:
! 732: /* If error is already set, ignore sr_status value. */
! 733: if (xs->error != XS_NOERROR)
! 734: goto finish;
! 735:
! 736: NCR_TRACE("done: check status=%d\n", sr->sr_status);
! 737:
! 738: switch (sr->sr_status) {
! 739: case SCSI_OK: /* 0 */
! 740: if (sr->sr_flags & SR_SENSE) {
! 741: #ifdef NCR5380_DEBUG
! 742: if (ncr5380_debug & NCR_DBG_CMDS) {
! 743: ncr5380_show_sense(xs);
! 744: }
! 745: #endif
! 746: xs->error = XS_SENSE;
! 747: }
! 748: break;
! 749:
! 750: case SCSI_CHECK:
! 751: if (sr->sr_flags & SR_SENSE) {
! 752: /* Sense command also asked for sense? */
! 753: printf("ncr5380_done: sense asked for sense\n");
! 754: NCR_BREAK();
! 755: xs->error = XS_DRIVER_STUFFUP;
! 756: break;
! 757: }
! 758: sr->sr_flags |= SR_SENSE;
! 759: NCR_TRACE("done: get sense, sr=0x%x\n", (long) sr);
! 760: /*
! 761: * Leave queued, but clear sc_current so we start over
! 762: * with selection. Guaranteed to get the same request.
! 763: */
! 764: sc->sc_state = NCR_IDLE;
! 765: sc->sc_current = NULL;
! 766: sc->sc_matrix[sr->sr_target][sr->sr_lun] = NULL;
! 767: return; /* XXX */
! 768:
! 769: case SCSI_BUSY:
! 770: xs->error = XS_BUSY;
! 771: break;
! 772:
! 773: case -1:
! 774: /* This is our "impossible" initial value. */
! 775: /* fallthrough */
! 776: default:
! 777: printf("%s: target %d, bad status=%d\n",
! 778: sc->sc_dev.dv_xname, sr->sr_target, sr->sr_status);
! 779: xs->error = XS_DRIVER_STUFFUP;
! 780: break;
! 781: }
! 782:
! 783: finish:
! 784:
! 785: NCR_TRACE("done: finish, error=%d\n", xs->error);
! 786:
! 787: /*
! 788: * Dequeue the finished command, but don't clear sc_state until
! 789: * after the call to scsi_done(), because that may call back to
! 790: * ncr5380_scsi_cmd() - unwanted recursion!
! 791: *
! 792: * Keeping sc->sc_state != idle terminates the recursion.
! 793: */
! 794: #ifdef DIAGNOSTIC
! 795: if ((sc->sc_state & NCR_WORKING) == 0)
! 796: panic("ncr5380_done: bad state");
! 797: #endif
! 798:
! 799: /* Clear our pointers to the request. */
! 800: sc->sc_current = NULL;
! 801: sc->sc_matrix[sr->sr_target][sr->sr_lun] = NULL;
! 802: timeout_del(&sr->sr_timeout);
! 803:
! 804: /* Make the request free. */
! 805: sr->sr_xs = NULL;
! 806: sc->sc_ncmds--;
! 807:
! 808: /* Tell common SCSI code it is done. */
! 809: xs->flags |= ITSDONE;
! 810: scsi_done(xs);
! 811:
! 812: sc->sc_state = NCR_IDLE;
! 813: /* Now ncr5380_sched() may be called again. */
! 814: }
! 815:
! 816:
! 817: /*
! 818: * Schedule a SCSI operation. This routine should return
! 819: * only after it achieves one of the following conditions:
! 820: * Busy (sc->sc_state != NCR_IDLE)
! 821: * No more work can be started.
! 822: */
! 823: static void
! 824: ncr5380_sched(sc)
! 825: struct ncr5380_softc *sc;
! 826: {
! 827: struct sci_req *sr;
! 828: struct scsi_xfer *xs;
! 829: int target = 0, lun = 0;
! 830: int error, i;
! 831:
! 832: /* Another hack (Er.. hook!) for the sun3 si: */
! 833: if (sc->sc_intr_off) {
! 834: NCR_TRACE("sched: top, intr off\n", 0);
! 835: sc->sc_intr_off(sc);
! 836: }
! 837:
! 838: next_job:
! 839: /*
! 840: * Grab the next job from queue. Must be idle.
! 841: */
! 842: #ifdef DIAGNOSTIC
! 843: if (sc->sc_state != NCR_IDLE)
! 844: panic("ncr5380_sched: not idle");
! 845: if (sc->sc_current)
! 846: panic("ncr5380_sched: current set");
! 847: #endif
! 848:
! 849: /*
! 850: * Always start the search where we last looked.
! 851: * The REQUEST_SENSE logic depends on this to
! 852: * choose the same job as was last picked, so it
! 853: * can just clear sc_current and reschedule.
! 854: * (Avoids loss of "contingent allegiance".)
! 855: */
! 856: i = sc->sc_rr;
! 857: sr = NULL;
! 858: do {
! 859: if (sc->sc_ring[i].sr_xs) {
! 860: target = sc->sc_ring[i].sr_target;
! 861: lun = sc->sc_ring[i].sr_lun;
! 862: if (sc->sc_matrix[target][lun] == NULL) {
! 863: /*
! 864: * Do not mark the target/LUN busy yet,
! 865: * because reselect may cause some other
! 866: * job to become the current one, so we
! 867: * might not actually start this job.
! 868: * Instead, set sc_matrix later on.
! 869: */
! 870: sc->sc_rr = i;
! 871: sr = &sc->sc_ring[i];
! 872: break;
! 873: }
! 874: }
! 875: i++;
! 876: if (i == SCI_OPENINGS)
! 877: i = 0;
! 878: } while (i != sc->sc_rr);
! 879:
! 880: if (sr == NULL) {
! 881: NCR_TRACE("sched: no work, cur=0x%x\n",
! 882: (long) sc->sc_current);
! 883:
! 884: /* Another hack (Er.. hook!) for the sun3 si: */
! 885: if (sc->sc_intr_on) {
! 886: NCR_TRACE("sched: ret, intr ON\n", 0);
! 887: sc->sc_intr_on(sc);
! 888: }
! 889:
! 890: return; /* No more work to do. */
! 891: }
! 892:
! 893: NCR_TRACE("sched: select for t/l=0x%02x\n",
! 894: (sr->sr_target << 4) | sr->sr_lun);
! 895:
! 896: sc->sc_state = NCR_WORKING;
! 897: error = ncr5380_select(sc, sr);
! 898: if (sc->sc_current) {
! 899: /* Lost the race! reselected out from under us! */
! 900: /* Work with the reselected job. */
! 901: if (sr->sr_flags & SR_IMMED) {
! 902: printf("%s: reselected while polling (abort)\n",
! 903: sc->sc_dev.dv_xname);
! 904: /* Abort the reselected job. */
! 905: sc->sc_state |= NCR_ABORTING;
! 906: sc->sc_msgpriq |= SEND_ABORT;
! 907: }
! 908: sr = sc->sc_current;
! 909: xs = sr->sr_xs;
! 910: NCR_TRACE("sched: reselect, new sr=0x%x\n", (long)sr);
! 911: goto have_nexus;
! 912: }
! 913:
! 914: /* Normal selection result. Target/LUN is now busy. */
! 915: sc->sc_matrix[target][lun] = sr;
! 916: sc->sc_current = sr; /* connected */
! 917: xs = sr->sr_xs;
! 918:
! 919: /*
! 920: * Initialize pointers, etc. for this job
! 921: */
! 922: sc->sc_dataptr = sr->sr_dataptr;
! 923: sc->sc_datalen = sr->sr_datalen;
! 924: sc->sc_prevphase = PHASE_INVALID;
! 925: sc->sc_msgpriq = SEND_IDENTIFY;
! 926: sc->sc_msgoutq = 0;
! 927: sc->sc_msgout = 0;
! 928:
! 929: NCR_TRACE("sched: select rv=%d\n", error);
! 930:
! 931: switch (error) {
! 932: case XS_NOERROR:
! 933: break;
! 934:
! 935: case XS_BUSY:
! 936: /* XXX - Reset and try again. */
! 937: printf("%s: select found SCSI bus busy, resetting...\n",
! 938: sc->sc_dev.dv_xname);
! 939: ncr5380_reset_scsibus(sc);
! 940: /* fallthrough */
! 941: case XS_SELTIMEOUT:
! 942: default:
! 943: xs->error = error; /* from select */
! 944: NCR_TRACE("sched: call done, sr=0x%x\n", (long)sr);
! 945: ncr5380_done(sc);
! 946:
! 947: /* Paranoia: clear everything. */
! 948: sc->sc_dataptr = NULL;
! 949: sc->sc_datalen = 0;
! 950: sc->sc_prevphase = PHASE_INVALID;
! 951: sc->sc_msgpriq = 0;
! 952: sc->sc_msgoutq = 0;
! 953: sc->sc_msgout = 0;
! 954:
! 955: goto next_job;
! 956: }
! 957:
! 958: /*
! 959: * Selection was successful. Normally, this means
! 960: * we are starting a new command. However, this
! 961: * might be the termination of an overdue job.
! 962: */
! 963: if (sr->sr_flags & SR_OVERDUE) {
! 964: NCR_TRACE("sched: overdue, sr=0x%x\n", (long)sr);
! 965: sc->sc_state |= NCR_ABORTING;
! 966: sc->sc_msgpriq |= SEND_ABORT;
! 967: goto have_nexus;
! 968: }
! 969:
! 970: /*
! 971: * This may be the continuation of some job that
! 972: * completed with a "check condition" code.
! 973: */
! 974: if (sr->sr_flags & SR_SENSE) {
! 975: NCR_TRACE("sched: get sense, sr=0x%x\n", (long)sr);
! 976: /* Do not allocate DMA, nor set timeout. */
! 977: goto have_nexus;
! 978: }
! 979:
! 980: /*
! 981: * OK, we are starting a new command.
! 982: * Initialize and allocate resources for the new command.
! 983: * Device reset is special (only uses MSG_OUT phase).
! 984: * Normal commands start in MSG_OUT phase where we will
! 985: * send and IDENDIFY message, and then expect CMD phase.
! 986: */
! 987: #ifdef NCR5380_DEBUG
! 988: if (ncr5380_debug & NCR_DBG_CMDS) {
! 989: printf("ncr5380_sched: begin, target=%d, LUN=%d\n",
! 990: xs->sc_link->target, xs->sc_link->lun);
! 991: ncr5380_show_scsi_cmd(xs);
! 992: }
! 993: #endif
! 994: if (xs->flags & SCSI_RESET) {
! 995: NCR_TRACE("sched: cmd=reset, sr=0x%x\n", (long)sr);
! 996: /* Not an error, so do not set NCR_ABORTING */
! 997: sc->sc_msgpriq |= SEND_DEV_RESET;
! 998: goto have_nexus;
! 999: }
! 1000:
! 1001: #ifdef DIAGNOSTIC
! 1002: if ((xs->flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) == 0) {
! 1003: if (sc->sc_dataptr) {
! 1004: printf("%s: ptr but no data in/out flags?\n",
! 1005: sc->sc_dev.dv_xname);
! 1006: NCR_BREAK();
! 1007: sc->sc_dataptr = NULL;
! 1008: }
! 1009: }
! 1010: #endif
! 1011:
! 1012: /* Allocate DMA space (maybe) */
! 1013: if (sc->sc_dataptr && sc->sc_dma_alloc &&
! 1014: (sc->sc_datalen >= sc->sc_min_dma_len))
! 1015: {
! 1016: NCR_TRACE("sched: dma_alloc, len=%d\n", sc->sc_datalen);
! 1017: (*sc->sc_dma_alloc)(sc);
! 1018: }
! 1019:
! 1020: /*
! 1021: * Initialization hook called just after select,
! 1022: * at the beginning of COMMAND phase.
! 1023: * (but AFTER the DMA allocation is done)
! 1024: *
! 1025: * The evil Sun "si" adapter (OBIO variant) needs some
! 1026: * setup done to the DMA engine BEFORE the target puts
! 1027: * the SCSI bus into any DATA phase.
! 1028: */
! 1029: if (sr->sr_dma_hand && sc->sc_dma_setup) {
! 1030: NCR_TRACE("sched: dma_setup, dh=0x%x\n",
! 1031: (long) sr->sr_dma_hand);
! 1032: sc->sc_dma_setup(sc);
! 1033: }
! 1034:
! 1035: /*
! 1036: * Schedule a timeout for the job we are starting.
! 1037: */
! 1038: if ((sr->sr_flags & SR_IMMED) == 0) {
! 1039: i = (xs->timeout * hz) / 1000;
! 1040: NCR_TRACE("sched: set timeout=%d\n", i);
! 1041: timeout_add(&sr->sr_timeout, i);
! 1042: }
! 1043:
! 1044: have_nexus:
! 1045: NCR_TRACE("sched: call machine, cur=0x%x\n",
! 1046: (long) sc->sc_current);
! 1047: ncr5380_machine(sc);
! 1048: NCR_TRACE("sched: machine done, cur=0x%x\n",
! 1049: (long) sc->sc_current);
! 1050:
! 1051: /*
! 1052: * What state did ncr5380_machine() leave us in?
! 1053: * Hopefully it sometimes completes a job...
! 1054: */
! 1055: if (sc->sc_state == NCR_IDLE)
! 1056: goto next_job;
! 1057:
! 1058: return; /* Have work in progress. */
! 1059: }
! 1060:
! 1061:
! 1062: /*
! 1063: * Reselect handler: checks for reselection, and if we are being
! 1064: * reselected, it sets up sc->sc_current.
! 1065: *
! 1066: * We are reselected when:
! 1067: * SEL is TRUE
! 1068: * IO is TRUE
! 1069: * BSY is FALSE
! 1070: */
! 1071: void
! 1072: ncr5380_reselect(sc)
! 1073: struct ncr5380_softc *sc;
! 1074: {
! 1075: struct sci_req *sr;
! 1076: int target, lun, phase, timo;
! 1077: int target_mask;
! 1078: u_char bus, data, icmd, msg;
! 1079:
! 1080: #ifdef DIAGNOSTIC
! 1081: /*
! 1082: * Note: sc_state will be "idle" when ncr5380_intr()
! 1083: * calls, or "working" when ncr5380_select() calls.
! 1084: * (So don't test that in this DIAGNOSTIC)
! 1085: */
! 1086: if (sc->sc_current)
! 1087: panic("ncr5380_reselect: current set");
! 1088: #endif
! 1089:
! 1090: /*
! 1091: * First, check the select line.
! 1092: * (That has to be set first.)
! 1093: */
! 1094: bus = *(sc->sci_bus_csr);
! 1095: if ((bus & SCI_BUS_SEL) == 0) {
! 1096: /* Not a selection or reselection. */
! 1097: return;
! 1098: }
! 1099:
! 1100: /*
! 1101: * The target will assert BSY first (for bus arbitration),
! 1102: * then raise SEL, and finally drop BSY. Only then is the
! 1103: * data bus required to have valid selection ID bits set.
! 1104: * Wait for: SEL==1, BSY==0 before reading the data bus.
! 1105: * While this theoretically can happen, we are apparently
! 1106: * never fast enough to get here before BSY drops.
! 1107: */
! 1108: timo = ncr5380_wait_nrq_timo;
! 1109: for (;;) {
! 1110: if ((bus & SCI_BUS_BSY) == 0)
! 1111: break;
! 1112: /* Probably never get here... */
! 1113: if (--timo <= 0) {
! 1114: printf("%s: reselect, BSY stuck, bus=0x%x\n",
! 1115: sc->sc_dev.dv_xname, bus);
! 1116: /* Not much we can do. Reset the bus. */
! 1117: ncr5380_reset_scsibus(sc);
! 1118: return;
! 1119: }
! 1120: delay(2);
! 1121: bus = *(sc->sci_bus_csr);
! 1122: /* If SEL went away, forget it. */
! 1123: if ((bus & SCI_BUS_SEL) == 0)
! 1124: return;
! 1125: /* Still have SEL, check BSY. */
! 1126: }
! 1127: NCR_TRACE("reselect, valid data after %d loops\n",
! 1128: ncr5380_wait_nrq_timo - timo);
! 1129:
! 1130: /*
! 1131: * Good. We have SEL=1 and BSY=0. Now wait for a
! 1132: * "bus settle delay" before we sample the data bus
! 1133: */
! 1134: delay(2);
! 1135: data = *(sc->sci_data) & 0xFF;
! 1136: /* Parity check is implicit in data validation below. */
! 1137:
! 1138: /*
! 1139: * Is this a reselect (I/O == 1) or have we been
! 1140: * selected as a target? (I/O == 0)
! 1141: */
! 1142: if ((bus & SCI_BUS_IO) == 0) {
! 1143: printf("%s: selected as target, data=0x%x\n",
! 1144: sc->sc_dev.dv_xname, data);
! 1145: /* Not much we can do. Reset the bus. */
! 1146: /* XXX: send some sort of message? */
! 1147: ncr5380_reset_scsibus(sc);
! 1148: return;
! 1149: }
! 1150:
! 1151: /*
! 1152: * OK, this is a reselection.
! 1153: */
! 1154: for (target = 0; target < 7; target++) {
! 1155: target_mask = (1 << target);
! 1156: if (data & target_mask)
! 1157: break;
! 1158: }
! 1159: if ((data & 0x7F) != target_mask) {
! 1160: /* No selecting ID? or >2 IDs on bus? */
! 1161: printf("%s: bad reselect, data=0x%x\n",
! 1162: sc->sc_dev.dv_xname, data);
! 1163: return;
! 1164: }
! 1165:
! 1166: NCR_TRACE("reselect: target=0x%x\n", target);
! 1167:
! 1168: /* Raise BSY to acknowledge target reselection. */
! 1169: *(sc->sci_icmd) = SCI_ICMD_BSY;
! 1170:
! 1171: /* Wait for target to drop SEL. */
! 1172: timo = ncr5380_wait_nrq_timo;
! 1173: for (;;) {
! 1174: bus = *(sc->sci_bus_csr);
! 1175: if ((bus & SCI_BUS_SEL) == 0)
! 1176: break; /* success */
! 1177: if (--timo <= 0) {
! 1178: printf("%s: reselect, SEL stuck, bus=0x%x\n",
! 1179: sc->sc_dev.dv_xname, bus);
! 1180: NCR_BREAK();
! 1181: /* assume connected (fail later if not) */
! 1182: break;
! 1183: }
! 1184: delay(2);
! 1185: }
! 1186:
! 1187: /* Now we drop BSY, and we are connected. */
! 1188: *(sc->sci_icmd) = 0;
! 1189: *sc->sci_sel_enb = 0;
! 1190: SCI_CLR_INTR(sc);
! 1191:
! 1192: /*
! 1193: * At this point the target should send an IDENTIFY message,
! 1194: * which will permit us to determine the reselecting LUN.
! 1195: * If not, we assume LUN 0.
! 1196: */
! 1197: lun = 0;
! 1198: /* Wait for REQ before reading bus phase. */
! 1199: if (ncr5380_wait_req(sc)) {
! 1200: printf("%s: reselect, no REQ\n",
! 1201: sc->sc_dev.dv_xname);
! 1202: /* Try to send an ABORT message. */
! 1203: goto abort;
! 1204: }
! 1205: phase = SCI_BUS_PHASE(*sc->sci_bus_csr);
! 1206: if (phase != PHASE_MSG_IN) {
! 1207: printf("%s: reselect, phase=%d\n",
! 1208: sc->sc_dev.dv_xname, phase);
! 1209: goto abort;
! 1210: }
! 1211:
! 1212: /* Ack. the change to PHASE_MSG_IN */
! 1213: *(sc->sci_tcmd) = PHASE_MSG_IN;
! 1214:
! 1215: /* Peek at the message byte without consuming it! */
! 1216: msg = *(sc->sci_data);
! 1217: if ((msg & 0x80) == 0) {
! 1218: printf("%s: reselect, not identify, msg=%d\n",
! 1219: sc->sc_dev.dv_xname, msg);
! 1220: goto abort;
! 1221: }
! 1222: lun = msg & 7;
! 1223:
! 1224: /* We now know target/LUN. Do we have the request? */
! 1225: sr = sc->sc_matrix[target][lun];
! 1226: if (sr) {
! 1227: /* We now have a nexus. */
! 1228: sc->sc_state |= NCR_WORKING;
! 1229: sc->sc_current = sr;
! 1230: NCR_TRACE("reselect: resume sr=0x%x\n", (long)sr);
! 1231:
! 1232: /* Implicit restore pointers message */
! 1233: sc->sc_dataptr = sr->sr_dataptr;
! 1234: sc->sc_datalen = sr->sr_datalen;
! 1235:
! 1236: sc->sc_prevphase = PHASE_INVALID;
! 1237: sc->sc_msgpriq = 0;
! 1238: sc->sc_msgoutq = 0;
! 1239: sc->sc_msgout = 0;
! 1240:
! 1241: /* XXX: Restore the normal mode register. */
! 1242: /* If this target's bit is set, do NOT check parity. */
! 1243: if (sc->sc_parity_disable & target_mask)
! 1244: *sc->sci_mode = (SCI_MODE_MONBSY);
! 1245: else
! 1246: *sc->sci_mode = (SCI_MODE_MONBSY | SCI_MODE_PAR_CHK);
! 1247:
! 1248: /*
! 1249: * Another hack for the Sun3 "si", which needs
! 1250: * some setup done to its DMA engine before the
! 1251: * target puts the SCSI bus into any DATA phase.
! 1252: */
! 1253: if (sr->sr_dma_hand && sc->sc_dma_setup) {
! 1254: NCR_TRACE("reselect: call DMA setup, dh=0x%x\n",
! 1255: (long) sr->sr_dma_hand);
! 1256: sc->sc_dma_setup(sc);
! 1257: }
! 1258:
! 1259: /* Now consume the IDENTIFY message. */
! 1260: ncr5380_pio_in(sc, PHASE_MSG_IN, 1, &msg);
! 1261: return;
! 1262: }
! 1263:
! 1264: printf("%s: phantom reselect: target=%d, LUN=%d\n",
! 1265: sc->sc_dev.dv_xname, target, lun);
! 1266: abort:
! 1267: /*
! 1268: * Try to send an ABORT message. This makes us
! 1269: * temporarily busy, but no current command...
! 1270: */
! 1271: sc->sc_state |= NCR_ABORTING;
! 1272:
! 1273: /* Raise ATN, delay, raise ACK... */
! 1274: icmd = SCI_ICMD_ATN;
! 1275: *sc->sci_icmd = icmd;
! 1276: delay(2);
! 1277:
! 1278: /* Now consume the IDENTIFY message. */
! 1279: ncr5380_pio_in(sc, PHASE_MSG_IN, 1, &msg);
! 1280:
! 1281: /* Finally try to send the ABORT. */
! 1282: sc->sc_prevphase = PHASE_INVALID;
! 1283: sc->sc_msgpriq = SEND_ABORT;
! 1284: ncr5380_msg_out(sc);
! 1285:
! 1286: *(sc->sci_tcmd) = PHASE_INVALID;
! 1287: *sc->sci_sel_enb = 0;
! 1288: SCI_CLR_INTR(sc);
! 1289: *sc->sci_sel_enb = 0x80;
! 1290:
! 1291: sc->sc_state &= ~NCR_ABORTING;
! 1292: }
! 1293:
! 1294:
! 1295: /*
! 1296: * Select target: xs is the transfer that we are selecting for.
! 1297: * sc->sc_current should be NULL.
! 1298: *
! 1299: * Returns:
! 1300: * sc->sc_current != NULL ==> we were reselected (race!)
! 1301: * XS_NOERROR ==> selection worked
! 1302: * XS_BUSY ==> lost arbitration
! 1303: * XS_SELTIMEOUT ==> no response to selection
! 1304: */
! 1305: static int
! 1306: ncr5380_select(sc, sr)
! 1307: struct ncr5380_softc *sc;
! 1308: struct sci_req *sr;
! 1309: {
! 1310: int timo, s, target_mask;
! 1311: u_char data, icmd;
! 1312:
! 1313: /* Check for reselect */
! 1314: ncr5380_reselect(sc);
! 1315: if (sc->sc_current) {
! 1316: NCR_TRACE("select: reselect, cur=0x%x\n",
! 1317: (long) sc->sc_current);
! 1318: return XS_BUSY; /* reselected */
! 1319: }
! 1320:
! 1321: /*
! 1322: * Set phase bits to 0, otherwise the 5380 won't drive the bus during
! 1323: * selection.
! 1324: */
! 1325: *sc->sci_tcmd = PHASE_DATA_OUT;
! 1326: *sc->sci_icmd = icmd = 0;
! 1327: *sc->sci_mode = 0;
! 1328:
! 1329: /*
! 1330: * Arbitrate for the bus. The 5380 takes care of the
! 1331: * time-critical bus interactions. We set our ID bit
! 1332: * in the output data register and set MODE_ARB. The
! 1333: * 5380 watches for the required "bus free" period.
! 1334: * If and when the "bus free" period is detected, the
! 1335: * 5380 drives BSY, drives the data bus, and sets the
! 1336: * "arbitration in progress" (AIP) bit to let us know
! 1337: * arbitration has started (and that it asserts BSY).
! 1338: * We then wait for one arbitration delay (2.2uS) and
! 1339: * check the ICMD_LST bit, which will be set if some
! 1340: * other target drives SEL during arbitration.
! 1341: *
! 1342: * There is a time-critical section during the period
! 1343: * after we enter arbitration up until we assert SEL.
! 1344: * Avoid long interrupts during this period.
! 1345: */
! 1346: s = splvm(); /* XXX: Begin time-critical section */
! 1347:
! 1348: *(sc->sci_odata) = 0x80; /* OUR_ID */
! 1349: *(sc->sci_mode) = SCI_MODE_ARB;
! 1350:
! 1351: #define WAIT_AIP_USEC 20 /* pleanty of time */
! 1352: /* Wait for the AIP bit to turn on. */
! 1353: timo = WAIT_AIP_USEC;
! 1354: for (;;) {
! 1355: if (*(sc->sci_icmd) & SCI_ICMD_AIP)
! 1356: break;
! 1357: if (timo <= 0) {
! 1358: /*
! 1359: * Did not see any "bus free" period.
! 1360: * The usual reason is a reselection,
! 1361: * so treat this as arbitration loss.
! 1362: */
! 1363: NCR_TRACE("select: bus busy, rc=%d\n", XS_BUSY);
! 1364: goto lost_arb;
! 1365: }
! 1366: timo -= 2;
! 1367: delay(2);
! 1368: }
! 1369: NCR_TRACE("select: have AIP after %d uSec.\n",
! 1370: WAIT_AIP_USEC - timo);
! 1371:
! 1372: /* Got AIP. Wait one arbitration delay (2.2 uS.) */
! 1373: delay(3);
! 1374:
! 1375: /* Check for ICMD_LST */
! 1376: if (*(sc->sci_icmd) & SCI_ICMD_LST) {
! 1377: /* Some other target asserted SEL. */
! 1378: NCR_TRACE("select: lost one, rc=%d\n", XS_BUSY);
! 1379: goto lost_arb;
! 1380: }
! 1381:
! 1382: /*
! 1383: * No other device has declared itself the winner.
! 1384: * The spec. says to check for higher IDs, but we
! 1385: * are always the highest (ID=7) so don't bother.
! 1386: * We can now declare victory by asserting SEL.
! 1387: *
! 1388: * Note that the 5380 is asserting BSY because we
! 1389: * have entered arbitration mode. We will now hold
! 1390: * BSY directly so we can turn off ARB mode.
! 1391: */
! 1392: icmd = (SCI_ICMD_BSY | SCI_ICMD_SEL);
! 1393: *sc->sci_icmd = icmd;
! 1394:
! 1395: /*
! 1396: * "The SCSI device that wins arbitration shall wait
! 1397: * at least a bus clear delay plus a bus settle delay
! 1398: * after asserting the SEL signal before changing
! 1399: * any [other] signal." (1.2uS. total)
! 1400: */
! 1401: delay(2);
! 1402:
! 1403: /*
! 1404: * Check one last time to see if we really did
! 1405: * win arbitration. This might only happen if
! 1406: * there can be a higher selection ID than ours.
! 1407: * Keep this code for reference anyway...
! 1408: */
! 1409: if (*(sc->sci_icmd) & SCI_ICMD_LST) {
! 1410: /* Some other target asserted SEL. */
! 1411: NCR_TRACE("select: lost two, rc=%d\n", XS_BUSY);
! 1412:
! 1413: lost_arb:
! 1414: *sc->sci_icmd = 0;
! 1415: *sc->sci_mode = 0;
! 1416:
! 1417: splx(s); /* XXX: End of time-critical section. */
! 1418:
! 1419: /*
! 1420: * When we lose arbitration, it usually means
! 1421: * there is a target trying to reselect us.
! 1422: */
! 1423: ncr5380_reselect(sc);
! 1424: return XS_BUSY;
! 1425: }
! 1426:
! 1427: /* Leave ARB mode Now that we drive BSY+SEL */
! 1428: *sc->sci_mode = 0;
! 1429: *sc->sci_sel_enb = 0;
! 1430:
! 1431: splx(s); /* XXX: End of time-critical section. */
! 1432:
! 1433: /*
! 1434: * Arbitration is complete. Now do selection:
! 1435: * Drive the data bus with the ID bits for both
! 1436: * the host and target. Also set ATN now, to
! 1437: * ask the target for a message out phase.
! 1438: */
! 1439: target_mask = (1 << sr->sr_target);
! 1440: data = 0x80 | target_mask;
! 1441: *(sc->sci_odata) = data;
! 1442: icmd |= (SCI_ICMD_DATA | SCI_ICMD_ATN);
! 1443: *(sc->sci_icmd) = icmd;
! 1444: delay(2); /* two deskew delays. */
! 1445:
! 1446: /* De-assert BSY (targets sample the data now). */
! 1447: icmd &= ~SCI_ICMD_BSY;
! 1448: *(sc->sci_icmd) = icmd;
! 1449: delay(3); /* Bus settle delay. */
! 1450:
! 1451: /*
! 1452: * Wait for the target to assert BSY.
! 1453: * SCSI spec. says wait for 250 mS.
! 1454: */
! 1455: for (timo = 25000;;) {
! 1456: if (*sc->sci_bus_csr & SCI_BUS_BSY)
! 1457: goto success;
! 1458: if (--timo <= 0)
! 1459: break;
! 1460: delay(10);
! 1461: }
! 1462:
! 1463: /*
! 1464: * There is no reaction from the target. Start the selection
! 1465: * timeout procedure. We release the databus but keep SEL+ATN
! 1466: * asserted. After that we wait a 'selection abort time' (200
! 1467: * usecs) and 2 deskew delays (90 ns) and check BSY again.
! 1468: * When BSY is asserted, we assume the selection succeeded,
! 1469: * otherwise we release the bus.
! 1470: */
! 1471: icmd &= ~SCI_ICMD_DATA;
! 1472: *(sc->sci_icmd) = icmd;
! 1473: delay(201);
! 1474: if ((*sc->sci_bus_csr & SCI_BUS_BSY) == 0) {
! 1475: /* Really no device on bus */
! 1476: *sc->sci_tcmd = PHASE_INVALID;
! 1477: *sc->sci_icmd = 0;
! 1478: *sc->sci_mode = 0;
! 1479: *sc->sci_sel_enb = 0;
! 1480: SCI_CLR_INTR(sc);
! 1481: *sc->sci_sel_enb = 0x80;
! 1482: NCR_TRACE("select: device down, rc=%d\n", XS_SELTIMEOUT);
! 1483: return XS_SELTIMEOUT;
! 1484: }
! 1485:
! 1486: success:
! 1487: /*
! 1488: * The target is now driving BSY, so we can stop
! 1489: * driving SEL and the data bus (keep ATN true).
! 1490: * Configure the ncr5380 to monitor BSY, parity.
! 1491: */
! 1492: icmd &= ~(SCI_ICMD_DATA | SCI_ICMD_SEL);
! 1493: *sc->sci_icmd = icmd;
! 1494:
! 1495: /* If this target's bit is set, do NOT check parity. */
! 1496: if (sc->sc_parity_disable & target_mask)
! 1497: *sc->sci_mode = (SCI_MODE_MONBSY);
! 1498: else
! 1499: *sc->sci_mode = (SCI_MODE_MONBSY | SCI_MODE_PAR_CHK);
! 1500:
! 1501: return XS_NOERROR;
! 1502: }
! 1503:
! 1504:
! 1505: /*****************************************************************
! 1506: * Functions to handle each info. transfer phase:
! 1507: *****************************************************************/
! 1508:
! 1509: /*
! 1510: * The message system:
! 1511: *
! 1512: * This is a revamped message system that now should easier accommodate
! 1513: * new messages, if necessary.
! 1514: *
! 1515: * Currently we accept these messages:
! 1516: * IDENTIFY (when reselecting)
! 1517: * COMMAND COMPLETE # (expect bus free after messages marked #)
! 1518: * NOOP
! 1519: * MESSAGE REJECT
! 1520: * SYNCHRONOUS DATA TRANSFER REQUEST
! 1521: * SAVE DATA POINTER
! 1522: * RESTORE POINTERS
! 1523: * DISCONNECT #
! 1524: *
! 1525: * We may send these messages in prioritized order:
! 1526: * BUS DEVICE RESET # if SCSI_RESET & xs->flags (or in weird sits.)
! 1527: * MESSAGE PARITY ERROR par. err. during MSGI
! 1528: * MESSAGE REJECT If we get a message we don't know how to handle
! 1529: * ABORT # send on errors
! 1530: * INITIATOR DETECTED ERROR also on errors (SCSI2) (during info xfer)
! 1531: * IDENTIFY At the start of each transfer
! 1532: * SYNCHRONOUS DATA TRANSFER REQUEST if appropriate
! 1533: * NOOP if nothing else fits the bill ...
! 1534: */
! 1535:
! 1536: #define IS1BYTEMSG(m) (((m) != 0x01 && (m) < 0x20) || (m) >= 0x80)
! 1537: #define IS2BYTEMSG(m) (((m) & 0xf0) == 0x20)
! 1538: #define ISEXTMSG(m) ((m) == 0x01)
! 1539:
! 1540: /*
! 1541: * Precondition:
! 1542: * The SCSI bus is already in the MSGI phase and there is a message byte
! 1543: * on the bus, along with an asserted REQ signal.
! 1544: *
! 1545: * Our return value determines whether our caller, ncr5380_machine()
! 1546: * will expect to see another REQ (and possibly phase change).
! 1547: */
! 1548: static int
! 1549: ncr5380_msg_in(sc)
! 1550: register struct ncr5380_softc *sc;
! 1551: {
! 1552: struct sci_req *sr = sc->sc_current;
! 1553: struct scsi_xfer *xs = sr->sr_xs;
! 1554: int n, phase;
! 1555: int act_flags;
! 1556: register u_char icmd;
! 1557:
! 1558: /* acknowledge phase change */
! 1559: *sc->sci_tcmd = PHASE_MSG_IN;
! 1560:
! 1561: act_flags = ACT_CONTINUE;
! 1562: icmd = *sc->sci_icmd & SCI_ICMD_RMASK;
! 1563:
! 1564: if (sc->sc_prevphase == PHASE_MSG_IN) {
! 1565: /* This is a continuation of the previous message. */
! 1566: n = sc->sc_imp - sc->sc_imess;
! 1567: NCR_TRACE("msg_in: continuation, n=%d\n", n);
! 1568: goto nextbyte;
! 1569: }
! 1570:
! 1571: /* This is a new MESSAGE IN phase. Clean up our state. */
! 1572: sc->sc_state &= ~NCR_DROP_MSGIN;
! 1573:
! 1574: nextmsg:
! 1575: n = 0;
! 1576: sc->sc_imp = &sc->sc_imess[n];
! 1577:
! 1578: nextbyte:
! 1579: /*
! 1580: * Read a whole message, but don't ack the last byte. If we reject the
! 1581: * message, we have to assert ATN during the message transfer phase
! 1582: * itself.
! 1583: */
! 1584: for (;;) {
! 1585: /*
! 1586: * Read a message byte.
! 1587: * First, check BSY, REQ, phase...
! 1588: */
! 1589: if (!SCI_BUSY(sc)) {
! 1590: NCR_TRACE("msg_in: lost BSY, n=%d\n", n);
! 1591: /* XXX - Assume the command completed? */
! 1592: act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
! 1593: return (act_flags);
! 1594: }
! 1595: if (ncr5380_wait_req(sc)) {
! 1596: NCR_TRACE("msg_in: BSY but no REQ, n=%d\n", n);
! 1597: /* Just let ncr5380_machine() handle it... */
! 1598: return (act_flags);
! 1599: }
! 1600: phase = SCI_BUS_PHASE(*sc->sci_bus_csr);
! 1601: if (phase != PHASE_MSG_IN) {
! 1602: /*
! 1603: * Target left MESSAGE IN, probably because it
! 1604: * a) noticed our ATN signal, or
! 1605: * b) ran out of messages.
! 1606: */
! 1607: return (act_flags);
! 1608: }
! 1609: /* Still in MESSAGE IN phase, and REQ is asserted. */
! 1610: if (*sc->sci_csr & SCI_CSR_PERR) {
! 1611: ncr_sched_msgout(sc, SEND_PARITY_ERROR);
! 1612: sc->sc_state |= NCR_DROP_MSGIN;
! 1613: }
! 1614:
! 1615: /* Gather incoming message bytes if needed. */
! 1616: if ((sc->sc_state & NCR_DROP_MSGIN) == 0) {
! 1617: if (n >= NCR_MAX_MSG_LEN) {
! 1618: ncr_sched_msgout(sc, SEND_REJECT);
! 1619: sc->sc_state |= NCR_DROP_MSGIN;
! 1620: } else {
! 1621: *sc->sc_imp++ = *sc->sci_data;
! 1622: n++;
! 1623: /*
! 1624: * This testing is suboptimal, but most
! 1625: * messages will be of the one byte variety, so
! 1626: * it should not affect performance
! 1627: * significantly.
! 1628: */
! 1629: if (n == 1 && IS1BYTEMSG(sc->sc_imess[0]))
! 1630: goto have_msg;
! 1631: if (n == 2 && IS2BYTEMSG(sc->sc_imess[0]))
! 1632: goto have_msg;
! 1633: if (n >= 3 && ISEXTMSG(sc->sc_imess[0]) &&
! 1634: n == sc->sc_imess[1] + 2)
! 1635: goto have_msg;
! 1636: }
! 1637: }
! 1638:
! 1639: /*
! 1640: * If we reach this spot we're either:
! 1641: * a) in the middle of a multi-byte message, or
! 1642: * b) dropping bytes.
! 1643: */
! 1644:
! 1645: /* Ack the last byte read. */
! 1646: icmd |= SCI_ICMD_ACK;
! 1647: *sc->sci_icmd = icmd;
! 1648:
! 1649: if (ncr5380_wait_not_req(sc)) {
! 1650: NCR_TRACE("msg_in: drop, stuck REQ, n=%d\n", n);
! 1651: act_flags |= ACT_RESET_BUS;
! 1652: }
! 1653:
! 1654: icmd &= ~SCI_ICMD_ACK;
! 1655: *sc->sci_icmd = icmd;
! 1656:
! 1657: if (act_flags != ACT_CONTINUE)
! 1658: return (act_flags);
! 1659:
! 1660: /* back to nextbyte */
! 1661: }
! 1662:
! 1663: have_msg:
! 1664: /* We now have a complete message. Parse it. */
! 1665:
! 1666: switch (sc->sc_imess[0]) {
! 1667: case MSG_CMDCOMPLETE:
! 1668: NCR_TRACE("msg_in: CMDCOMPLETE\n", 0);
! 1669: /* Target is about to disconnect. */
! 1670: act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
! 1671: break;
! 1672:
! 1673: case MSG_PARITY_ERROR:
! 1674: NCR_TRACE("msg_in: PARITY_ERROR\n", 0);
! 1675: /* Resend the last message. */
! 1676: ncr_sched_msgout(sc, sc->sc_msgout);
! 1677: /* Reset icmd after scheduling the REJECT cmd - jwg */
! 1678: icmd = *sc->sci_icmd & SCI_ICMD_RMASK;
! 1679: break;
! 1680:
! 1681: case MSG_MESSAGE_REJECT:
! 1682: /* The target rejects the last message we sent. */
! 1683: NCR_TRACE("msg_in: got reject for 0x%x\n", sc->sc_msgout);
! 1684: switch (sc->sc_msgout) {
! 1685: case SEND_IDENTIFY:
! 1686: /* Really old target controller? */
! 1687: /* XXX ... */
! 1688: break;
! 1689: case SEND_INIT_DET_ERR:
! 1690: goto abort;
! 1691: }
! 1692: break;
! 1693:
! 1694: case MSG_NOOP:
! 1695: NCR_TRACE("msg_in: NOOP\n", 0);
! 1696: break;
! 1697:
! 1698: case MSG_DISCONNECT:
! 1699: NCR_TRACE("msg_in: DISCONNECT\n", 0);
! 1700: /* Target is about to disconnect. */
! 1701: act_flags |= ACT_DISCONNECT;
! 1702: if ((xs->sc_link->quirks & SDEV_AUTOSAVE) == 0)
! 1703: break;
! 1704: /*FALLTHROUGH*/
! 1705:
! 1706: case MSG_SAVEDATAPOINTER:
! 1707: NCR_TRACE("msg_in: SAVE_PTRS\n", 0);
! 1708: sr->sr_dataptr = sc->sc_dataptr;
! 1709: sr->sr_datalen = sc->sc_datalen;
! 1710: break;
! 1711:
! 1712: case MSG_RESTOREPOINTERS:
! 1713: NCR_TRACE("msg_in: RESTORE_PTRS\n", 0);
! 1714: sc->sc_dataptr = sr->sr_dataptr;
! 1715: sc->sc_datalen = sr->sr_datalen;
! 1716: break;
! 1717:
! 1718: case MSG_EXTENDED:
! 1719: switch (sc->sc_imess[2]) {
! 1720: case MSG_EXT_SDTR:
! 1721: case MSG_EXT_WDTR:
! 1722: /* The ncr5380 can not do synchronous mode. */
! 1723: goto reject;
! 1724: default:
! 1725: printf("%s: unrecognized MESSAGE EXTENDED; sending REJECT\n",
! 1726: sc->sc_dev.dv_xname);
! 1727: NCR_BREAK();
! 1728: goto reject;
! 1729: }
! 1730: break;
! 1731:
! 1732: default:
! 1733: NCR_TRACE("msg_in: eh? imsg=0x%x\n", sc->sc_imess[0]);
! 1734: printf("%s: unrecognized MESSAGE; sending REJECT\n",
! 1735: sc->sc_dev.dv_xname);
! 1736: NCR_BREAK();
! 1737: /* fallthrough */
! 1738: reject:
! 1739: ncr_sched_msgout(sc, SEND_REJECT);
! 1740: /* Reset icmd after scheduling the REJECT cmd - jwg */
! 1741: icmd = *sc->sci_icmd & SCI_ICMD_RMASK;
! 1742: break;
! 1743:
! 1744: abort:
! 1745: sc->sc_state |= NCR_ABORTING;
! 1746: ncr_sched_msgout(sc, SEND_ABORT);
! 1747: break;
! 1748: }
! 1749:
! 1750: /* Ack the last byte read. */
! 1751: icmd |= SCI_ICMD_ACK;
! 1752: *sc->sci_icmd = icmd;
! 1753:
! 1754: if (ncr5380_wait_not_req(sc)) {
! 1755: NCR_TRACE("msg_in: last, stuck REQ, n=%d\n", n);
! 1756: act_flags |= ACT_RESET_BUS;
! 1757: }
! 1758:
! 1759: icmd &= ~SCI_ICMD_ACK;
! 1760: *sc->sci_icmd = icmd;
! 1761:
! 1762: /* Go get the next message, if any. */
! 1763: if (act_flags == ACT_CONTINUE)
! 1764: goto nextmsg;
! 1765:
! 1766: return (act_flags);
! 1767: }
! 1768:
! 1769:
! 1770: /*
! 1771: * The message out (and in) stuff is a bit complicated:
! 1772: * If the target requests another message (sequence) without
! 1773: * having changed phase in between it really asks for a
! 1774: * retransmit, probably due to parity error(s).
! 1775: * The following messages can be sent:
! 1776: * IDENTIFY @ These 4 stem from SCSI command activity
! 1777: * SDTR @
! 1778: * WDTR @
! 1779: * DEV_RESET @
! 1780: * REJECT if MSGI doesn't make sense
! 1781: * PARITY_ERROR if parity error while in MSGI
! 1782: * INIT_DET_ERR if parity error while not in MSGI
! 1783: * ABORT if INIT_DET_ERR rejected
! 1784: * NOOP if asked for a message and there's nothing to send
! 1785: *
! 1786: * Note that we call this one with (sc_current == NULL)
! 1787: * when sending ABORT for unwanted reselections.
! 1788: */
! 1789: static int
! 1790: ncr5380_msg_out(sc)
! 1791: register struct ncr5380_softc *sc;
! 1792: {
! 1793: struct sci_req *sr = sc->sc_current;
! 1794: int act_flags, n, phase, progress;
! 1795: register u_char icmd, msg;
! 1796:
! 1797: /* acknowledge phase change */
! 1798: *sc->sci_tcmd = PHASE_MSG_OUT;
! 1799:
! 1800: progress = 0; /* did we send any messages? */
! 1801: act_flags = ACT_CONTINUE;
! 1802:
! 1803: /*
! 1804: * Set ATN. If we're just sending a trivial 1-byte message,
! 1805: * we'll clear ATN later on anyway. Also drive the data bus.
! 1806: */
! 1807: icmd = *sc->sci_icmd & SCI_ICMD_RMASK;
! 1808: icmd |= (SCI_ICMD_ATN | SCI_ICMD_DATA);
! 1809: *sc->sci_icmd = icmd;
! 1810:
! 1811: if (sc->sc_prevphase == PHASE_MSG_OUT) {
! 1812: if (sc->sc_omp == sc->sc_omess) {
! 1813: /*
! 1814: * This is a retransmission.
! 1815: *
! 1816: * We get here if the target stayed in MESSAGE OUT
! 1817: * phase. Section 5.1.9.2 of the SCSI 2 spec indicates
! 1818: * that all of the previously transmitted messages must
! 1819: * be sent again, in the same order. Therefore, we
! 1820: * requeue all the previously transmitted messages, and
! 1821: * start again from the top. Our simple priority
! 1822: * scheme keeps the messages in the right order.
! 1823: */
! 1824: sc->sc_msgpriq |= sc->sc_msgoutq;
! 1825: NCR_TRACE("msg_out: retrans priq=0x%x\n", sc->sc_msgpriq);
! 1826: } else {
! 1827: /* This is a continuation of the previous message. */
! 1828: n = sc->sc_omp - sc->sc_omess;
! 1829: NCR_TRACE("msg_out: continuation, n=%d\n", n);
! 1830: goto nextbyte;
! 1831: }
! 1832: }
! 1833:
! 1834: /* No messages transmitted so far. */
! 1835: sc->sc_msgoutq = 0;
! 1836:
! 1837: nextmsg:
! 1838: /* Pick up highest priority message. */
! 1839: sc->sc_msgout = sc->sc_msgpriq & -sc->sc_msgpriq;
! 1840: sc->sc_msgpriq &= ~sc->sc_msgout;
! 1841: sc->sc_msgoutq |= sc->sc_msgout;
! 1842:
! 1843: /* Build the outgoing message data. */
! 1844: switch (sc->sc_msgout) {
! 1845: case SEND_IDENTIFY:
! 1846: NCR_TRACE("msg_out: SEND_IDENTIFY\n", 0);
! 1847: if (sr == NULL) {
! 1848: printf("%s: SEND_IDENTIFY while not connected; sending NOOP\n",
! 1849: sc->sc_dev.dv_xname);
! 1850: NCR_BREAK();
! 1851: goto noop;
! 1852: }
! 1853: /*
! 1854: * The identify message we send determines whether
! 1855: * disconnect/reselect is allowed for this command.
! 1856: * 0xC0+LUN: allows it, 0x80+LUN disallows it.
! 1857: */
! 1858: msg = 0xc0; /* MSG_IDENTIFY(0,1) */
! 1859: if (sc->sc_no_disconnect & (1 << sr->sr_target))
! 1860: msg = 0x80;
! 1861: if (sr->sr_flags & (SR_IMMED | SR_SENSE))
! 1862: msg = 0x80;
! 1863: sc->sc_omess[0] = msg | sr->sr_lun;
! 1864: n = 1;
! 1865: break;
! 1866:
! 1867: case SEND_DEV_RESET:
! 1868: NCR_TRACE("msg_out: SEND_DEV_RESET\n", 0);
! 1869: /* Expect disconnect after this! */
! 1870: /* XXX: Kill jobs for this target? */
! 1871: act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
! 1872: sc->sc_omess[0] = MSG_BUS_DEV_RESET;
! 1873: n = 1;
! 1874: break;
! 1875:
! 1876: case SEND_REJECT:
! 1877: NCR_TRACE("msg_out: SEND_REJECT\n", 0);
! 1878: sc->sc_omess[0] = MSG_MESSAGE_REJECT;
! 1879: n = 1;
! 1880: break;
! 1881:
! 1882: case SEND_PARITY_ERROR:
! 1883: NCR_TRACE("msg_out: SEND_PARITY_ERROR\n", 0);
! 1884: sc->sc_omess[0] = MSG_PARITY_ERROR;
! 1885: n = 1;
! 1886: break;
! 1887:
! 1888: case SEND_INIT_DET_ERR:
! 1889: NCR_TRACE("msg_out: SEND_INIT_DET_ERR\n", 0);
! 1890: sc->sc_omess[0] = MSG_INITIATOR_DET_ERR;
! 1891: n = 1;
! 1892: break;
! 1893:
! 1894: case SEND_ABORT:
! 1895: NCR_TRACE("msg_out: SEND_ABORT\n", 0);
! 1896: /* Expect disconnect after this! */
! 1897: /* XXX: Set error flag? */
! 1898: act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
! 1899: sc->sc_omess[0] = MSG_ABORT;
! 1900: n = 1;
! 1901: break;
! 1902:
! 1903: case 0:
! 1904: printf("%s: unexpected MESSAGE OUT; sending NOOP\n",
! 1905: sc->sc_dev.dv_xname);
! 1906: NCR_BREAK();
! 1907: noop:
! 1908: NCR_TRACE("msg_out: send NOOP\n", 0);
! 1909: sc->sc_omess[0] = MSG_NOOP;
! 1910: n = 1;
! 1911: break;
! 1912:
! 1913: default:
! 1914: printf("%s: weird MESSAGE OUT; sending NOOP\n",
! 1915: sc->sc_dev.dv_xname);
! 1916: NCR_BREAK();
! 1917: goto noop;
! 1918: }
! 1919: sc->sc_omp = &sc->sc_omess[n];
! 1920:
! 1921: nextbyte:
! 1922: /* Send message bytes. */
! 1923: while (n > 0) {
! 1924: /*
! 1925: * Send a message byte.
! 1926: * First check BSY, REQ, phase...
! 1927: */
! 1928: if (!SCI_BUSY(sc)) {
! 1929: NCR_TRACE("msg_out: lost BSY, n=%d\n", n);
! 1930: goto out;
! 1931: }
! 1932: if (ncr5380_wait_req(sc)) {
! 1933: NCR_TRACE("msg_out: no REQ, n=%d\n", n);
! 1934: goto out;
! 1935: }
! 1936: phase = SCI_BUS_PHASE(*sc->sci_bus_csr);
! 1937: if (phase != PHASE_MSG_OUT) {
! 1938: /*
! 1939: * Target left MESSAGE OUT, possibly to reject
! 1940: * our message.
! 1941: */
! 1942: NCR_TRACE("msg_out: new phase=%d\n", phase);
! 1943: goto out;
! 1944: }
! 1945:
! 1946: /* Yes, we can send this message byte. */
! 1947: --n;
! 1948:
! 1949: /* Clear ATN before last byte if this is the last message. */
! 1950: if (n == 0 && sc->sc_msgpriq == 0) {
! 1951: icmd &= ~SCI_ICMD_ATN;
! 1952: *sc->sci_icmd = icmd;
! 1953: /* 2 deskew delays */
! 1954: delay(2); /* XXX */
! 1955: }
! 1956:
! 1957: /* Put data on the bus. */
! 1958: *sc->sci_odata = *--sc->sc_omp;
! 1959:
! 1960: /* Raise ACK to tell target data is on the bus. */
! 1961: icmd |= SCI_ICMD_ACK;
! 1962: *sc->sci_icmd = icmd;
! 1963:
! 1964: /* Wait for REQ to be negated. */
! 1965: if (ncr5380_wait_not_req(sc)) {
! 1966: NCR_TRACE("msg_out: stuck REQ, n=%d\n", n);
! 1967: act_flags |= ACT_RESET_BUS;
! 1968: }
! 1969:
! 1970: /* Finally, drop ACK. */
! 1971: icmd &= ~SCI_ICMD_ACK;
! 1972: *sc->sci_icmd = icmd;
! 1973:
! 1974: /* Stuck bus or something... */
! 1975: if (act_flags & ACT_RESET_BUS)
! 1976: goto out;
! 1977:
! 1978: }
! 1979: progress++;
! 1980:
! 1981: /* We get here only if the entire message has been transmitted. */
! 1982: if (sc->sc_msgpriq != 0) {
! 1983: /* There are more outgoing messages. */
! 1984: goto nextmsg;
! 1985: }
! 1986:
! 1987: /*
! 1988: * The last message has been transmitted. We need to remember the last
! 1989: * message transmitted (in case the target switches to MESSAGE IN phase
! 1990: * and sends a MESSAGE REJECT), and the list of messages transmitted
! 1991: * this time around (in case the target stays in MESSAGE OUT phase to
! 1992: * request a retransmit).
! 1993: */
! 1994:
! 1995: out:
! 1996: /* Stop driving the data bus. */
! 1997: icmd &= ~SCI_ICMD_DATA;
! 1998: *sc->sci_icmd = icmd;
! 1999:
! 2000: if (!progress)
! 2001: act_flags |= ACT_RESET_BUS;
! 2002:
! 2003: return (act_flags);
! 2004: }
! 2005:
! 2006:
! 2007: /*
! 2008: * Handle command phase.
! 2009: */
! 2010: static int
! 2011: ncr5380_command(sc)
! 2012: struct ncr5380_softc *sc;
! 2013: {
! 2014: struct sci_req *sr = sc->sc_current;
! 2015: struct scsi_xfer *xs = sr->sr_xs;
! 2016: struct scsi_sense rqs;
! 2017: int len;
! 2018:
! 2019: /* acknowledge phase change */
! 2020: *sc->sci_tcmd = PHASE_COMMAND;
! 2021:
! 2022: if (sr->sr_flags & SR_SENSE) {
! 2023: rqs.opcode = REQUEST_SENSE;
! 2024: rqs.byte2 = xs->sc_link->lun << 5;
! 2025: rqs.length = sizeof(xs->sense);
! 2026:
! 2027: rqs.unused[0] = rqs.unused[1] = rqs.control = 0;
! 2028: len = ncr5380_pio_out(sc, PHASE_COMMAND, sizeof(rqs),
! 2029: (u_char *)&rqs);
! 2030: }
! 2031: else {
! 2032: /* Assume command can be sent in one go. */
! 2033: /* XXX: Do this using DMA, and get a phase change intr? */
! 2034: len = ncr5380_pio_out(sc, PHASE_COMMAND, xs->cmdlen,
! 2035: (u_char *)xs->cmd);
! 2036: }
! 2037:
! 2038: if (len != xs->cmdlen) {
! 2039: #ifdef NCR5380_DEBUG
! 2040: printf("ncr5380_command: short transfer: wanted %d got %d.\n",
! 2041: xs->cmdlen, len);
! 2042: ncr5380_show_scsi_cmd(xs);
! 2043: NCR_BREAK();
! 2044: #endif
! 2045: if (len < 6) {
! 2046: xs->error = XS_DRIVER_STUFFUP;
! 2047: sc->sc_state |= NCR_ABORTING;
! 2048: ncr_sched_msgout(sc, SEND_ABORT);
! 2049: }
! 2050:
! 2051: }
! 2052:
! 2053: return ACT_CONTINUE;
! 2054: }
! 2055:
! 2056:
! 2057: /*
! 2058: * Handle either data_in or data_out
! 2059: */
! 2060: static int
! 2061: ncr5380_data_xfer(sc, phase)
! 2062: struct ncr5380_softc *sc;
! 2063: int phase;
! 2064: {
! 2065: struct sci_req *sr = sc->sc_current;
! 2066: struct scsi_xfer *xs = sr->sr_xs;
! 2067: int expected_phase;
! 2068: int len;
! 2069:
! 2070: if (sr->sr_flags & SR_SENSE) {
! 2071: NCR_TRACE("data_xfer: get sense, sr=0x%x\n", (long)sr);
! 2072: if (phase != PHASE_DATA_IN) {
! 2073: printf("%s: sense phase error\n", sc->sc_dev.dv_xname);
! 2074: goto abort;
! 2075: }
! 2076: /* acknowledge phase change */
! 2077: *sc->sci_tcmd = PHASE_DATA_IN;
! 2078: len = ncr5380_pio_in(sc, phase, sizeof(xs->sense),
! 2079: (u_char *)&xs->sense);
! 2080: return ACT_CONTINUE;
! 2081: }
! 2082:
! 2083: /*
! 2084: * When aborting a command, disallow any data phase.
! 2085: */
! 2086: if (sc->sc_state & NCR_ABORTING) {
! 2087: printf("%s: aborting, but phase=%s (reset)\n",
! 2088: sc->sc_dev.dv_xname, phase_names[phase & 7]);
! 2089: return ACT_RESET_BUS; /* XXX */
! 2090: }
! 2091:
! 2092: /* Validate expected phase (data_in or data_out) */
! 2093: expected_phase = (xs->flags & SCSI_DATA_OUT) ?
! 2094: PHASE_DATA_OUT : PHASE_DATA_IN;
! 2095: if (phase != expected_phase) {
! 2096: printf("%s: data phase error\n", sc->sc_dev.dv_xname);
! 2097: goto abort;
! 2098: }
! 2099:
! 2100: /* Make sure we have some data to move. */
! 2101: if (sc->sc_datalen <= 0) {
! 2102: /* Device needs padding. */
! 2103: if (phase == PHASE_DATA_IN)
! 2104: ncr5380_pio_in(sc, phase, 4096, NULL);
! 2105: else
! 2106: ncr5380_pio_out(sc, phase, 4096, NULL);
! 2107: /* Make sure that caused a phase change. */
! 2108: if (SCI_BUS_PHASE(*sc->sci_bus_csr) == phase) {
! 2109: /* More than 4k is just too much! */
! 2110: printf("%s: too much data padding\n",
! 2111: sc->sc_dev.dv_xname);
! 2112: goto abort;
! 2113: }
! 2114: return ACT_CONTINUE;
! 2115: }
! 2116:
! 2117: /*
! 2118: * Attempt DMA only if dma_alloc gave us a DMA handle AND
! 2119: * there is enough left to transfer so DMA is worth while.
! 2120: */
! 2121: if (sr->sr_dma_hand &&
! 2122: (sc->sc_datalen >= sc->sc_min_dma_len))
! 2123: {
! 2124: /*
! 2125: * OK, really start DMA. Note, the MD start function
! 2126: * is responsible for setting the TCMD register, etc.
! 2127: * (Acknowledge the phase change there, not here.)
! 2128: */
! 2129: NCR_TRACE("data_xfer: dma_start, dh=0x%x\n",
! 2130: (long) sr->sr_dma_hand);
! 2131: (*sc->sc_dma_start)(sc);
! 2132: return ACT_WAIT_DMA;
! 2133: }
! 2134:
! 2135: /*
! 2136: * Doing PIO for data transfer. (Possibly "Pseudo DMA")
! 2137: * XXX: Do PDMA functions need to set tcmd later?
! 2138: */
! 2139: NCR_TRACE("data_xfer: doing PIO, len=%d\n", sc->sc_datalen);
! 2140: /* acknowledge phase change */
! 2141: *sc->sci_tcmd = phase; /* XXX: OK for PDMA? */
! 2142: if (phase == PHASE_DATA_OUT) {
! 2143: len = (*sc->sc_pio_out)(sc, phase, sc->sc_datalen, sc->sc_dataptr);
! 2144: } else {
! 2145: len = (*sc->sc_pio_in) (sc, phase, sc->sc_datalen, sc->sc_dataptr);
! 2146: }
! 2147: sc->sc_dataptr += len;
! 2148: sc->sc_datalen -= len;
! 2149:
! 2150: NCR_TRACE("data_xfer: did PIO, resid=%d\n", sc->sc_datalen);
! 2151: return (ACT_CONTINUE);
! 2152:
! 2153: abort:
! 2154: sc->sc_state |= NCR_ABORTING;
! 2155: ncr_sched_msgout(sc, SEND_ABORT);
! 2156: return (ACT_CONTINUE);
! 2157: }
! 2158:
! 2159:
! 2160: static int
! 2161: ncr5380_status(sc)
! 2162: struct ncr5380_softc *sc;
! 2163: {
! 2164: int len;
! 2165: u_char status;
! 2166: struct sci_req *sr = sc->sc_current;
! 2167:
! 2168: /* acknowledge phase change */
! 2169: *sc->sci_tcmd = PHASE_STATUS;
! 2170:
! 2171: len = ncr5380_pio_in(sc, PHASE_STATUS, 1, &status);
! 2172: if (len) {
! 2173: sr->sr_status = status;
! 2174: } else {
! 2175: printf("ncr5380_status: none?\n");
! 2176: }
! 2177:
! 2178: return ACT_CONTINUE;
! 2179: }
! 2180:
! 2181:
! 2182: /*
! 2183: * This is the big state machine that follows SCSI phase changes.
! 2184: * This is somewhat like a co-routine. It will do a SCSI command,
! 2185: * and exit if the command is complete, or if it must wait, i.e.
! 2186: * for DMA to complete or for reselect to resume the job.
! 2187: *
! 2188: * The bus must be selected, and we need to know which command is
! 2189: * being undertaken.
! 2190: */
! 2191: static void
! 2192: ncr5380_machine(sc)
! 2193: struct ncr5380_softc *sc;
! 2194: {
! 2195: struct sci_req *sr;
! 2196: struct scsi_xfer *xs;
! 2197: int act_flags, phase, timo;
! 2198:
! 2199: #ifdef DIAGNOSTIC
! 2200: if (sc->sc_state == NCR_IDLE)
! 2201: panic("ncr5380_machine: state=idle");
! 2202: if (sc->sc_current == NULL)
! 2203: panic("ncr5380_machine: no current cmd");
! 2204: #endif
! 2205:
! 2206: sr = sc->sc_current;
! 2207: xs = sr->sr_xs;
! 2208: act_flags = ACT_CONTINUE;
! 2209:
! 2210: /*
! 2211: * This will be called by ncr5380_intr() when DMA is
! 2212: * complete. Must stop DMA before touching the 5380 or
! 2213: * there will be "register conflict" errors.
! 2214: */
! 2215: if (sc->sc_state & NCR_DOINGDMA) {
! 2216: /* Pick-up where where we left off... */
! 2217: goto dma_done;
! 2218: }
! 2219:
! 2220: next_phase:
! 2221:
! 2222: if (!SCI_BUSY(sc)) {
! 2223: /* Unexpected disconnect */
! 2224: printf("ncr5380_machine: unexpected disconnect.\n");
! 2225: xs->error = XS_DRIVER_STUFFUP;
! 2226: act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
! 2227: goto do_actions;
! 2228: }
! 2229:
! 2230: /*
! 2231: * Wait for REQ before reading the phase.
! 2232: * Need to wait longer than usual here, because
! 2233: * some devices are just plain slow...
! 2234: */
! 2235: timo = ncr5380_wait_phase_timo;
! 2236: for (;;) {
! 2237: if (*sc->sci_bus_csr & SCI_BUS_REQ)
! 2238: break;
! 2239: if (--timo <= 0) {
! 2240: if (sc->sc_state & NCR_ABORTING) {
! 2241: printf("%s: no REQ while aborting, reset\n",
! 2242: sc->sc_dev.dv_xname);
! 2243: act_flags |= ACT_RESET_BUS;
! 2244: goto do_actions;
! 2245: }
! 2246: printf("%s: no REQ for next phase, abort\n",
! 2247: sc->sc_dev.dv_xname);
! 2248: sc->sc_state |= NCR_ABORTING;
! 2249: ncr_sched_msgout(sc, SEND_ABORT);
! 2250: goto next_phase;
! 2251: }
! 2252: delay(100);
! 2253: }
! 2254:
! 2255: phase = SCI_BUS_PHASE(*sc->sci_bus_csr);
! 2256: NCR_TRACE("machine: phase=%s\n",
! 2257: (long) phase_names[phase & 7]);
! 2258:
! 2259: /*
! 2260: * We assume that the device knows what it's doing,
! 2261: * so any phase is good.
! 2262: */
! 2263:
! 2264: #if 0
! 2265: /*
! 2266: * XXX: Do not ACK the phase yet! do it later...
! 2267: * XXX: ... each phase routine does that itself.
! 2268: * In particular, DMA needs it done LATER.
! 2269: */
! 2270: *sc->sci_tcmd = phase; /* acknowledge phase change */
! 2271: #endif
! 2272:
! 2273: switch (phase) {
! 2274:
! 2275: case PHASE_DATA_OUT:
! 2276: case PHASE_DATA_IN:
! 2277: act_flags = ncr5380_data_xfer(sc, phase);
! 2278: break;
! 2279:
! 2280: case PHASE_COMMAND:
! 2281: act_flags = ncr5380_command(sc);
! 2282: break;
! 2283:
! 2284: case PHASE_STATUS:
! 2285: act_flags = ncr5380_status(sc);
! 2286: break;
! 2287:
! 2288: case PHASE_MSG_OUT:
! 2289: act_flags = ncr5380_msg_out(sc);
! 2290: break;
! 2291:
! 2292: case PHASE_MSG_IN:
! 2293: act_flags = ncr5380_msg_in(sc);
! 2294: break;
! 2295:
! 2296: default:
! 2297: printf("ncr5380_machine: Unexpected phase 0x%x\n", phase);
! 2298: sc->sc_state |= NCR_ABORTING;
! 2299: ncr_sched_msgout(sc, SEND_ABORT);
! 2300: goto next_phase;
! 2301:
! 2302: } /* switch */
! 2303: sc->sc_prevphase = phase;
! 2304:
! 2305: do_actions:
! 2306: __asm("_ncr5380_actions:");
! 2307:
! 2308: if (act_flags & ACT_WAIT_DMA) {
! 2309: act_flags &= ~ACT_WAIT_DMA;
! 2310: /* Wait for DMA to complete (polling, or interrupt). */
! 2311: if ((sr->sr_flags & SR_IMMED) == 0) {
! 2312: NCR_TRACE("machine: wait for DMA intr.\n", 0);
! 2313: return; /* will resume at dma_done */
! 2314: }
! 2315: /* Busy-wait for it to finish. */
! 2316: NCR_TRACE("machine: dma_poll, dh=0x%x\n",
! 2317: (long) sr->sr_dma_hand);
! 2318: (*sc->sc_dma_poll)(sc);
! 2319: dma_done:
! 2320: /* Return here after interrupt. */
! 2321: if (sr->sr_flags & SR_OVERDUE)
! 2322: sc->sc_state |= NCR_ABORTING;
! 2323: NCR_TRACE("machine: dma_stop, dh=0x%x\n",
! 2324: (long) sr->sr_dma_hand);
! 2325: (*sc->sc_dma_stop)(sc);
! 2326: SCI_CLR_INTR(sc); /* XXX */
! 2327: /*
! 2328: * While DMA is running we can not touch the SBC,
! 2329: * so various places just set NCR_ABORTING and
! 2330: * expect us the "kick it" when DMA is done.
! 2331: */
! 2332: if (sc->sc_state & NCR_ABORTING) {
! 2333: ncr_sched_msgout(sc, SEND_ABORT);
! 2334: }
! 2335: }
! 2336:
! 2337: /*
! 2338: * Check for parity error.
! 2339: * XXX - better place to check?
! 2340: */
! 2341: if (*(sc->sci_csr) & SCI_CSR_PERR) {
! 2342: printf("%s: parity error!\n", sc->sc_dev.dv_xname);
! 2343: /* XXX: sc->sc_state |= NCR_ABORTING; */
! 2344: ncr_sched_msgout(sc, SEND_PARITY_ERROR);
! 2345: }
! 2346:
! 2347: if (act_flags == ACT_CONTINUE)
! 2348: goto next_phase;
! 2349: /* All other actions "break" from the loop. */
! 2350:
! 2351: NCR_TRACE("machine: act_flags=0x%x\n", act_flags);
! 2352:
! 2353: if (act_flags & ACT_RESET_BUS) {
! 2354: act_flags |= ACT_CMD_DONE;
! 2355: /*
! 2356: * Reset the SCSI bus, usually due to a timeout.
! 2357: * The error code XS_TIMEOUT allows retries.
! 2358: */
! 2359: sc->sc_state |= NCR_ABORTING;
! 2360: printf("%s: reset SCSI bus for TID=%d LUN=%d\n",
! 2361: sc->sc_dev.dv_xname, sr->sr_target, sr->sr_lun);
! 2362: ncr5380_reset_scsibus(sc);
! 2363: }
! 2364:
! 2365: if (act_flags & ACT_CMD_DONE) {
! 2366: act_flags |= ACT_DISCONNECT;
! 2367: /* Need to call scsi_done() */
! 2368: /* XXX: from the aic6360 driver, but why? */
! 2369: if (sc->sc_datalen < 0) {
! 2370: printf("%s: %d extra bytes from %d:%d\n",
! 2371: sc->sc_dev.dv_xname, -sc->sc_datalen,
! 2372: sr->sr_target, sr->sr_lun);
! 2373: sc->sc_datalen = 0;
! 2374: }
! 2375: xs->resid = sc->sc_datalen;
! 2376: /* Note: this will clear sc_current */
! 2377: NCR_TRACE("machine: call done, cur=0x%x\n", (long)sr);
! 2378: ncr5380_done(sc);
! 2379: }
! 2380:
! 2381: if (act_flags & ACT_DISCONNECT) {
! 2382: /*
! 2383: * The device has dropped BSY (or will soon).
! 2384: * We have to wait here for BSY to drop, otherwise
! 2385: * the next command may decide we need a bus reset.
! 2386: */
! 2387: timo = ncr5380_wait_req_timo; /* XXX */
! 2388: for (;;) {
! 2389: if (!SCI_BUSY(sc))
! 2390: goto busfree;
! 2391: if (--timo <= 0)
! 2392: break;
! 2393: delay(2);
! 2394: }
! 2395: /* Device is sitting on the bus! */
! 2396: printf("%s: Target %d LUN %d stuck busy, resetting...\n",
! 2397: sc->sc_dev.dv_xname, sr->sr_target, sr->sr_lun);
! 2398: ncr5380_reset_scsibus(sc);
! 2399: busfree:
! 2400: NCR_TRACE("machine: discon, waited %d\n",
! 2401: ncr5380_wait_req_timo - timo);
! 2402:
! 2403: *sc->sci_icmd = 0;
! 2404: *sc->sci_mode = 0;
! 2405: *sc->sci_tcmd = PHASE_INVALID;
! 2406: *sc->sci_sel_enb = 0;
! 2407: SCI_CLR_INTR(sc);
! 2408: *sc->sci_sel_enb = 0x80;
! 2409:
! 2410: if ((act_flags & ACT_CMD_DONE) == 0) {
! 2411: __asm("_ncr5380_disconnected:");
! 2412: NCR_TRACE("machine: discon, cur=0x%x\n", (long)sr);
! 2413: }
! 2414:
! 2415: /*
! 2416: * We may be here due to a disconnect message,
! 2417: * in which case we did NOT call ncr5380_done,
! 2418: * and we need to clear sc_current.
! 2419: */
! 2420: sc->sc_state = NCR_IDLE;
! 2421: sc->sc_current = NULL;
! 2422:
! 2423: /* Paranoia: clear everything. */
! 2424: sc->sc_dataptr = NULL;
! 2425: sc->sc_datalen = 0;
! 2426: sc->sc_prevphase = PHASE_INVALID;
! 2427: sc->sc_msgpriq = 0;
! 2428: sc->sc_msgoutq = 0;
! 2429: sc->sc_msgout = 0;
! 2430:
! 2431: /* Our caller will re-enable interrupts. */
! 2432: }
! 2433: }
! 2434:
! 2435:
! 2436: #ifdef NCR5380_DEBUG
! 2437:
! 2438: static void
! 2439: ncr5380_show_scsi_cmd(xs)
! 2440: struct scsi_xfer *xs;
! 2441: {
! 2442: u_char *b = (u_char *) xs->cmd;
! 2443: int i = 0;
! 2444:
! 2445: if ( ! ( xs->flags & SCSI_RESET ) ) {
! 2446: printf("si(%d:%d:%d)-",
! 2447: xs->sc_link->scsibus, xs->sc_link->target,
! 2448: xs->sc_link->lun);
! 2449: while (i < xs->cmdlen) {
! 2450: if (i) printf(",");
! 2451: printf("%x",b[i++]);
! 2452: }
! 2453: printf("-\n");
! 2454: } else {
! 2455: printf("si(%d:%d:%d)-RESET-\n",
! 2456: xs->sc_link->scsibus, xs->sc_link->target,
! 2457: xs->sc_link->lun);
! 2458: }
! 2459: }
! 2460:
! 2461:
! 2462: static void
! 2463: ncr5380_show_sense(xs)
! 2464: struct scsi_xfer *xs;
! 2465: {
! 2466: u_char *b = (u_char *)&xs->sense;
! 2467: int i;
! 2468:
! 2469: printf("sense:");
! 2470: for (i = 0; i < sizeof(xs->sense); i++)
! 2471: printf(" %02x", b[i]);
! 2472: printf("\n");
! 2473: }
! 2474:
! 2475: int ncr5380_traceidx = 0;
! 2476:
! 2477: #define TRACE_MAX 1024
! 2478: struct trace_ent {
! 2479: char *msg;
! 2480: long val;
! 2481: } ncr5380_tracebuf[TRACE_MAX];
! 2482:
! 2483: void
! 2484: ncr5380_trace(msg, val)
! 2485: char *msg;
! 2486: long val;
! 2487: {
! 2488: register struct trace_ent *tr;
! 2489: register int s;
! 2490:
! 2491: s = splbio();
! 2492:
! 2493: tr = &ncr5380_tracebuf[ncr5380_traceidx];
! 2494:
! 2495: ncr5380_traceidx++;
! 2496: if (ncr5380_traceidx >= TRACE_MAX)
! 2497: ncr5380_traceidx = 0;
! 2498:
! 2499: tr->msg = msg;
! 2500: tr->val = val;
! 2501:
! 2502: splx(s);
! 2503: }
! 2504:
! 2505: #ifdef DDB
! 2506: void
! 2507: ncr5380_clear_trace()
! 2508: {
! 2509: ncr5380_traceidx = 0;
! 2510: bzero((char *) ncr5380_tracebuf, sizeof(ncr5380_tracebuf));
! 2511: }
! 2512:
! 2513: void
! 2514: ncr5380_show_trace()
! 2515: {
! 2516: struct trace_ent *tr;
! 2517: int idx;
! 2518:
! 2519: idx = ncr5380_traceidx;
! 2520: do {
! 2521: tr = &ncr5380_tracebuf[idx];
! 2522: idx++;
! 2523: if (idx >= TRACE_MAX)
! 2524: idx = 0;
! 2525: if (tr->msg)
! 2526: db_printf(tr->msg, tr->val);
! 2527: } while (idx != ncr5380_traceidx);
! 2528: }
! 2529:
! 2530: void
! 2531: ncr5380_show_req(sr)
! 2532: struct sci_req *sr;
! 2533: {
! 2534: struct scsi_xfer *xs = sr->sr_xs;
! 2535:
! 2536: db_printf("TID=%d ", sr->sr_target);
! 2537: db_printf("LUN=%d ", sr->sr_lun);
! 2538: db_printf("dh=%p ", sr->sr_dma_hand);
! 2539: db_printf("dptr=%p ", sr->sr_dataptr);
! 2540: db_printf("dlen=0x%x ", sr->sr_datalen);
! 2541: db_printf("flags=%d ", sr->sr_flags);
! 2542: db_printf("stat=%d ", sr->sr_status);
! 2543:
! 2544: if (xs == NULL) {
! 2545: db_printf("(xs=NULL)\n");
! 2546: return;
! 2547: }
! 2548: db_printf("\n");
! 2549: #ifdef SCSIDEBUG
! 2550: show_scsi_xs(xs);
! 2551: #else
! 2552: db_printf("xs=%p\n", xs);
! 2553: #endif
! 2554: }
! 2555:
! 2556: void
! 2557: ncr5380_show_state()
! 2558: {
! 2559: struct ncr5380_softc *sc;
! 2560: struct sci_req *sr;
! 2561: int i, j, k;
! 2562:
! 2563: sc = ncr5380_debug_sc;
! 2564:
! 2565: if (sc == NULL) {
! 2566: db_printf("ncr5380_debug_sc == NULL\n");
! 2567: return;
! 2568: }
! 2569:
! 2570: db_printf("sc_ncmds=%d\n", sc->sc_ncmds);
! 2571: k = -1; /* which is current? */
! 2572: for (i = 0; i < SCI_OPENINGS; i++) {
! 2573: sr = &sc->sc_ring[i];
! 2574: if (sr->sr_xs) {
! 2575: if (sr == sc->sc_current)
! 2576: k = i;
! 2577: db_printf("req %d: (sr=%p)", i, (long)sr);
! 2578: ncr5380_show_req(sr);
! 2579: }
! 2580: }
! 2581: db_printf("sc_rr=%d, current=%d\n", sc->sc_rr, k);
! 2582:
! 2583: db_printf("Active request matrix:\n");
! 2584: for(i = 0; i < 8; i++) { /* targets */
! 2585: for (j = 0; j < 8; j++) { /* LUN */
! 2586: sr = sc->sc_matrix[i][j];
! 2587: if (sr) {
! 2588: db_printf("TID=%d LUN=%d sr=0x%x\n", i, j, (long)sr);
! 2589: }
! 2590: }
! 2591: }
! 2592:
! 2593: db_printf("sc_state=0x%x\n", sc->sc_state);
! 2594: db_printf("sc_current=%p\n", sc->sc_current);
! 2595: db_printf("sc_dataptr=%p\n", sc->sc_dataptr);
! 2596: db_printf("sc_datalen=0x%x\n", sc->sc_datalen);
! 2597:
! 2598: db_printf("sc_prevphase=%d\n", sc->sc_prevphase);
! 2599: db_printf("sc_msgpriq=0x%x\n", sc->sc_msgpriq);
! 2600: }
! 2601:
! 2602: #endif /* DDB */
! 2603: #endif /* NCR5380_DEBUG */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ncr5380sbc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic