![[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] / 43BSDReno / sys / vaxuba|
Return to up.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / 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: * @(#)up.c 7.9 (Berkeley) 2/17/90 ! 7: */ ! 8: ! 9: #include "up.h" ! 10: #if NSC > 0 ! 11: /* ! 12: * UNIBUS disk driver with: ! 13: * overlapped seeks, ! 14: * ECC recovery, and ! 15: * bad sector forwarding. ! 16: * ! 17: * TODO: ! 18: * Check that offset recovery code works ! 19: */ ! 20: #include "machine/pte.h" ! 21: ! 22: #include "param.h" ! 23: #include "systm.h" ! 24: #include "dkstat.h" ! 25: #include "dkbad.h" ! 26: #include "ioctl.h" ! 27: #include "disklabel.h" ! 28: #include "buf.h" ! 29: #include "conf.h" ! 30: #include "user.h" ! 31: #include "map.h" ! 32: #include "vm.h" ! 33: #include "cmap.h" ! 34: #include "uio.h" ! 35: #include "kernel.h" ! 36: #include "syslog.h" ! 37: ! 38: #include "../vax/cpu.h" ! 39: #include "../vax/nexus.h" ! 40: #include "ubavar.h" ! 41: #include "ubareg.h" ! 42: #include "upreg.h" ! 43: ! 44: struct up_softc { ! 45: int sc_softas; ! 46: int sc_ndrive; ! 47: int sc_wticks; ! 48: int sc_recal; ! 49: } up_softc[NSC]; ! 50: ! 51: #define upunit(dev) (minor(dev) >> 3) ! 52: ! 53: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */ ! 54: struct size { ! 55: daddr_t nblocks; ! 56: int cyloff; ! 57: } up9300_sizes[8] = { ! 58: 15884, 0, /* A=cyl 0 thru 26 */ ! 59: 33440, 27, /* B=cyl 27 thru 81 */ ! 60: 495520, 0, /* C=cyl 0 thru 814 */ ! 61: 15884, 562, /* D=cyl 562 thru 588 */ ! 62: 55936, 589, /* E=cyl 589 thru 680 */ ! 63: 81376, 681, /* F=cyl 681 thru 814 */ ! 64: 153728, 562, /* G=cyl 562 thru 814 */ ! 65: 291346, 82, /* H=cyl 82 thru 561 */ ! 66: }, up9766_sizes[8] = { ! 67: 15884, 0, /* A=cyl 0 thru 26 */ ! 68: 33440, 27, /* B=cyl 27 thru 81 */ ! 69: 500384, 0, /* C=cyl 0 thru 822 */ ! 70: 15884, 562, /* D=cyl 562 thru 588 */ ! 71: 55936, 589, /* E=cyl 589 thru 680 */ ! 72: 86240, 681, /* F=cyl 681 thru 822 */ ! 73: 158592, 562, /* G=cyl 562 thru 822 */ ! 74: 291346, 82, /* H=cyl 82 thru 561 */ ! 75: }, up160_sizes[8] = { ! 76: 15884, 0, /* A=cyl 0 thru 49 */ ! 77: 33440, 50, /* B=cyl 50 thru 154 */ ! 78: 263360, 0, /* C=cyl 0 thru 822 */ ! 79: 15884, 155, /* D=cyl 155 thru 204 */ ! 80: 55936, 205, /* E=cyl 205 thru 379 */ ! 81: 141664, 380, /* F=cyl 380 thru 822 */ ! 82: 213664, 155, /* G=cyl 155 thru 822 */ ! 83: 0, 0, ! 84: }, upam_sizes[8] = { ! 85: 15884, 0, /* A=cyl 0 thru 31 */ ! 86: 33440, 32, /* B=cyl 32 thru 97 */ ! 87: 524288, 0, /* C=cyl 0 thru 1023 */ ! 88: 15884, 668, /* D=cyl 668 thru 699 */ ! 89: 55936, 700, /* E=cyl 700 thru 809 */ ! 90: 109472, 810, /* F=cyl 810 thru 1023 */ ! 91: 182176, 668, /* G=cyl 668 thru 1023 */ ! 92: 291346, 98, /* H=cyl 98 thru 667 */ ! 93: }, up980_sizes[8] = { ! 94: 15884, 0, /* A=cyl 0 thru 99 */ ! 95: 33440, 100, /* B=cyl 100 thru 308 */ ! 96: 131680, 0, /* C=cyl 0 thru 822 */ ! 97: 15884, 309, /* D=cyl 309 thru 408 */ ! 98: 55936, 409, /* E=cyl 409 thru 758 */ ! 99: 10080, 759, /* F=cyl 759 thru 822 */ ! 100: 82080, 309, /* G=cyl 309 thru 822 */ ! 101: 0, 0, ! 102: }, upeagle_sizes[8] = { ! 103: 15884, 0, /* A=cyl 0 thru 16 */ ! 104: 66880, 17, /* B=cyl 17 thru 86 */ ! 105: 808320, 0, /* C=cyl 0 thru 841 */ ! 106: 15884, 391, /* D=cyl 391 thru 407 */ ! 107: 307200, 408, /* E=cyl 408 thru 727 */ ! 108: 109296, 728, /* F=cyl 728 thru 841 */ ! 109: 432816, 391, /* G=cyl 391 thru 841 */ ! 110: 291346, 87, /* H=cyl 87 thru 390 */ ! 111: }; ! 112: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */ ! 113: ! 114: int upprobe(), upslave(), upattach(), updgo(), upintr(); ! 115: struct uba_ctlr *upminfo[NSC]; ! 116: struct uba_device *updinfo[NUP]; ! 117: #define UPIPUNITS 8 ! 118: struct uba_device *upip[NSC][UPIPUNITS]; /* fuji w/fixed head gives n,n+4 */ ! 119: ! 120: u_short upstd[] = { 0776700, 0774400, 0776300, 0 }; ! 121: struct uba_driver scdriver = ! 122: { upprobe, upslave, upattach, updgo, upstd, "up", updinfo, "sc", upminfo }; ! 123: struct buf uputab[NUP]; ! 124: char upinit[NUP]; ! 125: ! 126: struct upst { ! 127: short nsect; /* # sectors/track */ ! 128: short ntrak; /* # tracks/cylinder */ ! 129: short nspc; /* # sectors/cylinder */ ! 130: short ncyl; /* # cylinders */ ! 131: struct size *sizes; /* partition tables */ ! 132: short sdist; /* seek distance metric */ ! 133: short rdist; /* rotational distance metric */ ! 134: } upst[] = { ! 135: { 32, 19, 32*19, 815, up9300_sizes, 3, 4 }, /* 9300 */ ! 136: { 32, 19, 32*19, 823, up9766_sizes, 3, 4 }, /* 9766 */ ! 137: { 32, 10, 32*10, 823, up160_sizes, 3, 4 }, /* fuji 160m */ ! 138: { 32, 16, 32*16, 1024, upam_sizes, 7, 8 }, /* Capricorn */ ! 139: { 32, 5, 32*5, 823, up980_sizes, 3, 4 }, /* DM980 */ ! 140: { 48, 20, 48*20, 842, upeagle_sizes, 15, 8 }, /* EAGLE */ ! 141: { 0, 0, 0, 0, 0, 0, 0 } ! 142: }; ! 143: ! 144: u_char up_offset[16] = { ! 145: UPOF_P400, UPOF_M400, UPOF_P400, UPOF_M400, ! 146: UPOF_P800, UPOF_M800, UPOF_P800, UPOF_M800, ! 147: UPOF_P1200, UPOF_M1200, UPOF_P1200, UPOF_M1200, ! 148: 0, 0, 0, 0 ! 149: }; ! 150: ! 151: struct buf bupbuf[NUP]; ! 152: struct dkbad upbad[NUP]; ! 153: ! 154: #define b_cylin b_resid ! 155: ! 156: int upwstart, upwatch(); /* Have started guardian */ ! 157: int upseek; ! 158: int upwaitdry; ! 159: ! 160: /*ARGSUSED*/ ! 161: upprobe(reg) ! 162: caddr_t reg; ! 163: { ! 164: register int br, cvec; ! 165: ! 166: #ifdef lint ! 167: br = 0; cvec = br; br = cvec; upintr(0); ! 168: #endif ! 169: ((struct updevice *)reg)->upcs1 = UP_IE|UP_RDY; ! 170: DELAY(10); ! 171: ((struct updevice *)reg)->upcs1 = 0; ! 172: return (sizeof (struct updevice)); ! 173: } ! 174: ! 175: upslave(ui, reg) ! 176: struct uba_device *ui; ! 177: caddr_t reg; ! 178: { ! 179: register struct updevice *upaddr = (struct updevice *)reg; ! 180: ! 181: upaddr->upcs1 = 0; /* conservative */ ! 182: upaddr->upcs2 = ui->ui_slave; ! 183: upaddr->upcs1 = UP_NOP|UP_GO; ! 184: if (upaddr->upcs2&UPCS2_NED) { ! 185: upaddr->upcs1 = UP_DCLR|UP_GO; ! 186: return (0); ! 187: } ! 188: return (1); ! 189: } ! 190: ! 191: upattach(ui) ! 192: register struct uba_device *ui; ! 193: { ! 194: ! 195: if (upwstart == 0) { ! 196: timeout(upwatch, (caddr_t)0, hz); ! 197: upwstart++; ! 198: } ! 199: if (ui->ui_dk >= 0) ! 200: dk_wpms[ui->ui_dk] = 491521; ! 201: upip[ui->ui_ctlr][ui->ui_slave] = ui; ! 202: up_softc[ui->ui_ctlr].sc_ndrive++; ! 203: ui->ui_type = upmaptype(ui); ! 204: } ! 205: ! 206: upmaptype(ui) ! 207: register struct uba_device *ui; ! 208: { ! 209: register struct updevice *upaddr = (struct updevice *)ui->ui_addr; ! 210: int type = ui->ui_type; ! 211: register struct upst *st; ! 212: ! 213: upaddr->upcs1 = 0; ! 214: upaddr->upcs2 = ui->ui_slave; ! 215: upaddr->uphr = UPHR_MAXTRAK; ! 216: for (st = upst; st->nsect != 0; st++) ! 217: if (upaddr->uphr == st->ntrak - 1) { ! 218: type = st - upst; ! 219: break; ! 220: } ! 221: if (st->nsect == 0) ! 222: printf(": uphr=%x", upaddr->uphr); ! 223: if (type == 0) { ! 224: upaddr->uphr = UPHR_MAXCYL; ! 225: if (upaddr->uphr == 822) ! 226: type++; ! 227: } ! 228: upaddr->upcs2 = UPCS2_CLR; ! 229: return (type); ! 230: } ! 231: ! 232: upopen(dev) ! 233: dev_t dev; ! 234: { ! 235: register int unit = upunit(dev); ! 236: register struct uba_device *ui; ! 237: ! 238: if (unit >= NUP || (ui = updinfo[unit]) == 0 || ui->ui_alive == 0) ! 239: return (ENXIO); ! 240: return (0); ! 241: } ! 242: ! 243: upstrategy(bp) ! 244: register struct buf *bp; ! 245: { ! 246: register struct uba_device *ui; ! 247: register struct upst *st; ! 248: register int unit; ! 249: register struct buf *dp; ! 250: int xunit = minor(bp->b_dev) & 07; ! 251: long bn, sz; ! 252: int s; ! 253: ! 254: sz = (bp->b_bcount+511) >> 9; ! 255: unit = upunit(bp->b_dev); ! 256: if (unit >= NUP) { ! 257: bp->b_error = ENXIO; ! 258: goto bad; ! 259: } ! 260: ui = updinfo[unit]; ! 261: if (ui == 0 || ui->ui_alive == 0) { ! 262: bp->b_error = ENXIO; ! 263: goto bad; ! 264: } ! 265: st = &upst[ui->ui_type]; ! 266: if (bp->b_blkno < 0 || ! 267: (bn = bp->b_blkno)+sz > st->sizes[xunit].nblocks) { ! 268: if (bp->b_blkno == st->sizes[xunit].nblocks) { ! 269: bp->b_resid = bp->b_bcount; ! 270: goto done; ! 271: } ! 272: bp->b_error = EINVAL; ! 273: goto bad; ! 274: } ! 275: bp->b_cylin = bn/st->nspc + st->sizes[xunit].cyloff; ! 276: s = spl5(); ! 277: dp = &uputab[ui->ui_unit]; ! 278: disksort(dp, bp); ! 279: if (dp->b_active == 0) { ! 280: (void) upustart(ui); ! 281: bp = &ui->ui_mi->um_tab; ! 282: if (bp->b_actf && bp->b_active == 0) ! 283: (void) upstart(ui->ui_mi); ! 284: } ! 285: splx(s); ! 286: return; ! 287: ! 288: bad: ! 289: bp->b_flags |= B_ERROR; ! 290: done: ! 291: iodone(bp); ! 292: return; ! 293: } ! 294: ! 295: /* ! 296: * Unit start routine. ! 297: * Seek the drive to be where the data is ! 298: * and then generate another interrupt ! 299: * to actually start the transfer. ! 300: * If there is only one drive on the controller, ! 301: * or we are very close to the data, don't ! 302: * bother with the search. If called after ! 303: * searching once, don't bother to look where ! 304: * we are, just queue for transfer (to avoid ! 305: * positioning forever without transferrring.) ! 306: */ ! 307: upustart(ui) ! 308: register struct uba_device *ui; ! 309: { ! 310: register struct buf *bp, *dp; ! 311: register struct uba_ctlr *um; ! 312: register struct updevice *upaddr; ! 313: register struct upst *st; ! 314: daddr_t bn; ! 315: int sn, csn; ! 316: /* ! 317: * The SC21 cancels commands if you just say ! 318: * cs1 = UP_IE ! 319: * so we are cautious about handling of cs1. ! 320: * Also don't bother to clear as bits other than in upintr(). ! 321: */ ! 322: int didie = 0; ! 323: ! 324: if (ui == 0) ! 325: return (0); ! 326: um = ui->ui_mi; ! 327: dk_busy &= ~(1<<ui->ui_dk); ! 328: dp = &uputab[ui->ui_unit]; ! 329: if ((bp = dp->b_actf) == NULL) ! 330: goto out; ! 331: /* ! 332: * If the controller is active, just remember ! 333: * that this device would like to be positioned... ! 334: * if we tried to position now we would confuse the SC21. ! 335: */ ! 336: if (um->um_tab.b_active) { ! 337: up_softc[um->um_ctlr].sc_softas |= 1<<ui->ui_slave; ! 338: return (0); ! 339: } ! 340: /* ! 341: * If we have already positioned this drive, ! 342: * then just put it on the ready queue. ! 343: */ ! 344: if (dp->b_active) ! 345: goto done; ! 346: dp->b_active = 1; ! 347: upaddr = (struct updevice *)um->um_addr; ! 348: upaddr->upcs2 = ui->ui_slave; ! 349: /* ! 350: * If drive has just come up, ! 351: * setup the pack. ! 352: */ ! 353: if ((upaddr->upds & UPDS_VV) == 0 || upinit[ui->ui_unit] == 0) { ! 354: struct buf *bbp = &bupbuf[ui->ui_unit]; ! 355: ! 356: /* SHOULD WARN SYSTEM THAT THIS HAPPENED */ ! 357: upinit[ui->ui_unit] = 1; ! 358: upaddr->upcs1 = UP_IE|UP_DCLR|UP_GO; ! 359: upaddr->upcs1 = UP_IE|UP_PRESET|UP_GO; ! 360: upaddr->upof = UPOF_FMT22; ! 361: didie = 1; ! 362: st = &upst[ui->ui_type]; ! 363: bbp->b_flags = B_READ|B_BUSY; ! 364: bbp->b_dev = bp->b_dev; ! 365: bbp->b_bcount = 512; ! 366: bbp->b_un.b_addr = (caddr_t)&upbad[ui->ui_unit]; ! 367: bbp->b_blkno = st->ncyl * st->nspc - st->nsect; ! 368: bbp->b_cylin = st->ncyl - 1; ! 369: dp->b_actf = bbp; ! 370: bbp->av_forw = bp; ! 371: bp = bbp; ! 372: } ! 373: /* ! 374: * If drive is offline, forget about positioning. ! 375: */ ! 376: if ((upaddr->upds & (UPDS_DPR|UPDS_MOL)) != (UPDS_DPR|UPDS_MOL)) ! 377: goto done; ! 378: /* ! 379: * If there is only one drive, ! 380: * dont bother searching. ! 381: */ ! 382: if (up_softc[um->um_ctlr].sc_ndrive == 1) ! 383: goto done; ! 384: /* ! 385: * Figure out where this transfer is going to ! 386: * and see if we are close enough to justify not searching. ! 387: */ ! 388: st = &upst[ui->ui_type]; ! 389: bn = bp->b_blkno; ! 390: sn = bn%st->nspc; ! 391: sn = (sn + st->nsect - st->sdist) % st->nsect; ! 392: if (bp->b_cylin - upaddr->updc) ! 393: goto search; /* Not on-cylinder */ ! 394: else if (upseek) ! 395: goto done; /* Ok just to be on-cylinder */ ! 396: csn = (upaddr->upla>>6) - sn - 1; ! 397: if (csn < 0) ! 398: csn += st->nsect; ! 399: if (csn > st->nsect - st->rdist) ! 400: goto done; ! 401: search: ! 402: upaddr->updc = bp->b_cylin; ! 403: /* ! 404: * Not on cylinder at correct position, ! 405: * seek/search. ! 406: */ ! 407: if (upseek) ! 408: upaddr->upcs1 = UP_IE|UP_SEEK|UP_GO; ! 409: else { ! 410: upaddr->upda = sn; ! 411: upaddr->upcs1 = UP_IE|UP_SEARCH|UP_GO; ! 412: } ! 413: didie = 1; ! 414: /* ! 415: * Mark unit busy for iostat. ! 416: */ ! 417: if (ui->ui_dk >= 0) { ! 418: dk_busy |= 1<<ui->ui_dk; ! 419: dk_seek[ui->ui_dk]++; ! 420: } ! 421: goto out; ! 422: done: ! 423: /* ! 424: * Device is ready to go. ! 425: * Put it on the ready queue for the controller ! 426: * (unless its already there.) ! 427: */ ! 428: if (dp->b_active != 2) { ! 429: dp->b_forw = NULL; ! 430: if (um->um_tab.b_actf == NULL) ! 431: um->um_tab.b_actf = dp; ! 432: else ! 433: um->um_tab.b_actl->b_forw = dp; ! 434: um->um_tab.b_actl = dp; ! 435: dp->b_active = 2; ! 436: } ! 437: out: ! 438: return (didie); ! 439: } ! 440: ! 441: /* ! 442: * Start up a transfer on a drive. ! 443: */ ! 444: upstart(um) ! 445: register struct uba_ctlr *um; ! 446: { ! 447: register struct buf *bp, *dp; ! 448: register struct uba_device *ui; ! 449: register struct updevice *upaddr; ! 450: struct upst *st; ! 451: daddr_t bn; ! 452: int dn, sn, tn, cmd, waitdry; ! 453: ! 454: loop: ! 455: /* ! 456: * Pull a request off the controller queue ! 457: */ ! 458: if ((dp = um->um_tab.b_actf) == NULL) ! 459: return (0); ! 460: if ((bp = dp->b_actf) == NULL) { ! 461: um->um_tab.b_actf = dp->b_forw; ! 462: goto loop; ! 463: } ! 464: /* ! 465: * Mark controller busy, and ! 466: * determine destination of this request. ! 467: */ ! 468: um->um_tab.b_active++; ! 469: ui = updinfo[upunit(bp->b_dev)]; ! 470: bn = bp->b_blkno; ! 471: dn = ui->ui_slave; ! 472: st = &upst[ui->ui_type]; ! 473: sn = bn%st->nspc; ! 474: tn = sn/st->nsect; ! 475: sn %= st->nsect; ! 476: upaddr = (struct updevice *)ui->ui_addr; ! 477: /* ! 478: * Select drive if not selected already. ! 479: */ ! 480: if ((upaddr->upcs2&07) != dn) ! 481: upaddr->upcs2 = dn; ! 482: /* ! 483: * Check that it is ready and online ! 484: */ ! 485: waitdry = 0; ! 486: while ((upaddr->upds&UPDS_DRY) == 0) { ! 487: printf("up%d: ds wait ds=%o\n",upunit(bp->b_dev),upaddr->upds); ! 488: if (++waitdry > 512) ! 489: break; ! 490: upwaitdry++; ! 491: } ! 492: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) { ! 493: printf("up%d: not ready", upunit(bp->b_dev)); ! 494: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) { ! 495: printf("\n"); ! 496: um->um_tab.b_active = 0; ! 497: um->um_tab.b_errcnt = 0; ! 498: dp->b_actf = bp->av_forw; ! 499: dp->b_active = 0; ! 500: bp->b_flags |= B_ERROR; ! 501: iodone(bp); ! 502: goto loop; ! 503: } ! 504: /* ! 505: * Oh, well, sometimes this ! 506: * happens, for reasons unknown. ! 507: */ ! 508: printf(" (flakey)\n"); ! 509: } ! 510: /* ! 511: * Setup for the transfer, and get in the ! 512: * UNIBUS adaptor queue. ! 513: */ ! 514: upaddr->updc = bp->b_cylin; ! 515: upaddr->upda = (tn << 8) + sn; ! 516: upaddr->upwc = -bp->b_bcount / sizeof (short); ! 517: if (bp->b_flags & B_READ) ! 518: cmd = UP_IE|UP_RCOM|UP_GO; ! 519: else ! 520: cmd = UP_IE|UP_WCOM|UP_GO; ! 521: um->um_cmd = cmd; ! 522: (void) ubago(ui); ! 523: return (1); ! 524: } ! 525: ! 526: /* ! 527: * Now all ready to go, stuff the registers. ! 528: */ ! 529: updgo(um) ! 530: struct uba_ctlr *um; ! 531: { ! 532: register struct updevice *upaddr = (struct updevice *)um->um_addr; ! 533: ! 534: um->um_tab.b_active = 2; /* should now be 2 */ ! 535: upaddr->upba = um->um_ubinfo; ! 536: upaddr->upcs1 = um->um_cmd|((um->um_ubinfo>>8)&0x300); ! 537: } ! 538: ! 539: /* ! 540: * Handle a disk interrupt. ! 541: */ ! 542: upintr(sc21) ! 543: register sc21; ! 544: { ! 545: register struct buf *bp, *dp; ! 546: register struct uba_ctlr *um = upminfo[sc21]; ! 547: register struct uba_device *ui; ! 548: register struct updevice *upaddr = (struct updevice *)um->um_addr; ! 549: register unit; ! 550: struct up_softc *sc = &up_softc[um->um_ctlr]; ! 551: int as = (upaddr->upas & 0377) | sc->sc_softas; ! 552: int needie = 1, waitdry; ! 553: ! 554: sc->sc_wticks = 0; ! 555: sc->sc_softas = 0; ! 556: /* ! 557: * If controller wasn't transferring, then this is an ! 558: * interrupt for attention status on seeking drives. ! 559: * Just service them. ! 560: */ ! 561: if (um->um_tab.b_active != 2 && !sc->sc_recal) { ! 562: if (upaddr->upcs1 & UP_TRE) ! 563: upaddr->upcs1 = UP_TRE; ! 564: goto doattn; ! 565: } ! 566: um->um_tab.b_active = 1; ! 567: /* ! 568: * Get device and block structures, and a pointer ! 569: * to the uba_device for the drive. Select the drive. ! 570: */ ! 571: dp = um->um_tab.b_actf; ! 572: bp = dp->b_actf; ! 573: ui = updinfo[upunit(bp->b_dev)]; ! 574: dk_busy &= ~(1 << ui->ui_dk); ! 575: if ((upaddr->upcs2&07) != ui->ui_slave) ! 576: upaddr->upcs2 = ui->ui_slave; ! 577: if (bp->b_flags&B_BAD) { ! 578: if (upecc(ui, CONT)) ! 579: return; ! 580: } ! 581: /* ! 582: * Check for and process errors on ! 583: * either the drive or the controller. ! 584: */ ! 585: if ((upaddr->upds&UPDS_ERR) || (upaddr->upcs1&UP_TRE)) { ! 586: waitdry = 0; ! 587: while ((upaddr->upds & UPDS_DRY) == 0) { ! 588: if (++waitdry > 512) ! 589: break; ! 590: upwaitdry++; ! 591: } ! 592: if (upaddr->uper1&UPER1_WLE) { ! 593: /* ! 594: * Give up on write locked devices ! 595: * immediately. ! 596: */ ! 597: printf("up%d: write locked\n", upunit(bp->b_dev)); ! 598: bp->b_flags |= B_ERROR; ! 599: } else if (++um->um_tab.b_errcnt > 27) { ! 600: /* ! 601: * After 28 retries (16 without offset, and ! 602: * 12 with offset positioning) give up. ! 603: * If the error was header CRC, the header is ! 604: * screwed up, and the sector may in fact exist ! 605: * in the bad sector table, better check... ! 606: */ ! 607: if (upaddr->uper1&UPER1_HCRC) { ! 608: if (upecc(ui, BSE)) ! 609: return; ! 610: } ! 611: hard: ! 612: diskerr(bp, "up", "hard error", LOG_PRINTF, -1, ! 613: (struct disklabel *)0); ! 614: printf(" cn=%d tn=%d sn=%d cs2=%b er1=%b er2=%b\n", ! 615: upaddr->updc, ((upaddr->upda)>>8)&077, ! 616: (upaddr->upda)&037, ! 617: upaddr->upcs2, UPCS2_BITS, ! 618: upaddr->uper1, UPER1_BITS, ! 619: upaddr->uper2, UPER2_BITS); ! 620: bp->b_flags |= B_ERROR; ! 621: } else if (upaddr->uper2 & UPER2_BSE) { ! 622: if (upecc(ui, BSE)) ! 623: return; ! 624: else ! 625: goto hard; ! 626: } else { ! 627: /* ! 628: * Retriable error. ! 629: * If a soft ecc, correct it (continuing ! 630: * by returning if necessary. ! 631: * Otherwise fall through and retry the transfer ! 632: */ ! 633: if ((upaddr->uper1&(UPER1_DCK|UPER1_ECH))==UPER1_DCK) { ! 634: if (upecc(ui, ECC)) ! 635: return; ! 636: } else ! 637: um->um_tab.b_active = 0; /* force retry */ ! 638: } ! 639: /* ! 640: * Clear drive error and, every eight attempts, ! 641: * (starting with the fourth) ! 642: * recalibrate to clear the slate. ! 643: */ ! 644: upaddr->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO; ! 645: needie = 0; ! 646: if ((um->um_tab.b_errcnt&07) == 4 && um->um_tab.b_active == 0) { ! 647: upaddr->upcs1 = UP_RECAL|UP_IE|UP_GO; ! 648: sc->sc_recal = 0; ! 649: goto nextrecal; ! 650: } ! 651: } ! 652: /* ! 653: * Advance recalibration finite state machine ! 654: * if recalibrate in progress, through ! 655: * RECAL ! 656: * SEEK ! 657: * OFFSET (optional) ! 658: * RETRY ! 659: */ ! 660: switch (sc->sc_recal) { ! 661: ! 662: case 1: ! 663: upaddr->updc = bp->b_cylin; ! 664: upaddr->upcs1 = UP_SEEK|UP_IE|UP_GO; ! 665: goto nextrecal; ! 666: case 2: ! 667: if (um->um_tab.b_errcnt < 16 || (bp->b_flags&B_READ) == 0) ! 668: goto donerecal; ! 669: upaddr->upof = up_offset[um->um_tab.b_errcnt & 017] | UPOF_FMT22; ! 670: upaddr->upcs1 = UP_IE|UP_OFFSET|UP_GO; ! 671: goto nextrecal; ! 672: nextrecal: ! 673: sc->sc_recal++; ! 674: um->um_tab.b_active = 1; ! 675: return; ! 676: donerecal: ! 677: case 3: ! 678: sc->sc_recal = 0; ! 679: um->um_tab.b_active = 0; ! 680: break; ! 681: } ! 682: /* ! 683: * If still ``active'', then don't need any more retries. ! 684: */ ! 685: if (um->um_tab.b_active) { ! 686: /* ! 687: * If we were offset positioning, ! 688: * return to centerline. ! 689: */ ! 690: if (um->um_tab.b_errcnt >= 16) { ! 691: upaddr->upof = UPOF_FMT22; ! 692: upaddr->upcs1 = UP_RTC|UP_GO|UP_IE; ! 693: while (upaddr->upds & UPDS_PIP) ! 694: DELAY(25); ! 695: needie = 0; ! 696: } ! 697: um->um_tab.b_active = 0; ! 698: um->um_tab.b_errcnt = 0; ! 699: um->um_tab.b_actf = dp->b_forw; ! 700: dp->b_active = 0; ! 701: dp->b_errcnt = 0; ! 702: dp->b_actf = bp->av_forw; ! 703: bp->b_resid = (-upaddr->upwc * sizeof(short)); ! 704: iodone(bp); ! 705: /* ! 706: * If this unit has more work to do, ! 707: * then start it up right away. ! 708: */ ! 709: if (dp->b_actf) ! 710: if (upustart(ui)) ! 711: needie = 0; ! 712: } ! 713: as &= ~(1<<ui->ui_slave); ! 714: /* ! 715: * Release unibus resources and flush data paths. ! 716: */ ! 717: ubadone(um); ! 718: doattn: ! 719: /* ! 720: * Process other units which need attention. ! 721: * For each unit which needs attention, call ! 722: * the unit start routine to place the slave ! 723: * on the controller device queue. ! 724: */ ! 725: while (unit = ffs((long)as)) { ! 726: unit--; /* was 1 origin */ ! 727: as &= ~(1<<unit); ! 728: upaddr->upas = 1<<unit; ! 729: if (unit < UPIPUNITS && upustart(upip[sc21][unit])) ! 730: needie = 0; ! 731: } ! 732: /* ! 733: * If the controller is not transferring, but ! 734: * there are devices ready to transfer, start ! 735: * the controller. ! 736: */ ! 737: if (um->um_tab.b_actf && um->um_tab.b_active == 0) ! 738: if (upstart(um)) ! 739: needie = 0; ! 740: if (needie) ! 741: upaddr->upcs1 = UP_IE; ! 742: } ! 743: ! 744: /* ! 745: * Correct an ECC error, and restart the i/o to complete ! 746: * the transfer if necessary. This is quite complicated because ! 747: * the transfer may be going to an odd memory address base and/or ! 748: * across a page boundary. ! 749: */ ! 750: upecc(ui, flag) ! 751: register struct uba_device *ui; ! 752: int flag; ! 753: { ! 754: register struct updevice *up = (struct updevice *)ui->ui_addr; ! 755: register struct buf *bp = uputab[ui->ui_unit].b_actf; ! 756: register struct uba_ctlr *um = ui->ui_mi; ! 757: register struct upst *st; ! 758: struct uba_regs *ubp = ui->ui_hd->uh_uba; ! 759: register int i; ! 760: caddr_t addr; ! 761: int reg, bit, byte, npf, mask, o, cmd, ubaddr; ! 762: int bn, cn, tn, sn; ! 763: ! 764: /* ! 765: * Npf is the number of sectors transferred before the sector ! 766: * containing the ECC error, and reg is the UBA register ! 767: * mapping (the first part of) the transfer. ! 768: * O is offset within a memory page of the first byte transferred. ! 769: */ ! 770: if (flag == CONT) ! 771: npf = bp->b_error; ! 772: else ! 773: npf = btodb(bp->b_bcount + (up->upwc * sizeof(short)) + 511); ! 774: reg = btop(UBAI_ADDR(um->um_ubinfo)) + npf; ! 775: o = (int)bp->b_un.b_addr & PGOFSET; ! 776: mask = up->upec2; ! 777: #ifdef UPECCDEBUG ! 778: printf("npf %d reg %x o %d mask %o pos %d\n", npf, reg, o, mask, ! 779: up->upec1); ! 780: #endif ! 781: bn = bp->b_blkno; ! 782: st = &upst[ui->ui_type]; ! 783: cn = bp->b_cylin; ! 784: sn = bn%st->nspc + npf; ! 785: tn = sn/st->nsect; ! 786: sn %= st->nsect; ! 787: cn += tn/st->ntrak; ! 788: tn %= st->ntrak; ! 789: ubapurge(um); ! 790: um->um_tab.b_active=2; ! 791: /* ! 792: * action taken depends on the flag ! 793: */ ! 794: switch(flag){ ! 795: case ECC: ! 796: npf--; ! 797: reg--; ! 798: mask = up->upec2; ! 799: diskerr(bp, "up", "soft ecc", LOG_WARNING, npf, ! 800: (struct disklabel *)0); ! 801: addlog("\n"); ! 802: /* ! 803: * Flush the buffered data path, and compute the ! 804: * byte and bit position of the error. The variable i ! 805: * is the byte offset in the transfer, the variable byte ! 806: * is the offset from a page boundary in main memory. ! 807: */ ! 808: i = up->upec1 - 1; /* -1 makes 0 origin */ ! 809: bit = i&07; ! 810: i = (i&~07)>>3; ! 811: byte = i + o; ! 812: /* ! 813: * Correct while possible bits remain of mask. Since mask ! 814: * contains 11 bits, we continue while the bit offset is > -11. ! 815: * Also watch out for end of this block and the end of the whole ! 816: * transfer. ! 817: */ ! 818: while (i < 512 && (int)dbtob(npf)+i < bp->b_bcount && bit > -11) { ! 819: struct pte pte; ! 820: ! 821: pte = ubp->uba_map[reg + btop(byte)]; ! 822: addr = ptob(pte.pg_pfnum) + (byte & PGOFSET); ! 823: #ifdef UPECCDEBUG ! 824: printf("addr %x map reg %x\n", ! 825: addr, *(int *)(&ubp->uba_map[reg+btop(byte)])); ! 826: printf("old: %x, ", getmemc(addr)); ! 827: #endif ! 828: putmemc(addr, getmemc(addr)^(mask<<bit)); ! 829: #ifdef UPECCDEBUG ! 830: printf("new: %x\n", getmemc(addr)); ! 831: #endif ! 832: byte++; ! 833: i++; ! 834: bit -= 8; ! 835: } ! 836: if (up->upwc == 0) ! 837: return (0); ! 838: npf++; ! 839: reg++; ! 840: break; ! 841: case BSE: ! 842: /* ! 843: * if not in bad sector table, return 0 ! 844: */ ! 845: if ((bn = isbad(&upbad[ui->ui_unit], cn, tn, sn)) < 0) ! 846: return(0); ! 847: /* ! 848: * flag this one as bad ! 849: */ ! 850: bp->b_flags |= B_BAD; ! 851: bp->b_error = npf + 1; ! 852: #ifdef UPECCDEBUG ! 853: printf("BSE: restart at %d\n",npf+1); ! 854: #endif ! 855: bn = st->ncyl * st->nspc -st->nsect - 1 - bn; ! 856: cn = bn / st->nspc; ! 857: sn = bn % st->nspc; ! 858: tn = sn / st->nsect; ! 859: sn %= st->nsect; ! 860: up->upwc = -(512 / sizeof (short)); ! 861: #ifdef UPECCDEBUG ! 862: printf("revector to cn %d tn %d sn %d\n", cn, tn, sn); ! 863: #endif ! 864: break; ! 865: case CONT: ! 866: #ifdef UPECCDEBUG ! 867: printf("upecc, CONT: bn %d cn %d tn %d sn %d\n", bn, cn, tn, sn); ! 868: #endif ! 869: bp->b_flags &= ~B_BAD; ! 870: if ((int)dbtob(npf) >= bp->b_bcount) ! 871: return (0); ! 872: up->upwc = -((bp->b_bcount - (int)dbtob(npf)) / sizeof(short)); ! 873: break; ! 874: } ! 875: if (up->upwc == 0) { ! 876: um->um_tab.b_active = 0; ! 877: return (0); ! 878: } ! 879: /* ! 880: * Have to continue the transfer... clear the drive, ! 881: * and compute the position where the transfer is to continue. ! 882: * We have completed npf+1 sectors of the transfer already; ! 883: * restart at offset o of next sector (i.e. in UBA register reg+1). ! 884: */ ! 885: #ifdef notdef ! 886: up->uper1 = 0; ! 887: up->upcs1 |= UP_GO; ! 888: #else ! 889: up->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO; ! 890: up->updc = cn; ! 891: up->upda = (tn << 8) | sn; ! 892: ubaddr = (int)ptob(reg) + o; ! 893: up->upba = ubaddr; ! 894: cmd = (ubaddr >> 8) & 0x300; ! 895: cmd |= ((bp->b_flags&B_READ)?UP_RCOM:UP_WCOM)|UP_IE|UP_GO; ! 896: um->um_tab.b_errcnt = 0; ! 897: up->upcs1 = cmd; ! 898: #endif ! 899: return (1); ! 900: } ! 901: ! 902: /* ! 903: * Reset driver after UBA init. ! 904: * Cancel software state of all pending transfers ! 905: * and restart all units and the controller. ! 906: */ ! 907: upreset(uban) ! 908: int uban; ! 909: { ! 910: register struct uba_ctlr *um; ! 911: register struct uba_device *ui; ! 912: register sc21, unit; ! 913: ! 914: for (sc21 = 0; sc21 < NSC; sc21++) { ! 915: if ((um = upminfo[sc21]) == 0 || um->um_ubanum != uban || ! 916: um->um_alive == 0) ! 917: continue; ! 918: printf(" sc%d", sc21); ! 919: um->um_tab.b_active = 0; ! 920: um->um_tab.b_actf = um->um_tab.b_actl = 0; ! 921: up_softc[sc21].sc_recal = 0; ! 922: up_softc[sc21].sc_wticks = 0; ! 923: if (um->um_ubinfo) { ! 924: printf("<%d>", (um->um_ubinfo>>28)&0xf); ! 925: um->um_ubinfo = 0; ! 926: } ! 927: ((struct updevice *)(um->um_addr))->upcs2 = UPCS2_CLR; ! 928: for (unit = 0; unit < NUP; unit++) { ! 929: if ((ui = updinfo[unit]) == 0) ! 930: continue; ! 931: if (ui->ui_alive == 0 || ui->ui_mi != um) ! 932: continue; ! 933: uputab[unit].b_active = 0; ! 934: (void) upustart(ui); ! 935: } ! 936: (void) upstart(um); ! 937: } ! 938: } ! 939: ! 940: /* ! 941: * Wake up every second and if an interrupt is pending ! 942: * but nothing has happened increment a counter. ! 943: * If nothing happens for 20 seconds, reset the UNIBUS ! 944: * and begin anew. ! 945: */ ! 946: upwatch() ! 947: { ! 948: register struct uba_ctlr *um; ! 949: register sc21, unit; ! 950: register struct up_softc *sc; ! 951: ! 952: timeout(upwatch, (caddr_t)0, hz); ! 953: for (sc21 = 0; sc21 < NSC; sc21++) { ! 954: um = upminfo[sc21]; ! 955: if (um == 0 || um->um_alive == 0) ! 956: continue; ! 957: sc = &up_softc[sc21]; ! 958: if (um->um_tab.b_active == 0) { ! 959: for (unit = 0; unit < NUP; unit++) ! 960: if (uputab[unit].b_active && ! 961: updinfo[unit]->ui_mi == um) ! 962: goto active; ! 963: sc->sc_wticks = 0; ! 964: continue; ! 965: } ! 966: active: ! 967: sc->sc_wticks++; ! 968: if (sc->sc_wticks >= 20) { ! 969: sc->sc_wticks = 0; ! 970: printf("sc%d: lost interrupt\n", sc21); ! 971: ubareset(um->um_ubanum); ! 972: } ! 973: } ! 974: } ! 975: ! 976: #define DBSIZE 20 ! 977: ! 978: updump(dev) ! 979: dev_t dev; ! 980: { ! 981: struct updevice *upaddr; ! 982: char *start; ! 983: int num, blk, unit; ! 984: struct size *sizes; ! 985: register struct uba_regs *uba; ! 986: register struct uba_device *ui; ! 987: register short *rp; ! 988: struct upst *st; ! 989: register int retry; ! 990: ! 991: unit = upunit(dev); ! 992: if (unit >= NUP) ! 993: return (ENXIO); ! 994: #define phys(cast, addr) ((cast)((int)addr & 0x7fffffff)) ! 995: ui = phys(struct uba_device *, updinfo[unit]); ! 996: if (ui->ui_alive == 0) ! 997: return (ENXIO); ! 998: uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba; ! 999: ubainit(uba); ! 1000: upaddr = (struct updevice *)ui->ui_physaddr; ! 1001: DELAY(5000000); ! 1002: num = maxfree; ! 1003: upaddr->upcs2 = unit; ! 1004: DELAY(100); ! 1005: upaddr->upcs1 = UP_DCLR|UP_GO; ! 1006: upaddr->upcs1 = UP_PRESET|UP_GO; ! 1007: upaddr->upof = UPOF_FMT22; ! 1008: retry = 0; ! 1009: do { ! 1010: DELAY(25); ! 1011: if (++retry > 527) ! 1012: break; ! 1013: } while ((upaddr->upds & UP_RDY) == 0); ! 1014: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) ! 1015: return (EFAULT); ! 1016: start = 0; ! 1017: st = &upst[ui->ui_type]; ! 1018: sizes = phys(struct size *, st->sizes); ! 1019: if (dumplo < 0) ! 1020: return (EINVAL); ! 1021: if (dumplo + num >= sizes[minor(dev)&07].nblocks) ! 1022: num = sizes[minor(dev)&07].nblocks - dumplo; ! 1023: while (num > 0) { ! 1024: register struct pte *io; ! 1025: register int i; ! 1026: int cn, sn, tn; ! 1027: daddr_t bn; ! 1028: ! 1029: blk = num > DBSIZE ? DBSIZE : num; ! 1030: io = uba->uba_map; ! 1031: for (i = 0; i < blk; i++) ! 1032: *(int *)io++ = (btop(start)+i) | (1<<21) | UBAMR_MRV; ! 1033: *(int *)io = 0; ! 1034: bn = dumplo + btop(start); ! 1035: cn = bn/st->nspc + sizes[minor(dev)&07].cyloff; ! 1036: sn = bn%st->nspc; ! 1037: tn = sn/st->nsect; ! 1038: sn = sn%st->nsect; ! 1039: upaddr->updc = cn; ! 1040: rp = (short *) &upaddr->upda; ! 1041: *rp = (tn << 8) + sn; ! 1042: *--rp = 0; ! 1043: *--rp = -blk*NBPG / sizeof (short); ! 1044: *--rp = UP_GO|UP_WCOM; ! 1045: retry = 0; ! 1046: do { ! 1047: DELAY(25); ! 1048: if (++retry > 527) ! 1049: break; ! 1050: } while ((upaddr->upcs1 & UP_RDY) == 0); ! 1051: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) { ! 1052: printf("up%d: not ready", unit); ! 1053: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) { ! 1054: printf("\n"); ! 1055: return (EIO); ! 1056: } ! 1057: printf(" (flakey)\n"); ! 1058: } ! 1059: if (upaddr->upds&UPDS_ERR) ! 1060: return (EIO); ! 1061: start += blk*NBPG; ! 1062: num -= blk; ! 1063: } ! 1064: return (0); ! 1065: } ! 1066: ! 1067: upsize(dev) ! 1068: dev_t dev; ! 1069: { ! 1070: int unit = upunit(dev); ! 1071: struct uba_device *ui; ! 1072: struct upst *st; ! 1073: ! 1074: if (unit >= NUP || (ui = updinfo[unit]) == 0 || ui->ui_alive == 0) ! 1075: return (-1); ! 1076: st = &upst[ui->ui_type]; ! 1077: return (st->sizes[minor(dev) & 07].nblocks); ! 1078: } ! 1079: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.