![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vaxmba|
Return to hp.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vaxmba |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: * ! 6: * @(#)hp.c 7.1 (Berkeley) 6/5/86 ! 7: */ ! 8: ! 9: #ifdef HPDEBUG ! 10: int hpdebug; ! 11: #endif ! 12: #ifdef HPBDEBUG ! 13: int hpbdebug; ! 14: #endif ! 15: ! 16: #include "hp.h" ! 17: #if NHP > 0 ! 18: /* ! 19: * HP disk driver for RP0x+RMxx+ML11 ! 20: * ! 21: * TODO: ! 22: * see if DCLR and/or RELEASE set attention status ! 23: */ ! 24: #include "../machine/pte.h" ! 25: ! 26: #include "param.h" ! 27: #include "systm.h" ! 28: #include "dk.h" ! 29: #include "buf.h" ! 30: #include "conf.h" ! 31: #include "dir.h" ! 32: #include "user.h" ! 33: #include "map.h" ! 34: #include "../vax/mtpr.h" ! 35: #include "vm.h" ! 36: #include "cmap.h" ! 37: #include "dkbad.h" ! 38: #include "ioctl.h" ! 39: #include "uio.h" ! 40: #include "syslog.h" ! 41: ! 42: #include "../vax/dkio.h" ! 43: #include "mbareg.h" ! 44: #include "mbavar.h" ! 45: #include "hpreg.h" ! 46: ! 47: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */ ! 48: struct size { ! 49: daddr_t nblocks; ! 50: int cyloff; ! 51: } rp06_sizes[8] = { ! 52: 15884, 0, /* A=cyl 0 thru 37 */ ! 53: 33440, 38, /* B=cyl 38 thru 117 */ ! 54: 340670, 0, /* C=cyl 0 thru 814 */ ! 55: 15884, 118, /* D=cyl 118 thru 155 */ ! 56: 55936, 156, /* E=cyl 156 thru 289 */ ! 57: 219384, 290, /* F=cyl 290 thru 814 */ ! 58: 291280, 118, /* G=cyl 118 thru 814 */ ! 59: 0, 0, ! 60: }, rp05_sizes[8] = { ! 61: 15884, 0, /* A=cyl 0 thru 37 */ ! 62: 33440, 38, /* B=cyl 38 thru 117 */ ! 63: 171798, 0, /* C=cyl 0 thru 410 */ ! 64: 15884, 118, /* D=cyl 118 thru 155 */ ! 65: 55936, 156, /* E=cyl 156 thru 289 */ ! 66: 50512, 290, /* F=cyl 290 thru 410 */ ! 67: 122408, 118, /* G=cyl 118 thru 410 */ ! 68: 0, 0, ! 69: }, rm03_sizes[8] = { ! 70: 15884, 0, /* A=cyl 0 thru 99 */ ! 71: 33440, 100, /* B=cyl 100 thru 308 */ ! 72: 131680, 0, /* C=cyl 0 thru 822 */ ! 73: 15884, 309, /* D=cyl 309 thru 408 */ ! 74: 55936, 409, /* E=cyl 409 thru 758 */ ! 75: 10144, 759, /* F=cyl 759 thru 822 */ ! 76: 82144, 309, /* G=cyl 309 thru 822 */ ! 77: 0, 0, ! 78: }, rm05_sizes[8] = { ! 79: 15884, 0, /* A=cyl 0 thru 26 */ ! 80: 33440, 27, /* B=cyl 27 thru 81 */ ! 81: 500384, 0, /* C=cyl 0 thru 822 */ ! 82: 15884, 562, /* D=cyl 562 thru 588 */ ! 83: 55936, 589, /* E=cyl 589 thru 680 */ ! 84: 86240, 681, /* F=cyl 681 thru 822 */ ! 85: 158592, 562, /* G=cyl 562 thru 822 */ ! 86: 291346, 82, /* H=cyl 82 thru 561 */ ! 87: }, rm80_sizes[8] = { ! 88: 15884, 0, /* A=cyl 0 thru 36 */ ! 89: 33440, 37, /* B=cyl 37 thru 114 */ ! 90: 242606, 0, /* C=cyl 0 thru 558 */ ! 91: 15884, 115, /* D=cyl 115 thru 151 */ ! 92: 55936, 152, /* E=cyl 152 thru 280 */ ! 93: 120559, 281, /* F=cyl 281 thru 558 */ ! 94: 192603, 115, /* G=cyl 115 thru 558 */ ! 95: 0, 0, ! 96: }, rp07_sizes[8] = { ! 97: 15884, 0, /* A=cyl 0 thru 9 */ ! 98: 66880, 10, /* B=cyl 10 thru 51 */ ! 99: 1008000, 0, /* C=cyl 0 thru 629 */ ! 100: 15884, 235, /* D=cyl 235 thru 244 */ ! 101: 307200, 245, /* E=cyl 245 thru 436 */ ! 102: 308650, 437, /* F=cyl 437 thru 629 */ ! 103: 631850, 235, /* G=cyl 235 thru 629 */ ! 104: 291346, 52, /* H=cyl 52 thru 234 */ ! 105: }, cdc9775_sizes[8] = { ! 106: 15884, 0, /* A=cyl 0 thru 12 */ ! 107: 66880, 13, /* B=cyl 13 thru 65 */ ! 108: 1077760, 0, /* C=cyl 0 thru 841 */ ! 109: 15884, 294, /* D=cyl 294 thru 306 */ ! 110: 307200, 307, /* E=cyl 307 thru 546 */ ! 111: 377440, 547, /* F=cyl 547 thru 841 */ ! 112: 701280, 294, /* G=cyl 294 thru 841 */ ! 113: 291346, 66, /* H=cyl 66 thru 293 */ ! 114: }, cdc9730_sizes[8] = { ! 115: 15884, 0, /* A=cyl 0 thru 49 */ ! 116: 33440, 50, /* B=cyl 50 thru 154 */ ! 117: 263360, 0, /* C=cyl 0 thru 822 */ ! 118: 15884, 155, /* D=cyl 155 thru 204 */ ! 119: 55936, 205, /* E=cyl 205 thru 379 */ ! 120: 141664, 380, /* F=cyl 380 thru 822 */ ! 121: 213664, 155, /* G=cyl 155 thru 822 */ ! 122: 0, 0, ! 123: }, capricorn_sizes[8] = { ! 124: 15884, 0, /* A=cyl 0 thru 31 */ ! 125: 33440, 32, /* B=cyl 32 thru 97 */ ! 126: 524288, 0, /* C=cyl 0 thru 1023 */ ! 127: 15884, 668, /* D=cyl 668 thru 699 */ ! 128: 55936, 700, /* E=cyl 700 thru 809 */ ! 129: 109472, 810, /* F=cyl 810 thru 1023 */ ! 130: 182176, 668, /* G=cyl 668 thru 1023 */ ! 131: 291346, 98, /* H=cyl 98 thru 667 */ ! 132: }, eagle_sizes[8] = { ! 133: 15884, 0, /* A=cyl 0 thru 16 */ ! 134: 66880, 17, /* B=cyl 17 thru 86 */ ! 135: 808320, 0, /* C=cyl 0 thru 841 */ ! 136: 15884, 391, /* D=cyl 391 thru 407 */ ! 137: 307200, 408, /* E=cyl 408 thru 727 */ ! 138: 109296, 728, /* F=cyl 728 thru 841 */ ! 139: 432816, 391, /* G=cyl 391 thru 841 */ ! 140: 291346, 87, /* H=cyl 87 thru 390 */ ! 141: }, ampex_sizes[8] = { ! 142: 15884, 0, /* A=cyl 0 thru 26 */ ! 143: 33440, 27, /* B=cyl 27 thru 81 */ ! 144: 495520, 0, /* C=cyl 0 thru 814 */ ! 145: 15884, 562, /* D=cyl 562 thru 588 */ ! 146: 55936, 589, /* E=cyl 589 thru 680 */ ! 147: 81312, 681, /* F=cyl 681 thru 814 */ ! 148: 153664, 562, /* G=cyl 562 thru 814 */ ! 149: 291346, 82, /* H=cyl 82 thru 561 */ ! 150: }, fj2361_sizes[8] = { ! 151: 15884, 0, /* A=cyl 0 thru 12 */ ! 152: 66880, 13, /* B=cyl 13 thru 65 */ ! 153: 1077760, 0, /* C=cyl 0 thru 841 */ ! 154: 15884, 294, /* D=cyl 294 thru 306 */ ! 155: 307200, 307, /* E=cyl 307 thru 546 */ ! 156: 377408, 547, /* F=cyl 547 thru 841 */ ! 157: 701248, 294, /* G=cyl 294 thru 841 */ ! 158: 291346, 66, /* H=cyl 66 thru 293 */ ! 159: }; ! 160: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */ ! 161: ! 162: /* ! 163: * Table for converting Massbus drive types into ! 164: * indices into the partition tables. Slots are ! 165: * left for those drives divined from other means ! 166: * (e.g. SI, AMPEX, etc.). ! 167: */ ! 168: short hptypes[] = { ! 169: #define HPDT_RM03 0 ! 170: MBDT_RM03, ! 171: #define HPDT_RM05 1 ! 172: MBDT_RM05, ! 173: #define HPDT_RP06 2 ! 174: MBDT_RP06, ! 175: #define HPDT_RM80 3 ! 176: MBDT_RM80, ! 177: #define HPDT_RP04 4 ! 178: MBDT_RP04, ! 179: #define HPDT_RP05 5 ! 180: MBDT_RP05, ! 181: #define HPDT_RP07 6 ! 182: MBDT_RP07, ! 183: #define HPDT_ML11A 7 ! 184: MBDT_ML11A, ! 185: #define HPDT_ML11B 8 ! 186: MBDT_ML11B, ! 187: #define HPDT_9775 9 ! 188: -1, ! 189: #define HPDT_9730 10 ! 190: -1, ! 191: #define HPDT_CAPRICORN 11 ! 192: -1, ! 193: #define HPDT_EAGLE 12 ! 194: -1, ! 195: #define HPDT_9300 13 ! 196: -1, ! 197: #define HPDT_RM02 14 ! 198: MBDT_RM02, /* beware, actually mapped */ ! 199: #define HPDT_2361 15 ! 200: -1, ! 201: 0 ! 202: }; ! 203: struct mba_device *hpinfo[NHP]; ! 204: int hpattach(),hpustart(),hpstart(),hpdtint(); ! 205: struct mba_driver hpdriver = ! 206: { hpattach, 0, hpustart, hpstart, hpdtint, 0, ! 207: hptypes, "hp", 0, hpinfo }; ! 208: ! 209: /* ! 210: * These variable are all measured in sectors. ! 211: * Sdist is how much to "lead" in the search for a desired sector ! 212: * (i.e. if want N, search for N-sdist.) ! 213: * Maxdist and mindist define the region right before our desired sector within ! 214: * which we don't bother searching. We don't search when we are already less ! 215: * then maxdist and more than mindist sectors "before" our desired sector. ! 216: * Maxdist should be >= sdist. ! 217: * ! 218: * Beware, sdist, mindist and maxdist are not well tuned ! 219: * for many of the drives listed in this table. ! 220: * Try patching things with something i/o intensive ! 221: * running and watch iostat. ! 222: */ ! 223: struct hpst { ! 224: short nsect; /* # sectors/track */ ! 225: short ntrak; /* # tracks/cylinder */ ! 226: short nspc; /* # sector/cylinders */ ! 227: short ncyl; /* # cylinders */ ! 228: struct size *sizes; /* partition tables */ ! 229: short sdist; /* seek distance metric */ ! 230: short maxdist; /* boundaries of non-searched area */ ! 231: short mindist; /* preceding the target sector */ ! 232: char *name; /* name of disk type */ ! 233: } hpst[] = { ! 234: { 32, 5, 32*5, 823, rm03_sizes, 7, 4, 1, "RM03" }, ! 235: { 32, 19, 32*19, 823, rm05_sizes, 7, 4, 1, "RM05" }, ! 236: { 22,19, 22*19, 815, rp06_sizes, 7, 4, 1, "RP06"}, ! 237: { 31, 14, 31*14, 559, rm80_sizes, 7, 4, 1, "RM80"}, ! 238: { 22, 19, 22*19, 411, rp05_sizes, 7, 4, 1, "RP04"}, ! 239: { 22, 19, 22*19, 411, rp05_sizes, 7, 4, 1, "RP05"}, ! 240: { 50, 32, 50*32, 630, rp07_sizes, 15, 8, 3, "RP07"}, ! 241: { 1, 1, 1, 1, 0, 0, 0, 0, "ML11A"}, ! 242: { 1, 1, 1, 1, 0, 0, 0, 0, "ML11B" }, ! 243: { 32, 40, 32*40, 843, cdc9775_sizes, 7, 4, 1, "9775" }, ! 244: { 32, 10, 32*10, 823, cdc9730_sizes, 7, 4, 1, "9730-160" }, ! 245: { 32, 16, 32*16, 1024, capricorn_sizes,10,4, 3, "capricorn" }, ! 246: { 48, 20, 48*20, 842, eagle_sizes, 15, 8, 3, "eagle" }, ! 247: { 32, 19, 32*19, 815, ampex_sizes, 7, 4, 1, "9300" }, ! 248: { 64, 20, 64*20, 842, fj2361_sizes, 15, 8, 3, "2361" }, ! 249: }; ! 250: ! 251: u_char hp_offset[16] = { ! 252: HPOF_P400, HPOF_M400, HPOF_P400, HPOF_M400, ! 253: HPOF_P800, HPOF_M800, HPOF_P800, HPOF_M800, ! 254: HPOF_P1200, HPOF_M1200, HPOF_P1200, HPOF_M1200, ! 255: 0, 0, 0, 0, ! 256: }; ! 257: ! 258: struct buf rhpbuf[NHP]; ! 259: struct buf bhpbuf[NHP]; ! 260: struct dkbad hpbad[NHP]; ! 261: ! 262: struct hpsoftc { ! 263: u_char sc_hpinit; /* drive initialized */ ! 264: u_char sc_recal; /* recalibrate state */ ! 265: u_char sc_hdr; /* next i/o includes header */ ! 266: u_char sc_doseeks; /* perform explicit seeks */ ! 267: daddr_t sc_mlsize; /* ML11 size */ ! 268: int sc_blkdone; /* amount sucessfully transfered */ ! 269: daddr_t sc_badbn; /* replacement block number */ ! 270: } hpsoftc[NHP]; ! 271: ! 272: #define b_cylin b_resid ! 273: ! 274: /* #define ML11 0 to remove ML11 support */ ! 275: #define ML11 (hptypes[mi->mi_type] == MBDT_ML11A) ! 276: #define RP06 (hptypes[mi->mi_type] <= MBDT_RP06) ! 277: #define RM80 (hptypes[mi->mi_type] == MBDT_RM80) ! 278: ! 279: #define hpunit(dev) (minor(dev) >> 3) ! 280: #define MASKREG(reg) ((reg)&0xffff) ! 281: #ifdef lint ! 282: #define HPWAIT(mi, addr) (hpwait(mi)) ! 283: #else ! 284: #define HPWAIT(mi, addr) (((addr)->hpds & HPDS_DRY) || hpwait(mi)) ! 285: #endif ! 286: ! 287: /*ARGSUSED*/ ! 288: hpattach(mi, slave) ! 289: register struct mba_device *mi; ! 290: { ! 291: ! 292: mi->mi_type = hpmaptype(mi); ! 293: if (!ML11 && mi->mi_dk >= 0) { ! 294: struct hpst *st = &hpst[mi->mi_type]; ! 295: ! 296: dk_mspw[mi->mi_dk] = 1.0 / 60 / (st->nsect * 256); ! 297: } ! 298: } ! 299: ! 300: /* ! 301: * Map apparent MASSBUS drive type into manufacturer ! 302: * specific configuration. For SI controllers this is done ! 303: * based on codes in the serial number register. For ! 304: * EMULEX controllers, the track and sector attributes are ! 305: * used when the drive type is an RM02 (not supported by DEC). ! 306: */ ! 307: hpmaptype(mi) ! 308: register struct mba_device *mi; ! 309: { ! 310: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; ! 311: register int type = mi->mi_type; ! 312: ! 313: /* ! 314: * Model-byte processing for SI controllers. ! 315: * NB: Only deals with RM03 and RM05 emulations. ! 316: */ ! 317: if (type == HPDT_RM03 || type == HPDT_RM05) { ! 318: int hpsn = hpaddr->hpsn; ! 319: ! 320: if ((hpsn & SIMB_LU) != mi->mi_drive) ! 321: return (type); ! 322: switch ((hpsn & SIMB_MB) & ~(SIMB_S6|SIRM03|SIRM05)) { ! 323: ! 324: case SI9775D: ! 325: printf("hp%d: 9775 (direct)\n", mi->mi_unit); ! 326: type = HPDT_9775; ! 327: break; ! 328: ! 329: case SI9730D: ! 330: printf("hp%d: 9730 (direct)\n", mi->mi_unit); ! 331: type = HPDT_9730; ! 332: break; ! 333: ! 334: case SI9766: ! 335: printf("hp%d: 9766\n", mi->mi_unit); ! 336: type = HPDT_RM05; ! 337: break; ! 338: ! 339: case SI9762: ! 340: printf("hp%d: 9762\n", mi->mi_unit); ! 341: type = HPDT_RM03; ! 342: break; ! 343: ! 344: case SICAPD: ! 345: printf("hp%d: capricorn\n", mi->mi_unit); ! 346: type = HPDT_CAPRICORN; ! 347: break; ! 348: ! 349: case SI9751D: ! 350: printf("hp%d: eagle\n", mi->mi_unit); ! 351: type = HPDT_EAGLE; ! 352: break; ! 353: } ! 354: return (type); ! 355: } ! 356: ! 357: /* ! 358: * EMULEX SC750 or SC780. Poke the holding register. ! 359: */ ! 360: if (type == HPDT_RM02) { ! 361: int nsectors, ntracks, ncyl; ! 362: ! 363: hpaddr->hpof = HPOF_FMT22; ! 364: mbclrattn(mi); ! 365: hpaddr->hpcs1 = HP_NOP; ! 366: hpaddr->hphr = HPHR_MAXTRAK; ! 367: ntracks = MASKREG(hpaddr->hphr) + 1; ! 368: DELAY(100); ! 369: hpaddr->hpcs1 = HP_NOP; ! 370: hpaddr->hphr = HPHR_MAXSECT; ! 371: nsectors = MASKREG(hpaddr->hphr) + 1; ! 372: DELAY(100); ! 373: hpaddr->hpcs1 = HP_NOP; ! 374: hpaddr->hphr = HPHR_MAXCYL; ! 375: ncyl = MASKREG(hpaddr->hphr) + 1; ! 376: for (type = 0; hptypes[type] != 0; type++) ! 377: if (hpst[type].nsect == nsectors && ! 378: hpst[type].ntrak == ntracks && ! 379: hpst[type].ncyl == ncyl) ! 380: break; ! 381: ! 382: if (hptypes[type] == 0) { ! 383: printf("hp%d: %d sectors, %d tracks, %d cylinders: unknown device\n", ! 384: mi->mi_unit, nsectors, ntracks, ncyl); ! 385: type = HPDT_RM02; ! 386: } ! 387: printf("hp%d: %s\n", mi->mi_unit, hpst[type].name); ! 388: hpaddr->hpcs1 = HP_DCLR|HP_GO; ! 389: mbclrattn(mi); /* conservative */ ! 390: return (type); ! 391: } ! 392: ! 393: /* ! 394: * Map all ML11's to the same type. Also calculate ! 395: * transfer rates based on device characteristics. ! 396: */ ! 397: if (type == HPDT_ML11A || type == HPDT_ML11B) { ! 398: register struct hpsoftc *sc = &hpsoftc[mi->mi_unit]; ! 399: register int trt; ! 400: ! 401: sc->sc_mlsize = hpaddr->hpmr & HPMR_SZ; ! 402: if ((hpaddr->hpmr & HPMR_ARRTYP) == 0) ! 403: sc->sc_mlsize >>= 2; ! 404: if (mi->mi_dk >= 0) { ! 405: trt = (hpaddr->hpmr & HPMR_TRT) >> 8; ! 406: dk_mspw[mi->mi_dk] = 1.0 / (1<<(20-trt)); ! 407: } ! 408: type = HPDT_ML11A; ! 409: } ! 410: return (type); ! 411: } ! 412: ! 413: hpopen(dev) ! 414: dev_t dev; ! 415: { ! 416: register int unit = hpunit(dev); ! 417: register struct mba_device *mi; ! 418: ! 419: if (unit >= NHP || (mi = hpinfo[unit]) == 0 || mi->mi_alive == 0) ! 420: return (ENXIO); ! 421: return (0); ! 422: } ! 423: ! 424: hpstrategy(bp) ! 425: register struct buf *bp; ! 426: { ! 427: register struct mba_device *mi; ! 428: register struct hpst *st; ! 429: register int unit; ! 430: long sz; ! 431: int xunit = minor(bp->b_dev) & 07; ! 432: int s; ! 433: ! 434: sz = bp->b_bcount; ! 435: sz = (sz+511) >> 9; ! 436: unit = hpunit(bp->b_dev); ! 437: if (unit >= NHP) { ! 438: bp->b_error = ENXIO; ! 439: goto bad; ! 440: } ! 441: mi = hpinfo[unit]; ! 442: if (mi == 0 || mi->mi_alive == 0) { ! 443: bp->b_error = ENXIO; ! 444: goto bad; ! 445: } ! 446: st = &hpst[mi->mi_type]; ! 447: if (ML11) { ! 448: struct hpsoftc *sc = &hpsoftc[unit]; ! 449: ! 450: if (bp->b_blkno < 0 || ! 451: bp->b_blkno+sz > sc->sc_mlsize) { ! 452: if (bp->b_blkno == sc->sc_mlsize) { ! 453: bp->b_resid = bp->b_bcount; ! 454: goto done; ! 455: } ! 456: bp->b_error = EINVAL; ! 457: goto bad; ! 458: } ! 459: bp->b_cylin = 0; ! 460: } else { ! 461: if (bp->b_blkno < 0 || ! 462: bp->b_blkno+sz > st->sizes[xunit].nblocks) { ! 463: if (bp->b_blkno == st->sizes[xunit].nblocks) { ! 464: bp->b_resid = bp->b_bcount; ! 465: goto done; ! 466: } ! 467: bp->b_error = EINVAL; ! 468: goto bad; ! 469: } ! 470: bp->b_cylin = bp->b_blkno/st->nspc + st->sizes[xunit].cyloff; ! 471: } ! 472: s = spl5(); ! 473: disksort(&mi->mi_tab, bp); ! 474: if (mi->mi_tab.b_active == 0) ! 475: mbustart(mi); ! 476: splx(s); ! 477: return; ! 478: ! 479: bad: ! 480: bp->b_flags |= B_ERROR; ! 481: done: ! 482: iodone(bp); ! 483: return; ! 484: } ! 485: ! 486: hpustart(mi) ! 487: register struct mba_device *mi; ! 488: { ! 489: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; ! 490: register struct buf *bp = mi->mi_tab.b_actf; ! 491: register struct hpst *st; ! 492: struct hpsoftc *sc = &hpsoftc[mi->mi_unit]; ! 493: daddr_t bn; ! 494: int sn, tn, dist; ! 495: ! 496: st = &hpst[mi->mi_type]; ! 497: hpaddr->hpcs1 = 0; ! 498: if ((hpaddr->hpcs1&HP_DVA) == 0) ! 499: return (MBU_BUSY); ! 500: ! 501: switch (sc->sc_recal) { ! 502: ! 503: case 1: ! 504: (void)HPWAIT(mi, hpaddr); ! 505: hpaddr->hpdc = bp->b_cylin; ! 506: hpaddr->hpcs1 = HP_SEEK|HP_GO; ! 507: sc->sc_recal++; ! 508: return (MBU_STARTED); ! 509: case 2: ! 510: break; ! 511: } ! 512: sc->sc_recal = 0; ! 513: if ((hpaddr->hpds & HPDS_VV) == 0 || !sc->sc_hpinit) { ! 514: struct buf *bbp = &bhpbuf[mi->mi_unit]; ! 515: ! 516: sc->sc_hpinit = 1; ! 517: hpaddr->hpcs1 = HP_DCLR|HP_GO; ! 518: if (mi->mi_mba->mba_drv[0].mbd_as & (1<<mi->mi_drive)) ! 519: printf("DCLR attn\n"); ! 520: hpaddr->hpcs1 = HP_PRESET|HP_GO; ! 521: if (!ML11) ! 522: hpaddr->hpof = HPOF_FMT22; ! 523: mbclrattn(mi); ! 524: if (!ML11) { ! 525: bbp->b_flags = B_READ|B_BUSY; ! 526: bbp->b_dev = bp->b_dev; ! 527: bbp->b_bcount = 512; ! 528: bbp->b_un.b_addr = (caddr_t)&hpbad[mi->mi_unit]; ! 529: bbp->b_blkno = st->ncyl*st->nspc - st->nsect; ! 530: bbp->b_cylin = st->ncyl - 1; ! 531: mi->mi_tab.b_actf = bbp; ! 532: bbp->av_forw = bp; ! 533: bp = bbp; ! 534: } ! 535: } ! 536: if (mi->mi_tab.b_active || mi->mi_hd->mh_ndrive == 1) { ! 537: if (mi->mi_tab.b_errcnt >= 16 && (bp->b_flags & B_READ)) { ! 538: hpaddr->hpof = ! 539: hp_offset[mi->mi_tab.b_errcnt & 017]|HPOF_FMT22; ! 540: hpaddr->hpcs1 = HP_OFFSET|HP_GO; ! 541: (void)HPWAIT(mi, hpaddr); ! 542: mbclrattn(mi); ! 543: } ! 544: return (MBU_DODATA); ! 545: } ! 546: if (ML11) ! 547: return (MBU_DODATA); ! 548: if ((hpaddr->hpds & HPDS_DREADY) != HPDS_DREADY) ! 549: return (MBU_DODATA); ! 550: bn = bp->b_blkno; ! 551: sn = bn % st->nspc; ! 552: tn = sn / st->nsect; ! 553: sn = sn % st->nsect; ! 554: if (bp->b_cylin == MASKREG(hpaddr->hpdc)) { ! 555: if (sc->sc_doseeks) ! 556: return (MBU_DODATA); ! 557: dist = sn - (MASKREG(hpaddr->hpla) >> 6) - 1; ! 558: if (dist < 0) ! 559: dist += st->nsect; ! 560: if (dist > st->maxdist || dist < st->mindist) ! 561: return (MBU_DODATA); ! 562: } else ! 563: hpaddr->hpdc = bp->b_cylin; ! 564: if (sc->sc_doseeks) ! 565: hpaddr->hpcs1 = HP_SEEK|HP_GO; ! 566: else { ! 567: sn = (sn + st->nsect - st->sdist) % st->nsect; ! 568: hpaddr->hpda = (tn << 8) + sn; ! 569: hpaddr->hpcs1 = HP_SEARCH|HP_GO; ! 570: } ! 571: return (MBU_STARTED); ! 572: } ! 573: ! 574: hpstart(mi) ! 575: register struct mba_device *mi; ! 576: { ! 577: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; ! 578: register struct buf *bp = mi->mi_tab.b_actf; ! 579: register struct hpst *st = &hpst[mi->mi_type]; ! 580: struct hpsoftc *sc = &hpsoftc[mi->mi_unit]; ! 581: daddr_t bn; ! 582: int sn, tn, cn; ! 583: ! 584: if (ML11) ! 585: hpaddr->hpda = bp->b_blkno + sc->sc_blkdone; ! 586: else { ! 587: if (bp->b_flags & B_BAD) { ! 588: bn = sc->sc_badbn; ! 589: cn = bn / st->nspc; ! 590: } else { ! 591: bn = bp->b_blkno; ! 592: cn = bp->b_cylin; ! 593: } ! 594: sn = bn % st->nspc; ! 595: if ((bp->b_flags & B_BAD) == 0) ! 596: sn += sc->sc_blkdone; ! 597: tn = sn / st->nsect; ! 598: sn %= st->nsect; ! 599: cn += tn / st->ntrak; ! 600: tn %= st->ntrak; ! 601: hpaddr->hpda = (tn << 8) + sn; ! 602: hpaddr->hpdc = cn; ! 603: } ! 604: mi->mi_tab.b_bdone = dbtob(sc->sc_blkdone); ! 605: if (sc->sc_hdr) { ! 606: if (bp->b_flags & B_READ) ! 607: return (HP_RHDR|HP_GO); ! 608: else ! 609: return (HP_WHDR|HP_GO); ! 610: } ! 611: return (0); ! 612: } ! 613: ! 614: hpdtint(mi, mbsr) ! 615: register struct mba_device *mi; ! 616: int mbsr; ! 617: { ! 618: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; ! 619: register struct buf *bp = mi->mi_tab.b_actf; ! 620: register int er1, er2; ! 621: struct hpsoftc *sc = &hpsoftc[mi->mi_unit]; ! 622: int retry = 0; ! 623: int npf; ! 624: daddr_t bn; ! 625: int bcr; ! 626: ! 627: bcr = MASKREG(-mi->mi_mba->mba_bcr); ! 628: if (hpaddr->hpds&HPDS_ERR || mbsr&MBSR_EBITS) { ! 629: er1 = hpaddr->hper1; ! 630: er2 = hpaddr->hper2; ! 631: if (bp->b_flags & B_BAD) { ! 632: npf = bp->b_error; ! 633: bn = sc->sc_badbn; ! 634: } else { ! 635: npf = btop(bp->b_bcount - bcr); ! 636: if (er1 & (HPER1_DCK | HPER1_ECH)) ! 637: npf--; ! 638: bn = bp->b_blkno + npf; ! 639: } ! 640: if (HPWAIT(mi, hpaddr) == 0) ! 641: goto hard; ! 642: #ifdef HPDEBUG ! 643: if (hpdebug) { ! 644: int dc = hpaddr->hpdc, da = hpaddr->hpda; ! 645: ! 646: log(LOG_DEBUG, ! 647: "hperr: bp %x cyl %d blk %d blkdone %d as %o dc %x da %x\n", ! 648: bp, bp->b_cylin, bn, sc->sc_blkdone, ! 649: hpaddr->hpas&0xff, MASKREG(dc), MASKREG(da)); ! 650: log(LOG_DEBUG, ! 651: "errcnt %d mbsr=%b er1=%b er2=%b bcr -%d\n", ! 652: mi->mi_tab.b_errcnt, mbsr, mbsr_bits, ! 653: MASKREG(er1), HPER1_BITS, ! 654: MASKREG(er2), HPER2_BITS, bcr); ! 655: } ! 656: #endif ! 657: if (er1 & HPER1_HCRC) { ! 658: er1 &= ~(HPER1_HCE|HPER1_FER); ! 659: er2 &= ~HPER2_BSE; ! 660: } ! 661: if (er1 & HPER1_WLE) { ! 662: log(LOG_WARNING, "hp%d: write locked\n", ! 663: hpunit(bp->b_dev)); ! 664: bp->b_flags |= B_ERROR; ! 665: } else if (sc->sc_hdr) { ! 666: goto hard; ! 667: } else if (RM80 && er2&HPER2_SSE) { ! 668: (void) hpecc(mi, SSE); ! 669: return (MBD_RESTARTED); ! 670: } else if ((er2 & HPER2_BSE) && !ML11) { ! 671: if (hpecc(mi, BSE)) ! 672: return (MBD_RESTARTED); ! 673: goto hard; ! 674: } else if (MASKREG(er1) == HPER1_FER && RP06) { ! 675: if (hpecc(mi, BSE)) ! 676: return (MBD_RESTARTED); ! 677: goto hard; ! 678: } else if ((er1 & (HPER1_DCK | HPER1_ECH)) == HPER1_DCK && ! 679: mi->mi_tab.b_errcnt >= 3) { ! 680: if (hpecc(mi, ECC)) ! 681: return (MBD_RESTARTED); ! 682: /* ! 683: * ECC corrected. Only log retries below ! 684: * if we got errors other than soft ECC ! 685: * (as indicated by additional retries). ! 686: */ ! 687: if (mi->mi_tab.b_errcnt == 3) ! 688: mi->mi_tab.b_errcnt = 0; ! 689: } else if ((er1 & HPER1_HCRC) && !ML11 && hpecc(mi, BSE)) { ! 690: /* ! 691: * HCRC means the header is screwed up and the sector ! 692: * might well exist in the bad sector table, ! 693: * better check.... ! 694: */ ! 695: return (MBD_RESTARTED); ! 696: } else if (++mi->mi_tab.b_errcnt > 27 || ! 697: (ML11 && mi->mi_tab.b_errcnt > 15) || ! 698: mbsr & MBSR_HARD || ! 699: er1 & HPER1_HARD || ! 700: (!ML11 && (er2 & HPER2_HARD))) { ! 701: hard: ! 702: bp->b_blkno = bn; /* XXX */ ! 703: harderr(bp, "hp"); ! 704: if (mbsr & (MBSR_EBITS &~ (MBSR_DTABT|MBSR_MBEXC))) ! 705: printf("mbsr=%b ", mbsr, mbsr_bits); ! 706: printf("er1=%b er2=%b", ! 707: MASKREG(hpaddr->hper1), HPER1_BITS, ! 708: MASKREG(hpaddr->hper2), HPER2_BITS); ! 709: if (sc->sc_hdr) ! 710: printf(" (hdr i/o)"); ! 711: printf("\n"); ! 712: bp->b_flags |= B_ERROR; ! 713: bp->b_flags &= ~B_BAD; ! 714: } else ! 715: retry = 1; ! 716: hpaddr->hpcs1 = HP_DCLR|HP_GO; ! 717: if (retry && (mi->mi_tab.b_errcnt & 07) == 4) { ! 718: hpaddr->hpcs1 = HP_RECAL|HP_GO; ! 719: sc->sc_recal = 1; ! 720: return (MBD_REPOSITION); ! 721: } ! 722: } ! 723: #ifdef HPDEBUG ! 724: else ! 725: if (hpdebug && sc->sc_recal) { ! 726: log(LOG_DEBUG, ! 727: "recal %d errcnt %d mbsr=%b er1=%b er2=%b\n", ! 728: sc->sc_recal, mi->mi_tab.b_errcnt, mbsr, mbsr_bits, ! 729: hpaddr->hper1, HPER1_BITS, ! 730: hpaddr->hper2, HPER2_BITS); ! 731: } ! 732: #endif ! 733: (void)HPWAIT(mi, hpaddr); ! 734: if (retry) ! 735: return (MBD_RETRY); ! 736: if (mi->mi_tab.b_errcnt >= 16) { ! 737: /* ! 738: * This is fast and occurs rarely; we don't ! 739: * bother with interrupts. ! 740: */ ! 741: hpaddr->hpcs1 = HP_RTC|HP_GO; ! 742: (void)HPWAIT(mi, hpaddr); ! 743: mbclrattn(mi); ! 744: } ! 745: if (mi->mi_tab.b_errcnt && (bp->b_flags & B_ERROR) == 0) ! 746: log(LOG_INFO, "hp%d%c: %d retries %sing sn%d\n", ! 747: hpunit(bp->b_dev), 'a'+(minor(bp->b_dev)&07), ! 748: mi->mi_tab.b_errcnt, ! 749: (bp->b_flags & B_READ) ? "read" : "writ", ! 750: (bp->b_flags & B_BAD) ? ! 751: sc->sc_badbn : bp->b_blkno + sc->sc_blkdone); ! 752: if ((bp->b_flags & B_BAD) && hpecc(mi, CONT)) ! 753: return (MBD_RESTARTED); ! 754: sc->sc_hdr = 0; ! 755: sc->sc_blkdone = 0; ! 756: bp->b_resid = bcr; ! 757: if (!ML11) { ! 758: hpaddr->hpof = HPOF_FMT22; ! 759: hpaddr->hpcs1 = HP_RELEASE|HP_GO; ! 760: } ! 761: return (MBD_DONE); ! 762: } ! 763: ! 764: /* ! 765: * Wait (for a bit) for a drive to come ready; ! 766: * returns nonzero on success. ! 767: */ ! 768: hpwait(mi) ! 769: register struct mba_device *mi; ! 770: { ! 771: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; ! 772: register i = 100000; ! 773: ! 774: while ((hpaddr->hpds & HPDS_DRY) == 0 && --i) ! 775: DELAY(10); ! 776: if (i == 0) ! 777: printf("hp%d: intr, not ready\n", mi->mi_unit); ! 778: return (i); ! 779: } ! 780: ! 781: hpread(dev, uio) ! 782: dev_t dev; ! 783: struct uio *uio; ! 784: { ! 785: register int unit = hpunit(dev); ! 786: ! 787: if (unit >= NHP) ! 788: return (ENXIO); ! 789: return (physio(hpstrategy, &rhpbuf[unit], dev, B_READ, minphys, uio)); ! 790: } ! 791: ! 792: hpwrite(dev, uio) ! 793: dev_t dev; ! 794: struct uio *uio; ! 795: { ! 796: register int unit = hpunit(dev); ! 797: ! 798: if (unit >= NHP) ! 799: return (ENXIO); ! 800: return (physio(hpstrategy, &rhpbuf[unit], dev, B_WRITE, minphys, uio)); ! 801: } ! 802: ! 803: /*ARGSUSED*/ ! 804: hpioctl(dev, cmd, data, flag) ! 805: dev_t dev; ! 806: int cmd; ! 807: caddr_t data; ! 808: int flag; ! 809: { ! 810: ! 811: switch (cmd) { ! 812: ! 813: case DKIOCHDR: /* do header read/write */ ! 814: hpsoftc[hpunit(dev)].sc_hdr = 1; ! 815: return (0); ! 816: ! 817: default: ! 818: return (ENXIO); ! 819: } ! 820: } ! 821: ! 822: hpecc(mi, flag) ! 823: register struct mba_device *mi; ! 824: int flag; ! 825: { ! 826: register struct mba_regs *mbp = mi->mi_mba; ! 827: register struct hpdevice *rp = (struct hpdevice *)mi->mi_drv; ! 828: register struct buf *bp = mi->mi_tab.b_actf; ! 829: register struct hpst *st = &hpst[mi->mi_type]; ! 830: struct hpsoftc *sc = &hpsoftc[mi->mi_unit]; ! 831: int npf, o; ! 832: int bn, cn, tn, sn; ! 833: int bcr; ! 834: ! 835: bcr = MASKREG(-mbp->mba_bcr); ! 836: if (bp->b_flags & B_BAD) ! 837: npf = bp->b_error; ! 838: else { ! 839: npf = bp->b_bcount - bcr; ! 840: /* ! 841: * Watch out for fractional sector at end of transfer; ! 842: * want to round up if finished, otherwise round down. ! 843: */ ! 844: if (bcr == 0) ! 845: npf += 511; ! 846: npf = btodb(npf); ! 847: } ! 848: o = (int)bp->b_un.b_addr & PGOFSET; ! 849: bn = bp->b_blkno; ! 850: cn = bp->b_cylin; ! 851: sn = bn%(st->nspc) + npf; ! 852: tn = sn/st->nsect; ! 853: sn %= st->nsect; ! 854: cn += tn/st->ntrak; ! 855: tn %= st->ntrak; ! 856: bn += npf; ! 857: switch (flag) { ! 858: case ECC: { ! 859: register int i; ! 860: caddr_t addr; ! 861: struct pte mpte; ! 862: int bit, byte, mask; ! 863: ! 864: npf--; /* because block in error is previous block */ ! 865: bn--; ! 866: if (bp->b_flags & B_BAD) ! 867: bn = sc->sc_badbn; ! 868: log(LOG_WARNING, "hp%d%c: soft ecc sn%d\n", hpunit(bp->b_dev), ! 869: 'a'+(minor(bp->b_dev)&07), bn); ! 870: mask = MASKREG(rp->hpec2); ! 871: i = MASKREG(rp->hpec1) - 1; /* -1 makes 0 origin */ ! 872: bit = i&07; ! 873: i = (i&~07)>>3; ! 874: byte = i + o; ! 875: while (i < 512 && (int)dbtob(npf)+i < bp->b_bcount && bit > -11) { ! 876: mpte = mbp->mba_map[npf+btop(byte)]; ! 877: addr = ptob(mpte.pg_pfnum) + (byte & PGOFSET); ! 878: putmemc(addr, getmemc(addr)^(mask<<bit)); ! 879: byte++; ! 880: i++; ! 881: bit -= 8; ! 882: } ! 883: if (bcr == 0) ! 884: return (0); ! 885: npf++; ! 886: break; ! 887: } ! 888: ! 889: case SSE: ! 890: rp->hpof |= HPOF_SSEI; ! 891: if (bp->b_flags & B_BAD) { ! 892: bn = sc->sc_badbn; ! 893: goto fixregs; ! 894: } ! 895: mbp->mba_bcr = -(bp->b_bcount - (int)ptob(npf)); ! 896: break; ! 897: ! 898: case BSE: ! 899: if (rp->hpof & HPOF_SSEI) ! 900: sn++; ! 901: #ifdef HPBDEBUG ! 902: if (hpbdebug) ! 903: log(LOG_DEBUG, "hpecc, BSE: bn %d cn %d tn %d sn %d\n", bn, cn, tn, sn); ! 904: #endif ! 905: if (bp->b_flags & B_BAD) ! 906: return (0); ! 907: if ((bn = isbad(&hpbad[mi->mi_unit], cn, tn, sn)) < 0) ! 908: return (0); ! 909: bp->b_flags |= B_BAD; ! 910: bp->b_error = npf + 1; ! 911: rp->hpof &= ~HPOF_SSEI; ! 912: bn = st->ncyl*st->nspc - st->nsect - 1 - bn; ! 913: sc->sc_badbn = bn; ! 914: fixregs: ! 915: cn = bn/st->nspc; ! 916: sn = bn%st->nspc; ! 917: tn = sn/st->nsect; ! 918: sn %= st->nsect; ! 919: bcr = bp->b_bcount - (int)ptob(npf); ! 920: bcr = MIN(bcr, 512); ! 921: mbp->mba_bcr = -bcr; ! 922: #ifdef HPBDEBUG ! 923: if (hpbdebug) ! 924: log(LOG_DEBUG, "revector to cn %d tn %d sn %d\n", cn, tn, sn); ! 925: #endif ! 926: break; ! 927: ! 928: case CONT: ! 929: #ifdef HPBDEBUG ! 930: if (hpbdebug) ! 931: log(LOG_DEBUG, "hpecc, CONT: bn %d cn %d tn %d sn %d\n", bn,cn,tn,sn); ! 932: #endif ! 933: bp->b_flags &= ~B_BAD; ! 934: if ((int)ptob(npf) >= bp->b_bcount) ! 935: return (0); ! 936: mbp->mba_bcr = -(bp->b_bcount - (int)ptob(npf)); ! 937: break; ! 938: } ! 939: rp->hpcs1 = HP_DCLR|HP_GO; ! 940: if (rp->hpof & HPOF_SSEI) ! 941: sn++; ! 942: rp->hpdc = cn; ! 943: rp->hpda = (tn<<8) + sn; ! 944: mbp->mba_sr = -1; ! 945: mbp->mba_var = (int)ptob(npf) + o; ! 946: rp->hpcs1 = bp->b_flags&B_READ ? HP_RCOM|HP_GO : HP_WCOM|HP_GO; ! 947: mi->mi_tab.b_errcnt = 0; /* error has been corrected */ ! 948: sc->sc_blkdone = npf; ! 949: return (1); ! 950: } ! 951: ! 952: #define DBSIZE 20 ! 953: ! 954: hpdump(dev) ! 955: dev_t dev; ! 956: { ! 957: register struct mba_device *mi; ! 958: register struct mba_regs *mba; ! 959: struct hpdevice *hpaddr; ! 960: char *start; ! 961: int num, unit; ! 962: register struct hpst *st; ! 963: ! 964: num = maxfree; ! 965: start = 0; ! 966: unit = hpunit(dev); ! 967: if (unit >= NHP) ! 968: return (ENXIO); ! 969: #define phys(a,b) ((b)((int)(a)&0x7fffffff)) ! 970: mi = phys(hpinfo[unit],struct mba_device *); ! 971: if (mi == 0 || mi->mi_alive == 0) ! 972: return (ENXIO); ! 973: mba = phys(mi->mi_hd, struct mba_hd *)->mh_physmba; ! 974: mba->mba_cr = MBCR_INIT; ! 975: hpaddr = (struct hpdevice *)&mba->mba_drv[mi->mi_drive]; ! 976: if ((hpaddr->hpds & HPDS_VV) == 0) { ! 977: hpaddr->hpcs1 = HP_DCLR|HP_GO; ! 978: hpaddr->hpcs1 = HP_PRESET|HP_GO; ! 979: hpaddr->hpof = HPOF_FMT22; ! 980: } ! 981: st = &hpst[mi->mi_type]; ! 982: if (dumplo < 0) ! 983: return (EINVAL); ! 984: if (dumplo + num >= st->sizes[minor(dev)&07].nblocks) ! 985: num = st->sizes[minor(dev)&07].nblocks - dumplo; ! 986: while (num > 0) { ! 987: register struct pte *hpte = mba->mba_map; ! 988: register int i; ! 989: int blk, cn, sn, tn; ! 990: daddr_t bn; ! 991: ! 992: blk = num > DBSIZE ? DBSIZE : num; ! 993: bn = dumplo + btop(start); ! 994: cn = bn/st->nspc + st->sizes[minor(dev)&07].cyloff; ! 995: sn = bn%st->nspc; ! 996: tn = sn/st->nsect; ! 997: sn = sn%st->nsect; ! 998: hpaddr->hpdc = cn; ! 999: hpaddr->hpda = (tn << 8) + sn; ! 1000: for (i = 0; i < blk; i++) ! 1001: *(int *)hpte++ = (btop(start)+i) | PG_V; ! 1002: mba->mba_sr = -1; ! 1003: mba->mba_bcr = -(blk*NBPG); ! 1004: mba->mba_var = 0; ! 1005: hpaddr->hpcs1 = HP_WCOM | HP_GO; ! 1006: while ((hpaddr->hpds & HPDS_DRY) == 0) ! 1007: DELAY(10); ! 1008: if (hpaddr->hpds&HPDS_ERR) ! 1009: return (EIO); ! 1010: start += blk*NBPG; ! 1011: num -= blk; ! 1012: } ! 1013: return (0); ! 1014: } ! 1015: ! 1016: hpsize(dev) ! 1017: dev_t dev; ! 1018: { ! 1019: int unit = hpunit(dev); ! 1020: struct mba_device *mi; ! 1021: struct hpst *st; ! 1022: ! 1023: if (unit >= NHP || (mi = hpinfo[unit]) == 0 || mi->mi_alive == 0) ! 1024: return (-1); ! 1025: st = &hpst[mi->mi_type]; ! 1026: return ((int)st->sizes[minor(dev) & 07].nblocks); ! 1027: } ! 1028: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.