![[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 / vaxuba|
Return to up.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: * @(#)up.c 7.1 (Berkeley) 6/5/86 ! 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 "dk.h" ! 25: #include "dkbad.h" ! 26: #include "buf.h" ! 27: #include "conf.h" ! 28: #include "dir.h" ! 29: #include "user.h" ! 30: #include "map.h" ! 31: #include "vm.h" ! 32: #include "cmap.h" ! 33: #include "uio.h" ! 34: #include "kernel.h" ! 35: #include "syslog.h" ! 36: ! 37: #include "../vax/cpu.h" ! 38: #include "../vax/nexus.h" ! 39: #include "ubavar.h" ! 40: #include "ubareg.h" ! 41: #include "upreg.h" ! 42: ! 43: struct up_softc { ! 44: int sc_softas; ! 45: int sc_ndrive; ! 46: int sc_wticks; ! 47: int sc_recal; ! 48: } up_softc[NSC]; ! 49: ! 50: #define upunit(dev) (minor(dev) >> 3) ! 51: ! 52: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */ ! 53: struct size { ! 54: daddr_t nblocks; ! 55: int cyloff; ! 56: } up9300_sizes[8] = { ! 57: 15884, 0, /* A=cyl 0 thru 26 */ ! 58: 33440, 27, /* B=cyl 27 thru 81 */ ! 59: 495520, 0, /* C=cyl 0 thru 814 */ ! 60: 15884, 562, /* D=cyl 562 thru 588 */ ! 61: 55936, 589, /* E=cyl 589 thru 680 */ ! 62: 81376, 681, /* F=cyl 681 thru 814 */ ! 63: 153728, 562, /* G=cyl 562 thru 814 */ ! 64: 291346, 82, /* H=cyl 82 thru 561 */ ! 65: }, up9766_sizes[8] = { ! 66: 15884, 0, /* A=cyl 0 thru 26 */ ! 67: 33440, 27, /* B=cyl 27 thru 81 */ ! 68: 500384, 0, /* C=cyl 0 thru 822 */ ! 69: 15884, 562, /* D=cyl 562 thru 588 */ ! 70: 55936, 589, /* E=cyl 589 thru 680 */ ! 71: 86240, 681, /* F=cyl 681 thru 822 */ ! 72: 158592, 562, /* G=cyl 562 thru 822 */ ! 73: 291346, 82, /* H=cyl 82 thru 561 */ ! 74: }, up160_sizes[8] = { ! 75: 15884, 0, /* A=cyl 0 thru 49 */ ! 76: 33440, 50, /* B=cyl 50 thru 154 */ ! 77: 263360, 0, /* C=cyl 0 thru 822 */ ! 78: 15884, 155, /* D=cyl 155 thru 204 */ ! 79: 55936, 205, /* E=cyl 205 thru 379 */ ! 80: 141664, 380, /* F=cyl 380 thru 822 */ ! 81: 213664, 155, /* G=cyl 155 thru 822 */ ! 82: 0, 0, ! 83: }, upam_sizes[8] = { ! 84: 15884, 0, /* A=cyl 0 thru 31 */ ! 85: 33440, 32, /* B=cyl 32 thru 97 */ ! 86: 524288, 0, /* C=cyl 0 thru 1023 */ ! 87: 15884, 668, /* D=cyl 668 thru 699 */ ! 88: 55936, 700, /* E=cyl 700 thru 809 */ ! 89: 109472, 810, /* F=cyl 810 thru 1023 */ ! 90: 182176, 668, /* G=cyl 668 thru 1023 */ ! 91: 291346, 98, /* H=cyl 98 thru 667 */ ! 92: }, up980_sizes[8] = { ! 93: 15884, 0, /* A=cyl 0 thru 99 */ ! 94: 33440, 100, /* B=cyl 100 thru 308 */ ! 95: 131680, 0, /* C=cyl 0 thru 822 */ ! 96: 15884, 309, /* D=cyl 309 thru 408 */ ! 97: 55936, 409, /* E=cyl 409 thru 758 */ ! 98: 10080, 759, /* F=cyl 759 thru 822 */ ! 99: 82080, 309, /* G=cyl 309 thru 822 */ ! 100: 0, 0, ! 101: }, upeagle_sizes[8] = { ! 102: 15884, 0, /* A=cyl 0 thru 16 */ ! 103: 66880, 17, /* B=cyl 17 thru 86 */ ! 104: 808320, 0, /* C=cyl 0 thru 841 */ ! 105: 15884, 391, /* D=cyl 391 thru 407 */ ! 106: 307200, 408, /* E=cyl 408 thru 727 */ ! 107: 109296, 728, /* F=cyl 728 thru 841 */ ! 108: 432816, 391, /* G=cyl 391 thru 841 */ ! 109: 291346, 87, /* H=cyl 87 thru 390 */ ! 110: }; ! 111: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */ ! 112: ! 113: int upprobe(), upslave(), upattach(), updgo(), upintr(); ! 114: struct uba_ctlr *upminfo[NSC]; ! 115: struct uba_device *updinfo[NUP]; ! 116: #define UPIPUNITS 8 ! 117: struct uba_device *upip[NSC][UPIPUNITS]; /* fuji w/fixed head gives n,n+4 */ ! 118: ! 119: u_short upstd[] = { 0776700, 0774400, 0776300, 0 }; ! 120: struct uba_driver scdriver = ! 121: { upprobe, upslave, upattach, updgo, upstd, "up", updinfo, "sc", upminfo }; ! 122: struct buf uputab[NUP]; ! 123: char upinit[NUP]; ! 124: ! 125: struct upst { ! 126: short nsect; /* # sectors/track */ ! 127: short ntrak; /* # tracks/cylinder */ ! 128: short nspc; /* # sectors/cylinder */ ! 129: short ncyl; /* # cylinders */ ! 130: struct size *sizes; /* partition tables */ ! 131: short sdist; /* seek distance metric */ ! 132: short rdist; /* rotational distance metric */ ! 133: } upst[] = { ! 134: { 32, 19, 32*19, 815, up9300_sizes, 3, 4 }, /* 9300 */ ! 135: { 32, 19, 32*19, 823, up9766_sizes, 3, 4 }, /* 9766 */ ! 136: { 32, 10, 32*10, 823, up160_sizes, 3, 4 }, /* fuji 160m */ ! 137: { 32, 16, 32*16, 1024, upam_sizes, 7, 8 }, /* Capricorn */ ! 138: { 32, 5, 32*5, 823, up980_sizes, 3, 4 }, /* DM980 */ ! 139: { 48, 20, 48*20, 842, upeagle_sizes, 15, 8 }, /* EAGLE */ ! 140: { 0, 0, 0, 0, 0, 0, 0 } ! 141: }; ! 142: ! 143: u_char up_offset[16] = { ! 144: UPOF_P400, UPOF_M400, UPOF_P400, UPOF_M400, ! 145: UPOF_P800, UPOF_M800, UPOF_P800, UPOF_M800, ! 146: UPOF_P1200, UPOF_M1200, UPOF_P1200, UPOF_M1200, ! 147: 0, 0, 0, 0 ! 148: }; ! 149: ! 150: struct buf rupbuf[NUP]; ! 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_mspw[ui->ui_dk] = .0000020345; ! 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("up%d: uphr=%x\n", ui->ui_slave, 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: harderr(bp, "up"); ! 613: printf("cn=%d tn=%d sn=%d cs2=%b er1=%b er2=%b\n", ! 614: upaddr->updc, ((upaddr->upda)>>8)&077, ! 615: (upaddr->upda)&037, ! 616: upaddr->upcs2, UPCS2_BITS, ! 617: upaddr->uper1, UPER1_BITS, ! 618: upaddr->uper2, UPER2_BITS); ! 619: bp->b_flags |= B_ERROR; ! 620: } else if (upaddr->uper2 & UPER2_BSE) { ! 621: if (upecc(ui, BSE)) ! 622: return; ! 623: else ! 624: goto hard; ! 625: } else { ! 626: /* ! 627: * Retriable error. ! 628: * If a soft ecc, correct it (continuing ! 629: * by returning if necessary. ! 630: * Otherwise fall through and retry the transfer ! 631: */ ! 632: if ((upaddr->uper1&(UPER1_DCK|UPER1_ECH))==UPER1_DCK) { ! 633: if (upecc(ui, ECC)) ! 634: return; ! 635: } else ! 636: um->um_tab.b_active = 0; /* force retry */ ! 637: } ! 638: /* ! 639: * Clear drive error and, every eight attempts, ! 640: * (starting with the fourth) ! 641: * recalibrate to clear the slate. ! 642: */ ! 643: upaddr->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO; ! 644: needie = 0; ! 645: if ((um->um_tab.b_errcnt&07) == 4 && um->um_tab.b_active == 0) { ! 646: upaddr->upcs1 = UP_RECAL|UP_IE|UP_GO; ! 647: sc->sc_recal = 0; ! 648: goto nextrecal; ! 649: } ! 650: } ! 651: /* ! 652: * Advance recalibration finite state machine ! 653: * if recalibrate in progress, through ! 654: * RECAL ! 655: * SEEK ! 656: * OFFSET (optional) ! 657: * RETRY ! 658: */ ! 659: switch (sc->sc_recal) { ! 660: ! 661: case 1: ! 662: upaddr->updc = bp->b_cylin; ! 663: upaddr->upcs1 = UP_SEEK|UP_IE|UP_GO; ! 664: goto nextrecal; ! 665: case 2: ! 666: if (um->um_tab.b_errcnt < 16 || (bp->b_flags&B_READ) == 0) ! 667: goto donerecal; ! 668: upaddr->upof = up_offset[um->um_tab.b_errcnt & 017] | UPOF_FMT22; ! 669: upaddr->upcs1 = UP_IE|UP_OFFSET|UP_GO; ! 670: goto nextrecal; ! 671: nextrecal: ! 672: sc->sc_recal++; ! 673: um->um_tab.b_active = 1; ! 674: return; ! 675: donerecal: ! 676: case 3: ! 677: sc->sc_recal = 0; ! 678: um->um_tab.b_active = 0; ! 679: break; ! 680: } ! 681: /* ! 682: * If still ``active'', then don't need any more retries. ! 683: */ ! 684: if (um->um_tab.b_active) { ! 685: /* ! 686: * If we were offset positioning, ! 687: * return to centerline. ! 688: */ ! 689: if (um->um_tab.b_errcnt >= 16) { ! 690: upaddr->upof = UPOF_FMT22; ! 691: upaddr->upcs1 = UP_RTC|UP_GO|UP_IE; ! 692: while (upaddr->upds & UPDS_PIP) ! 693: DELAY(25); ! 694: needie = 0; ! 695: } ! 696: um->um_tab.b_active = 0; ! 697: um->um_tab.b_errcnt = 0; ! 698: um->um_tab.b_actf = dp->b_forw; ! 699: dp->b_active = 0; ! 700: dp->b_errcnt = 0; ! 701: dp->b_actf = bp->av_forw; ! 702: bp->b_resid = (-upaddr->upwc * sizeof(short)); ! 703: iodone(bp); ! 704: /* ! 705: * If this unit has more work to do, ! 706: * then start it up right away. ! 707: */ ! 708: if (dp->b_actf) ! 709: if (upustart(ui)) ! 710: needie = 0; ! 711: } ! 712: as &= ~(1<<ui->ui_slave); ! 713: /* ! 714: * Release unibus resources and flush data paths. ! 715: */ ! 716: ubadone(um); ! 717: doattn: ! 718: /* ! 719: * Process other units which need attention. ! 720: * For each unit which needs attention, call ! 721: * the unit start routine to place the slave ! 722: * on the controller device queue. ! 723: */ ! 724: while (unit = ffs((long)as)) { ! 725: unit--; /* was 1 origin */ ! 726: as &= ~(1<<unit); ! 727: upaddr->upas = 1<<unit; ! 728: if (unit < UPIPUNITS && upustart(upip[sc21][unit])) ! 729: needie = 0; ! 730: } ! 731: /* ! 732: * If the controller is not transferring, but ! 733: * there are devices ready to transfer, start ! 734: * the controller. ! 735: */ ! 736: if (um->um_tab.b_actf && um->um_tab.b_active == 0) ! 737: if (upstart(um)) ! 738: needie = 0; ! 739: if (needie) ! 740: upaddr->upcs1 = UP_IE; ! 741: } ! 742: ! 743: upread(dev, uio) ! 744: dev_t dev; ! 745: struct uio *uio; ! 746: { ! 747: register int unit = upunit(dev); ! 748: ! 749: if (unit >= NUP) ! 750: return (ENXIO); ! 751: return (physio(upstrategy, &rupbuf[unit], dev, B_READ, minphys, uio)); ! 752: } ! 753: ! 754: upwrite(dev, uio) ! 755: dev_t dev; ! 756: struct uio *uio; ! 757: { ! 758: register int unit = upunit(dev); ! 759: ! 760: if (unit >= NUP) ! 761: return (ENXIO); ! 762: return (physio(upstrategy, &rupbuf[unit], dev, B_WRITE, minphys, uio)); ! 763: } ! 764: ! 765: /* ! 766: * Correct an ECC error, and restart the i/o to complete ! 767: * the transfer if necessary. This is quite complicated because ! 768: * the transfer may be going to an odd memory address base and/or ! 769: * across a page boundary. ! 770: */ ! 771: upecc(ui, flag) ! 772: register struct uba_device *ui; ! 773: int flag; ! 774: { ! 775: register struct updevice *up = (struct updevice *)ui->ui_addr; ! 776: register struct buf *bp = uputab[ui->ui_unit].b_actf; ! 777: register struct uba_ctlr *um = ui->ui_mi; ! 778: register struct upst *st; ! 779: struct uba_regs *ubp = ui->ui_hd->uh_uba; ! 780: register int i; ! 781: caddr_t addr; ! 782: int reg, bit, byte, npf, mask, o, cmd, ubaddr; ! 783: int bn, cn, tn, sn; ! 784: ! 785: /* ! 786: * Npf is the number of sectors transferred before the sector ! 787: * containing the ECC error, and reg is the UBA register ! 788: * mapping (the first part of) the transfer. ! 789: * O is offset within a memory page of the first byte transferred. ! 790: */ ! 791: if (flag == CONT) ! 792: npf = bp->b_error; ! 793: else ! 794: npf = btodb(bp->b_bcount + (up->upwc * sizeof(short)) + 511); ! 795: reg = btop(um->um_ubinfo&0x3ffff) + npf; ! 796: o = (int)bp->b_un.b_addr & PGOFSET; ! 797: mask = up->upec2; ! 798: #ifdef UPECCDEBUG ! 799: printf("npf %d reg %x o %d mask %o pos %d\n", npf, reg, o, mask, ! 800: up->upec1); ! 801: #endif ! 802: bn = bp->b_blkno; ! 803: st = &upst[ui->ui_type]; ! 804: cn = bp->b_cylin; ! 805: sn = bn%st->nspc + npf; ! 806: tn = sn/st->nsect; ! 807: sn %= st->nsect; ! 808: cn += tn/st->ntrak; ! 809: tn %= st->ntrak; ! 810: ubapurge(um); ! 811: um->um_tab.b_active=2; ! 812: /* ! 813: * action taken depends on the flag ! 814: */ ! 815: switch(flag){ ! 816: case ECC: ! 817: npf--; ! 818: reg--; ! 819: mask = up->upec2; ! 820: log(LOG_WARNING, "up%d%c: soft ecc sn%d\n", upunit(bp->b_dev), ! 821: 'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf); ! 822: /* ! 823: * Flush the buffered data path, and compute the ! 824: * byte and bit position of the error. The variable i ! 825: * is the byte offset in the transfer, the variable byte ! 826: * is the offset from a page boundary in main memory. ! 827: */ ! 828: i = up->upec1 - 1; /* -1 makes 0 origin */ ! 829: bit = i&07; ! 830: i = (i&~07)>>3; ! 831: byte = i + o; ! 832: /* ! 833: * Correct while possible bits remain of mask. Since mask ! 834: * contains 11 bits, we continue while the bit offset is > -11. ! 835: * Also watch out for end of this block and the end of the whole ! 836: * transfer. ! 837: */ ! 838: while (i < 512 && (int)dbtob(npf)+i < bp->b_bcount && bit > -11) { ! 839: struct pte pte; ! 840: ! 841: pte = ubp->uba_map[reg + btop(byte)]; ! 842: addr = ptob(pte.pg_pfnum) + (byte & PGOFSET); ! 843: #ifdef UPECCDEBUG ! 844: printf("addr %x map reg %x\n", ! 845: addr, *(int *)(&ubp->uba_map[reg+btop(byte)])); ! 846: printf("old: %x, ", getmemc(addr)); ! 847: #endif ! 848: putmemc(addr, getmemc(addr)^(mask<<bit)); ! 849: #ifdef UPECCDEBUG ! 850: printf("new: %x\n", getmemc(addr)); ! 851: #endif ! 852: byte++; ! 853: i++; ! 854: bit -= 8; ! 855: } ! 856: if (up->upwc == 0) ! 857: return (0); ! 858: npf++; ! 859: reg++; ! 860: break; ! 861: case BSE: ! 862: /* ! 863: * if not in bad sector table, return 0 ! 864: */ ! 865: if ((bn = isbad(&upbad[ui->ui_unit], cn, tn, sn)) < 0) ! 866: return(0); ! 867: /* ! 868: * flag this one as bad ! 869: */ ! 870: bp->b_flags |= B_BAD; ! 871: bp->b_error = npf + 1; ! 872: #ifdef UPECCDEBUG ! 873: printf("BSE: restart at %d\n",npf+1); ! 874: #endif ! 875: bn = st->ncyl * st->nspc -st->nsect - 1 - bn; ! 876: cn = bn / st->nspc; ! 877: sn = bn % st->nspc; ! 878: tn = sn / st->nsect; ! 879: sn %= st->nsect; ! 880: up->upwc = -(512 / sizeof (short)); ! 881: #ifdef UPECCDEBUG ! 882: printf("revector to cn %d tn %d sn %d\n", cn, tn, sn); ! 883: #endif ! 884: break; ! 885: case CONT: ! 886: #ifdef UPECCDEBUG ! 887: printf("upecc, CONT: bn %d cn %d tn %d sn %d\n", bn, cn, tn, sn); ! 888: #endif ! 889: bp->b_flags &= ~B_BAD; ! 890: if ((int)dbtob(npf) >= bp->b_bcount) ! 891: return (0); ! 892: up->upwc = -((bp->b_bcount - (int)dbtob(npf)) / sizeof(short)); ! 893: break; ! 894: } ! 895: if (up->upwc == 0) { ! 896: um->um_tab.b_active = 0; ! 897: return (0); ! 898: } ! 899: /* ! 900: * Have to continue the transfer... clear the drive, ! 901: * and compute the position where the transfer is to continue. ! 902: * We have completed npf+1 sectors of the transfer already; ! 903: * restart at offset o of next sector (i.e. in UBA register reg+1). ! 904: */ ! 905: #ifdef notdef ! 906: up->uper1 = 0; ! 907: up->upcs1 |= UP_GO; ! 908: #else ! 909: up->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO; ! 910: up->updc = cn; ! 911: up->upda = (tn << 8) | sn; ! 912: ubaddr = (int)ptob(reg) + o; ! 913: up->upba = ubaddr; ! 914: cmd = (ubaddr >> 8) & 0x300; ! 915: cmd |= ((bp->b_flags&B_READ)?UP_RCOM:UP_WCOM)|UP_IE|UP_GO; ! 916: um->um_tab.b_errcnt = 0; ! 917: up->upcs1 = cmd; ! 918: #endif ! 919: return (1); ! 920: } ! 921: ! 922: /* ! 923: * Reset driver after UBA init. ! 924: * Cancel software state of all pending transfers ! 925: * and restart all units and the controller. ! 926: */ ! 927: upreset(uban) ! 928: int uban; ! 929: { ! 930: register struct uba_ctlr *um; ! 931: register struct uba_device *ui; ! 932: register sc21, unit; ! 933: ! 934: for (sc21 = 0; sc21 < NSC; sc21++) { ! 935: if ((um = upminfo[sc21]) == 0 || um->um_ubanum != uban || ! 936: um->um_alive == 0) ! 937: continue; ! 938: printf(" sc%d", sc21); ! 939: um->um_tab.b_active = 0; ! 940: um->um_tab.b_actf = um->um_tab.b_actl = 0; ! 941: up_softc[sc21].sc_recal = 0; ! 942: up_softc[sc21].sc_wticks = 0; ! 943: if (um->um_ubinfo) { ! 944: printf("<%d>", (um->um_ubinfo>>28)&0xf); ! 945: um->um_ubinfo = 0; ! 946: } ! 947: ((struct updevice *)(um->um_addr))->upcs2 = UPCS2_CLR; ! 948: for (unit = 0; unit < NUP; unit++) { ! 949: if ((ui = updinfo[unit]) == 0) ! 950: continue; ! 951: if (ui->ui_alive == 0 || ui->ui_mi != um) ! 952: continue; ! 953: uputab[unit].b_active = 0; ! 954: (void) upustart(ui); ! 955: } ! 956: (void) upstart(um); ! 957: } ! 958: } ! 959: ! 960: /* ! 961: * Wake up every second and if an interrupt is pending ! 962: * but nothing has happened increment a counter. ! 963: * If nothing happens for 20 seconds, reset the UNIBUS ! 964: * and begin anew. ! 965: */ ! 966: upwatch() ! 967: { ! 968: register struct uba_ctlr *um; ! 969: register sc21, unit; ! 970: register struct up_softc *sc; ! 971: ! 972: timeout(upwatch, (caddr_t)0, hz); ! 973: for (sc21 = 0; sc21 < NSC; sc21++) { ! 974: um = upminfo[sc21]; ! 975: if (um == 0 || um->um_alive == 0) ! 976: continue; ! 977: sc = &up_softc[sc21]; ! 978: if (um->um_tab.b_active == 0) { ! 979: for (unit = 0; unit < NUP; unit++) ! 980: if (uputab[unit].b_active && ! 981: updinfo[unit]->ui_mi == um) ! 982: goto active; ! 983: sc->sc_wticks = 0; ! 984: continue; ! 985: } ! 986: active: ! 987: sc->sc_wticks++; ! 988: if (sc->sc_wticks >= 20) { ! 989: sc->sc_wticks = 0; ! 990: printf("sc%d: lost interrupt\n", sc21); ! 991: ubareset(um->um_ubanum); ! 992: } ! 993: } ! 994: } ! 995: ! 996: #define DBSIZE 20 ! 997: ! 998: updump(dev) ! 999: dev_t dev; ! 1000: { ! 1001: struct updevice *upaddr; ! 1002: char *start; ! 1003: int num, blk, unit; ! 1004: struct size *sizes; ! 1005: register struct uba_regs *uba; ! 1006: register struct uba_device *ui; ! 1007: register short *rp; ! 1008: struct upst *st; ! 1009: register int retry; ! 1010: ! 1011: unit = upunit(dev); ! 1012: if (unit >= NUP) ! 1013: return (ENXIO); ! 1014: #define phys(cast, addr) ((cast)((int)addr & 0x7fffffff)) ! 1015: ui = phys(struct uba_device *, updinfo[unit]); ! 1016: if (ui->ui_alive == 0) ! 1017: return (ENXIO); ! 1018: uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba; ! 1019: ubainit(uba); ! 1020: upaddr = (struct updevice *)ui->ui_physaddr; ! 1021: DELAY(5000000); ! 1022: num = maxfree; ! 1023: upaddr->upcs2 = unit; ! 1024: DELAY(100); ! 1025: upaddr->upcs1 = UP_DCLR|UP_GO; ! 1026: upaddr->upcs1 = UP_PRESET|UP_GO; ! 1027: upaddr->upof = UPOF_FMT22; ! 1028: retry = 0; ! 1029: do { ! 1030: DELAY(25); ! 1031: if (++retry > 527) ! 1032: break; ! 1033: } while ((upaddr->upds & UP_RDY) == 0); ! 1034: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) ! 1035: return (EFAULT); ! 1036: start = 0; ! 1037: st = &upst[ui->ui_type]; ! 1038: sizes = phys(struct size *, st->sizes); ! 1039: if (dumplo < 0) ! 1040: return (EINVAL); ! 1041: if (dumplo + num >= sizes[minor(dev)&07].nblocks) ! 1042: num = sizes[minor(dev)&07].nblocks - dumplo; ! 1043: while (num > 0) { ! 1044: register struct pte *io; ! 1045: register int i; ! 1046: int cn, sn, tn; ! 1047: daddr_t bn; ! 1048: ! 1049: blk = num > DBSIZE ? DBSIZE : num; ! 1050: io = uba->uba_map; ! 1051: for (i = 0; i < blk; i++) ! 1052: *(int *)io++ = (btop(start)+i) | (1<<21) | UBAMR_MRV; ! 1053: *(int *)io = 0; ! 1054: bn = dumplo + btop(start); ! 1055: cn = bn/st->nspc + sizes[minor(dev)&07].cyloff; ! 1056: sn = bn%st->nspc; ! 1057: tn = sn/st->nsect; ! 1058: sn = sn%st->nsect; ! 1059: upaddr->updc = cn; ! 1060: rp = (short *) &upaddr->upda; ! 1061: *rp = (tn << 8) + sn; ! 1062: *--rp = 0; ! 1063: *--rp = -blk*NBPG / sizeof (short); ! 1064: *--rp = UP_GO|UP_WCOM; ! 1065: retry = 0; ! 1066: do { ! 1067: DELAY(25); ! 1068: if (++retry > 527) ! 1069: break; ! 1070: } while ((upaddr->upcs1 & UP_RDY) == 0); ! 1071: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) { ! 1072: printf("up%d: not ready", unit); ! 1073: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) { ! 1074: printf("\n"); ! 1075: return (EIO); ! 1076: } ! 1077: printf(" (flakey)\n"); ! 1078: } ! 1079: if (upaddr->upds&UPDS_ERR) ! 1080: return (EIO); ! 1081: start += blk*NBPG; ! 1082: num -= blk; ! 1083: } ! 1084: return (0); ! 1085: } ! 1086: ! 1087: upsize(dev) ! 1088: dev_t dev; ! 1089: { ! 1090: int unit = upunit(dev); ! 1091: struct uba_device *ui; ! 1092: struct upst *st; ! 1093: ! 1094: if (unit >= NUP || (ui = updinfo[unit]) == 0 || ui->ui_alive == 0) ! 1095: return (-1); ! 1096: st = &upst[ui->ui_type]; ! 1097: return (st->sizes[minor(dev) & 07].nblocks); ! 1098: } ! 1099: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.