![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / sundev|
Return to sc.c CVS log | Up to [Research Unix] / researchv9 / sys / sundev |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)sc.c 1.1 86/02/03 Copyr 1985 Sun Micro"; ! 3: #endif ! 4: ! 5: /* ! 6: * Copyright (c) 1985 by Sun Microsystems, Inc. ! 7: */ ! 8: ! 9: #include "sc.h" ! 10: ! 11: #if NSC > 0 ! 12: /* ! 13: * Generic scsi routines. ! 14: */ ! 15: ! 16: #include "../h/param.h" ! 17: #include "../h/systm.h" ! 18: #include "../h/dk.h" ! 19: #include "../h/buf.h" ! 20: #include "../h/conf.h" ! 21: #include "../h/dir.h" ! 22: #include "../h/user.h" ! 23: #include "../h/map.h" ! 24: #include "../h/vmmac.h" ! 25: /* ! 26: *#include "../h/ioctl.h" ! 27: *#include "../h/uio.h" ! 28: *#include "../h/kernel.h" ! 29: */ ! 30: #include "../h/dkbad.h" ! 31: ! 32: #include "../machine/pte.h" ! 33: #include "../machine/psl.h" ! 34: #include "../machine/mmu.h" ! 35: #include "../machine/cpu.h" ! 36: #include "../machine/scb.h" ! 37: ! 38: #include "../sun/dklabel.h" ! 39: #include "../sun/dkio.h" ! 40: ! 41: #include "../sundev/mbvar.h" ! 42: #include "../sundev/screg.h" ! 43: #include "../sundev/sireg.h" ! 44: #include "../sundev/scsi.h" ! 45: ! 46: struct scsi_ctlr scctlrs[NSC]; ! 47: #define SCNUM(sc) (sc - scctlrs) ! 48: ! 49: int scprobe(), scslave(), scattach(), scgo(), scdone(), scpoll(); ! 50: int scustart(), scstart(), sc_cmd(), sc_getstatus(), sc_cmdwait(); ! 51: int sc_off(), sc_reset(), sc_dmacnt(); ! 52: ! 53: struct mb_ctlr *scinfo[NSC]; ! 54: extern struct mb_device *sdinfo[]; ! 55: struct mb_driver scdriver = { ! 56: scprobe, scslave, scattach, scgo, scdone, scpoll, ! 57: sizeof (struct scsi_ha_reg), "sd", sdinfo, "sc", scinfo, MDR_BIODMA, ! 58: }; ! 59: ! 60: /* routines available to devices for mainbus scsi host adaptor */ ! 61: struct scsi_ctlr_subr scsubr = { ! 62: scustart, scstart, scdone, sc_cmd, sc_getstatus, sc_cmdwait, ! 63: sc_off, sc_reset, sc_dmacnt, scgo, ! 64: }; ! 65: ! 66: extern int scsi_debug; ! 67: extern int scsi_ntype; ! 68: extern struct scsi_unit_subr scsi_unit_subr[]; ! 69: ! 70: /* ! 71: * Determine existence of SCSI host adapter. ! 72: */ ! 73: scprobe(reg, ctlr) ! 74: register struct scsi_ha_reg *reg; ! 75: register int ctlr; ! 76: { ! 77: register struct scsi_ctlr *c; ! 78: ! 79: /* probe for different scsi host adaptor interfaces */ ! 80: c = &scctlrs[ctlr]; ! 81: if (peekc((char *)®->dma_count) == -1) { ! 82: return (0); ! 83: } ! 84: reg->dma_count = 0x6789; ! 85: if (reg->dma_count != 0x6789) { ! 86: return (0); ! 87: } ! 88: ! 89: /* allocate memory for sense information */ ! 90: c->c_sense = (struct scsi_sense *) rmalloc(iopbmap, ! 91: (long) sizeof (struct scsi_sense)); ! 92: if (c->c_sense == NULL) { ! 93: printf("scprobe: no iopb memory for sense.\n"); ! 94: return (0); ! 95: } ! 96: ! 97: /* init controller information */ ! 98: c->c_flags = SCSI_PRESENT; ! 99: c->c_har = reg; ! 100: c->c_ss = &scsubr; ! 101: sc_reset(c); ! 102: return (sizeof (struct scsi_ha_reg)); ! 103: } ! 104: ! 105: /* ! 106: * See if a slave exists. ! 107: * Since it may exist but be powered off, we always say yes. ! 108: */ ! 109: /*ARGSUSED*/ ! 110: scslave(md, reg) ! 111: struct mb_device *md; ! 112: register struct scsi_ha_reg *reg; ! 113: { ! 114: register struct scsi_unit *un; ! 115: register int type; ! 116: ! 117: /* ! 118: * This kludge allows autoconfig to print out "sd" for ! 119: * disks and "st" for tapes. The problem is that there ! 120: * is only one md_driver for scsi devices. ! 121: */ ! 122: type = TYPE(md->md_flags); ! 123: if (type >= scsi_ntype) { ! 124: panic("scslave: unknown type in md_flags"); ! 125: } ! 126: ! 127: /* link unit to its controller */ ! 128: un = (struct scsi_unit *)(*scsi_unit_subr[type].ss_unit_ptr)(md); ! 129: if (un == 0) { ! 130: panic("scslave: md_flags scsi type not configured in\n"); ! 131: } ! 132: un->un_c = &scctlrs[md->md_ctlr]; ! 133: md->md_driver->mdr_dname = scsi_unit_subr[type].ss_devname; ! 134: return (1); ! 135: } ! 136: ! 137: /* ! 138: * Attach device (boot time). ! 139: */ ! 140: scattach(md) ! 141: register struct mb_device *md; ! 142: { ! 143: register struct mb_ctlr *mc = md->md_mc; ! 144: register struct scsi_ctlr *c = &scctlrs[md->md_ctlr]; ! 145: register int type = TYPE(md->md_flags); ! 146: ! 147: if (type >= scsi_ntype) { ! 148: panic("scattach: unknown type in md_flags"); ! 149: } ! 150: (*scsi_unit_subr[type].ss_attach)(md); ! 151: ! 152: /* ! 153: * Initialize interrupt register ! 154: */ ! 155: if (mc->mc_intr) { ! 156: /* set up for vectored interrupts - we will pass ctlr ptr */ ! 157: c->c_har->intvec = mc->mc_intr->v_vec; ! 158: *(mc->mc_intr->v_vptr) = (int)c; ! 159: } else { ! 160: /* use auto-vectoring */ ! 161: c->c_har->intvec = AUTOBASE + mc->mc_intpri; ! 162: } ! 163: } ! 164: ! 165: /* ! 166: * SCSI unit start routine. ! 167: * Called by SCSI device drivers. ! 168: */ ! 169: scustart(un) ! 170: register struct scsi_unit *un; ! 171: { ! 172: register struct buf *dp; ! 173: register struct mb_ctlr *mc; ! 174: ! 175: mc = un->un_mc; ! 176: dp = &un->un_utab; ! 177: /* ! 178: * Caller guarantees: dp->b_actf != NULL && dp->b_active == 0 ! 179: */ ! 180: /* ! 181: * Put device on ready queue for bus. ! 182: */ ! 183: if (mc->mc_tab.b_actf == NULL) { ! 184: mc->mc_tab.b_actf = dp; ! 185: } else { ! 186: mc->mc_tab.b_actl->b_forw = dp; ! 187: } ! 188: dp->b_forw = NULL; ! 189: mc->mc_tab.b_actl = dp; ! 190: dp->b_active = 1; ! 191: dp->b_un.b_addr = (caddr_t) un; ! 192: } ! 193: ! 194: /* ! 195: * Set up a transfer for the bus. ! 196: */ ! 197: scstart(un) ! 198: register struct scsi_unit *un; ! 199: { ! 200: register struct mb_ctlr *mc; ! 201: register struct buf *bp, *dp; ! 202: ! 203: mc = un->un_mc; ! 204: dp = mc->mc_tab.b_actf; /* != NULL guaranteed by caller */ ! 205: un = (struct scsi_unit *) dp->b_un.b_addr; ! 206: bp = dp->b_actf; ! 207: for (;;) { ! 208: if (bp == NULL) { /* no more blocks for this device */ ! 209: un->un_utab.b_active = 0; ! 210: dp = mc->mc_tab.b_actf = dp->b_forw; ! 211: if (dp == NULL) { /* no more devices for this ctlr */ ! 212: return; ! 213: } ! 214: un = (struct scsi_unit *) dp->b_un.b_addr; ! 215: bp = dp->b_actf; ! 216: } else { ! 217: if ((*un->un_ss->ss_start)(bp, un)) { ! 218: mc->mc_tab.b_active = 1; ! 219: un->un_c->c_un = un; ! 220: if (bp == &un->un_sbuf && ! 221: ((un->un_flags & SC_UNF_DVMA) == 0)) { ! 222: scgo(mc); ! 223: } else { ! 224: (void) mbgo(mc); ! 225: } ! 226: return; ! 227: } ! 228: dp->b_actf = bp = bp->av_forw; ! 229: } ! 230: } ! 231: } ! 232: ! 233: /* ! 234: * Start up a transfer ! 235: * Called via mbgo after buffer is in memory ! 236: */ ! 237: scgo(mc) ! 238: register struct mb_ctlr *mc; ! 239: { ! 240: register struct scsi_unit *un; ! 241: register struct scsi_ctlr *c; ! 242: register struct buf *bp, *dp; ! 243: register int unit; ! 244: ! 245: c = &scctlrs[mc->mc_ctlr]; ! 246: dp = mc->mc_tab.b_actf; ! 247: if (dp == NULL || dp->b_actf == NULL) { ! 248: panic("scgo queueing error 1"); ! 249: } ! 250: bp = dp->b_actf; ! 251: un = c->c_un; ! 252: if (dp != &un->un_utab) { ! 253: panic("scgo queueing error 2"); ! 254: } ! 255: un->un_baddr = MBI_ADDR(mc->mc_mbinfo); ! 256: if ((unit = un->un_md->md_dk) >= 0) { ! 257: dk_busy |= 1<<unit; ! 258: dk_xfer[unit]++; ! 259: dk_wds[unit] += bp->b_bcount >> 6; ! 260: } ! 261: (*un->un_ss->ss_mkcdb)(c, un); ! 262: if (sc_cmd(c, un, 1) == 0) { ! 263: (*un->un_ss->ss_intr)(c, 0, SE_RETRYABLE); ! 264: sc_off(un); ! 265: } ! 266: } ! 267: ! 268: /* ! 269: * Pass a command to the SCSI bus. ! 270: */ ! 271: sc_cmd(c, un, intr) ! 272: register struct scsi_ctlr *c; ! 273: register struct scsi_unit *un; ! 274: register int intr; ! 275: { ! 276: register u_char *cp; ! 277: register int i, errct; ! 278: register u_short icr_mode; ! 279: ! 280: errct = 0; ! 281: do { ! 282: /* make sure scsi bus is not continuously busy */ ! 283: for (i = WAIT_COUNT; i > 0; i--) { ! 284: if (!(c->c_har->icr & ICR_BUSY)) ! 285: break; ! 286: DELAY(10); ! 287: } ! 288: if (i == 0) { ! 289: sc_reset(c); ! 290: return (0); ! 291: } ! 292: ! 293: /* select target and wait for response */ ! 294: c->c_har->data = (1 << un->un_target) | HOST_ADDR; ! 295: c->c_har->icr = ICR_SELECT; ! 296: ! 297: /* target never responded to selection */ ! 298: if (sc_wait(c, ICR_BUSY) == 0) { ! 299: c->c_har->data = 0; ! 300: c->c_har->icr = 0; ! 301: return (0); ! 302: } ! 303: /* ! 304: * may need to map between the CPU's kernel context address ! 305: * and the device's DVMA bus address ! 306: */ ! 307: c->c_har->dma_addr = un->un_dma_addr; ! 308: c->c_har->dma_count = ~un->un_dma_count; /* hardware is funny */ ! 309: icr_mode = ICR_DMA_ENABLE; ! 310: if (intr) { ! 311: icr_mode |= ICR_INTERRUPT_ENABLE; ! 312: un->un_wantint = 1; ! 313: } ! 314: if (! (un->un_dma_count & 1)) { ! 315: icr_mode |= ICR_WORD_MODE; ! 316: } ! 317: c->c_har->icr = icr_mode; ! 318: cp = (u_char *) &c->c_cdb; ! 319: if (scsi_debug) { ! 320: printf("sc%d: sc_cmd: target %d issuing command ", ! 321: SCNUM(c), un->un_target); ! 322: for (i = 0; i < sizeof (struct scsi_cdb); i++) { ! 323: printf("%x ", *cp++); ! 324: } ! 325: printf("\n"); ! 326: cp = (u_char *) &c->c_cdb; ! 327: } ! 328: for (i = 0; i < sizeof (struct scsi_cdb); i++) { ! 329: if (sc_putbyte(c, ICR_COMMAND, *cp++) == 0) { ! 330: errct++; ! 331: break; ! 332: } ! 333: } ! 334: if (i == sizeof (struct scsi_cdb)) { ! 335: return (1); ! 336: } ! 337: } while (errct < 5); ! 338: printf("sc_cmd: unrecoverable errors\n"); ! 339: return (0); ! 340: } ! 341: ! 342: /* ! 343: * Handle a scsi bus interrupt for the mainbus scsi. ! 344: */ ! 345: scintr(c) ! 346: register struct scsi_ctlr *c; ! 347: { ! 348: register int resid; ! 349: register struct scsi_unit *un; ! 350: ! 351: un = c->c_un; ! 352: if (un->un_wantint == 0) { ! 353: if (c->c_har->icr & ICR_BUS_ERROR) { ! 354: printf("scsi bus error (unwanted interrupt)\n"); ! 355: } else { ! 356: printf("scsi: unwanted interrupt\n"); ! 357: } ! 358: sc_reset(c); ! 359: return; ! 360: } ! 361: un->un_wantint = 0; ! 362: resid = ~c->c_har->dma_count; ! 363: if (c->c_har->icr & ICR_BUS_ERROR) { ! 364: printf("scsi bus error. icr %x resid %d\n", ! 365: c->c_har->icr, resid); ! 366: sc_reset(c); ! 367: (*c->c_un->un_ss->ss_intr)(c, resid, SE_FATAL); ! 368: return; ! 369: } ! 370: if (c->c_har->icr & ICR_ODD_LENGTH) { ! 371: if ((c->c_cdb.cmd == SC_READ) || ! 372: (c->c_cdb.cmd == SC_REQUEST_SENSE)) { ! 373: DVMA[un->un_baddr + un->un_dma_count - resid] = ! 374: c->c_har->data; ! 375: resid--; ! 376: } else if (c->c_cdb.cmd == SC_WRITE) { ! 377: resid++; ! 378: } else { ! 379: printf("scsi: odd length without xfer\n"); ! 380: } ! 381: } ! 382: if (resid < 0) { ! 383: panic("scsi resid"); ! 384: } ! 385: if (sc_getstatus(c->c_un, 0) == 0) { ! 386: (*c->c_un->un_ss->ss_intr)(c, resid, SE_RETRYABLE); ! 387: } else { ! 388: (*c->c_un->un_ss->ss_intr)(c, resid, SE_NO_ERROR); ! 389: } ! 390: } ! 391: ! 392: /* ! 393: * Handle a polling SCSI bus interrupt. ! 394: */ ! 395: scpoll() ! 396: { ! 397: register struct scsi_ctlr *c; ! 398: register int serviced = 0; ! 399: ! 400: for (c = scctlrs; c < &scctlrs[NSC]; c++) { ! 401: if ((c->c_flags & SCSI_PRESENT) == 0) ! 402: continue; ! 403: if ((c->c_har->icr & (ICR_INTERRUPT_REQUEST | ICR_BUS_ERROR)) ! 404: == 0) { ! 405: continue; ! 406: } ! 407: serviced = 1; ! 408: scintr(c); ! 409: } ! 410: return (serviced); ! 411: } ! 412: ! 413: /* ! 414: * Clean up queues, free resources, and start next I/O ! 415: * all done after I/O finishes ! 416: * Called by mbdone after moving read data from Mainbus ! 417: */ ! 418: scdone(mc) ! 419: register struct mb_ctlr *mc; ! 420: { ! 421: register struct buf *bp, *dp; ! 422: register struct scsi_unit *un; ! 423: register struct scsi_ctlr *c; ! 424: ! 425: bp = mc->mc_tab.b_actf->b_actf; ! 426: c = &scctlrs[mc->mc_ctlr]; ! 427: un = c->c_un; ! 428: ! 429: /* advance controller queue */ ! 430: dp = mc->mc_tab.b_actf; ! 431: mc->mc_tab.b_active = 0; ! 432: mc->mc_tab.b_actf = dp->b_forw; ! 433: ! 434: /* advance unit queue */ ! 435: dp->b_active = 0; ! 436: dp->b_actf = bp->av_forw; ! 437: ! 438: iodone(bp); ! 439: ! 440: /* start next I/O on unit */ ! 441: if (dp->b_actf) ! 442: scustart(un); ! 443: ! 444: /* start next I/O on controller */ ! 445: if (mc->mc_tab.b_actf && mc->mc_tab.b_active == 0) ! 446: scstart(un); ! 447: } ! 448: ! 449: /*ARGSUSED*/ ! 450: sc_off(un) ! 451: struct scsi_unit *un; ! 452: { ! 453: ! 454: #ifdef notdef ! 455: /* if done to root real bad things happen... */ ! 456: un->un_present = 0; ! 457: printf("scsi unit %d/%d offline\n", un->un_target, un->un_lun); ! 458: if (un->un_md->md_dk > 0) { ! 459: dk_mspw[un->un_md->md_dk]=0; ! 460: } ! 461: #endif ! 462: } ! 463: ! 464: /* ! 465: * Wait for a condition on the scsi bus. ! 466: */ ! 467: sc_wait(c, cond) ! 468: register struct scsi_ctlr *c; ! 469: { ! 470: register struct scsi_ha_reg *har = c->c_har; ! 471: register int i, icr; ! 472: ! 473: for (i = 0; i < WAIT_COUNT; i++) { ! 474: icr = har->icr; ! 475: if ((icr & cond) == cond) { ! 476: return (1); ! 477: } ! 478: if (icr & ICR_BUS_ERROR) { ! 479: break; ! 480: } ! 481: DELAY(10); ! 482: } ! 483: return (0); ! 484: } ! 485: ! 486: /* ! 487: * Wait for the completion of a scsi command. ! 488: */ ! 489: sc_cmdwait(c) ! 490: register struct scsi_ctlr *c; ! 491: { ! 492: if (sc_wait(c, ICR_INTERRUPT_REQUEST) == 0) { ! 493: sc_reset(c); ! 494: return(0); ! 495: } else { ! 496: return(1); ! 497: } ! 498: } ! 499: ! 500: /* ! 501: * Put a byte into the scsi command register. ! 502: */ ! 503: sc_putbyte(c, bits, data) ! 504: register struct scsi_ctlr *c; ! 505: register u_short bits; ! 506: register u_char data; ! 507: { ! 508: register struct scsi_ha_reg *har = c->c_har; ! 509: register int icr; ! 510: ! 511: if (sc_wait(c, ICR_REQUEST) == 0) { ! 512: sc_reset(c); ! 513: return (0); ! 514: } ! 515: icr = har->icr; ! 516: if ((icr & ICR_BITS) != bits) { ! 517: #ifdef SCSI_DEBUG ! 518: printf("sc_putbyte error.\n"); ! 519: sc_pr_icr("icr is ", icr); ! 520: sc_pr_icr("waiting for", bits); ! 521: #endif SCSI_DEBUG ! 522: sc_reset(c); ! 523: return (0); ! 524: } ! 525: har->cmd_stat = data; ! 526: return (1); ! 527: } ! 528: ! 529: /* ! 530: * Get a byte from the scsi command/status register. ! 531: */ ! 532: sc_getbyte(c, bits) ! 533: register struct scsi_ctlr *c; ! 534: { ! 535: register struct scsi_ha_reg *har = c->c_har; ! 536: register int icr; ! 537: ! 538: if (sc_wait(c, ICR_REQUEST) == 0) { ! 539: sc_reset(c); ! 540: return (-1); ! 541: } ! 542: icr = har->icr; ! 543: if ((icr & ICR_BITS) != bits) { ! 544: if (bits == ICR_STATUS) { ! 545: return (-1); /* no more status */ ! 546: } ! 547: #ifdef SCSI_DEBUG ! 548: printf("sc_getbyte error.\n"); ! 549: sc_pr_icr("icr is ", icr); ! 550: sc_pr_icr("waiting for", bits); ! 551: #endif SCSI_DEBUG ! 552: sc_reset(c); ! 553: return (-1); ! 554: } ! 555: return (har->cmd_stat); ! 556: } ! 557: ! 558: sc_dmacnt(c) ! 559: register struct scsi_ctlr *c; ! 560: { ! 561: return (~c->c_har->dma_count); ! 562: } ! 563: ! 564: sc_reset(c) ! 565: register struct scsi_ctlr *c; ! 566: { ! 567: register struct scsi_ha_reg *har = c->c_har; ! 568: ! 569: har->icr = ICR_RESET; ! 570: DELAY(50); ! 571: har->icr = 0; ! 572: #ifdef SCSI_DEBUG ! 573: printf("scsi host adapter reset\n"); ! 574: #endif SCSI_DEBUG ! 575: } ! 576: ! 577: /* ! 578: * Get status bytes from scsi bus. ! 579: */ ! 580: sc_getstatus(un, recurse) ! 581: register struct scsi_unit *un; ! 582: { ! 583: register struct scsi_ctlr *c = un->un_c; ! 584: register u_char *cp = (u_char *)&c->c_scb; ! 585: struct scsi_cdb save_cdb; ! 586: struct scsi_scb save_scb; ! 587: register int i; ! 588: register int b; ! 589: register int save_dma_addr; ! 590: register int save_dma_count; ! 591: register int save_reg_dma_count; ! 592: int resid; ! 593: short retval = 1; ! 594: int s; ! 595: ! 596: /* get all the status bytes */ ! 597: for (i = 0;;) { ! 598: b = sc_getbyte(c, ICR_STATUS); ! 599: if (b < 0) { ! 600: break; ! 601: } ! 602: if (i < STATUS_LEN) { ! 603: cp[i++] = b; ! 604: } ! 605: } ! 606: ! 607: /* get command complete message */ ! 608: b = sc_getbyte(c, ICR_MESSAGE_IN); ! 609: if (b != SC_COMMAND_COMPLETE) { ! 610: if (scsi_debug) { ! 611: printf("Invalid SCSI message: %x\n", b); ! 612: printf("Status bytes:"); ! 613: for (b = 0; b < i; b++) { ! 614: printf(" %x", cp[b]); ! 615: } ! 616: printf("\n"); ! 617: } ! 618: return (0); ! 619: } ! 620: if (scsi_debug) { ! 621: printf("sc%d: sc_getstatus: Got status ", SCNUM(c)); ! 622: for (b = 0; b < i; b++) { ! 623: printf(" %x", cp[b]); ! 624: } ! 625: printf("\n"); ! 626: } ! 627: if (c->c_scb.busy) { ! 628: return (0); ! 629: } ! 630: ! 631: /* check for sense data */ ! 632: if (c->c_scb.chk) { ! 633: if (recurse) { ! 634: printf("scsi: chk on sense: invalid\n"); ! 635: return (0); ! 636: } ! 637: ! 638: /* save information while we get sense */ ! 639: save_cdb = c->c_cdb; ! 640: save_scb = c->c_scb; ! 641: save_dma_addr = un->un_dma_addr; ! 642: save_dma_count = un->un_dma_count; ! 643: save_reg_dma_count = c->c_har->dma_count; ! 644: ! 645: /* set up for getting sense */ ! 646: c->c_cdb.cmd = SC_REQUEST_SENSE; ! 647: c->c_cdb.lun = un->un_lun; ! 648: cdbaddr(&c->c_cdb, 0); ! 649: c->c_cdb.count = sizeof(struct scsi_sense); ! 650: un->un_dma_addr = (int)c->c_sense - (int)DVMA; ! 651: un->un_dma_count = sizeof(struct scsi_sense); ! 652: ! 653: /* get sense */ ! 654: if ((s=0),sc_cmd(c, un, 0) == 0 || ! 655: (s=1),sc_cmdwait(c) == 0 || ! 656: (s=2),sc_getstatus(un, 1) == 0) { ! 657: printf("scsi: cannot get sense %d\n", s); ! 658: sc_off(un); ! 659: retval = 0; ! 660: } ! 661: resid = ~c->c_har->dma_count; ! 662: if (resid < 0) { ! 663: printf("scsi: dma_count %x resid %d", ! 664: c->c_har->dma_count, resid); ! 665: panic("scsi sense count too big."); ! 666: } ! 667: ! 668: /* restore pre sense information */ ! 669: c->c_cdb = save_cdb; ! 670: c->c_scb = save_scb; ! 671: un->un_dma_addr = save_dma_addr; ! 672: un->un_dma_count = save_dma_count; ! 673: c->c_har->dma_count = save_reg_dma_count; ! 674: } ! 675: return (retval); ! 676: } ! 677: ! 678: #ifdef SCSI_DEBUG ! 679: /* ! 680: * Print out the scsi host adapter interface control register. ! 681: */ ! 682: sc_pr_icr(cp, i) ! 683: register char *cp; ! 684: { ! 685: printf("\t%s: %x ", cp, i); ! 686: if (i & ICR_PARITY_ERROR) ! 687: printf("Parity err "); ! 688: if (i & ICR_BUS_ERROR) ! 689: printf("Bus err "); ! 690: if (i & ICR_ODD_LENGTH) ! 691: printf("Odd len "); ! 692: if (i & ICR_INTERRUPT_REQUEST) ! 693: printf("Int req "); ! 694: if (i & ICR_REQUEST) { ! 695: printf("Req "); ! 696: switch (i & ICR_BITS) { ! 697: case 0: ! 698: printf("Data out "); ! 699: break; ! 700: case ICR_INPUT_OUTPUT: ! 701: printf("Data in "); ! 702: break; ! 703: case ICR_COMMAND_DATA: ! 704: printf("Command "); ! 705: break; ! 706: case ICR_COMMAND_DATA | ICR_INPUT_OUTPUT: ! 707: printf("Status "); ! 708: break; ! 709: case ICR_MESSAGE | ICR_COMMAND_DATA: ! 710: printf("Msg out "); ! 711: break; ! 712: case ICR_MESSAGE | ICR_COMMAND_DATA | ICR_INPUT_OUTPUT: ! 713: printf("Msg in "); ! 714: break; ! 715: default: ! 716: printf("DCM: %x ", i & ICR_BITS); ! 717: break; ! 718: } ! 719: } ! 720: if (i & ICR_PARITY) ! 721: printf("Parity "); ! 722: if (i & ICR_BUSY) ! 723: printf("Busy "); ! 724: if (i & ICR_SELECT) ! 725: printf("Sel "); ! 726: if (i & ICR_RESET) ! 727: printf("Reset "); ! 728: if (i & ICR_PARITY_ENABLE) ! 729: printf("Par ena "); ! 730: if (i & ICR_WORD_MODE) ! 731: printf("Word mode "); ! 732: if (i & ICR_DMA_ENABLE) ! 733: printf("Dma ena "); ! 734: if (i & ICR_INTERRUPT_ENABLE) ! 735: printf("Int ena "); ! 736: printf("\n"); ! 737: } ! 738: ! 739: /* ! 740: * Print out status completion block. ! 741: */ ! 742: sc_pr_scb(scbp) ! 743: register struct scsi_scb *scbp; ! 744: { ! 745: register u_char *cp; ! 746: ! 747: cp = (u_char *) scbp; ! 748: printf("scb: %x", cp[0]); ! 749: if (scbp->ext_st1) { ! 750: printf(" %x", cp[1]); ! 751: if (scbp->ext_st2) { ! 752: printf(" %x", cp[2]); ! 753: } ! 754: } ! 755: if (scbp->is) { ! 756: printf(" intermediate status"); ! 757: } ! 758: if (scbp->busy) { ! 759: printf(" busy"); ! 760: } ! 761: if (scbp->cm) { ! 762: printf(" condition met"); ! 763: } ! 764: if (scbp->chk) { ! 765: printf(" check"); ! 766: } ! 767: if (scbp->ext_st1 && scbp->ha_er) { ! 768: printf(" host adapter detected error"); ! 769: } ! 770: printf("\n"); ! 771: } ! 772: #endif SCSI_DEBUG ! 773: #endif NSC > 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.