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