![[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 [Research Unix] / researchv10no / sys / io|
Return to hp.c CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 ! root 1: /* ! 2: * MASSBUS SMD disk driver ! 3: */ ! 4: ! 5: #include "sys/param.h" ! 6: #include "sys/buf.h" ! 7: #include "sys/conf.h" ! 8: #include "sys/dir.h" ! 9: #include "sys/user.h" ! 10: #include "sys/hp.h" ! 11: #include "sys/mbaddr.h" ! 12: #include "sys/mbsts.h" ! 13: #include "sys/bad144.h" ! 14: #include "sys/diskio.h" ! 15: #include "sys/file.h" ! 16: ! 17: /* ! 18: * hardware registers ! 19: */ ! 20: ! 21: struct hpdevice { ! 22: int hpcs1; /* control and status register 1 */ ! 23: int hpds; /* drive status */ ! 24: int hper1; /* error register 1 */ ! 25: int hpmr; /* maintenance */ ! 26: int hpas; /* attention summary */ ! 27: int hpda; /* desired address register */ ! 28: int hpdt; /* drive type */ ! 29: int hpla; /* look ahead */ ! 30: int hpsn; /* serial number */ ! 31: int hpof; /* offset register */ ! 32: int hpdc; /* desired cylinder address register */ ! 33: int hpcc; /* current cylinder */ ! 34: /* on an rp drive, mr2 is called er2 and er2 is called er3 */ ! 35: /* we use rm terminology here */ ! 36: int hpmr2; /* maintenance register 2 */ ! 37: int hper2; /* error register 2 */ ! 38: int hpec1; /* burst error bit position */ ! 39: int hpec2; /* burst error bit pattern */ ! 40: }; ! 41: ! 42: /* ! 43: * hpcs1 ! 44: */ ! 45: ! 46: #define HP_GO 0000001 ! 47: ! 48: #define HP_SEEK 004 /* seek */ ! 49: #define HP_RECAL 006 /* recalibrate */ ! 50: #define HP_DCLR 010 /* drive clear */ ! 51: #define HP_OFFSET 014 /* offset */ ! 52: #define HP_RTC 016 /* return to center-line */ ! 53: #define HP_PRESET 020 /* read-in preset */ ! 54: #define HP_SEARCH 030 /* search */ ! 55: #define HP_WCOM 060 /* write */ ! 56: #define HP_RCOM 070 /* read data */ ! 57: ! 58: /* ! 59: * hpds ! 60: */ ! 61: #define HPDS_ERR 0040000 /* composite drive error */ ! 62: #define HPDS_PIP 0020000 /* positioning in progress */ ! 63: #define HPDS_MOL 0010000 /* medium on line */ ! 64: #define HPDS_DPR 0000400 /* drive present */ ! 65: #define HPDS_DRY 0000200 /* drive ready */ ! 66: #define HPDS_VV 0000100 /* volume valid */ ! 67: #define HPDS_DREADY (HPDS_DPR|HPDS_DRY|HPDS_MOL|HPDS_VV) ! 68: ! 69: /* ! 70: * hper1 ! 71: */ ! 72: #define HPER1_DCK 0100000 /* data check */ ! 73: #define HPER1_WLE 0004000 /* write lock error */ ! 74: #define HPER1_ECH 0000100 /* ecc hard error */ ! 75: #define HPER1_FER 0000020 /* format error */ ! 76: ! 77: /* ! 78: * hpdt ! 79: */ ! 80: #define HPDT_TYPE 0x1ff ! 81: #define HPDT_RP05 021 ! 82: #define HPDT_RP06 022 ! 83: #define HPDT_RP07 042 ! 84: #define HPDT_RM03 024 ! 85: #define HPDT_RM05 027 ! 86: #define HPDT_FUJI 025 ! 87: ! 88: /* ! 89: * hpcc: emulex hack ! 90: */ ! 91: #define HPHR_MAXCYL 0100027 /* max cyl address */ ! 92: #define HPHR_MAXTRAK 0100030 /* max track address */ ! 93: #define HPHR_MAXSECT 0100031 /* max sector address */ ! 94: ! 95: /* ! 96: * hpof ! 97: */ ! 98: #define HPOF_FMT22 0010000 /* 16 bit format */ ! 99: #define HPOF_P400 0020 /* +400 uinches */ ! 100: #define HPOF_M400 0220 /* -400 uinches */ ! 101: #define HPOF_P800 0040 /* +800 uinches */ ! 102: #define HPOF_M800 0240 /* -800 uinches */ ! 103: #define HPOF_P1200 0060 /* +1200 uinches */ ! 104: #define HPOF_M1200 0260 /* -1200 uinches */ ! 105: ! 106: /* ! 107: * hper2 ! 108: */ ! 109: #define HPER2_BSE 0100000 /* bad sector */ ! 110: ! 111: #define SECTOR 512 /* size of a hardware sector */ ! 112: ! 113: /* ! 114: * monstrous size tables ! 115: * one per type of drive ! 116: */ ! 117: struct size ! 118: { ! 119: daddr_t nblocks; ! 120: daddr_t blkoff; ! 121: }; ! 122: struct size hp6_sizes[8] = { ! 123: 15884, 0, /* A=cyl 0 thru 37 */ ! 124: 33440, 15884, /* B=cyl 38 thru 117 */ ! 125: 340670, 0, /* C=cyl 0 thru 814 */ ! 126: 0, 0, ! 127: 0, 0, ! 128: 0, 0, ! 129: #ifndef NOBADSECT ! 130: 291280, 49324, /* G=cyl 118 thru 814 */ ! 131: #else ! 132: 291346, 49324, ! 133: #endif ! 134: 0, 0, ! 135: }; ! 136: struct size rm3_sizes[8] = { ! 137: 15884, 0, /* A=cyl 0 thru 99 */ ! 138: 33440, 16000, /* B=cyl 100 thru 309 */ ! 139: 131680, 0, /* C=cyl 0 thru 822 */ ! 140: 0, 0, ! 141: 0, 0, ! 142: 0, 0, ! 143: #ifndef NOBADSECT ! 144: 81984, 49600, /* G=cyl 310 thru 822 */ ! 145: #else ! 146: 82080, 49600, ! 147: #endif ! 148: 113280, 18400, /* H=cyl 115 thru 708 -- ex 32v */ ! 149: }; ! 150: struct size rm5_sizes[8] = { ! 151: 15884, 0, /* A=cyl 0 thru 26 */ ! 152: 33440, 16416, /* B=cyl 27 thru 81 */ ! 153: 500384, 0, /* C=cyl 0 thru 822 */ ! 154: 15884, 341696, /* D=cyl 562 thru 588 */ ! 155: 55936, 358112, /* E=cyl 589 thru 680 */ ! 156: #ifndef NOBADSECT ! 157: 86240, 414048, /* F=cyl 681 thru 822 */ ! 158: 158592, 341696, /* G=cyl 562 thru 822 */ ! 159: #else ! 160: 86636, 414048, ! 161: 158688, 341696, ! 162: #endif ! 163: 291346, 49856, /* H=cyl 82 thru 561 */ ! 164: }; ! 165: struct size mfj_sizes[8] = { ! 166: 10240, 0, /* A=cyl 0 thru 31 */ ! 167: 20480, 10240, /* B=cyl 32 thru 95 */ ! 168: 232640, 30720, /* C=cyl 96 thru 822 */ ! 169: 0, 0, ! 170: 0, 0, ! 171: 0, 0, ! 172: 0, 0, ! 173: 0, 0, ! 174: }; ! 175: struct size eagle_sizes[8] ={ ! 176: 27520, 0, /* A=cyl 0 thru 31 */ ! 177: 27520, 27520, /* B=cyl 32 thru 63 */ ! 178: 667360, 55040, /* C=cyl 64 thru 839 */ ! 179: 232640, 55040, /* D=cyl 64 thru 340 (partial) */ ! 180: 232640, 293260, /* E=cyl 341 thru 617 (partial) */ ! 181: 0, 0, ! 182: 0, 0, ! 183: 0, 0, ! 184: }; ! 185: /* 48 sector Emulex Eagle */ ! 186: struct size eag48_sizes[8] = { /* cyl 841 used for bad sectors + info */ ! 187: #ifndef OLDPART ! 188: 11*960, 0*960, /* A = cyl 0 thru 10 for / */ ! 189: 22*960, 11*960, /* B = cyl 11 thru 32 for swap */ ! 190: 842*960, 0*960, /* C = all cyl 0 thru 841 for testing */ ! 191: 16*960, 33*960, /* D = cyl 33 thru 48 for /usr/guest */ ! 192: 66*960, 49*960, /* E = cyl 49 thru 114 for /usr/src */ ! 193: 242*960,115*960, /* F = cyl 115 thru 356 nearly 1/3 */ ! 194: 242*960,357*960, /* G = cyl 357 thru 598 nearly 1/3 */ ! 195: 242*960,599*960, /* H = cyl 599 thru 840 nearly 1/3 */ ! 196: #else /* old jones partitions */ ! 197: 45*960, 0*960, /* A = cyl 0 thru 44 for /tmp */ ! 198: 64*960, 45*960, /* B = cyl 45 thru 108 for swap */ ! 199: 842*960, 0*960, /* C = all cyl 0 thru 841 for testing */ ! 200: 244*960,109*960, /* D = cyl 109 thru 352 nearly 1/3 */ ! 201: 244*960,353*960, /* E = cyl 353 thru 596 nearly 1/3 */ ! 202: 244*960,597*960, /* F = cyl 597 thru 840 nearly 1/3 */ ! 203: 0, 0*960, /* G = cyl 0 thru 402 nearly 1/2 */ ! 204: 0, 0*960, /* H = cyl 438 thru 840 nearly 1/2 */ ! 205: #endif ! 206: }; ! 207: struct size hp7_sizes[8] = { ! 208: 15884, 0, /* A=cyl 0 thru 9 */ ! 209: 64000, 16000, /* B=cyl 10 thru 49 */ ! 210: 1008000,0, /* C=cyl 0 thru 629 */ ! 211: 504000, 0, /* D=cyl 0 thru 314 */ ! 212: 504000, 504000, /* E=cyl 315 thru 629 */ ! 213: 928000, 80000, /* F=cyl 50 thru 629 */ ! 214: 0, 0, ! 215: 0, 0, ! 216: }; ! 217: ! 218: /* ! 219: * tables of per-drive info, mostly sizes of things ! 220: * indexed by numbers in hptypes ! 221: */ ! 222: ! 223: struct hptype hptype[] = { ! 224: HPDT_RM03, 32, 5, 3, 4, 32*5, 823, rm3_sizes, /* RM03 */ ! 225: HPDT_RM05, 32, 19, 2, 3, 32*19, 823, rm5_sizes, /* RM05 */ ! 226: HPDT_RP06, 22, 19, 2, 3, 22*19, 815, hp6_sizes, /* RP06 */ ! 227: HPDT_RP05, 22, 19, 2, 3, 22*19, 411, hp6_sizes, /* RP05 */ ! 228: HPDT_RP07, 50, 32, 2, 3, 50*32, 630, hp7_sizes, /* RP07 */ ! 229: /* HPDT_FUJI (emulex) entries must be contiguous and last */ ! 230: HPDT_FUJI, 32, 10, 2, 3, 32*10, 823, mfj_sizes, /* little fujitsu */ ! 231: HPDT_FUJI, 43, 20, 8, 9, 43*20, 842, eagle_sizes, /* eagle */ ! 232: HPDT_FUJI, 48, 20, 8, 9, 48*20, 842, eag48_sizes, /* eagle 48 sectors */ ! 233: 0 ! 234: }; ! 235: ! 236: #define NOFFS 16 ! 237: unsigned char hp_offset[NOFFS] = { ! 238: HPOF_P400, HPOF_M400, HPOF_P400, HPOF_M400, ! 239: HPOF_P800, HPOF_M800, HPOF_P800, HPOF_M800, ! 240: HPOF_P1200, HPOF_M1200, HPOF_P1200, HPOF_M1200, ! 241: 0, 0, 0, 0 ! 242: }; ! 243: ! 244: /* ! 245: * things from config ! 246: */ ! 247: extern int hpcnt; ! 248: extern struct mbaddr hpaddr[]; ! 249: extern struct hpdisk hpdisk[]; ! 250: extern struct buf hpbuf[]; ! 251: extern struct buf hpbadbuf[]; ! 252: extern struct bad144 hpbad[]; ! 253: ! 254: /* ! 255: * unit flags, hpdisk.flags ! 256: */ ! 257: ! 258: #define UACTIVE 01 /* started seek */ ! 259: #define UXFER 02 /* done with any seeking; ready to transfer */ ! 260: #define UWOL 04 /* waiting for offline drive */ ! 261: #define UWAITOL 010 /* waiting and timer has ticked */ ! 262: #define UHAVBAD 020 /* have read bad block table */ ! 263: #define UREVEC 040 /* halfway through reading revectored sector */ ! 264: ! 265: /* ! 266: * device number ! 267: * 0100 in the minor device is (temporarily?) ! 268: * usurped to indicate bitmapped file systems ! 269: * quietly ignore it for now ! 270: * when things improve, change the UNIT mask to 037 ! 271: */ ! 272: ! 273: #define UNIT(d) ((minor(d)>>3) & 027) ! 274: #define PART(d) (minor(d) & 07) ! 275: ! 276: /* ! 277: * abuse of spare bits of struct buf ! 278: */ ! 279: #define b_cylin b_resid /* for disksort */ ! 280: ! 281: int hpwstart; ! 282: int hpwatch(); ! 283: int hpwaitdry; ! 284: ! 285: int hpopen(), hpstrategy(), hpread(), hpwrite(), hpioctl(); ! 286: struct cdevsw hpcdev = cdinit(hpopen, nulldev, hpread, hpwrite, hpioctl); ! 287: struct bdevsw hpbdev = bdinit(hpopen, nulldev, hpstrategy, 0); ! 288: ! 289: hpopen(dev, flag) ! 290: int dev, flag; ! 291: { ! 292: register struct hpdisk *hp; ! 293: register struct hptype *st; ! 294: register int p; ! 295: ! 296: if (hpuinit(UNIT(dev)) == 0) { ! 297: u.u_error = ENXIO; ! 298: return; ! 299: } ! 300: hp = &hpdisk[UNIT(dev)]; ! 301: st = &hptype[hp->type]; ! 302: p = PART(dev); ! 303: if ((hp->pinit & (1<<p)) == 0) { ! 304: hp->nblocks[p] = st->sizes[p].nblocks; ! 305: hp->blkoff[p] = st->sizes[p].blkoff; ! 306: if ((hp->blkoff[p] % st->nspc) != 0) { ! 307: printf("hp minor %d bad blkoff\n", minor(dev)); ! 308: u.u_error = EINVAL; ! 309: return; ! 310: } ! 311: hp->pinit |= (1<<p); ! 312: } ! 313: } ! 314: ! 315: static char hponce; ! 316: ! 317: hpuinit(unit) ! 318: register int unit; ! 319: { ! 320: register struct hpdevice *reg; ! 321: register struct hpdisk *hp; ! 322: ! 323: if (unit < 0 || unit > hpcnt) ! 324: return (0); ! 325: hp = &hpdisk[unit]; ! 326: if (hp->addr) ! 327: return (1); ! 328: if ((reg = (struct hpdevice *)mbaddr(&hpaddr[unit])) == NULL ! 329: || badaddr(®->hpcs1, sizeof(long)) ! 330: || (reg->hpds & HPDS_DPR) == 0) { ! 331: printf("hp%d absent\n", unit); ! 332: return (0); ! 333: } ! 334: if ((hp->type = hputype(reg)) < 0) { ! 335: printf("hp%d absent or bad type\n", unit); ! 336: return (0); ! 337: } ! 338: hp->addr = reg; ! 339: if (hponce == 0) { ! 340: hponce++; ! 341: hpwatch(); ! 342: } ! 343: return (1); ! 344: } ! 345: ! 346: /* ! 347: * determine drive type ! 348: * this is called by hpdump too; ! 349: * be prepared to run without memory management ! 350: * return is an index into hpst ! 351: */ ! 352: int ! 353: hputype(reg) ! 354: register struct hpdevice *reg; ! 355: { ! 356: register int t, i; ! 357: register int nsect, ntrak; ! 358: ! 359: t = reg->hpdt & HPDT_TYPE; ! 360: for (i = 0; hptype[i].type; i++) ! 361: if (hptype[i].type == t) ! 362: break; ! 363: if (hptype[i].type == 0) { ! 364: printf("hp type 0%o unknown\n", t); ! 365: return (-1); ! 366: } ! 367: if (hptype[i].type != HPDT_FUJI) ! 368: return (i); ! 369: /* ! 370: * special hackery for emulex ! 371: */ ! 372: reg->hpcc = HPHR_MAXTRAK; ! 373: DELAY(2); /* hack */ ! 374: ntrak = reg->hpcc + 1; ! 375: ntrak &= 0xffff; ! 376: reg->hpcc = HPHR_MAXSECT; ! 377: DELAY(2); /* hack */ ! 378: nsect = reg->hpcc + 1; ! 379: nsect &= 0xffff; ! 380: for (; hptype[i].type; i++) ! 381: if (ntrak == hptype[i].ntrak && nsect == hptype[i].nsect) ! 382: return (i); ! 383: /* ! 384: * 48-sector eagle known to be last, ! 385: * so the following broken-hardware test might work ! 386: */ ! 387: if (nsect == 46) { ! 388: printf("hp said ntrak %d nsect %d, eag48 assumed\n", ntrak, nsect); ! 389: return (i - 1); ! 390: } ! 391: printf("hp fuji ntrak %d nsect %d unknown\n", ntrak, nsect); ! 392: return (-1); ! 393: } ! 394: ! 395: /* ! 396: * a subtlety: ! 397: * b_cylin = cylinder number; ! 398: * later, when computing disk address, ! 399: * we use b_cylin, and take b_blkno % cylindersize ! 400: * i.e. there's an embedded assumption that every disk partition ! 401: * begins on a cylinder boundary ! 402: */ ! 403: hpstrategy(bp) ! 404: register struct buf *bp; ! 405: { ! 406: register struct hpdisk *hp; ! 407: register struct hptype *st; ! 408: register int unit; ! 409: register int part; ! 410: long sz; ! 411: int s; ! 412: ! 413: sz = (bp->b_bcount+SECTOR-1)/SECTOR; ! 414: unit = UNIT(bp->b_dev); ! 415: hp = &hpdisk[unit]; ! 416: if (hp->addr == NULL) { /* safety check */ ! 417: bp->b_flags |= B_ERROR; ! 418: iodone(bp); ! 419: return; ! 420: } ! 421: st = &hptype[hp->type]; ! 422: part = PART(bp->b_dev); ! 423: if (bp->b_blkno < 0 || bp->b_blkno+sz > hp->nblocks[part]) { ! 424: if (bp->b_blkno == hp->nblocks[part]) ! 425: bp->b_resid = bp->b_bcount; ! 426: else { /* partial read too hard for now */ ! 427: bp->b_error = ENXIO; ! 428: bp->b_flags |= B_ERROR; ! 429: } ! 430: iodone(bp); ! 431: return; ! 432: } ! 433: bp->b_cylin = (bp->b_blkno + hp->blkoff[part])/st->nspc; ! 434: s = spl6(); ! 435: disksort(&hp->actf, &hp->actl, bp); ! 436: if ((hp->flags & UACTIVE) == 0) ! 437: hpustart(hp); ! 438: splx(s); ! 439: } ! 440: ! 441: /* ! 442: * unit start: ! 443: * if there's a block for this drive, start seeking there ! 444: */ ! 445: int hpxfer(); ! 446: ! 447: hpustart(hp) ! 448: register struct hpdisk *hp; ! 449: { ! 450: register struct buf *bp; ! 451: register struct hpdevice *reg; ! 452: register struct hptype *st; ! 453: int sn, csn; ! 454: ! 455: if ((bp = hp->actf) == NULL) ! 456: return; ! 457: reg = hp->addr; ! 458: if ((reg->hpds & HPDS_VV) == 0) { ! 459: reg->hpcs1 = HP_DCLR|HP_GO; ! 460: reg->hpcs1 = HP_PRESET|HP_GO; ! 461: reg->hpof = HPOF_FMT22; ! 462: hp->flags &=~ UHAVBAD; ! 463: } ! 464: if ((hp->flags & UHAVBAD) == 0) { ! 465: hprbad(hp); ! 466: bp = hp->actf; ! 467: hp->flags |= UHAVBAD; ! 468: } ! 469: if ((reg->hpds & (HPDS_DPR|HPDS_MOL)) != (HPDS_DPR|HPDS_MOL)) { ! 470: hp->flags |= UWOL; ! 471: return; ! 472: } ! 473: if ((hp->flags & UACTIVE) == 0) { /* start seek if didn't already */ ! 474: hp->flags |= UACTIVE; ! 475: st = &hptype[hp->type]; ! 476: sn = bp->b_blkno%st->nsect - st->sdist; /* seek here before io */ ! 477: if (sn < 0) ! 478: sn += st->nsect; ! 479: csn = sn - (reg->hpla>>6); ! 480: if (csn < 0) ! 481: csn += st->nsect; ! 482: if (bp->b_cylin != reg->hpdc /* seek if off cylinder */ ! 483: || csn > st->rdist) { /* or not close enough */ ! 484: reg->hpdc = bp->b_cylin; ! 485: reg->hpda = sn; ! 486: reg->hpcs1 = HP_SEARCH|HP_GO; ! 487: return; ! 488: } ! 489: } ! 490: if ((hp->flags & UXFER) == 0) { /* seek done, time for transfer */ ! 491: hp->flags |= UXFER; ! 492: mbstart(&hpaddr[UNIT(bp->b_dev)], bp, hpxfer); ! 493: } ! 494: } ! 495: ! 496: /* ! 497: * start transfer ! 498: */ ! 499: hpxfer(bp) ! 500: register struct buf *bp; ! 501: { ! 502: register struct hpdisk *hp; ! 503: register struct hpdevice *reg; ! 504: register struct hptype *st; ! 505: int sn, tn; ! 506: ! 507: hp = &hpdisk[UNIT(bp->b_dev)]; ! 508: st = &hptype[hp->type]; ! 509: sn = bp->b_blkno%st->nspc; ! 510: tn = sn/st->nsect; ! 511: sn %= st->nsect; ! 512: reg = hp->addr; ! 513: if ((reg->hpds & HPDS_DREADY) != HPDS_DREADY) { ! 514: printf("hp%d: not ready\n", UNIT(bp->b_dev)); ! 515: hp->errcnt = 0; ! 516: hp->actf = bp->av_forw; ! 517: hp->flags &=~ (UACTIVE|UXFER); ! 518: bp->b_flags |= B_ERROR; ! 519: iodone(bp); ! 520: return; ! 521: } ! 522: reg->hpdc = bp->b_cylin; ! 523: reg->hpda = (tn << 8) + sn; ! 524: if (bp->b_flags & B_READ) ! 525: reg->hpcs1 = HP_RCOM|HP_GO; ! 526: else ! 527: reg->hpcs1 = HP_WCOM|HP_GO; ! 528: } ! 529: ! 530: /* ! 531: * interrupt, passed from MBA code ! 532: */ ! 533: hp0int(unit, mbsr, mbbc, attn) ! 534: int unit, mbsr, mbbc, attn; ! 535: { ! 536: register struct hpdisk *hp; ! 537: ! 538: hp = &hpdisk[unit]; ! 539: if (hp->addr == 0) { ! 540: if (hpuinit(unit) == 0) { ! 541: printf("hp%d: hopeless interrupt\n", unit); ! 542: return; /* but ATTN wasn't cleared; will recur */ ! 543: } ! 544: /* init ok, so addr nonzero, so can clear it */ ! 545: } ! 546: hp->addr->hpas = attn; ! 547: if (hp->flags & UXFER) ! 548: hpxdone(hp, mbsr, mbbc); ! 549: if ((hp->flags & UXFER) == 0) ! 550: hpustart(hp); ! 551: } ! 552: ! 553: /* ! 554: * transfer stopped: ! 555: * because it's done, or because of an error ! 556: * common convention in error-sniffing routines: ! 557: * return 1 if the error was recovered ! 558: * and the device has been restarted ! 559: * return 0 if this transfer has been abandoned ! 560: * leave flags & UXFER set if we're all done; ! 561: * clear UXFER if the transfer should be retried ! 562: */ ! 563: ! 564: #define ERRCMIN 16 /* after this many errors, try offsets */ ! 565: #define ERRCAL(e) (((e)%8)==4) /* try recal this often */ ! 566: #define ERRMAX 28 /* after this many errors, give up on transfer */ ! 567: ! 568: hpxdone(hp, mbsr, mbbc) ! 569: register struct hpdisk *hp; ! 570: int mbsr, mbbc; ! 571: { ! 572: register struct hpdevice *reg; ! 573: register struct buf *bp; ! 574: ! 575: reg = hp->addr; ! 576: bp = hp->actf; ! 577: if ((reg->hpds&HPDS_ERR) || (mbsr&MBSR_EBITS)) { ! 578: if (hpwhaterr(hp, mbsr, mbbc)) ! 579: return; ! 580: reg->hpcs1 = HP_DCLR|HP_GO; ! 581: } ! 582: if (hp->recal && hpmorecal(hp)) ! 583: return; ! 584: if (hp->flags & UREVEC && hpbadcont(hp)) ! 585: return; ! 586: if (hp->flags & UXFER) { /* `active' means we're done */ ! 587: if (hp->errcnt >= ERRCMIN) { ! 588: reg->hpof = HPOF_FMT22; ! 589: reg->hpcs1 = HP_RTC|HP_GO; ! 590: while (reg->hpds & HPDS_PIP) ! 591: DELAY(25); ! 592: } ! 593: hp->errcnt = 0; ! 594: hp->flags &=~ (UACTIVE|UXFER); ! 595: hp->actf = bp->av_forw; ! 596: bp->b_resid = mbbc; ! 597: iodone(bp); ! 598: } ! 599: } ! 600: ! 601: /* ! 602: * sort out errors ! 603: */ ! 604: ! 605: hpwhaterr(hp, mbsr, mbbc) ! 606: register struct hpdisk *hp; ! 607: int mbsr, mbbc; ! 608: { ! 609: register struct hpdevice *reg; ! 610: register struct buf *bp; ! 611: register int i; ! 612: ! 613: reg = hp->addr; ! 614: bp = hp->actf; ! 615: /* ! 616: * let registers settle ! 617: */ ! 618: i = 0; ! 619: while ((reg->hpds & HPDS_DRY) == 0) { ! 620: if (++i > 512) ! 621: break; ! 622: hpwaitdry++; ! 623: } ! 624: if (reg->hper1 & HPER1_WLE) { ! 625: printf("hp%d: write locked\n", UNIT(bp->b_dev)); ! 626: bp->b_flags |= B_ERROR; ! 627: return (0); /* finished */ ! 628: } ! 629: if ((reg->hper2 & HPER2_BSE || reg->hper1 & HPER1_FER) ! 630: && hpbadrep(hp, mbbc)) ! 631: return (1); /* restarted, reading replacement */ ! 632: if (++hp->errcnt > ERRMAX) { ! 633: harderr(bp, "hp"); ! 634: printf("mbsr %o er1 %o er2 %o\n", ! 635: mbsr, reg->hper1&0177777, reg->hper2&0177777); ! 636: bp->b_flags |= B_ERROR; ! 637: return (0); /* finished */ ! 638: } ! 639: if (bp->b_flags & B_READ ! 640: && (reg->hper1 & (HPER1_DCK|HPER1_ECH)) == HPER1_DCK) ! 641: return (hpecc(hp, mbbc)); /* restart or finish */ ! 642: /* ! 643: * hard error: clear and try again, ! 644: * perhaps with recal ! 645: */ ! 646: if (ERRCAL(hp->errcnt)) { ! 647: hpstrecal(hp); ! 648: return (1); /* restarted */ ! 649: } ! 650: hp->flags &=~ UXFER; ! 651: return (0); /* please restart me */ ! 652: } ! 653: ! 654: /* ! 655: * recalibration state machine ! 656: * walks through the sequence ! 657: * RECAL ! 658: * SEEK back to the cylinder we wanted ! 659: * perhaps offset the heads slightly ! 660: * and try the operation again ! 661: */ ! 662: ! 663: hpstrecal(hp) ! 664: register struct hpdisk *hp; ! 665: { ! 666: ! 667: hp->addr->hpcs1 = HP_DCLR|HP_GO; ! 668: hp->addr->hpcs1 = HP_RECAL|HP_GO; ! 669: hp->recal = 1; ! 670: } ! 671: ! 672: hpmorecal(hp) ! 673: register struct hpdisk *hp; ! 674: { ! 675: register struct hpdevice *reg; ! 676: ! 677: reg = hp->addr; ! 678: switch (hp->recal) { ! 679: case 1: /* did RECAL, time to seek */ ! 680: reg->hpdc = hp->actf->b_cylin; ! 681: reg->hpcs1 = HP_SEEK|HP_GO; ! 682: hp->recal++; ! 683: return (1); ! 684: ! 685: case 2: /* did seek, time for offset */ ! 686: if (hp->errcnt > ERRCMIN && hp->actf->b_flags & B_READ) { ! 687: reg->hpof = hp_offset[hp->errcnt%NOFFS]|HPOF_FMT22; ! 688: reg->hpcs1 = HP_OFFSET|HP_GO; ! 689: hp->recal++; ! 690: return (1); ! 691: } ! 692: /* too soon or a write, fall through */ ! 693: default: /* time to restart the transfer */ ! 694: hp->recal = 0; ! 695: hp->flags &=~ UXFER; ! 696: return (0); ! 697: } ! 698: } ! 699: ! 700: /* ! 701: * read the bad144 bad block table: ! 702: * call on first access to drive, ! 703: * or when VV was down ! 704: */ ! 705: ! 706: hprbad(hp) ! 707: register struct hpdisk *hp; ! 708: { ! 709: register struct buf *xbp, *bp; ! 710: register struct hptype *st; ! 711: ! 712: st = &hptype[hp->type]; ! 713: xbp = hp->actf; ! 714: bp = &hpbadbuf[UNIT(xbp->b_dev)]; ! 715: if (xbp == bp) ! 716: return; /* cheap reentry protection */ ! 717: bp->b_flags = B_BUSY|B_READ; ! 718: bp->b_dev = xbp->b_dev; ! 719: bp->b_un.b_addr = (caddr_t)&hpbad[UNIT(xbp->b_dev)]; ! 720: bp->b_bcount = sizeof(struct bad144); ! 721: bp->b_resid = 0; ! 722: bp->b_blkno = st->ncyl * st->nspc - st->nsect; /* fake-ish */ ! 723: bp->b_cylin = st->ncyl - 1; ! 724: bp->av_forw = xbp; ! 725: hp->actf = bp; ! 726: bzero(bp->b_un.b_addr, sizeof(struct bad144)); ! 727: } ! 728: ! 729: /* ! 730: * here when a bad block is detected: ! 731: * find the replacement block, and restart transfer for it ! 732: */ ! 733: hpbadrep(hp, mbbc) ! 734: register struct hpdisk *hp; ! 735: int mbbc; ! 736: { ! 737: register daddr_t bno; ! 738: register struct hptype *st; ! 739: struct buf *bp; ! 740: register int i; ! 741: ! 742: if (hp->flags & UREVEC) ! 743: return (0); ! 744: st = &hptype[hp->type]; ! 745: bp = hp->actf; ! 746: hp->badsec = (bp->b_bcount - mbbc) / SECTOR; ! 747: bno = bp->b_cylin * st->nspc + bp->b_blkno % st->nspc; /* true lbn */ ! 748: bno += hp->badsec; ! 749: i = bno / st->nspc; ! 750: bno %= st->nspc; ! 751: i = bad144rep(&hpbad[UNIT(bp->b_dev)], i, (int)bno/st->nsect, (int)bno%st->nsect); ! 752: if (i < 0) ! 753: return (0); ! 754: bno = st->ncyl*st->nspc - st->nsect - 1 - i; ! 755: hp->addr->hpcs1 = HP_DCLR|HP_GO; ! 756: if (mbbc > SECTOR) ! 757: mbbc = SECTOR; ! 758: hpcontin(hp, bno, hp->badsec*SECTOR, mbbc); ! 759: hp->flags |= UREVEC; ! 760: return (1); ! 761: } ! 762: ! 763: /* ! 764: * here after replacing the bad block: ! 765: * now do the rest of the original transfer ! 766: */ ! 767: hpbadcont(hp) ! 768: register struct hpdisk *hp; ! 769: { ! 770: register struct buf *bp; ! 771: int next, resid; ! 772: daddr_t bno; ! 773: int nspc; ! 774: ! 775: hp->flags &=~ UREVEC; ! 776: bp = hp->actf; ! 777: next = (hp->badsec + 1) * SECTOR; ! 778: resid = bp->b_bcount - next; ! 779: if (resid <= 0) ! 780: return (0); ! 781: nspc = hptype[hp->type].nspc; ! 782: bno = bp->b_cylin*nspc + bp->b_blkno%nspc; ! 783: bno += hp->badsec + 1; ! 784: hpcontin(hp, bno, next, resid); ! 785: return (1); ! 786: } ! 787: ! 788: /* ! 789: * correct an ECC error and restart the transfer ! 790: * the error is (hpec1-1) bits into the current sector; ! 791: * at that point, the bits set in hpec2 are wrong. ! 792: */ ! 793: hpecc(hp, bc) ! 794: register struct hpdisk *hp; ! 795: int bc; ! 796: { ! 797: register struct hpdevice *reg; ! 798: register struct buf *bp; ! 799: register int i; ! 800: int nxf; ! 801: unsigned int mask; ! 802: long a, lasta; ! 803: struct mbaddr *ap; ! 804: register daddr_t bno; ! 805: register struct hptype *st; ! 806: ! 807: if ((bp = hp->actf) == NULL) ! 808: panic("hpecc"); ! 809: reg = hp->addr; ! 810: ap = &hpaddr[UNIT(bp->b_dev)]; ! 811: lasta = mbcuraddr(ap); ! 812: nxf = bp->b_bcount - bc; ! 813: i = reg->hpec1 - 1; /* -1 makes 0 origin */ ! 814: a = lasta - (nxf > SECTOR ? SECTOR : nxf) + ((i&~07)>>3); ! 815: mask = reg->hpec2; ! 816: mask <<= i&07; ! 817: for (; a < lasta && mask; mask >>= 8, a++) ! 818: mbputc(ap, a, mbgetc(ap, a)^mask); ! 819: st = &hptype[hp->type]; ! 820: bno = bp->b_cylin*st->nspc + bp->b_blkno%st->nspc + nxf/SECTOR; ! 821: printf("hp%d: soft ecc sec %ld\n", UNIT(bp->b_dev), bno - 1); ! 822: if (bc == 0) ! 823: return (0); ! 824: reg->hpcs1 = HP_DCLR|HP_GO; ! 825: hpcontin(hp, bno, bp->b_bcount - bc, bc); ! 826: return (1); ! 827: } ! 828: ! 829: /* ! 830: * continue the current transfer, ! 831: * which was interrupted: ! 832: * move size bytes to or from the current buffer at offset off, ! 833: * starting with disk sector bno ! 834: * used for bad sector replacement, ! 835: * and to continue after bad sectors or ECC correction ! 836: */ ! 837: hpcontin(hp, bno, off, size) ! 838: register struct hpdisk *hp; ! 839: daddr_t bno; ! 840: int off, size; ! 841: { ! 842: register struct hpdevice *reg; ! 843: struct mbaddr *ap; ! 844: register struct buf *bp; ! 845: register struct hptype *st; ! 846: ! 847: reg = hp->addr; ! 848: bp = hp->actf; ! 849: ap = &hpaddr[UNIT(bp->b_dev)]; ! 850: st = &hptype[hp->type]; ! 851: mbadj(ap, off, size); ! 852: reg->hpdc = bno / st->nspc; ! 853: bno %= st->nspc; ! 854: reg->hpda = ((bno/st->nsect)<<8) | (bno%st->nsect); ! 855: mbcontin(ap); ! 856: if (bp->b_flags & B_READ) ! 857: reg->hpcs1 = HP_RCOM|HP_GO; ! 858: else ! 859: reg->hpcs1 = HP_WCOM|HP_GO; ! 860: } ! 861: ! 862: hpread(dev) ! 863: dev_t dev; ! 864: { ! 865: physio(hpstrategy, &hpbuf[UNIT(dev)], dev, B_READ, minphys); ! 866: } ! 867: ! 868: hpwrite(dev) ! 869: dev_t dev; ! 870: { ! 871: physio(hpstrategy, &hpbuf[UNIT(dev)], dev, B_WRITE, minphys); ! 872: } ! 873: ! 874: hpioctl(dev, cmd, addr, flag) ! 875: dev_t dev; ! 876: int cmd; ! 877: caddr_t addr; ! 878: int flag; ! 879: { ! 880: register struct hpdisk *hp; ! 881: long parts[2]; ! 882: ! 883: hp = &hpdisk[UNIT(dev)]; ! 884: switch (cmd) { ! 885: case DIOSSIZ: ! 886: if ((flag & FWRITE) == 0) { ! 887: u.u_error = EBADF; ! 888: return; ! 889: } ! 890: if (copyin(addr, (caddr_t)parts, sizeof(parts)) < 0) { ! 891: u.u_error = EFAULT; ! 892: return; ! 893: } ! 894: /* ! 895: * why test this? see comments above hpstrategy ! 896: */ ! 897: if ((parts[0] % hptype[hp->type].nspc) != 0) { ! 898: u.u_error = EINVAL; ! 899: return; ! 900: } ! 901: hp->blkoff[PART(dev)] = parts[0]; ! 902: hp->nblocks[PART(dev)] = parts[1]; ! 903: return; ! 904: ! 905: case DIOGSIZ: ! 906: parts[0] = hp->blkoff[PART(dev)]; ! 907: parts[1] = hp->nblocks[PART(dev)]; ! 908: if (copyout((caddr_t)parts, addr, sizeof(parts)) < 0) ! 909: u.u_error = EFAULT; ! 910: return; ! 911: ! 912: default: ! 913: u.u_error = ENOTTY; ! 914: return; ! 915: } ! 916: } ! 917: ! 918: /* ! 919: * check for offline drives and hung controllers ! 920: */ ! 921: ! 922: hpwatch() ! 923: { ! 924: register struct hpdisk *hp; ! 925: register struct hpdevice *reg; ! 926: register struct buf *bp; ! 927: register int s; ! 928: ! 929: s = spl6(); ! 930: timeout(hpwatch, (caddr_t)0, 15*HZ); ! 931: for (hp = &hpdisk[hpcnt-1]; hp >= hpdisk; hp--) { ! 932: if ((hp->flags & UWOL) == 0 || (reg = hp->addr) == 0) ! 933: continue; ! 934: if ((reg->hpds & (HPDS_DPR|HPDS_MOL)) != (HPDS_DPR|HPDS_MOL)) { ! 935: if ((hp->flags & UWAITOL) == 0) { ! 936: hp->flags |= UWAITOL; ! 937: continue; ! 938: } ! 939: printf("hp%d offline\n", hp - hpdisk); ! 940: while ((bp = hp->actf) != NULL) { ! 941: bp->b_flags |= B_ERROR; ! 942: hp->actf = bp->av_forw; ! 943: iodone(bp); ! 944: } ! 945: } ! 946: hp->flags &=~ (UWAITOL|UWOL); ! 947: hpustart(hp); ! 948: } ! 949: splx(s); ! 950: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.