![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to up.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxstand|
Return to up.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxstand |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1988 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: * @(#)up.c 7.7 (Berkeley) 7/9/88 ! 7: */ ! 8: ! 9: /* ! 10: * UNIBUS peripheral standalone driver with ECC correction and bad ! 11: * block forwarding. Also supports header operation and write check ! 12: * for data and/or header. ! 13: */ ! 14: #include "param.h" ! 15: #include "inode.h" ! 16: #include "fs.h" ! 17: #include "dkbad.h" ! 18: #include "disklabel.h" ! 19: ! 20: #include "../vax/pte.h" ! 21: ! 22: #include "../vaxuba/upreg.h" ! 23: #include "../vaxuba/ubareg.h" ! 24: ! 25: #include "saio.h" ! 26: #include "savax.h" ! 27: ! 28: #define RETRIES 27 ! 29: ! 30: #define MAXBADDESC 126 /* max number of bad sectors recorded */ ! 31: #define SECTSIZ 512 /* sector size in bytes */ ! 32: #define HDRSIZ 4 /* number of bytes in sector header */ ! 33: ! 34: #define MAXUNIT 8 ! 35: #define MAXCTLR 1 /* all addresses must be specified */ ! 36: u_short ubastd[MAXCTLR] = { 0776700 }; ! 37: struct disklabel uplabel[MAXNUBA][MAXCTLR][MAXUNIT]; ! 38: char lbuf[SECTSIZ]; ! 39: ! 40: extern struct st upst[]; ! 41: ! 42: #ifndef SMALL ! 43: struct dkbad upbad[MAXNUBA][MAXCTLR][MAXUNIT]; /* bad sector table */ ! 44: #endif ! 45: int sectsiz; /* real sector size */ ! 46: ! 47: struct up_softc { ! 48: char gottype; ! 49: char type; ! 50: char debug; ! 51: # define UPF_BSEDEBUG 01 /* debugging bad sector forwarding */ ! 52: # define UPF_ECCDEBUG 02 /* debugging ecc correction */ ! 53: int retries; ! 54: int ecclim; ! 55: } up_softc[MAXNUBA][MAXCTLR][MAXUNIT]; ! 56: ! 57: u_char up_offset[16] = { ! 58: UPOF_P400, UPOF_M400, UPOF_P400, UPOF_M400, ! 59: UPOF_P800, UPOF_M800, UPOF_P800, UPOF_M800, ! 60: UPOF_P1200, UPOF_M1200, UPOF_P1200, UPOF_M1200, ! 61: 0, 0, 0, 0 ! 62: }; ! 63: ! 64: upopen(io) ! 65: register struct iob *io; ! 66: { ! 67: register struct updevice *upaddr; ! 68: register struct up_softc *sc; ! 69: register struct st *st; ! 70: register struct disklabel *lp; ! 71: struct disklabel *dlp; ! 72: register int unit; ! 73: int error = 0, uba, ctlr; ! 74: ! 75: if ((u_int)(uba = io->i_adapt) >= nuba) ! 76: return (EADAPT); ! 77: if ((u_int)(ctlr = io->i_ctlr) >= MAXCTLR) ! 78: return (ECTLR); ! 79: unit = io->i_unit; ! 80: if ((u_int)unit >= MAXUNIT) ! 81: return (EUNIT); ! 82: upaddr = (struct updevice *)ubamem(uba, ubastd[ctlr]); ! 83: upaddr->upcs2 = unit; ! 84: while ((upaddr->upcs1 & UP_DVA) == 0); ! 85: sc = &up_softc[uba][ctlr][unit]; ! 86: lp = &uplabel[uba][ctlr][unit]; ! 87: if (sc->gottype == 0) { ! 88: register int i; ! 89: struct iob tio; ! 90: ! 91: #ifndef SMALL ! 92: sc->retries = RETRIES; ! 93: sc->ecclim = 11; ! 94: sc->debug = 0; ! 95: #endif ! 96: /* Read in the pack label. */ ! 97: lp->d_nsectors = 32; ! 98: lp->d_secpercyl = 19*32; ! 99: tio = *io; ! 100: tio.i_bn = LABELSECTOR; ! 101: tio.i_ma = lbuf; ! 102: tio.i_cc = SECTSIZ; ! 103: tio.i_flgs |= F_RDDATA; ! 104: if (upstrategy(&tio, READ) != SECTSIZ) ! 105: error = ERDLAB; ! 106: dlp = (struct disklabel *)(lbuf + LABELOFFSET); ! 107: if (error == 0 && (dlp->d_magic != DISKMAGIC || ! 108: dlp->d_magic2 != DISKMAGIC)) ! 109: error = EUNLAB; ! 110: if (error == 0) ! 111: *lp = *dlp; ! 112: else ! 113: #ifdef COMPAT_42 ! 114: if (upmaptype(unit, upaddr, lp) == 0) ! 115: #endif ! 116: return (error); ! 117: ! 118: #ifndef SMALL ! 119: /* Read in the bad sector table. */ ! 120: tio.i_bn = lp->d_secpercyl * lp->d_ncylinders - lp->d_nsectors; ! 121: tio.i_ma = (char *)&upbad[uba][ctlr][unit]; ! 122: tio.i_cc = sizeof(struct dkbad); ! 123: tio.i_flgs |= F_RDDATA; ! 124: for (i = 0; i < 5; i++) { ! 125: if (upstrategy(&tio, READ) == sizeof(struct dkbad)) ! 126: break; ! 127: tio.i_bn += 2; ! 128: } ! 129: if (i == 5) { ! 130: printf("up: can't read bad sector table\n"); ! 131: for (i = 0; i < MAXBADDESC; i++) { ! 132: upbad[uba][ctlr][unit].bt_bad[i].bt_cyl = -1; ! 133: upbad[uba][ctlr][unit].bt_bad[i].bt_trksec = -1; ! 134: } ! 135: } ! 136: #endif ! 137: sc->gottype = 1; ! 138: } ! 139: if (io->i_part >= lp->d_npartitions || ! 140: lp->d_partitions[io->i_part].p_size == 0) ! 141: return (EPART); ! 142: io->i_boff = lp->d_partitions[io->i_part].p_offset; ! 143: io->i_flgs &= ~F_TYPEMASK; ! 144: return (0); ! 145: } ! 146: ! 147: upstrategy(io, func) ! 148: register struct iob *io; ! 149: int func; ! 150: { ! 151: int cn, tn, sn, o; ! 152: register unit = io->i_unit; ! 153: register daddr_t bn; ! 154: int recal, info, waitdry; ! 155: register struct updevice *upaddr; ! 156: register struct disklabel *lp; ! 157: struct up_softc *sc; ! 158: int error, rv = io->i_cc; ! 159: #ifndef SMALL ! 160: int doprintf = 0; ! 161: #endif ! 162: ! 163: upaddr = (struct updevice *)ubamem(io->i_adapt, ubastd[io->i_ctlr]); ! 164: sc = &up_softc[io->i_adapt][io->i_ctlr][unit]; ! 165: lp = &uplabel[io->i_adapt][io->i_ctlr][unit]; ! 166: sectsiz = SECTSIZ; ! 167: #ifndef SMALL ! 168: if (io->i_flgs & (F_HDR|F_HCHECK)) ! 169: sectsiz += HDRSIZ; ! 170: #endif ! 171: upaddr->upcs2 = unit; ! 172: if ((upaddr->upds & UPDS_VV) == 0) { ! 173: upaddr->upcs1 = UP_DCLR|UP_GO; ! 174: upaddr->upcs1 = UP_PRESET|UP_GO; ! 175: upaddr->upof = UPOF_FMT22; ! 176: } ! 177: if ((upaddr->upds & UPDS_DREADY) == 0) { ! 178: printf("up%d not ready\n", unit); ! 179: return (-1); ! 180: } ! 181: info = ubasetup(io, 1); ! 182: upaddr->upwc = -io->i_cc / sizeof (short); ! 183: recal = 0; ! 184: io->i_errcnt = 0; ! 185: ! 186: restart: ! 187: o = io->i_cc + (upaddr->upwc * sizeof (short)); ! 188: upaddr->upba = info + o; ! 189: bn = io->i_bn + o / sectsiz; ! 190: #ifndef SMALL ! 191: error = 0; ! 192: if (doprintf && sc->debug & (UPF_ECCDEBUG|UPF_BSEDEBUG)) ! 193: printf("wc=%d o=%d i_bn=%d bn=%d\n", ! 194: upaddr->upwc, o, io->i_bn, bn); ! 195: #endif ! 196: upwaitdry(upaddr); ! 197: if (upstart(io, bn, lp) != 0) { ! 198: rv = -1; ! 199: goto done; ! 200: } ! 201: upwaitrdy(upaddr); ! 202: /* ! 203: * If transfer has completed, free UNIBUS ! 204: * resources and return transfer size. ! 205: */ ! 206: if ((upaddr->upds&UPDS_ERR) == 0 && (upaddr->upcs1&UP_TRE) == 0) ! 207: goto done; ! 208: bn = io->i_bn + ! 209: (io->i_cc + upaddr->upwc * sizeof (short)) / sectsiz; ! 210: if (upaddr->uper1 & (UPER1_DCK|UPER1_ECH)) ! 211: bn--; ! 212: cn = bn / lp->d_secpercyl; ! 213: sn = bn % lp->d_secpercyl; ! 214: tn = sn / lp->d_nsectors; ! 215: sn = sn % lp->d_nsectors; ! 216: #ifndef SMALL ! 217: if (sc->debug & (UPF_ECCDEBUG|UPF_BSEDEBUG)) { ! 218: printf("up error: sn%d (cyl,trk,sec)=(%d,%d,%d) ", ! 219: bn, cn, tn, sn); ! 220: printf("cs2=%b er1=%b er2=%b wc=%d\n", ! 221: upaddr->upcs2, UPCS2_BITS, upaddr->uper1, ! 222: UPER1_BITS, upaddr->uper2, UPER2_BITS, upaddr->upwc); ! 223: } ! 224: #endif ! 225: waitdry = 0; ! 226: while ((upaddr->upds&UPDS_DRY) == 0 && ++waitdry < sectsiz) ! 227: DELAY(5); ! 228: #ifndef SMALL ! 229: if (upaddr->uper1&UPER1_WLE) { ! 230: /* ! 231: * Give up on write locked devices immediately. ! 232: */ ! 233: printf("up%d: write locked\n", unit); ! 234: rv = -1; ! 235: goto done; ! 236: } ! 237: if (upaddr->uper2 & UPER2_BSE) { ! 238: if ((io->i_flgs&F_NBSF) == 0 && upecc(io, BSE) == 0) ! 239: goto success; ! 240: error = EBSE; ! 241: goto hard; ! 242: } ! 243: /* ! 244: * ECC error. If a soft error, correct it; ! 245: * if correction is too large, no more retries. ! 246: */ ! 247: if ((upaddr->uper1 & (UPER1_DCK|UPER1_ECH|UPER1_HCRC)) == UPER1_DCK) { ! 248: if (upecc(io, ECC) == 0) ! 249: goto success; ! 250: error = EECC; ! 251: goto hard; ! 252: } ! 253: /* ! 254: * If the error is a header CRC, check if a replacement sector ! 255: * exists in the bad sector table. ! 256: */ ! 257: if ((upaddr->uper1&UPER1_HCRC) && (io->i_flgs&F_NBSF) == 0 && ! 258: upecc(io, BSE) == 0) ! 259: goto success; ! 260: #endif ! 261: if (++io->i_errcnt > sc->retries) { ! 262: /* ! 263: * After 28 retries (16 without offset, and ! 264: * 12 with offset positioning) give up. ! 265: */ ! 266: hard: ! 267: #ifndef SMALL ! 268: if (error == 0) { ! 269: error = EHER; ! 270: if (upaddr->upcs2 & UPCS2_WCE) ! 271: error = EWCK; ! 272: } ! 273: io->i_error = error; ! 274: #endif ! 275: printf("up error: sn%d (cyl,trk,sec)=(%d,%d,%d) ", ! 276: bn, cn, tn, sn); ! 277: printf("cs2=%b er1=%b er2=%b\n", ! 278: upaddr->upcs2, UPCS2_BITS, upaddr->uper1, ! 279: UPER1_BITS, upaddr->uper2, UPER2_BITS); ! 280: upaddr->upcs1 = UP_TRE|UP_DCLR|UP_GO; ! 281: io->i_errblk = bn; ! 282: if (io->i_errcnt >= 16) { ! 283: upaddr->upof = UPOF_FMT22; ! 284: upaddr->upcs1 = UP_RTC|UP_GO; ! 285: upwaitdry(upaddr); ! 286: } ! 287: rv = -1; ! 288: goto done; ! 289: } ! 290: /* ! 291: * Clear drive error and, every eight attempts, (starting with the ! 292: * fourth) recalibrate to clear the slate. ! 293: */ ! 294: upaddr->upcs1 = UP_TRE|UP_DCLR|UP_GO; ! 295: if ((io->i_errcnt&07) == 4 ) { ! 296: upaddr->upcs1 = UP_RECAL|UP_GO; ! 297: upwaitdry(upaddr); ! 298: upaddr->updc = cn; ! 299: upaddr->upcs1 = UP_SEEK|UP_GO; ! 300: upwaitdry(upaddr); ! 301: } ! 302: if (io->i_errcnt >= 16 && (func & READ)) { ! 303: upaddr->upof = up_offset[io->i_errcnt & 017] | UPOF_FMT22; ! 304: upaddr->upcs1 = UP_OFFSET|UP_GO; ! 305: upwaitdry(upaddr); ! 306: } ! 307: goto restart; ! 308: ! 309: success: ! 310: #define rounddown(x, y) (((x) / (y)) * (y)) ! 311: upaddr->upwc = rounddown(upaddr->upwc, sectsiz / sizeof (short)); ! 312: if (upaddr->upwc) { ! 313: #ifndef SMALL ! 314: doprintf++; ! 315: #endif ! 316: goto restart; ! 317: } ! 318: done: ! 319: ubafree(io, info); ! 320: /* ! 321: * If we were offset positioning, ! 322: * return to centerline. ! 323: */ ! 324: if (io->i_errcnt >= 16) { ! 325: upaddr->upof = UPOF_FMT22; ! 326: upaddr->upcs1 = UP_RTC|UP_GO; ! 327: upwaitdry(upaddr); ! 328: } ! 329: return (rv); ! 330: } ! 331: ! 332: upwaitrdy(upaddr) ! 333: register struct updevice *upaddr; ! 334: { ! 335: do { ! 336: DELAY(25); ! 337: } while ((upaddr->upcs1 & UP_RDY) == 0); ! 338: } ! 339: ! 340: upwaitdry(upaddr) ! 341: register struct updevice *upaddr; ! 342: { ! 343: while ((upaddr->upds&UPDS_DRY) == 0) ! 344: DELAY(25); ! 345: } ! 346: ! 347: #ifndef SMALL ! 348: /* ! 349: * Correct an ECC error, and restart the i/o to complete the transfer (if ! 350: * necessary). This is quite complicated because the transfer may be going ! 351: * to an odd memory address base and/or across a page boundary. ! 352: */ ! 353: upecc(io, flag) ! 354: register struct iob *io; ! 355: int flag; ! 356: { ! 357: register i, unit; ! 358: register struct up_softc *sc; ! 359: register struct updevice *up; ! 360: register struct disklabel *lp; ! 361: caddr_t addr; ! 362: int bn, twc, npf, mask, cn, tn, sn; ! 363: daddr_t bbn; ! 364: ! 365: /* ! 366: * Npf is the number of sectors transferred ! 367: * before the sector containing the ECC error; ! 368: * bn is the current block number. ! 369: */ ! 370: unit = io->i_unit; ! 371: sc = &up_softc[io->i_adapt][io->i_ctlr][unit]; ! 372: lp = &uplabel[io->i_adapt][io->i_ctlr][unit]; ! 373: up = (struct updevice *)ubamem(io->i_adapt, ubastd[io->i_ctlr]); ! 374: twc = up->upwc; ! 375: npf = ((twc * sizeof(short)) + io->i_cc) / sectsiz; ! 376: if (flag == ECC) ! 377: npf--; ! 378: if (sc->debug & UPF_ECCDEBUG) ! 379: printf("npf=%d mask=0x%x ec1=%d wc=%d\n", ! 380: npf, up->upec2, up->upec1, twc); ! 381: bn = io->i_bn + npf; ! 382: cn = bn / lp->d_secpercyl; ! 383: sn = bn % lp->d_secpercyl; ! 384: tn = sn / lp->d_nsectors; ! 385: sn = sn % lp->d_nsectors; ! 386: ! 387: /* ! 388: * ECC correction. ! 389: */ ! 390: if (flag == ECC) { ! 391: int bit, o; ! 392: ! 393: mask = up->upec2; ! 394: printf("up%d: soft ecc sn%d\n", unit, bn); ! 395: for (i = mask, bit = 0; i; i >>= 1) ! 396: if (i & 1) ! 397: bit++; ! 398: if (bit > sc->ecclim) { ! 399: printf("%d-bit error\n", bit); ! 400: return (1); ! 401: } ! 402: /* ! 403: * Compute the byte and bit position of ! 404: * the error. o is the byte offset in ! 405: * the transfer at which the correction ! 406: * applied. ! 407: */ ! 408: i = up->upec1 - 1; /* -1 makes 0 origin */ ! 409: bit = i & 07; ! 410: o = (i & ~07) >> 3; ! 411: up->upcs1 = UP_TRE|UP_DCLR|UP_GO; ! 412: /* ! 413: * Correct while possible bits remain of mask. ! 414: * Since mask contains 11 bits, we continue while ! 415: * the bit offset is > -11. Also watch out for ! 416: * end of this block and the end of the transfer. ! 417: */ ! 418: while (o < sectsiz && (npf*sectsiz)+o < io->i_cc && bit > -11) { ! 419: /* ! 420: * addr = ! 421: * (base address of transfer) + ! 422: * (# sectors transferred before the error) * ! 423: * (sector size) + ! 424: * (byte offset to incorrect data) ! 425: */ ! 426: addr = io->i_ma + (npf * sectsiz) + o; ! 427: /* ! 428: * No data transfer occurs with a write check, ! 429: * so don't correct the resident copy of data. ! 430: */ ! 431: if ((io->i_flgs & (F_CHECK|F_HCHECK)) == 0) { ! 432: if (sc->debug & UPF_ECCDEBUG) ! 433: printf("addr=0x%x old=0x%x ", addr, ! 434: (*addr&0xff)); ! 435: *addr ^= (mask << bit); ! 436: if (sc->debug & UPF_ECCDEBUG) ! 437: printf("new=0x%x\n", (*addr&0xff)); ! 438: } ! 439: o++, bit -= 8; ! 440: } ! 441: return (0); ! 442: } ! 443: ! 444: /* ! 445: * Bad sector forwarding. ! 446: */ ! 447: if (flag == BSE) { ! 448: /* ! 449: * If not in bad sector table, ! 450: * indicate a hard error to caller. ! 451: */ ! 452: up->upcs1 = UP_TRE|UP_DCLR|UP_GO; ! 453: if ((bbn = isbad(&upbad[io->i_adapt][io->i_ctlr][unit], cn, tn, sn)) < 0) ! 454: return (1); ! 455: bbn = (lp->d_ncylinders * lp->d_secpercyl) - ! 456: lp->d_nsectors - 1 - bbn; ! 457: twc = up->upwc + sectsiz; ! 458: up->upwc = - (sectsiz / sizeof (short)); ! 459: if (sc->debug & UPF_BSEDEBUG) ! 460: printf("revector sn %d to %d\n", sn, bbn); ! 461: /* ! 462: * Clear the drive & read the replacement ! 463: * sector. If this is in the middle of a ! 464: * transfer, then set up the controller ! 465: * registers in a normal fashion. ! 466: * The UNIBUS address need not be changed. ! 467: */ ! 468: upwaitrdy(up); ! 469: if (upstart(io, bbn, lp)) ! 470: return (1); /* error */ ! 471: io->i_errcnt = 0; /* success */ ! 472: upwaitrdy(up); ! 473: if ((up->upds & UPDS_ERR) || (up->upcs1 & UP_TRE)) { ! 474: up->upwc = twc - sectsiz; ! 475: return (1); ! 476: } ! 477: } ! 478: if (twc) ! 479: up->upwc = twc; ! 480: return (0); ! 481: } ! 482: #endif /* !SMALL */ ! 483: ! 484: upstart(io, bn, lp) ! 485: register struct iob *io; ! 486: daddr_t bn; ! 487: register struct disklabel *lp; ! 488: { ! 489: register struct updevice *upaddr; ! 490: register struct up_softc *sc; ! 491: int sn, tn; ! 492: ! 493: upaddr = (struct updevice *)ubamem(io->i_adapt, ubastd[io->i_ctlr]); ! 494: sc = &up_softc[io->i_adapt][io->i_ctlr][io->i_unit]; ! 495: sn = bn % lp->d_secpercyl; ! 496: tn = sn / lp->d_nsectors; ! 497: sn = sn % lp->d_nsectors; ! 498: upaddr->updc = bn / lp->d_secpercyl; ! 499: upaddr->upda = (tn << 8) + sn; ! 500: switch (io->i_flgs & F_TYPEMASK) { ! 501: ! 502: case F_RDDATA: ! 503: upaddr->upcs1 = UP_RCOM|UP_GO; ! 504: break; ! 505: ! 506: case F_WRDATA: ! 507: upaddr->upcs1 = UP_WCOM|UP_GO; ! 508: break; ! 509: ! 510: #ifndef SMALL ! 511: case F_HDR|F_RDDATA: ! 512: upaddr->upcs1 = UP_RHDR|UP_GO; ! 513: break; ! 514: ! 515: case F_HDR|F_WRDATA: ! 516: upaddr->upcs1 = UP_WHDR|UP_GO; ! 517: break; ! 518: ! 519: case F_CHECK|F_WRDATA: ! 520: case F_CHECK|F_RDDATA: ! 521: upaddr->upcs1 = UP_WCDATA|UP_GO; ! 522: break; ! 523: ! 524: case F_HCHECK|F_WRDATA: ! 525: case F_HCHECK|F_RDDATA: ! 526: upaddr->upcs1 = UP_WCHDR|UP_GO; ! 527: break; ! 528: #endif ! 529: ! 530: default: ! 531: io->i_error = ECMD; ! 532: io->i_flgs &= ~F_TYPEMASK; ! 533: return (1); ! 534: } ! 535: return (0); ! 536: } ! 537: ! 538: #ifndef SMALL ! 539: /*ARGSUSED*/ ! 540: upioctl(io, cmd, arg) ! 541: struct iob *io; ! 542: int cmd; ! 543: caddr_t arg; ! 544: { ! 545: register struct up_softc *sc; ! 546: ! 547: sc = &up_softc[io->i_adapt][io->i_ctlr][io->i_unit]; ! 548: switch(cmd) { ! 549: case SAIODEBUG: ! 550: sc->debug = (int)arg; ! 551: break; ! 552: case SAIODEVDATA: ! 553: *(struct disklabel *)arg = ! 554: uplabel[io->i_adapt][io->i_ctlr][io->i_unit]; ! 555: break; ! 556: case SAIOGBADINFO: ! 557: *(struct dkbad *)arg = ! 558: upbad[io->i_adapt][io->i_ctlr][io->i_unit]; ! 559: break; ! 560: case SAIOECCLIM: ! 561: sc->ecclim = (int)arg; ! 562: break; ! 563: case SAIORETRIES: ! 564: sc->retries = (int)arg; ! 565: break; ! 566: default: ! 567: return (ECMD); ! 568: } ! 569: return (0); ! 570: } ! 571: #endif /* !SMALL */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.