![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sf.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 sf.c CVS log | Up to [Research Unix] / researchv9 / sys / sundev |
1.1 ! root 1: /* @(#)sf.c 1.1 86/02/03 SMI */ ! 2: ! 3: /* ! 4: * Copyright (c) 1984 by Sun Microsystems, Inc. ! 5: */ ! 6: ! 7: #include "sf.h" ! 8: #if NSF > 0 ! 9: ! 10: /* ! 11: * SCSI driver for SCSI floppy disks. ! 12: */ ! 13: #include "../h/param.h" ! 14: #include "../h/systm.h" ! 15: #include "../h/dk.h" ! 16: #include "../h/buf.h" ! 17: #include "../h/conf.h" ! 18: #include "../h/user.h" ! 19: #include "../h/map.h" ! 20: #include "../h/vmmac.h" ! 21: /* ! 22: *#include "../h/ioctl.h" ! 23: *#include "../h/uio.h" ! 24: *#include "../h/kernel.h" ! 25: */ ! 26: #include "../h/dkbad.h" ! 27: /* ! 28: *#include "../h/vfs.h" ! 29: *#include "../h/vnode.h" ! 30: */ ! 31: #include "../machine/pte.h" ! 32: #include "../machine/psl.h" ! 33: #include "../machine/mmu.h" ! 34: #include "../machine/cpu.h" ! 35: #include "../sun/dklabel.h" ! 36: #include "../sun/dkio.h" ! 37: /*#include "../pcfs/pc_label.h"*/ ! 38: #include "../sundev/mbvar.h" ! 39: #include "../sundev/screg.h" ! 40: #include "../sundev/sireg.h" ! 41: #include "../sundev/scsi.h" ! 42: ! 43: #define MAX_RETRIES 0 ! 44: #define MAX_RESTORES 1 ! 45: ! 46: #define SFUNIT(dev) (minor(dev)) ! 47: #define SFNUM(un) (un - sfunits) ! 48: ! 49: #define b_cylin b_resid ! 50: ! 51: #define BUSY_RETRY 1000 ! 52: ! 53: /* ! 54: * Error message control. ! 55: */ ! 56: #define EL_RETRY 3 ! 57: #define EL_REST 2 ! 58: #define EL_FAIL 1 ! 59: int sferrlvl = EL_REST; ! 60: ! 61: /* ! 62: * sf specific SCSI commands ! 63: */ ! 64: #define SC_INIT_CHARACTERISTICS 0x0c /* initialize drive characteristics */ ! 65: ! 66: extern struct scsi_unit sfunits[]; ! 67: extern struct scsi_unit_subr scsi_unit_subr[]; ! 68: extern struct scsi_floppy sfloppy[]; ! 69: extern int nsfloppy; ! 70: ! 71: #define SF_LABELGET 0x01 /* getting device label */ ! 72: #define SF_LABELWANT 0x02 /* waiting to get label */ ! 73: ! 74: struct sf_characteristics { ! 75: u_char sfc_ncyl; /* number of cylinders */ ! 76: u_int sfc_trkswtch : 4; /* track switching rate code */ ! 77: u_int sfc_mstart : 12; /* motor start time (msec) */ ! 78: u_char sfc_drive : 4; /* drive type (5 or 8 inch) */ ! 79: u_char sfc_nhead : 4; /* number of heads */ ! 80: u_char sfc_secsize; /* sector size / 256 */ ! 81: u_char sfc_uload; /* head unload time in 1/10 sec */ ! 82: u_char sfc_spt; /* sectors per track */ ! 83: u_char sfc_record; /* recording density code */ ! 84: }; ! 85: ! 86: /* ! 87: * track switching codes ! 88: */ ! 89: #define TS_6MSEC 0 /* 6 msec */ ! 90: #define TS_12MSEC 1 /* 12 msec */ ! 91: #define TS_20MSEC 2 /* 20 msec */ ! 92: #define TS_30MSEC 3 /* 30 msec */ ! 93: ! 94: /* ! 95: * recording density codes ! 96: */ ! 97: #define SDENSITY 0x00 /* single denisity */ ! 98: #define DDENSITY 0xC0 /* double density */ ! 99: ! 100: static struct sf_characteristics default_characteristics = { ! 101: 40, ! 102: TS_6MSEC, ! 103: 500, ! 104: 5, ! 105: 2, ! 106: PC_SECSIZE/256, ! 107: 10, ! 108: 9, ! 109: DDENSITY ! 110: }; ! 111: ! 112: static struct sf_characteristics current_characteristics; ! 113: ! 114: /* ! 115: * Return a pointer to this unit's unit structure. ! 116: */ ! 117: sfunitptr(md) ! 118: register struct mb_device *md; ! 119: { ! 120: return ((int)&sfunits[md->md_unit]); ! 121: } ! 122: ! 123: /* ! 124: * Attach device (boot time). ! 125: */ ! 126: sfattach(md) ! 127: register struct mb_device *md; ! 128: { ! 129: register struct scsi_unit *un; ! 130: ! 131: un = &sfunits[md->md_unit]; ! 132: un->un_md = md; ! 133: un->un_mc = md->md_mc; ! 134: un->un_unit = md->md_unit; ! 135: un->un_target = TARGET(md->md_slave); ! 136: un->un_lun = LUN(md->md_slave); ! 137: un->un_ss = &scsi_unit_subr[TYPE(md->md_flags)]; ! 138: } ! 139: ! 140: static int ! 141: getlabel(dev) ! 142: register dev_t dev; ! 143: { ! 144: register struct scsi_unit *un; ! 145: register char *bufp; ! 146: register struct scsi_floppy *dsi; ! 147: char c; ! 148: ! 149: un = &sfunits[SFUNIT(dev)]; ! 150: dsi = &sfloppy[SFUNIT(dev)]; ! 151: /* ! 152: * We don't want multiple opens going on at the same time. ! 153: */ ! 154: while (dsi->sf_flags & SF_LABELGET) { ! 155: dsi->sf_flags |= SF_LABELWANT; ! 156: sleep((caddr_t)dsi, PRIBIO); ! 157: if (un->un_present) ! 158: return (1); ! 159: } ! 160: dsi->sf_flags |= SF_LABELGET; ! 161: dsi->sf_nblk = 8; ! 162: dsi->sf_spt = 8; ! 163: dsi->sf_nhead = 1; ! 164: if (sfcmd(dev, SC_TEST_UNIT_READY, 0, 0, (caddr_t)0)) { ! 165: uprintf("sf%d: not online\n", SFNUM(un)); ! 166: goto out; ! 167: } ! 168: if (sfcmd(dev, SC_INIT_CHARACTERISTICS, 0, ! 169: sizeof(default_characteristics), ! 170: (caddr_t)&default_characteristics) ) { ! 171: uprintf("sf%d: cannot init drive\n", SFNUM(un)); ! 172: goto out; ! 173: } ! 174: bufp = kmem_alloc(PC_SECSIZE); ! 175: if (sfcmd(dev, SC_READ, PC_FATBLOCK, PC_SECSIZE, bufp)) { ! 176: uprintf("sf%d: error reading label\n", SFNUM(un)); ! 177: kmem_free(bufp, PC_SECSIZE); ! 178: goto out; ! 179: } ! 180: dsi->sf_mdb = bufp[0]; ! 181: c = bufp[1] & bufp[2]; ! 182: kmem_free(bufp, PC_SECSIZE); ! 183: if (c != 0xFF) { ! 184: uprintf("sf%d: bad label\n", SFNUM(un)); ! 185: goto out; ! 186: } ! 187: switch (dsi->sf_mdb) { ! 188: case SS8SPT: ! 189: dsi->sf_spt = 8; ! 190: dsi->sf_nhead = 1; ! 191: dsi->sf_nblk = 320; ! 192: break; ! 193: ! 194: case DS8SPT: ! 195: dsi->sf_spt = 8; ! 196: dsi->sf_nhead = 2; ! 197: dsi->sf_nblk = 640; ! 198: break; ! 199: ! 200: case SS9SPT: ! 201: dsi->sf_spt = 9; ! 202: dsi->sf_nhead = 1; ! 203: dsi->sf_nblk = 360; ! 204: break; ! 205: ! 206: case DS9SPT: ! 207: dsi->sf_spt = 9; ! 208: dsi->sf_nhead = 2; ! 209: dsi->sf_nblk = 720; ! 210: break; ! 211: ! 212: default: ! 213: uprintf("sf%d: bad label\n", SFNUM(un)); ! 214: goto out; ! 215: } ! 216: current_characteristics = default_characteristics; ! 217: current_characteristics.sfc_spt = dsi->sf_spt; ! 218: current_characteristics.sfc_nhead = dsi->sf_nhead; ! 219: if (sfcmd(dev, SC_INIT_CHARACTERISTICS, 0, ! 220: sizeof(current_characteristics), ! 221: (caddr_t)¤t_characteristics)) { ! 222: uprintf("sf%d: cannot reinit drive\n", SFNUM(un)); ! 223: } else { ! 224: un->un_present = 1; ! 225: } ! 226: out: ! 227: dsi->sf_flags &= ~SF_LABELGET; ! 228: if (dsi->sf_flags & SF_LABELWANT) { ! 229: dsi->sf_flags &= ~SF_LABELWANT; ! 230: wakeup((caddr_t)dsi); ! 231: } ! 232: return (un->un_present); ! 233: } ! 234: ! 235: /*ARGSUSED*/ ! 236: sfopen(dev, flag) ! 237: dev_t dev; ! 238: int flag; ! 239: { ! 240: register struct scsi_unit *un; ! 241: register int unit; ! 242: ! 243: unit = SFUNIT(dev); ! 244: if (unit >= nsfloppy) { ! 245: return (ENXIO); ! 246: } ! 247: un = &sfunits[unit]; ! 248: if (un->un_mc == 0) { /* never attached */ ! 249: return (ENXIO); ! 250: } ! 251: if (!un->un_present) { ! 252: if (!getlabel(dev)) { ! 253: return (EIO); ! 254: } ! 255: } ! 256: return (0); ! 257: } ! 258: ! 259: /*ARGSUSED*/ ! 260: sfclose(dev, flag) ! 261: dev_t dev; ! 262: int flag; ! 263: { ! 264: register struct scsi_unit *un; ! 265: ! 266: un = &sfunits[SFUNIT(dev)]; ! 267: /* ! 268: * make the driver get the label again on the next open ! 269: */ ! 270: un->un_present = 0; ! 271: } ! 272: ! 273: sfsize(dev) ! 274: register dev_t dev; ! 275: { ! 276: register struct scsi_unit *un; ! 277: ! 278: un = &sfunits[SFUNIT(dev)]; ! 279: if (!un->un_present) { ! 280: return (-1); ! 281: } ! 282: return (sfloppy[SFUNIT(dev)].sf_nblk); ! 283: } ! 284: ! 285: sfstrategy(bp) ! 286: register struct buf *bp; ! 287: { ! 288: register struct scsi_unit *un; ! 289: register daddr_t bn; ! 290: register int unit, s; ! 291: register struct buf *dp; ! 292: register struct scsi_floppy *dsi; ! 293: ! 294: unit = SFUNIT(bp->b_dev); ! 295: if (unit >= nsfloppy) { ! 296: printf("sf%d: sfstrategy: invalid unit\n", unit); ! 297: bp->b_flags |= B_ERROR; ! 298: iodone(bp); ! 299: return; ! 300: } ! 301: un = &sfunits[unit]; ! 302: dsi = &sfloppy[unit]; ! 303: bn = dkblock(bp); ! 304: if ((!un->un_present && bp != &un->un_sbuf) || (bn > dsi->sf_nblk)) { ! 305: bp->b_flags |= B_ERROR; ! 306: iodone(bp); ! 307: return; ! 308: } ! 309: if (un->un_present) { ! 310: if (bn == dsi->sf_nblk) { /* EOF */ ! 311: bp->b_resid = bp->b_bcount; ! 312: iodone(bp); ! 313: return; ! 314: } ! 315: bp->b_cylin = bn / (dsi->sf_spt * dsi->sf_nhead); ! 316: } else { ! 317: bp->b_cylin = 0; ! 318: } ! 319: dp = &un->un_utab; ! 320: s = splx(pritospl(un->un_mc->mc_intpri)); ! 321: disksort(dp, bp); ! 322: if (dp->b_active == 0) { ! 323: (*un->un_c->c_ss->scs_ustart)(un); ! 324: bp = &un->un_mc->mc_tab; ! 325: if (bp->b_actf && bp->b_active == 0) { ! 326: (*un->un_c->c_ss->scs_start)(un); ! 327: } ! 328: } ! 329: (void) splx(s); ! 330: } ! 331: ! 332: /* ! 333: * Do a special command. ! 334: */ ! 335: sfcmd(dev, cmd, sector, len, addr) ! 336: register dev_t dev; ! 337: register int cmd, sector, len; ! 338: register caddr_t addr; ! 339: { ! 340: register struct scsi_unit *un; ! 341: register struct buf *bp; ! 342: register int s; ! 343: ! 344: un = &sfunits[SFUNIT(dev)]; ! 345: bp = &un->un_sbuf; ! 346: s = splx(pritospl(un->un_mc->mc_intpri)); ! 347: while (bp->b_flags&B_BUSY) { ! 348: bp->b_flags |= B_WANTED; ! 349: sleep((caddr_t)bp, PRIBIO); ! 350: } ! 351: bp->b_flags = B_BUSY|B_READ; ! 352: (void) splx(s); ! 353: un->un_scmd = cmd; ! 354: bp->b_dev = dev; ! 355: bp->b_blkno = sector; ! 356: bp->b_un.b_addr = addr; ! 357: bp->b_bcount = len; ! 358: sfstrategy(bp); ! 359: iowait(bp); ! 360: bp->b_flags &= ~B_BUSY; ! 361: if (bp->b_flags&B_WANTED) ! 362: wakeup((caddr_t)bp); ! 363: return (bp->b_flags & B_ERROR); ! 364: } ! 365: ! 366: /* ! 367: * Set up a transfer for the controller ! 368: */ ! 369: sfstart(bp, un) ! 370: register struct buf *bp; ! 371: register struct scsi_unit *un; ! 372: { ! 373: register int nblk; ! 374: register struct scsi_floppy *dsi; ! 375: ! 376: dsi = &sfloppy[SFUNIT(bp->b_dev)]; ! 377: un->un_blkno = dkblock(bp); ! 378: if (bp == &un->un_sbuf) { ! 379: un->un_cmd = un->un_scmd; ! 380: } else if (bp->b_flags & B_READ) { ! 381: un->un_cmd = SC_READ; ! 382: } else { ! 383: un->un_cmd = SC_WRITE; ! 384: } ! 385: if (un->un_cmd == SC_READ || un->un_cmd == SC_WRITE) { ! 386: nblk = howmany(bp->b_bcount, PC_SECSIZE); ! 387: un->un_count = MIN(nblk, dsi->sf_nblk - bp->b_blkno); ! 388: bp->b_resid = bp->b_bcount - un->un_count * PC_SECSIZE; ! 389: un->un_flags |= SC_UNF_DVMA; ! 390: } else { ! 391: if (un->un_cmd == SC_INIT_CHARACTERISTICS) ! 392: un->un_flags |= SC_UNF_DVMA; ! 393: un->un_count = bp->b_bcount; ! 394: } ! 395: return (1); ! 396: } ! 397: ! 398: /* ! 399: * Make a cdb for disk i/o. ! 400: */ ! 401: sfmkcdb(c, un) ! 402: register struct scsi_ctlr *c; ! 403: struct scsi_unit *un; ! 404: { ! 405: register struct scsi_cdb *cdb; ! 406: ! 407: cdb = &c->c_cdb; ! 408: bzero((caddr_t)cdb, sizeof (*cdb)); ! 409: un->un_dma_addr = 0; ! 410: un->un_dma_count = 0; ! 411: cdb->cmd = un->un_cmd; ! 412: cdb->lun = un->un_lun; ! 413: switch (un->un_cmd) { ! 414: case SC_TEST_UNIT_READY: ! 415: case SC_REZERO_UNIT: ! 416: case SC_REQUEST_SENSE: ! 417: break; ! 418: case SC_SEEK: ! 419: cdbaddr(cdb, un->un_blkno); ! 420: break; ! 421: case SC_READ: ! 422: case SC_WRITE: ! 423: cdbaddr(cdb, un->un_blkno); ! 424: cdb->count = un->un_count; ! 425: un->un_dma_addr = un->un_baddr; ! 426: un->un_dma_count = un->un_count * PC_SECSIZE; ! 427: break; ! 428: case SC_INIT_CHARACTERISTICS: ! 429: un->un_dma_addr = un->un_baddr; ! 430: un->un_dma_count = un->un_count; ! 431: break; ! 432: default: ! 433: panic("sfmkcdb"); ! 434: break; ! 435: } ! 436: } ! 437: ! 438: /* ! 439: * Interrupt processing. ! 440: */ ! 441: sfintr(c, resid, error) ! 442: register struct scsi_ctlr *c; ! 443: register int resid, error; ! 444: { ! 445: register struct scsi_unit *un; ! 446: register struct buf *bp; ! 447: register struct mb_device *md; ! 448: ! 449: un = c->c_un; ! 450: bp = un->un_mc->mc_tab.b_actf->b_actf; ! 451: md = un->un_md; ! 452: if (md->md_dk >= 0) { ! 453: dk_busy &= ~(1 << md->md_dk); ! 454: } ! 455: if (error == SE_FATAL) { ! 456: if (bp == &un->un_sbuf && ! 457: ((un->un_flags & SC_UNF_DVMA) == 0)) { ! 458: (*c->c_ss->scs_done)(un->un_mc); ! 459: } else { ! 460: mbdone(un->un_mc); ! 461: un->un_flags &= ~SC_UNF_DVMA; ! 462: } ! 463: bp->b_flags |= B_ERROR; ! 464: printf("sf%d: SCSI FAILURE\n", SFNUM(un)); ! 465: (*c->c_ss->scs_off)(un); ! 466: return; ! 467: } ! 468: if (error == SE_RETRYABLE || c->c_scb.chk || resid > 0) { ! 469: sferror(c, un, bp); ! 470: return; ! 471: } ! 472: if (c->c_cdb.cmd == SC_REZERO_UNIT && ! 473: !(bp == &un->un_sbuf && ! 474: un->un_scmd == SC_REZERO_UNIT)) { ! 475: /* error recovery */ ! 476: sfmkcdb(c, un); ! 477: if ((*c->c_ss->scs_cmd)(c, un, 1) == 0) { ! 478: printf("sf%d sfintr: scsi cmd failed 1\n", SFNUM(un)); ! 479: (*c->c_ss->scs_off)(un); ! 480: } ! 481: return; ! 482: } ! 483: /* transfer worked */ ! 484: un->un_retries = un->un_restores = 0; ! 485: if (un->un_sec_left) { /* single sector stuff */ ! 486: un->un_sec_left--; ! 487: un->un_baddr += PC_SECSIZE; ! 488: un->un_blkno++; ! 489: sfmkcdb(c, un); ! 490: if ((*c->c_ss->scs_cmd)(c, un, 1) == 0) { ! 491: printf("sf%d: sfintr: scsi cmd failed 2\n", SFNUM(un)); ! 492: (*c->c_ss->scs_off)(un); ! 493: } ! 494: } else if (bp == &un->un_sbuf && ! 495: ((un->un_flags & SC_UNF_DVMA) == 0)) { ! 496: (*c->c_ss->scs_done)(un->un_mc); ! 497: } else { ! 498: mbdone(un->un_mc); ! 499: un->un_flags &= ~SC_UNF_DVMA; ! 500: } ! 501: } ! 502: ! 503: /* ! 504: * Error handling. ! 505: */ ! 506: sferror(c, un, bp) ! 507: register struct scsi_ctlr *c; ! 508: register struct scsi_unit *un; ! 509: register struct buf *bp; ! 510: { ! 511: ! 512: if (un->un_present == 0) { /* error trying to open */ ! 513: bp->b_flags |= B_ERROR; ! 514: if (bp == &un->un_sbuf && ! 515: ((un->un_flags & SC_UNF_DVMA) == 0)) { ! 516: (*c->c_ss->scs_done)(un->un_mc); ! 517: } else { ! 518: mbdone(un->un_mc); ! 519: un->un_flags &= ~SC_UNF_DVMA; ! 520: } ! 521: } else if (un->un_retries++ < MAX_RETRIES) { ! 522: /* retry */ ! 523: if (sferrlvl >= EL_RETRY) { ! 524: sferrmsg(c, un, bp, "retry"); ! 525: } ! 526: if ((*c->c_ss->scs_cmd)(c, un, 1) == 0) { ! 527: printf("sf%d: sferror: scsi cmd failed 2\n", SFNUM(un)); ! 528: (*c->c_ss->scs_off)(un); ! 529: } ! 530: } else if (un->un_restores++ < MAX_RESTORES) { ! 531: /* retries exhausted, try restore */ ! 532: un->un_retries = 0; ! 533: if (sferrlvl >= EL_REST) { ! 534: sferrmsg(c, un, bp, "restore"); ! 535: } ! 536: c->c_cdb.cmd = SC_REZERO_UNIT; ! 537: cdbaddr(&c->c_cdb, 0); ! 538: c->c_cdb.count = 0; ! 539: un->un_dma_addr = un->un_dma_count = 0; ! 540: if ((*c->c_ss->scs_cmd)(c, un, 1) == 0) { ! 541: printf("sf%d: sferror: scsi cmd failed 3\n", SFNUM(un)); ! 542: (*c->c_ss->scs_off)(un); ! 543: } ! 544: } else { ! 545: /* complete failure */ ! 546: if (sferrlvl >= EL_FAIL) { ! 547: sferrmsg(c, un, bp, "failed"); ! 548: } ! 549: (*c->c_ss->scs_off)(un); ! 550: bp->b_flags |= B_ERROR; ! 551: if (bp == &un->un_sbuf && ! 552: ((un->un_flags & SC_UNF_DVMA) == 0)) { ! 553: (*c->c_ss->scs_done)(un->un_mc); ! 554: } else { ! 555: mbdone(un->un_mc); ! 556: un->un_flags &= ~SC_UNF_DVMA; ! 557: } ! 558: } ! 559: } ! 560: ! 561: sfread(dev, uio) ! 562: dev_t dev; ! 563: struct uio *uio; ! 564: { ! 565: ! 566: return (sfrw(dev, uio, B_READ)); ! 567: } ! 568: ! 569: sfrw(dev, uio, direction) ! 570: dev_t dev; ! 571: struct uio *uio; ! 572: int direction; ! 573: { ! 574: register struct scsi_unit *un; ! 575: register int unit; ! 576: ! 577: unit = SFUNIT(dev); ! 578: if (unit >= nsfloppy) { ! 579: return (ENXIO); ! 580: } ! 581: un = &sfunits[unit]; ! 582: if ((uio->uio_offset % DEV_BSIZE) != 0) { ! 583: return (EINVAL); ! 584: } ! 585: if ((uio->uio_iov->iov_len % DEV_BSIZE) != 0) { ! 586: return (EINVAL); ! 587: } ! 588: return (physio(sfstrategy, &un->un_rbuf, dev, direction, minphys,uio)); ! 589: } ! 590: ! 591: sfwrite(dev, uio) ! 592: dev_t dev; ! 593: struct uio *uio; ! 594: { ! 595: ! 596: return (sfrw(dev, uio, B_WRITE)); ! 597: } ! 598: ! 599: /*ARGSUSED*/ ! 600: sfioctl(dev, cmd, data, flag) ! 601: register dev_t dev; ! 602: register caddr_t data; ! 603: { ! 604: register struct scsi_unit *un; ! 605: register struct dk_info *inf; ! 606: register int unit; ! 607: ! 608: unit = SFUNIT(dev); ! 609: if (unit >= nsfloppy) { ! 610: return (ENXIO); ! 611: } ! 612: un = &sfunits[unit]; ! 613: switch (cmd) { ! 614: ! 615: case DKIOCINFO: ! 616: inf = (struct dk_info *)data; ! 617: inf->dki_ctlr = getdevaddr(un->un_mc->mc_addr); ! 618: inf->dki_unit = un->un_md->md_slave; ! 619: inf->dki_ctype = DKC_SCSI; ! 620: inf->dki_flags = DKI_FMTVOL; ! 621: break; ! 622: ! 623: default: ! 624: return (ENOTTY); ! 625: } ! 626: return (0); ! 627: } ! 628: ! 629: static char *sf_class_00_errors[] = { ! 630: "invalid sense code", ! 631: "invalid sense code", ! 632: "no seek complete", ! 633: "invalid sense code", ! 634: "drive not ready", ! 635: "invalid sense code", ! 636: "no track 00", ! 637: "door open", ! 638: "media not loaded", ! 639: }; ! 640: ! 641: static char *sf_class_01_errors[] = { ! 642: "I.D. CRC error", ! 643: "write fault", ! 644: "write protected", ! 645: "invalid sense code", ! 646: "sector not found", ! 647: "seek error", ! 648: "(0x16) unformatted or bad format on drive", ! 649: "(0x17) unformatted or bad format on drive", ! 650: "invalid sense code", ! 651: "two sided error", ! 652: "wrong data mark found", ! 653: "pad error", ! 654: "invalid sense code", ! 655: "lost data in FDC", ! 656: "CRC error", ! 657: "FDC failure", ! 658: }; ! 659: ! 660: static char *sf_class_02_errors[] = { ! 661: "invalid command", ! 662: "illegal block address", ! 663: "invalid cdb", ! 664: "invalid interleave", ! 665: }; ! 666: ! 667: static char *sf_class_03_errors[] = { ! 668: "RAM error", ! 669: "controller program memory checksum error", ! 670: }; ! 671: ! 672: static char **sf_errors[] = { ! 673: sf_class_00_errors, ! 674: sf_class_01_errors, ! 675: sf_class_02_errors, ! 676: sf_class_03_errors, ! 677: }; ! 678: ! 679: int sf_errct[] = { ! 680: sizeof sf_class_00_errors / sizeof (char *), ! 681: sizeof sf_class_01_errors / sizeof (char *), ! 682: sizeof sf_class_02_errors / sizeof (char *), ! 683: sizeof sf_class_03_errors / sizeof (char *), ! 684: }; ! 685: ! 686: char *sf_cmds[] = { ! 687: "test unit ready", ! 688: "rezero unit", ! 689: "bad cmd", ! 690: "request sense", ! 691: "bad cmd", ! 692: "bad cmd", ! 693: "bad cmd", ! 694: "bad cmd", ! 695: "read", ! 696: "bad cmd", ! 697: "write", ! 698: "seek", ! 699: "initialize characteristics", ! 700: }; ! 701: ! 702: /*ARGSUSED*/ ! 703: sferrmsg(c, un, bp, action) ! 704: register struct scsi_ctlr *c; ! 705: struct scsi_unit *un; ! 706: struct buf *bp; ! 707: char *action; ! 708: { ! 709: char *sensemsg, *cmdname; ! 710: register struct scsi_sense *sense; ! 711: register int blkno; ! 712: ! 713: sense = c->c_sense; ! 714: if (c->c_scb.chk == 0) { ! 715: sensemsg = "invalid sense code"; ! 716: } else if (sense->class <= 3) { ! 717: if (sense->code < sf_errct[sense->class]) { ! 718: sensemsg = sf_errors[sense->class][sense->code]; ! 719: } else { ! 720: sensemsg = "invalid sense code"; ! 721: } ! 722: } else { ! 723: sensemsg = "invalid sense class"; ! 724: } ! 725: if (un->un_cmd < sizeof(sf_cmds)) { ! 726: cmdname = sf_cmds[un->un_cmd]; ! 727: } else { ! 728: cmdname = "bad cmd"; ! 729: } ! 730: blkno = (sense->high_addr << 16) | (sense->mid_addr << 8) | ! 731: sense->low_addr; ! 732: printf("sf%d: %s %s (%s) blk %d\n", SFNUM(un), ! 733: cmdname, action, sensemsg, blkno); ! 734: } ! 735: #endif NSF > 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.