![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba|
Return to rk.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba |
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: * @(#)rk.c 7.1 (Berkeley) 6/5/86 ! 7: */ ! 8: ! 9: #include "rk.h" ! 10: #if NHK > 0 ! 11: int rkpip; /* DEBUG */ ! 12: int rknosval; /* DEBUG */ ! 13: #ifdef RKDEBUG ! 14: int rkdebug; ! 15: #endif ! 16: #ifdef RKBDEBUG ! 17: int rkbdebug; ! 18: #endif ! 19: /* ! 20: * RK611/RK0[67] disk driver ! 21: * ! 22: * This driver mimics up.c; see it for an explanation of common code. ! 23: * ! 24: * TODO: ! 25: * Learn why we lose an interrupt sometime when spinning drives down ! 26: */ ! 27: #include "../machine/pte.h" ! 28: ! 29: #include "param.h" ! 30: #include "systm.h" ! 31: #include "buf.h" ! 32: #include "conf.h" ! 33: #include "dir.h" ! 34: #include "user.h" ! 35: #include "map.h" ! 36: #include "vm.h" ! 37: #include "dk.h" ! 38: #include "cmap.h" ! 39: #include "dkbad.h" ! 40: #include "uio.h" ! 41: #include "kernel.h" ! 42: #include "syslog.h" ! 43: ! 44: #include "../vax/cpu.h" ! 45: #include "ubareg.h" ! 46: #include "ubavar.h" ! 47: #include "rkreg.h" ! 48: ! 49: struct rk_softc { ! 50: int sc_softas; ! 51: int sc_ndrive; ! 52: int sc_wticks; ! 53: int sc_recal; ! 54: } rk_softc[NHK]; ! 55: ! 56: #define rkunit(dev) (minor(dev) >> 3) ! 57: ! 58: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */ ! 59: struct size { ! 60: daddr_t nblocks; ! 61: int cyloff; ! 62: } rk7_sizes[8] = { ! 63: 15884, 0, /* A=cyl 0 thru 240 */ ! 64: 10032, 241, /* B=cyl 241 thru 392 */ ! 65: 53790, 0, /* C=cyl 0 thru 814 */ ! 66: 15884, 393, /* D=cyl 393 thru 633 */ ! 67: 0, 0, ! 68: 11792, 634, /* F=cyl 634 thru 814 */ ! 69: 27786, 393, /* G=cyl 393 thru 814, should be 27698 */ ! 70: 0, 0, ! 71: }, rk6_sizes[8] ={ ! 72: 15884, 0, /* A=cyl 0 thru 240 */ ! 73: 11154, 241, /* B=cyl 241 thru 409 */ ! 74: 27126, 0, /* C=cyl 0 thru 410 */ ! 75: 0, 0, ! 76: 0, 0, ! 77: 0, 0, ! 78: 0, 0, ! 79: 0, 0, ! 80: }; ! 81: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */ ! 82: ! 83: short rktypes[] = { RK_CDT, 0 }; ! 84: ! 85: int rkprobe(), rkslave(), rkattach(), rkdgo(), rkintr(); ! 86: struct uba_ctlr *rkminfo[NHK]; ! 87: struct uba_device *rkdinfo[NRK]; ! 88: struct uba_device *rkip[NHK][4]; ! 89: ! 90: u_short rkstd[] = { 0777440, 0 }; ! 91: struct uba_driver hkdriver = ! 92: { rkprobe, rkslave, rkattach, rkdgo, rkstd, "rk", rkdinfo, "hk", rkminfo, 1 }; ! 93: struct buf rkutab[NRK]; ! 94: short rkcyl[NRK]; ! 95: struct dkbad rkbad[NRK]; ! 96: struct buf brkbuf[NRK]; ! 97: ! 98: struct rkst { ! 99: short nsect; ! 100: short ntrak; ! 101: short nspc; ! 102: short ncyl; ! 103: struct size *sizes; ! 104: } rkst[] = { ! 105: NRKSECT, NRKTRK, NRKSECT*NRKTRK, NRK7CYL, rk7_sizes, ! 106: NRKSECT, NRKTRK, NRKSECT*NRKTRK, NRK6CYL, rk6_sizes, ! 107: }; ! 108: ! 109: u_char rk_offset[16] = ! 110: { RKAS_P400,RKAS_M400,RKAS_P400,RKAS_M400,RKAS_P800,RKAS_M800,RKAS_P800, ! 111: RKAS_M800,RKAS_P1200,RKAS_M1200,RKAS_P1200,RKAS_M1200,0,0,0,0 ! 112: }; ! 113: ! 114: struct buf rrkbuf[NRK]; ! 115: ! 116: #define b_cylin b_resid ! 117: ! 118: int rkwstart, rkwatch(); ! 119: ! 120: rkprobe(reg) ! 121: caddr_t reg; ! 122: { ! 123: register int br, cvec; ! 124: ! 125: #ifdef lint ! 126: br = 0; cvec = br; br = cvec; ! 127: rkintr(0); ! 128: #endif ! 129: ((struct rkdevice *)reg)->rkcs1 = RK_CDT|RK_IE|RK_CRDY; ! 130: DELAY(10); ! 131: ((struct rkdevice *)reg)->rkcs1 = RK_CDT; ! 132: return (sizeof (struct rkdevice)); ! 133: } ! 134: ! 135: rkslave(ui, reg) ! 136: struct uba_device *ui; ! 137: caddr_t reg; ! 138: { ! 139: register struct rkdevice *rkaddr = (struct rkdevice *)reg; ! 140: ! 141: ui->ui_type = 0; ! 142: rkaddr->rkcs1 = RK_CCLR; ! 143: rkaddr->rkcs2 = ui->ui_slave; ! 144: rkaddr->rkcs1 = RK_CDT|RK_DCLR|RK_GO; ! 145: rkwait(rkaddr); ! 146: DELAY(50); ! 147: if (rkaddr->rkcs2&RKCS2_NED || (rkaddr->rkds&RKDS_SVAL) == 0) { ! 148: rkaddr->rkcs1 = RK_CCLR; ! 149: return (0); ! 150: } ! 151: if (rkaddr->rkcs1&RK_CERR && rkaddr->rker&RKER_DTYE) { ! 152: ui->ui_type = 1; ! 153: rkaddr->rkcs1 = RK_CCLR; ! 154: } ! 155: return (1); ! 156: } ! 157: ! 158: rkattach(ui) ! 159: register struct uba_device *ui; ! 160: { ! 161: ! 162: if (rkwstart == 0) { ! 163: timeout(rkwatch, (caddr_t)0, hz); ! 164: rkwstart++; ! 165: } ! 166: if (ui->ui_dk >= 0) ! 167: dk_mspw[ui->ui_dk] = 1.0 / (60 * NRKSECT * 256); ! 168: rkip[ui->ui_ctlr][ui->ui_slave] = ui; ! 169: rk_softc[ui->ui_ctlr].sc_ndrive++; ! 170: rkcyl[ui->ui_unit] = -1; ! 171: ui->ui_flags = 0; ! 172: } ! 173: ! 174: rkopen(dev) ! 175: dev_t dev; ! 176: { ! 177: register int unit = rkunit(dev); ! 178: register struct uba_device *ui; ! 179: ! 180: if (unit >= NRK || (ui = rkdinfo[unit]) == 0 || ui->ui_alive == 0) ! 181: return (ENXIO); ! 182: return (0); ! 183: } ! 184: ! 185: rkstrategy(bp) ! 186: register struct buf *bp; ! 187: { ! 188: register struct uba_device *ui; ! 189: register struct rkst *st; ! 190: register int unit; ! 191: register struct buf *dp; ! 192: int xunit = minor(bp->b_dev) & 07; ! 193: long bn, sz; ! 194: int s; ! 195: ! 196: sz = (bp->b_bcount+511) >> 9; ! 197: unit = rkunit(bp->b_dev); ! 198: if (unit >= NRK) { ! 199: bp->b_error = ENXIO; ! 200: goto bad; ! 201: } ! 202: ui = rkdinfo[unit]; ! 203: if (ui == 0 || ui->ui_alive == 0) { ! 204: bp->b_error = ENXIO; ! 205: goto bad; ! 206: } ! 207: st = &rkst[ui->ui_type]; ! 208: if (bp->b_blkno < 0 || ! 209: (bn = bp->b_blkno)+sz > st->sizes[xunit].nblocks) { ! 210: if (bp->b_blkno == st->sizes[xunit].nblocks) { ! 211: bp->b_resid = bp->b_bcount; ! 212: goto done; ! 213: } ! 214: bp->b_error = EINVAL; ! 215: goto bad; ! 216: } ! 217: bp->b_cylin = bn/st->nspc + st->sizes[xunit].cyloff; ! 218: s = spl5(); ! 219: dp = &rkutab[ui->ui_unit]; ! 220: disksort(dp, bp); ! 221: if (dp->b_active == 0) { ! 222: (void) rkustart(ui); ! 223: bp = &ui->ui_mi->um_tab; ! 224: if (bp->b_actf && bp->b_active == 0) ! 225: (void) rkstart(ui->ui_mi); ! 226: } ! 227: splx(s); ! 228: return; ! 229: ! 230: bad: ! 231: bp->b_flags |= B_ERROR; ! 232: done: ! 233: iodone(bp); ! 234: return; ! 235: } ! 236: ! 237: rkustart(ui) ! 238: register struct uba_device *ui; ! 239: { ! 240: register struct buf *bp, *dp; ! 241: register struct uba_ctlr *um; ! 242: register struct rkdevice *rkaddr; ! 243: ! 244: if (ui == 0) ! 245: return; ! 246: dk_busy &= ~(1<<ui->ui_dk); ! 247: dp = &rkutab[ui->ui_unit]; ! 248: um = ui->ui_mi; ! 249: rkaddr = (struct rkdevice *)um->um_addr; ! 250: if (um->um_tab.b_active) { ! 251: rk_softc[um->um_ctlr].sc_softas |= 1<<ui->ui_slave; ! 252: return; ! 253: } ! 254: if ((bp = dp->b_actf) == NULL) ! 255: return; ! 256: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_CERR; ! 257: rkaddr->rkcs2 = ui->ui_slave; ! 258: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO; ! 259: rkwait(rkaddr); ! 260: if ((rkaddr->rkds & RKDS_VV) == 0 || ui->ui_flags == 0) { ! 261: /* SHOULD WARN SYSTEM THAT THIS HAPPENED */ ! 262: struct rkst *st = &rkst[ui->ui_type]; ! 263: struct buf *bbp = &brkbuf[ui->ui_unit]; ! 264: ! 265: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_PACK|RK_GO; ! 266: ui->ui_flags = 1; ! 267: bbp->b_flags = B_READ|B_BUSY; ! 268: bbp->b_dev = bp->b_dev; ! 269: bbp->b_bcount = 512; ! 270: bbp->b_un.b_addr = (caddr_t)&rkbad[ui->ui_unit]; ! 271: bbp->b_blkno = st->ncyl*st->nspc - st->nsect; ! 272: bbp->b_cylin = st->ncyl - 1; ! 273: dp->b_actf = bbp; ! 274: bbp->av_forw = bp; ! 275: bp = bbp; ! 276: rkwait(rkaddr); ! 277: } ! 278: if (dp->b_active) ! 279: goto done; ! 280: dp->b_active = 1; ! 281: if ((rkaddr->rkds & RKDS_DREADY) != RKDS_DREADY) ! 282: goto done; ! 283: if (rk_softc[um->um_ctlr].sc_ndrive == 1) ! 284: goto done; ! 285: if (bp->b_cylin == rkcyl[ui->ui_unit]) ! 286: goto done; ! 287: rkaddr->rkcyl = bp->b_cylin; ! 288: rkcyl[ui->ui_unit] = bp->b_cylin; ! 289: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_IE|RK_SEEK|RK_GO; ! 290: if (ui->ui_dk >= 0) { ! 291: dk_busy |= 1<<ui->ui_dk; ! 292: dk_seek[ui->ui_dk]++; ! 293: } ! 294: goto out; ! 295: done: ! 296: if (dp->b_active != 2) { ! 297: dp->b_forw = NULL; ! 298: if (um->um_tab.b_actf == NULL) ! 299: um->um_tab.b_actf = dp; ! 300: else ! 301: um->um_tab.b_actl->b_forw = dp; ! 302: um->um_tab.b_actl = dp; ! 303: dp->b_active = 2; ! 304: } ! 305: out: ! 306: return; ! 307: } ! 308: ! 309: rkstart(um) ! 310: register struct uba_ctlr *um; ! 311: { ! 312: register struct buf *bp, *dp; ! 313: register struct uba_device *ui; ! 314: register struct rkdevice *rkaddr; ! 315: struct rkst *st; ! 316: daddr_t bn; ! 317: int sn, tn, cmd; ! 318: ! 319: loop: ! 320: if ((dp = um->um_tab.b_actf) == NULL) ! 321: return; ! 322: if ((bp = dp->b_actf) == NULL) { ! 323: um->um_tab.b_actf = dp->b_forw; ! 324: goto loop; ! 325: } ! 326: um->um_tab.b_active++; ! 327: ui = rkdinfo[rkunit(bp->b_dev)]; ! 328: bn = bp->b_blkno; ! 329: st = &rkst[ui->ui_type]; ! 330: sn = bn%st->nspc; ! 331: tn = sn/st->nsect; ! 332: sn %= st->nsect; ! 333: rkaddr = (struct rkdevice *)ui->ui_addr; ! 334: retry: ! 335: rkaddr->rkcs1 = RK_CCLR; ! 336: rkaddr->rkcs2 = ui->ui_slave; ! 337: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO; ! 338: rkwait(rkaddr); ! 339: if ((rkaddr->rkds&RKDS_SVAL) == 0) { ! 340: rknosval++; ! 341: goto nosval; ! 342: } ! 343: if (rkaddr->rkds&RKDS_PIP) { ! 344: rkpip++; ! 345: goto retry; ! 346: } ! 347: if ((rkaddr->rkds&RKDS_DREADY) != RKDS_DREADY) { ! 348: printf("rk%d: not ready", rkunit(bp->b_dev)); ! 349: if ((rkaddr->rkds&RKDS_DREADY) != RKDS_DREADY) { ! 350: printf("\n"); ! 351: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO; ! 352: rkwait(rkaddr); ! 353: rkaddr->rkcs1 = RK_CCLR; ! 354: rkwait(rkaddr); ! 355: um->um_tab.b_active = 0; ! 356: um->um_tab.b_errcnt = 0; ! 357: dp->b_actf = bp->av_forw; ! 358: dp->b_active = 0; ! 359: bp->b_flags |= B_ERROR; ! 360: iodone(bp); ! 361: goto loop; ! 362: } ! 363: printf(" (came back!)\n"); ! 364: } ! 365: nosval: ! 366: rkaddr->rkcyl = bp->b_cylin; ! 367: rkcyl[ui->ui_unit] = bp->b_cylin; ! 368: rkaddr->rkda = (tn << 8) + sn; ! 369: rkaddr->rkwc = -bp->b_bcount / sizeof (short); ! 370: if (bp->b_flags & B_READ) ! 371: cmd = rktypes[ui->ui_type]|RK_IE|RK_READ|RK_GO; ! 372: else ! 373: cmd = rktypes[ui->ui_type]|RK_IE|RK_WRITE|RK_GO; ! 374: um->um_cmd = cmd; ! 375: (void) ubago(ui); ! 376: } ! 377: ! 378: rkdgo(um) ! 379: register struct uba_ctlr *um; ! 380: { ! 381: register struct rkdevice *rkaddr = (struct rkdevice *)um->um_addr; ! 382: ! 383: um->um_tab.b_active = 2; /* should now be 2 */ ! 384: rkaddr->rkba = um->um_ubinfo; ! 385: rkaddr->rkcs1 = um->um_cmd|((um->um_ubinfo>>8)&0x300); ! 386: } ! 387: ! 388: rkintr(rk11) ! 389: int rk11; ! 390: { ! 391: register struct uba_ctlr *um = rkminfo[rk11]; ! 392: register struct uba_device *ui; ! 393: register struct rkdevice *rkaddr = (struct rkdevice *)um->um_addr; ! 394: register struct buf *bp, *dp; ! 395: int unit; ! 396: struct rk_softc *sc = &rk_softc[um->um_ctlr]; ! 397: int as = (rkaddr->rkatt >> 8) | sc->sc_softas; ! 398: ! 399: sc->sc_wticks = 0; ! 400: sc->sc_softas = 0; ! 401: if (um->um_tab.b_active == 2 || sc->sc_recal) { ! 402: um->um_tab.b_active = 1; ! 403: dp = um->um_tab.b_actf; ! 404: bp = dp->b_actf; ! 405: ui = rkdinfo[rkunit(bp->b_dev)]; ! 406: dk_busy &= ~(1 << ui->ui_dk); ! 407: if (bp->b_flags&B_BAD) ! 408: if (rkecc(ui, CONT)) ! 409: return; ! 410: if (rkaddr->rkcs1 & RK_CERR) { ! 411: int recal; ! 412: u_short ds = rkaddr->rkds; ! 413: u_short cs2 = rkaddr->rkcs2; ! 414: u_short er = rkaddr->rker; ! 415: #ifdef RKDEBUG ! 416: if (rkdebug) { ! 417: printf("cs2=%b ds=%b er=%b\n", ! 418: cs2, RKCS2_BITS, ds, ! 419: RKDS_BITS, er, RKER_BITS); ! 420: } ! 421: #endif ! 422: if (er & RKER_WLE) { ! 423: printf("rk%d: write locked\n", ! 424: rkunit(bp->b_dev)); ! 425: bp->b_flags |= B_ERROR; ! 426: } else if (++um->um_tab.b_errcnt > 28 || ! 427: ds&RKDS_HARD || er&RKER_HARD || cs2&RKCS2_HARD) { ! 428: hard: ! 429: harderr(bp, "rk"); ! 430: printf("cs2=%b ds=%b er=%b\n", ! 431: cs2, RKCS2_BITS, ds, ! 432: RKDS_BITS, er, RKER_BITS); ! 433: bp->b_flags |= B_ERROR; ! 434: sc->sc_recal = 0; ! 435: } else if (er & RKER_BSE) { ! 436: if (rkecc(ui, BSE)) ! 437: return; ! 438: else ! 439: goto hard; ! 440: } else { ! 441: if ((er & (RKER_DCK|RKER_ECH)) == RKER_DCK) { ! 442: if (rkecc(ui, ECC)) ! 443: return; ! 444: } else ! 445: um->um_tab.b_active = 0; ! 446: } ! 447: if (cs2&RKCS2_MDS) { ! 448: rkaddr->rkcs2 = RKCS2_SCLR; ! 449: goto retry; ! 450: } ! 451: recal = 0; ! 452: if (ds&RKDS_DROT || er&(RKER_OPI|RKER_SKI|RKER_UNS) || ! 453: (um->um_tab.b_errcnt&07) == 4) ! 454: recal = 1; ! 455: rkaddr->rkcs1 = RK_CCLR; ! 456: rkaddr->rkcs2 = ui->ui_slave; ! 457: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO; ! 458: rkwait(rkaddr); ! 459: if (recal && um->um_tab.b_active == 0) { ! 460: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_IE|RK_RECAL|RK_GO; ! 461: rkcyl[ui->ui_unit] = -1; ! 462: sc->sc_recal = 0; ! 463: goto nextrecal; ! 464: } ! 465: } ! 466: retry: ! 467: switch (sc->sc_recal) { ! 468: ! 469: case 1: ! 470: rkaddr->rkcyl = bp->b_cylin; ! 471: rkcyl[ui->ui_unit] = bp->b_cylin; ! 472: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_IE|RK_SEEK|RK_GO; ! 473: goto nextrecal; ! 474: case 2: ! 475: if (um->um_tab.b_errcnt < 16 || ! 476: (bp->b_flags&B_READ) == 0) ! 477: goto donerecal; ! 478: rkaddr->rkatt = rk_offset[um->um_tab.b_errcnt & 017]; ! 479: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_IE|RK_OFFSET|RK_GO; ! 480: /* fall into ... */ ! 481: nextrecal: ! 482: sc->sc_recal++; ! 483: rkwait(rkaddr); ! 484: um->um_tab.b_active = 1; ! 485: return; ! 486: donerecal: ! 487: case 3: ! 488: sc->sc_recal = 0; ! 489: um->um_tab.b_active = 0; ! 490: break; ! 491: } ! 492: ubadone(um); ! 493: if (um->um_tab.b_active) { ! 494: um->um_tab.b_active = 0; ! 495: um->um_tab.b_errcnt = 0; ! 496: um->um_tab.b_actf = dp->b_forw; ! 497: dp->b_active = 0; ! 498: dp->b_errcnt = 0; ! 499: dp->b_actf = bp->av_forw; ! 500: bp->b_resid = -rkaddr->rkwc * sizeof(short); ! 501: iodone(bp); ! 502: if (dp->b_actf) ! 503: rkustart(ui); ! 504: } ! 505: as &= ~(1<<ui->ui_slave); ! 506: } ! 507: for (unit = 0; as; as >>= 1, unit++) ! 508: if (as & 1) { ! 509: ui = rkip[rk11][unit]; ! 510: if (ui) { ! 511: rkustart(rkip[rk11][unit]); ! 512: } else { ! 513: rkaddr->rkcs1 = RK_CCLR; ! 514: rkaddr->rkcs2 = unit; ! 515: rkaddr->rkcs1 = RK_DCLR|RK_GO; ! 516: rkwait(rkaddr); ! 517: rkaddr->rkcs1 = RK_CCLR; ! 518: } ! 519: } ! 520: if (um->um_tab.b_actf && um->um_tab.b_active == 0) ! 521: rkstart(um); ! 522: if (((rkaddr->rkcs1) & RK_IE) == 0) ! 523: rkaddr->rkcs1 = RK_IE; ! 524: } ! 525: ! 526: rkwait(addr) ! 527: register struct rkdevice *addr; ! 528: { ! 529: ! 530: while ((addr->rkcs1 & RK_CRDY) == 0) ! 531: ; ! 532: } ! 533: ! 534: rkread(dev, uio) ! 535: dev_t dev; ! 536: struct uio *uio; ! 537: { ! 538: register int unit = rkunit(dev); ! 539: ! 540: if (unit >= NRK) ! 541: return (ENXIO); ! 542: return (physio(rkstrategy, &rrkbuf[unit], dev, B_READ, minphys, uio)); ! 543: } ! 544: ! 545: rkwrite(dev, uio) ! 546: dev_t dev; ! 547: struct uio *uio; ! 548: { ! 549: register int unit = rkunit(dev); ! 550: ! 551: if (unit >= NRK) ! 552: return (ENXIO); ! 553: return (physio(rkstrategy, &rrkbuf[unit], dev, B_WRITE, minphys, uio)); ! 554: } ! 555: ! 556: rkecc(ui, flag) ! 557: register struct uba_device *ui; ! 558: { ! 559: register struct rkdevice *rk = (struct rkdevice *)ui->ui_addr; ! 560: register struct buf *bp = rkutab[ui->ui_unit].b_actf; ! 561: register struct uba_ctlr *um = ui->ui_mi; ! 562: register struct rkst *st; ! 563: struct uba_regs *ubp = ui->ui_hd->uh_uba; ! 564: caddr_t addr; ! 565: int reg, npf, o, cmd, ubaddr; ! 566: int bn, cn, tn, sn; ! 567: ! 568: if (flag == CONT) ! 569: npf = bp->b_error; ! 570: else ! 571: npf = btodb(bp->b_bcount + (rk->rkwc * sizeof(short)) + 511); ! 572: reg = btop(um->um_ubinfo&0x3ffff) + npf; ! 573: o = (int)bp->b_un.b_addr & PGOFSET; ! 574: bn = bp->b_blkno; ! 575: st = &rkst[ui->ui_type]; ! 576: cn = bp->b_cylin; ! 577: sn = bn%st->nspc + npf; ! 578: tn = sn/st->nsect; ! 579: sn %= st->nsect; ! 580: cn += tn/st->ntrak; ! 581: tn %= st->ntrak; ! 582: ubapurge(um); ! 583: switch (flag) { ! 584: case ECC: ! 585: { ! 586: register int i; ! 587: int bit, byte, mask; ! 588: ! 589: npf--; ! 590: reg--; ! 591: log(LOG_WARNING, "rk%d%c: soft ecc sn%d\n", rkunit(bp->b_dev), ! 592: 'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf); ! 593: mask = rk->rkec2; ! 594: i = rk->rkec1 - 1; /* -1 makes 0 origin */ ! 595: bit = i&07; ! 596: i = (i&~07)>>3; ! 597: byte = i + o; ! 598: while (i < 512 && (int)dbtob(npf)+i < bp->b_bcount && bit > -11) { ! 599: addr = ptob(ubp->uba_map[reg+btop(byte)].pg_pfnum)+ ! 600: (byte & PGOFSET); ! 601: putmemc(addr, getmemc(addr)^(mask<<bit)); ! 602: byte++; ! 603: i++; ! 604: bit -= 8; ! 605: } ! 606: if (rk->rkwc == 0) { ! 607: um->um_tab.b_active = 0; ! 608: return (0); ! 609: } ! 610: npf++; ! 611: reg++; ! 612: break; ! 613: } ! 614: ! 615: case BSE: ! 616: #ifdef RKBDEBUG ! 617: if (rkbdebug) ! 618: printf("rkecc, BSE: bn %d cn %d tn %d sn %d\n", bn, cn, tn, sn); ! 619: #endif ! 620: if ((bn = isbad(&rkbad[ui->ui_unit], cn, tn, sn)) < 0) ! 621: return(0); ! 622: bp->b_flags |= B_BAD; ! 623: bp->b_error = npf + 1; ! 624: bn = st->ncyl*st->nspc - st->nsect - 1 - bn; ! 625: cn = bn/st->nspc; ! 626: sn = bn%st->nspc; ! 627: tn = sn/st->nsect; ! 628: sn %= st->nsect; ! 629: #ifdef RKBDEBUG ! 630: if (rkbdebug) ! 631: printf("revector to cn %d tn %d sn %d\n", cn, tn, sn); ! 632: #endif ! 633: rk->rkwc = -(512 / sizeof (short)); ! 634: break; ! 635: ! 636: case CONT: ! 637: #ifdef RKBDEBUG ! 638: if (rkbdebug) ! 639: printf("rkecc, CONT: bn %d cn %d tn %d sn %d\n", bn,cn,tn,sn); ! 640: #endif ! 641: bp->b_flags &= ~B_BAD; ! 642: if ((int)dbtob(npf) >= bp->b_bcount) ! 643: return (0); ! 644: rk->rkwc = -((bp->b_bcount - (int)dbtob(npf)) / sizeof (short)); ! 645: break; ! 646: } ! 647: rk->rkcs1 = RK_CCLR; ! 648: rk->rkcs2 = ui->ui_slave; ! 649: rk->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO; ! 650: rkwait(rk); ! 651: rk->rkcyl = cn; ! 652: rk->rkda = (tn << 8) | sn; ! 653: ubaddr = (int)ptob(reg) + o; ! 654: rk->rkba = ubaddr; ! 655: cmd = (bp->b_flags&B_READ ? RK_READ : RK_WRITE)|RK_IE|RK_GO; ! 656: cmd |= (ubaddr >> 8) & 0x300; ! 657: cmd |= rktypes[ui->ui_type]; ! 658: rk->rkcs1 = cmd; ! 659: um->um_tab.b_active = 2; /* continuing */ ! 660: um->um_tab.b_errcnt = 0; /* error has been corrected */ ! 661: return (1); ! 662: } ! 663: ! 664: rkreset(uban) ! 665: int uban; ! 666: { ! 667: register struct uba_ctlr *um; ! 668: register struct uba_device *ui; ! 669: register rk11, unit; ! 670: ! 671: for (rk11 = 0; rk11 < NHK; rk11++) { ! 672: if ((um = rkminfo[rk11]) == 0 || um->um_ubanum != uban || ! 673: um->um_alive == 0) ! 674: continue; ! 675: printf(" hk%d", rk11); ! 676: um->um_tab.b_active = 0; ! 677: um->um_tab.b_actf = um->um_tab.b_actl = 0; ! 678: rk_softc[um->um_ctlr].sc_recal = 0; ! 679: rk_softc[um->um_ctlr].sc_wticks = 0; ! 680: if (um->um_ubinfo) { ! 681: printf("<%d>", (um->um_ubinfo>>28)&0xf); ! 682: um->um_ubinfo = 0; ! 683: } ! 684: for (unit = 0; unit < NRK; unit++) { ! 685: if ((ui = rkdinfo[unit]) == 0) ! 686: continue; ! 687: if (ui->ui_alive == 0 || ui->ui_mi != um) ! 688: continue; ! 689: rkutab[unit].b_active = 0; ! 690: (void) rkustart(ui); ! 691: } ! 692: (void) rkstart(um); ! 693: } ! 694: } ! 695: ! 696: rkwatch() ! 697: { ! 698: register struct uba_ctlr *um; ! 699: register rk11, unit; ! 700: register struct rk_softc *sc; ! 701: ! 702: timeout(rkwatch, (caddr_t)0, hz); ! 703: for (rk11 = 0; rk11 < NHK; rk11++) { ! 704: um = rkminfo[rk11]; ! 705: if (um == 0 || um->um_alive == 0) ! 706: continue; ! 707: sc = &rk_softc[rk11]; ! 708: if (um->um_tab.b_active == 0) { ! 709: for (unit = 0; unit < NRK; unit++) ! 710: if (rkutab[unit].b_active && ! 711: rkdinfo[unit]->ui_mi == um) ! 712: goto active; ! 713: sc->sc_wticks = 0; ! 714: continue; ! 715: } ! 716: active: ! 717: sc->sc_wticks++; ! 718: if (sc->sc_wticks >= 20) { ! 719: sc->sc_wticks = 0; ! 720: printf("hk%d: lost interrupt\n", rk11); ! 721: ubareset(um->um_ubanum); ! 722: } ! 723: } ! 724: } ! 725: ! 726: #define DBSIZE 20 ! 727: ! 728: rkdump(dev) ! 729: dev_t dev; ! 730: { ! 731: struct rkdevice *rkaddr; ! 732: char *start; ! 733: int num, blk, unit; ! 734: struct size *sizes; ! 735: register struct uba_regs *uba; ! 736: register struct uba_device *ui; ! 737: register short *rp; ! 738: struct rkst *st; ! 739: ! 740: unit = rkunit(dev); ! 741: if (unit >= NRK) ! 742: return (ENXIO); ! 743: #define phys(cast, addr) ((cast)((int)addr & 0x7fffffff)) ! 744: ui = phys(struct uba_device *, rkdinfo[unit]); ! 745: if (ui->ui_alive == 0) ! 746: return (ENXIO); ! 747: uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba; ! 748: ubainit(uba); ! 749: rkaddr = (struct rkdevice *)ui->ui_physaddr; ! 750: num = maxfree; ! 751: start = 0; ! 752: rkaddr->rkcs1 = RK_CCLR; ! 753: rkaddr->rkcs2 = unit; ! 754: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO; ! 755: rkwait(rkaddr); ! 756: if ((rkaddr->rkds & RKDS_VV) == 0) { ! 757: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_IE|RK_PACK|RK_GO; ! 758: rkwait(rkaddr); ! 759: } ! 760: st = &rkst[ui->ui_type]; ! 761: sizes = phys(struct size *, st->sizes); ! 762: if (dumplo < 0) ! 763: return (EINVAL); ! 764: if (dumplo + num >= sizes[minor(dev)&07].nblocks) ! 765: num = sizes[minor(dev)&07].nblocks - dumplo; ! 766: while (num > 0) { ! 767: register struct pte *io; ! 768: register int i; ! 769: int cn, sn, tn; ! 770: daddr_t bn; ! 771: ! 772: blk = num > DBSIZE ? DBSIZE : num; ! 773: io = uba->uba_map; ! 774: for (i = 0; i < blk; i++) ! 775: *(int *)io++ = (btop(start)+i) | (1<<21) | UBAMR_MRV; ! 776: *(int *)io = 0; ! 777: bn = dumplo + btop(start); ! 778: cn = bn/st->nspc + sizes[minor(dev)&07].cyloff; ! 779: sn = bn%st->nspc; ! 780: tn = sn/st->nsect; ! 781: sn = sn%st->nsect; ! 782: rkaddr->rkcyl = cn; ! 783: rp = (short *) &rkaddr->rkda; ! 784: *rp = (tn << 8) + sn; ! 785: *--rp = 0; ! 786: *--rp = -blk*NBPG / sizeof (short); ! 787: *--rp = rktypes[ui->ui_type]|RK_GO|RK_WRITE; ! 788: rkwait(rkaddr); ! 789: if (rkaddr->rkcs1 & RK_CERR) ! 790: return (EIO); ! 791: start += blk*NBPG; ! 792: num -= blk; ! 793: } ! 794: return (0); ! 795: } ! 796: ! 797: rksize(dev) ! 798: dev_t dev; ! 799: { ! 800: int unit = rkunit(dev); ! 801: struct uba_device *ui; ! 802: struct rkst *st; ! 803: ! 804: if (unit >= NRK || (ui = rkdinfo[unit]) == 0 || ui->ui_alive == 0) ! 805: return (-1); ! 806: st = &rkst[ui->ui_type]; ! 807: return (st->sizes[minor(dev) & 07].nblocks); ! 808: } ! 809: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.