![[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] / 42BSD / sys / stand|
Return to hp.c CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / stand |
1.1 ! root 1: /* hp.c 6.3 83/09/23 */ ! 2: ! 3: /* ! 4: * RP??/RM?? disk driver ! 5: * with ECC handling and bad block forwarding. ! 6: * Also supports header io operations and ! 7: * commands to write check header and data. ! 8: */ ! 9: #include "../h/param.h" ! 10: #include "../h/inode.h" ! 11: #include "../h/fs.h" ! 12: #include "../h/dkbad.h" ! 13: ! 14: #include "../vax/pte.h" ! 15: #include "../vaxmba/hpreg.h" ! 16: #include "../vaxmba/mbareg.h" ! 17: ! 18: #include "saio.h" ! 19: #include "savax.h" ! 20: ! 21: #define MASKREG(reg) ((reg)&0xffff) ! 22: ! 23: #define MAXBADDESC 126 ! 24: #define SECTSIZ 512 /* sector size in bytes */ ! 25: #define HDRSIZ 4 /* number of bytes in sector header */ ! 26: #define MAXECC 5 /* max # bits allow in ecc error w/ F_ECCLM */ ! 27: ! 28: char hp_type[MAXNMBA*8] = { 0 }; ! 29: extern struct st hpst[]; ! 30: ! 31: short hptypes[] = { ! 32: MBDT_RM03, ! 33: MBDT_RM05, ! 34: MBDT_RP06, ! 35: MBDT_RM80, ! 36: MBDT_RP05, ! 37: MBDT_RP07, ! 38: MBDT_ML11A, ! 39: MBDT_ML11B, ! 40: -1, /* 9755 */ ! 41: -1, /* 9730 */ ! 42: -1, /* Capricorn */ ! 43: -1, /* Eagle */ ! 44: MBDT_RM02, /* actually something else */ ! 45: -1, /* 9300 */ ! 46: 0 ! 47: }; ! 48: ! 49: #define RP06 (hptypes[hp_type[unit]] <= MBDT_RP06) ! 50: #define ML11 (hptypes[hp_type[unit]] == MBDT_ML11A) ! 51: #define RM80 (hptypes[hp_type[unit]] == MBDT_RM80) ! 52: ! 53: u_char hp_offset[16] = { ! 54: HPOF_P400, HPOF_M400, HPOF_P400, HPOF_M400, ! 55: HPOF_P800, HPOF_M800, HPOF_P800, HPOF_M800, ! 56: HPOF_P1200, HPOF_M1200, HPOF_P1200, HPOF_M1200, ! 57: 0, 0, 0, 0, ! 58: }; ! 59: ! 60: struct dkbad hpbad[MAXNMBA*8]; ! 61: int ssect[MAXNMBA*8]; /* 1 when on track w/skip sector */ ! 62: ! 63: int hpdebug[MAXNMBA*8]; ! 64: #define HPF_BSEDEBUG 01 /* debugging bad sector forwarding */ ! 65: #define HPF_ECCDEBUG 02 /* debugging ecc correction */ ! 66: ! 67: int sectsiz; ! 68: ! 69: /* ! 70: * When awaiting command completion, don't ! 71: * hang on to the status register since ! 72: * this ties up some controllers. ! 73: */ ! 74: #define HPWAIT(addr) \ ! 75: while ((((addr)->hpds)&HPDS_DRY)==0) DELAY(500); ! 76: ! 77: hpopen(io) ! 78: register struct iob *io; ! 79: { ! 80: register unit = io->i_unit; ! 81: struct hpdevice *hpaddr = (struct hpdevice *)mbadrv(unit); ! 82: register struct st *st; ! 83: ! 84: mbainit(UNITTOMBA(unit)); ! 85: if (hp_type[unit] == 0) { ! 86: register i, type = hpaddr->hpdt & MBDT_TYPE; ! 87: struct iob tio; ! 88: ! 89: for (i = 0; hptypes[i]; i++) ! 90: if (hptypes[i] == type) ! 91: goto found; ! 92: _stop("unknown drive type"); ! 93: found: ! 94: hpaddr->hpcs1 = HP_DCLR|HP_GO; /* init drive */ ! 95: hpaddr->hpcs1 = HP_PRESET|HP_GO; ! 96: if (!ML11) ! 97: hpaddr->hpof = HPOF_FMT22; ! 98: hp_type[unit] = hpmaptype(hpaddr, i, unit); ! 99: /* ! 100: * Read in the bad sector table. ! 101: */ ! 102: st = &hpst[hp_type[unit]]; ! 103: tio = *io; ! 104: tio.i_bn = st->nspc * st->ncyl - st->nsect; ! 105: tio.i_ma = (char *)&hpbad[unit]; ! 106: tio.i_cc = sizeof (struct dkbad); ! 107: tio.i_flgs |= F_RDDATA; ! 108: for (i = 0; i < 5; i++) { ! 109: if (hpstrategy(&tio, READ) == sizeof (struct dkbad)) ! 110: break; ! 111: tio.i_bn += 2; ! 112: } ! 113: if (i == 5) { ! 114: printf("Unable to read bad sector table\n"); ! 115: for (i = 0; i < MAXBADDESC; i++) { ! 116: hpbad[unit].bt_bad[i].bt_cyl = -1; ! 117: hpbad[unit].bt_bad[i].bt_trksec = -1; ! 118: } ! 119: } ! 120: } ! 121: if (io->i_boff < 0 || io->i_boff > 7 || ! 122: st->off[io->i_boff]== -1) ! 123: _stop("hp bad minor"); ! 124: io->i_boff = st->off[io->i_boff] * st->nspc; ! 125: } ! 126: ! 127: hpstrategy(io, func) ! 128: register struct iob *io; ! 129: { ! 130: register unit = io->i_unit; ! 131: struct mba_regs *mba = mbamba(unit); ! 132: daddr_t bn, startblock; ! 133: struct hpdevice *hpaddr = (struct hpdevice *)mbadrv(unit); ! 134: struct st *st = &hpst[hp_type[unit]]; ! 135: int cn, tn, sn, bytecnt, bytesleft; ! 136: char *membase; ! 137: int er1, er2, hprecal; ! 138: ! 139: sectsiz = SECTSIZ; ! 140: if ((io->i_flgs & (F_HDR|F_HCHECK)) != 0) ! 141: sectsiz += HDRSIZ; ! 142: if ((hpaddr->hpds & HPDS_VV) == 0) { ! 143: hpaddr->hpcs1 = HP_DCLR|HP_GO; ! 144: hpaddr->hpcs1 = HP_PRESET|HP_GO; ! 145: if (!ML11) ! 146: hpaddr->hpof = HPOF_FMT22; ! 147: } ! 148: io->i_errcnt = 0; ! 149: ssect[unit] = 0; ! 150: bytecnt = io->i_cc; ! 151: membase = io->i_ma; ! 152: startblock = io->i_bn; ! 153: hprecal = 0; ! 154: ! 155: restart: ! 156: bn = io->i_bn; ! 157: cn = bn/st->nspc; ! 158: sn = bn%st->nspc; ! 159: tn = sn/st->nsect; ! 160: sn = sn%st->nsect + ssect[unit]; ! 161: ! 162: HPWAIT(hpaddr); ! 163: mba->mba_sr = -1; ! 164: if (ML11) ! 165: hpaddr->hpda = bn; ! 166: else { ! 167: hpaddr->hpdc = cn; ! 168: hpaddr->hpda = (tn << 8) + sn; ! 169: } ! 170: if (mbastart(io, func) != 0) /* start transfer */ ! 171: return (-1); ! 172: HPWAIT(hpaddr); ! 173: /* ! 174: * Successful data transfer, return. ! 175: */ ! 176: if ((hpaddr->hpds&HPDS_ERR) == 0 && (mba->mba_sr&MBSR_EBITS) == 0) ! 177: goto done; ! 178: ! 179: /* ! 180: * Error handling. Calculate location of error. ! 181: */ ! 182: bytesleft = MASKREG(mba->mba_bcr); ! 183: if (bytesleft) ! 184: bytesleft |= 0xffff0000; /* sxt */ ! 185: bn = io->i_bn + (io->i_cc + bytesleft) / sectsiz; ! 186: er1 = MASKREG(hpaddr->hper1); ! 187: er2 = MASKREG(hpaddr->hper2); ! 188: if (er1 & (HPER1_DCK|HPER1_ECH)) ! 189: bn--; /* Error is in Prev block */ ! 190: cn = bn/st->nspc; ! 191: sn = bn%st->nspc; ! 192: tn = sn/st->nsect; ! 193: sn = sn%st->nsect; ! 194: if (hpdebug[unit] & (HPF_ECCDEBUG|HPF_BSEDEBUG)) { ! 195: printf("hp error: (cyl,trk,sec)=(%d,%d,%d) ds=%b\n", ! 196: cn, tn, sn, MASKREG(hpaddr->hpds), HPDS_BITS); ! 197: printf("er1=%b er2=%b\n", er1, HPER1_BITS, er2, HPER2_BITS); ! 198: printf("bytes left: %d, of 0x%x, da 0x%x\n",-bytesleft, ! 199: hpaddr->hpof, hpaddr->hpda); ! 200: } ! 201: if (er1 & HPER1_HCRC) { ! 202: er1 &= ~(HPER1_HCE|HPER1_FER); ! 203: er2 &= ~HPER2_BSE; ! 204: } ! 205: /* ! 206: * Give up early if drive write locked. ! 207: */ ! 208: if (er1&HPER1_WLE) { ! 209: printf("hp%d: write locked\n", unit); ! 210: return (-1); ! 211: } ! 212: /* ! 213: * Interpret format error bit as a bad block on RP06's. ! 214: */ ! 215: if (MASKREG(er1) == HPER1_FER && RP06) ! 216: goto badsect; ! 217: ! 218: /* ! 219: * If a hard error, or maximum retry count ! 220: * exceeded, clear controller state and ! 221: * pass back error to caller. ! 222: */ ! 223: if (++io->i_errcnt > 27 || (er1 & HPER1_HARD) || ! 224: (!ML11 && (er2 & HPER2_HARD))) { ! 225: /* ! 226: * The last ditch effort to bad sector forward ! 227: * below will probably fail since mba byte ctr ! 228: * (bcr) is different for BSE and ECC errors and ! 229: * the wrong block will be revectored to if one ! 230: * has 2 contiguous bad blocks and reads the second. ! 231: * For now, we can probably just let a header CRC ! 232: * error be handled like a BSE since no data will ! 233: * have been transferred and the bcr should the same ! 234: * as it would with a BSE error. ! 235: * --ghg. ! 236: */ ! 237: if (er1 & HPER1_HCRC) ! 238: if ((io->i_flgs&F_NBSF) == 0 && hpecc(io, BSE) == 0) ! 239: goto success; ! 240: hard0: ! 241: io->i_error = EHER; ! 242: if (mba->mba_sr & (MBSR_WCKUP|MBSR_WCKLWR)) ! 243: io->i_error = EWCK; ! 244: hard: ! 245: io->i_errblk = bn + ssect[unit]; ! 246: printf("hp error: (cyl,trk,sec)=(%d,%d,%d) ds=%b \n", ! 247: cn, tn, sn, MASKREG(hpaddr->hpds), HPDS_BITS); ! 248: printf("er1=%b er2=%b", er1, HPER1_BITS, er2, HPER2_BITS); ! 249: if (hpaddr->hpmr) ! 250: printf(" mr1=%o", MASKREG(hpaddr->hpmr)); ! 251: if (hpaddr->hpmr2) ! 252: printf(" mr2=%o", MASKREG(hpaddr->hpmr2)); ! 253: if (hpdebug[unit] & (HPF_BSEDEBUG|HPF_ECCDEBUG)) ! 254: printf(" dc=%d, da=0x%x",MASKREG(hpaddr->hpdc), ! 255: MASKREG(hpaddr->hpda)); ! 256: hpaddr->hpcs1 = HP_DCLR|HP_GO; ! 257: printf("\n"); ! 258: bytecnt = -1; ! 259: goto done; ! 260: ! 261: } ! 262: /* ! 263: * Attempt to forward bad sectors on ! 264: * anything but an ML11. If drive ! 265: * supports skip sector handling, try to ! 266: * use it first; otherwise try the ! 267: * bad sector table. ! 268: */ ! 269: if ((er2 & HPER2_BSE) && !ML11) { ! 270: badsect: ! 271: if (!ssect[unit] && (er2&HPER2_SSE)) ! 272: goto skipsect; ! 273: if (io->i_flgs & F_NBSF) { ! 274: io->i_error = EBSE; ! 275: goto hard; ! 276: } ! 277: if (hpecc(io, BSE) == 0) ! 278: goto success; ! 279: io->i_error = EBSE; ! 280: goto hard; ! 281: } ! 282: ! 283: /* ! 284: * Skip sector handling. ! 285: */ ! 286: if (RM80 && (er2 & HPER2_SSE)) { ! 287: skipsect: ! 288: (void) hpecc(io, SSE); ! 289: ssect[unit] = 1; ! 290: goto success; ! 291: } ! 292: /* ! 293: * ECC correction? ! 294: */ ! 295: if ((er1 & (HPER1_DCK|HPER1_ECH)) == HPER1_DCK) { ! 296: if (hpecc(io, ECC) == 0) ! 297: goto success; ! 298: io->i_error = EECC; ! 299: io->i_errblk = bn + ssect[unit]; ! 300: return (-1); ! 301: } ! 302: #ifdef F_SEVRE ! 303: if (io->i_flgs & F_SEVRE) ! 304: goto hard; ! 305: #endif ! 306: if (ML11 && (io->i_errcnt >= 16)) ! 307: goto hard0; ! 308: /* fall thru to retry */ ! 309: hpaddr->hpcs1 = HP_DCLR|HP_GO; ! 310: HPWAIT(hpaddr); ! 311: ! 312: /* ! 313: * Every fourth retry recalibrate. ! 314: */ ! 315: if (((io->i_errcnt & 07) == 4) ) { ! 316: hpaddr->hpcs1 = HP_RECAL|HP_GO; ! 317: HPWAIT(hpaddr); ! 318: hpaddr->hpdc = cn; ! 319: hpaddr->hpcs1 = HP_SEEK|HP_GO; ! 320: HPWAIT(hpaddr); ! 321: } ! 322: ! 323: if (io->i_errcnt >= 16 && (io->i_flgs & F_READ)) { ! 324: hpaddr->hpof = hp_offset[io->i_errcnt & 017]|HPOF_FMT22; ! 325: hpaddr->hpcs1 = HP_OFFSET|HP_GO; ! 326: HPWAIT(hpaddr); ! 327: } ! 328: if (hpdebug[unit] & (HPF_ECCDEBUG|HPF_BSEDEBUG)) ! 329: printf("restart: bn=%d, cc=%d, ma=0x%x hprecal=%d\n", ! 330: io->i_bn, io->i_cc, io->i_ma, hprecal); ! 331: goto restart; /* retry whole transfer --ghg */ ! 332: ! 333: success: ! 334: /* ! 335: * On successful error recovery, bump ! 336: * block number to advance to next portion ! 337: * of i/o transfer. ! 338: */ ! 339: bn++; ! 340: if ((bn-startblock) * sectsiz < bytecnt) { ! 341: io->i_bn = bn; ! 342: io->i_ma = membase + (io->i_bn - startblock)*sectsiz; ! 343: io->i_cc = bytecnt - (io->i_bn - startblock)*sectsiz; ! 344: if (hpdebug[unit] & (HPF_ECCDEBUG|HPF_BSEDEBUG)) ! 345: printf("restart: bn=%d, cc=%d, ma=0x%x hprecal=%d\n", ! 346: io->i_bn, io->i_cc, io->i_ma, hprecal); ! 347: goto restart; ! 348: } ! 349: done: ! 350: if (io->i_errcnt >= 16) { ! 351: hpaddr->hpcs1 = HP_RTC|HP_GO; ! 352: while (hpaddr->hpds & HPDS_PIP) ! 353: ; ! 354: } ! 355: return (bytecnt); ! 356: } ! 357: ! 358: hpecc(io, flag) ! 359: register struct iob *io; ! 360: int flag; ! 361: { ! 362: register unit = io->i_unit; ! 363: register struct mba_regs *mbp = mbamba(unit); ! 364: register struct hpdevice *rp = (struct hpdevice *)mbadrv(unit); ! 365: register struct st *st = &hpst[hp_type[unit]]; ! 366: int npf, bn, cn, tn, sn, bcr; ! 367: ! 368: bcr = MASKREG(mbp->mba_bcr); ! 369: if (bcr) ! 370: bcr |= 0xffff0000; /* sxt */ ! 371: npf = (bcr + io->i_cc) / sectsiz; /* # sectors read */ ! 372: if (flag == ECC) ! 373: npf--; /* Error is in prev block --ghg */ ! 374: bn = io->i_bn + npf + ssect[unit]; /* physical block #*/ ! 375: if (hpdebug[unit]&HPF_ECCDEBUG) ! 376: printf("bcr=%d npf=%d ssect=%d sectsiz=%d i_cc=%d\n", ! 377: bcr, npf, ssect[unit], sectsiz, io->i_cc); ! 378: /* ! 379: * ECC correction logic. ! 380: */ ! 381: if (flag == ECC) { ! 382: register int i; ! 383: caddr_t addr; ! 384: int bit, o, mask, ecccnt = 0; ! 385: ! 386: printf("hp%d: soft ecc sn%d\n", unit, bn); ! 387: mask = MASKREG(rp->hpec2); ! 388: i = MASKREG(rp->hpec1) - 1; /* -1 makes 0 origin */ ! 389: bit = i&07; ! 390: o = (i & ~07) >> 3; ! 391: rp->hpcs1 = HP_DCLR | HP_GO; ! 392: while (o <sectsiz && npf*sectsiz + o < io->i_cc && bit > -11) { ! 393: addr = io->i_ma + (npf*sectsiz) + o; ! 394: /* ! 395: * No data transfer occurs with a write check, ! 396: * so don't correct the resident copy of data. ! 397: */ ! 398: if ((io->i_flgs & (F_CHECK|F_HCHECK)) == 0) { ! 399: if (hpdebug[unit] & HPF_ECCDEBUG) ! 400: printf("addr=%x old=%x ", addr, ! 401: (*addr & 0xff)); ! 402: *addr ^= (mask << bit); ! 403: if (hpdebug[unit] & HPF_ECCDEBUG) ! 404: printf("new=%x\n",(*addr & 0xff)); ! 405: } ! 406: o++, bit -= 8; ! 407: if ((io->i_flgs & F_ECCLM) && ecccnt++ >= MAXECC) ! 408: return (1); ! 409: } ! 410: #ifdef F_SEVRE ! 411: if (io->i_flgs & F_SEVRE) ! 412: return(1); ! 413: #endif ! 414: return (0); ! 415: } ! 416: ! 417: /* ! 418: * Skip sector error. ! 419: * Set skip-sector-inhibit and ! 420: * read next sector ! 421: */ ! 422: if (flag == SSE) { ! 423: rp->hpcs1 = HP_DCLR | HP_GO; ! 424: HPWAIT(rp); ! 425: rp->hpof |= HPOF_SSEI; ! 426: return (0); ! 427: } ! 428: ! 429: /* ! 430: * Bad block forwarding. ! 431: */ ! 432: if (flag == BSE) { ! 433: int bbn; ! 434: ! 435: rp->hpcs1 = HP_DCLR | HP_GO; ! 436: if (hpdebug[unit] & HPF_BSEDEBUG) ! 437: printf("hpecc: BSE @ bn %d\n", bn); ! 438: cn = bn/st->nspc; ! 439: sn = bn%st->nspc; ! 440: tn = sn/st->nsect; ! 441: sn = sn%st->nsect; ! 442: bcr += sectsiz; ! 443: if ((bbn = isbad(&hpbad[unit], cn, tn, sn)) < 0) ! 444: return (1); ! 445: bbn = st->ncyl*st->nspc - st->nsect - 1 - bbn; ! 446: cn = bbn/st->nspc; ! 447: sn = bbn%st->nspc; ! 448: tn = sn/st->nsect; ! 449: sn = sn%st->nsect; ! 450: io->i_cc = sectsiz; ! 451: io->i_ma += npf*sectsiz; ! 452: if (hpdebug[unit] & HPF_BSEDEBUG) ! 453: printf("revector to cn %d tn %d sn %d\n", cn, tn, sn); ! 454: rp->hpof &= ~HPOF_SSEI; ! 455: mbp->mba_sr = -1; ! 456: rp->hpdc = cn; ! 457: rp->hpda = (tn<<8) + sn; ! 458: mbastart(io,io->i_flgs); ! 459: io->i_errcnt = 0; ! 460: HPWAIT(rp); ! 461: return (rp->hpds&HPDS_ERR); ! 462: } ! 463: printf("hpecc: flag=%d\n", flag); ! 464: return (1); ! 465: } ! 466: ! 467: /*ARGSUSED*/ ! 468: hpioctl(io, cmd, arg) ! 469: struct iob *io; ! 470: int cmd; ! 471: caddr_t arg; ! 472: { ! 473: register unit = io->i_unit; ! 474: struct st *st = &hpst[hp_type[unit]], *tmp; ! 475: struct mba_drv *drv = mbadrv(unit); ! 476: int flag; ! 477: ! 478: switch(cmd) { ! 479: ! 480: case SAIODEBUG: ! 481: flag = (int)arg; ! 482: if (flag > 0) ! 483: hpdebug[unit] |= flag; ! 484: else ! 485: hpdebug[unit] &= ~flag; ! 486: return (0); ! 487: ! 488: case SAIODEVDATA: ! 489: if ((drv->mbd_dt&MBDT_TAP) == 0) { ! 490: tmp = (struct st *)arg; ! 491: *tmp = *st; ! 492: return (0); ! 493: } ! 494: return (ECMD); ! 495: ! 496: case SAIOSSI: /* skip-sector-inhibit */ ! 497: if (drv->mbd_dt&MBDT_TAP) ! 498: return (ECMD); ! 499: if ((io->i_flgs&F_SSI) == 0) { ! 500: /* make sure this is done once only */ ! 501: io->i_flgs |= F_SSI; ! 502: st->nsect++; ! 503: st->nspc += st->ntrak; ! 504: } ! 505: return (0); ! 506: ! 507: case SAIONOSSI: /* remove skip-sector-inhibit */ ! 508: if (io->i_flgs & F_SSI) { ! 509: io->i_flgs &= ~F_SSI; ! 510: drv->mbd_of &= ~HPOF_SSEI; ! 511: st->nsect--; ! 512: st->nspc -= st->ntrak; ! 513: } ! 514: return(0); ! 515: ! 516: case SAIOSSDEV: /* drive have skip sector? */ ! 517: return (RM80 ? 0 : ECMD); ! 518: } ! 519: return (ECMD); ! 520: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.