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