![[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 [Research Unix] / researchv10dc / lsys / io|
Return to up.c CVS log | Up to [Research Unix] / researchv10dc / lsys / io |
1.1 ! root 1: /* ! 2: * UNIBUS SMD disk driver ! 3: * ! 4: * undone: ! 5: * Add bad sector forwarding code ! 6: * Check that offset recovery code works ! 7: * unibus mapping is suboptimal; if the queue gets long, ! 8: * buffered data paths will be underused ! 9: */ ! 10: ! 11: #include "sys/param.h" ! 12: #include "sys/buf.h" ! 13: #include "sys/conf.h" ! 14: #include "sys/user.h" ! 15: #include "sys/up.h" ! 16: #include "sys/ubaddr.h" ! 17: #include "sys/subaddr.h" ! 18: ! 19: #define NOUPSEEK 1 /* because emulex doesn't do it right */ ! 20: ! 21: /* ! 22: * hardware registers ! 23: */ ! 24: ! 25: struct updevice ! 26: { ! 27: u_short upcs1; /* control and status register 1 */ ! 28: short upwc; /* word count register */ ! 29: u_short upba; /* UNIBUS address register */ ! 30: u_short upda; /* desired address register */ ! 31: u_short upcs2; /* control and status register 2 */ ! 32: u_short upds; /* drive status */ ! 33: u_short uper1; /* error register 1 */ ! 34: u_short upas; /* attention summary */ ! 35: u_short upla; /* look ahead */ ! 36: u_short updb; /* data buffer */ ! 37: u_short upmr; /* maintenance */ ! 38: u_short updt; /* drive type */ ! 39: u_short upsn; /* serial number */ ! 40: u_short upof; /* offset register */ ! 41: u_short updc; /* desired cylinder address register */ ! 42: u_short uphr; /* holding register */ ! 43: u_short upmr2; /* maintenance register 2 */ ! 44: u_short uper2; /* error register 2 */ ! 45: u_short upec1; /* burst error bit position */ ! 46: u_short upec2; /* burst error bit pattern */ ! 47: }; ! 48: ! 49: /* ! 50: * upcs1 ! 51: */ ! 52: ! 53: #define UP_SC 0100000 /* special condition */ ! 54: #define UP_TRE 0040000 /* transfer error */ ! 55: #define UP_IE 0000100 /* interrupt enable */ ! 56: #define UP_GO 0000001 ! 57: ! 58: #define UP_SEEK 004 /* seek */ ! 59: #define UP_RECAL 006 /* recalibrate */ ! 60: #define UP_DCLR 010 /* drive clear */ ! 61: #define UP_OFFSET 014 /* offset */ ! 62: #define UP_RTC 016 /* return to center-line */ ! 63: #define UP_PRESET 020 /* read-in preset */ ! 64: #define UP_SEARCH 030 /* search */ ! 65: #define UP_WCOM 060 /* write */ ! 66: #define UP_RCOM 070 /* read data */ ! 67: ! 68: /* ! 69: * upcs2 ! 70: */ ! 71: #define UPCS2_NED 0010000 /* nonexistent drive */ ! 72: #define UPCS2_CLR 0000040 /* controller clear */ ! 73: #define UPCS2_SEL 0000007 /* unit select */ ! 74: ! 75: /* ! 76: * upds ! 77: */ ! 78: #define UPDS_ERR 0040000 /* composite drive error */ ! 79: #define UPDS_PIP 0020000 /* positioning in progress */ ! 80: #define UPDS_MOL 0010000 /* medium on line */ ! 81: #define UPDS_DPR 0000400 /* drive present */ ! 82: #define UPDS_DRY 0000200 /* drive ready */ ! 83: #define UPDS_VV 0000100 /* volume valid */ ! 84: #define UPDS_DREADY (UPDS_DPR|UPDS_DRY|UPDS_MOL|UPDS_VV) ! 85: ! 86: /* ! 87: * uper1 ! 88: */ ! 89: #define UPER1_DCK 0100000 /* data check */ ! 90: #define UPER1_WLE 0004000 /* write lock error */ ! 91: #define UPER1_ECH 0000100 /* ecc hard error */ ! 92: ! 93: /* ! 94: * uphr: emulex hack ! 95: */ ! 96: #define UPHR_MAXCYL 0100027 /* max cyl address */ ! 97: #define UPHR_MAXTRAK 0100030 /* max track address */ ! 98: #define UPHR_MAXSECT 0100031 /* max sector address */ ! 99: ! 100: /* ! 101: * upof ! 102: */ ! 103: #define UPOF_FMT22 0010000 /* 16 bit format */ ! 104: /* THE SC21 ACTUALLY JUST IMPLEMENTS ADVANCE/RETARD... */ ! 105: #define UPOF_P400 0020 /* +400 uinches */ ! 106: #define UPOF_M400 0220 /* -400 uinches */ ! 107: #define UPOF_P800 0040 /* +800 uinches */ ! 108: #define UPOF_M800 0240 /* -800 uinches */ ! 109: #define UPOF_P1200 0060 /* +1200 uinches */ ! 110: #define UPOF_M1200 0260 /* -1200 uinches */ ! 111: ! 112: #define SECTOR 512 /* size of a hardware sector */ ! 113: ! 114: /* ! 115: * monstrous size tables ! 116: * one per type of drive ! 117: */ ! 118: struct size ! 119: { ! 120: daddr_t nblocks; ! 121: int cyloff; ! 122: } up_sizes[8] = { ! 123: 15884, 0, /* A=cyl 0 thru 26 */ ! 124: 33440, 27, /* B=cyl 27 thru 81 */ ! 125: 495520, 0, /* C=cyl 0 thru 814 */ ! 126: 15884, 562, /* D=cyl 562 thru 588 */ ! 127: 55936, 589, /* E=cyl 589 thru 680 */ ! 128: #ifndef NOBADSECT ! 129: 81376, 681, /* F=cyl 681 thru 814 */ ! 130: 153728, 562, /* G=cyl 562 thru 814 */ ! 131: #else ! 132: 81472, 681, ! 133: 153824, 562, ! 134: #endif ! 135: 291346, 82, /* H=cyl 82 thru 561 */ ! 136: }, fj_sizes[8] = { ! 137: 10240, 0, /* A=cyl 0 thru 31 */ ! 138: 20480, 32, /* B=cyl 32 thru 95 */ ! 139: 232640, 96, /* C=cyl 96 thru 822 */ ! 140: 0, 0, ! 141: 0, 0, ! 142: 0, 0, ! 143: 0, 0, ! 144: #ifndef NOBADSECT ! 145: 0, 0, /* H=cyl 155 thru 822 */ ! 146: #else ! 147: 0, 0, ! 148: #endif ! 149: }, fj3_sizes[8] = { ! 150: 10240, 0, /* A=cyl 0 thru 19 */ ! 151: 20480, 20, /* B=cyl 20 thru 59 */ ! 152: 246784, 60, /* C=cyl 60 thru 541 */ ! 153: 246784, 542, /* D=cyl 542 thru 1024 */ ! 154: 0, 0, ! 155: 0, 0, ! 156: 0, 0, ! 157: #ifndef NOBADSECT ! 158: 0, 0, /* H=cyl 155 thru 822 */ ! 159: #else ! 160: 0, 0, ! 161: #endif ! 162: }, cd_sizes[8] = { ! 163: 10240, 0, /* A=cyl 0 thru 63 */ ! 164: 20480, 64, /* B=cyl 64 thru 191 */ ! 165: 100960, 192, /* C=cyl 192 thru 822 */ ! 166: 0, 0, ! 167: 0, 0, ! 168: 0, 0, ! 169: 0, 0, ! 170: #ifndef NOBADSECT ! 171: 100960, 0, /* H=cyl 0 thru 630 */ ! 172: #else ! 173: 100960, 0, ! 174: #endif ! 175: }, fj1_sizes[8] = { ! 176: 1024, 0, /* cyl 0 through 3 */ ! 177: 0, 0, ! 178: 0, 0, ! 179: 0, 0, ! 180: 0, 0, ! 181: 0, 0, ! 182: 0, 0, ! 183: 0, 0, ! 184: }; ! 185: ! 186: /* ! 187: * tables of per-drive info, mostly sizes of things ! 188: * indexed by magic numbers; see uputype ! 189: */ ! 190: struct upst upst[] = { ! 191: 32, 19, 3, 4, 32*19, 823, up_sizes, /* 9300/cdc */ ! 192: /* 9300 actually has 815 cylinders... */ ! 193: 32, 10, 3, 4, 32*10, 823, fj_sizes, /* fujitsu 160m */ ! 194: 32, 5, 3, 4, 32*5, 631, cd_sizes, /* CDC 76 MB */ ! 195: 32, 8, 3, 4, 32*8, 4, fj1_sizes, /* Fixed part of FJ */ ! 196: 32, 16, 3, 4, 32*16, 1024, fj3_sizes, /* fujitsu 330m */ ! 197: }; ! 198: ! 199: u_char up_offset[16] = { ! 200: UPOF_P400, UPOF_M400, UPOF_P400, UPOF_M400, ! 201: UPOF_P800, UPOF_M800, UPOF_P800, UPOF_M800, ! 202: UPOF_P1200, UPOF_M1200, UPOF_P1200, UPOF_M1200, ! 203: 0, 0, 0, 0 ! 204: }; ! 205: ! 206: /* ! 207: * things from config ! 208: */ ! 209: extern int upcnt, sccnt; ! 210: extern struct ubaddr scaddr[]; ! 211: extern struct subaddr upaddr[]; ! 212: extern struct scctl scctl[]; ! 213: extern struct updisk updisk[]; ! 214: extern struct buf upbuf[]; ! 215: ! 216: /* ! 217: * controller flags, scctl.flags ! 218: */ ! 219: ! 220: #define CACTIVE 01 /* xfer in progress */ ! 221: #define CWAITING 02 /* xfering and timer has ticked */ ! 222: ! 223: /* ! 224: * unit flags, updisk.flags ! 225: */ ! 226: ! 227: #define UACTIVE 01 /* working on this xfer */ ! 228: #define URXFR 02 /* done with any seeking; ready to roll */ ! 229: #define UWOL 04 /* waiting for offline drive */ ! 230: #define UWAITOL 010 /* waiting and timer has ticked */ ! 231: ! 232: /* ! 233: * device number ! 234: */ ! 235: ! 236: #define UNIT(d) ((minor(d)>>3) & 07) ! 237: #define PART(d) (minor(d) & 07) ! 238: ! 239: /* ! 240: * abuse of spare bits of struct buf ! 241: */ ! 242: #define b_cylin b_resid /* for disksort */ ! 243: #define b_ubm av_back /* this buffer's map */ ! 244: ! 245: int upwstart, upwatch(); /* Have started guardian */ ! 246: int upwaitdry; ! 247: ! 248: int upopen(), upstrategy(), upread(), upwrite(); ! 249: ! 250: struct cdevsw upcdev = cdinit(upopen, nulldev, upread, upwrite, nodev); ! 251: ! 252: struct bdevsw upbdev = bdinit(upopen, nulldev, upstrategy, 0); ! 253: ! 254: upopen(dev, flag) ! 255: int dev, flag; ! 256: { ! 257: if (upuinit(UNIT(dev)) == 0) ! 258: u.u_error = ENXIO; ! 259: } ! 260: ! 261: upuinit(unit) ! 262: register int unit; ! 263: { ! 264: register struct updevice *reg; ! 265: register struct updisk *up; ! 266: register struct subaddr *ua; ! 267: ! 268: if (unit < 0 || unit > upcnt) ! 269: return (0); ! 270: ua = &upaddr[unit]; ! 271: if (ua->ctl < 0) ! 272: return (0); ! 273: up = &updisk[unit]; ! 274: if (up->ctl) ! 275: return (1); ! 276: if (upcinit(ua->ctl) == 0) ! 277: return (0); ! 278: reg = scctl[ua->ctl].addr; ! 279: if ((up->type = uputype(reg, ua->unit)) < 0) { ! 280: printf("up%d absent or bad type\n", unit); ! 281: return (0); ! 282: } ! 283: up->unit = ua->unit; ! 284: up->ctl = &scctl[ua->ctl]; ! 285: up->ctl->drives[ua->unit] = up; ! 286: return (1); ! 287: } ! 288: ! 289: ! 290: /* ! 291: * determine drive type ! 292: * very emulex dependent; should look at drive type register too. ! 293: * perhaps there should be a way to change it? ! 294: * this is called by updump too; ! 295: * be prepared to run without memory management ! 296: * unit is the hardware unit ! 297: * return is an index into upst ! 298: */ ! 299: int ! 300: uputype(reg, unit) ! 301: register struct updevice *reg; ! 302: int unit; ! 303: { ! 304: ! 305: reg->upcs1 = 0; /* conservative */ ! 306: reg->upcs2 = unit; ! 307: if (reg->upcs2&UPCS2_NED) { ! 308: reg->upcs1 = UP_DCLR|UP_GO; ! 309: return (-1); ! 310: } ! 311: reg->uphr = UPHR_MAXTRAK; ! 312: switch (reg->uphr) { ! 313: default: ! 314: reg->upcs1 = UP_DCLR|UP_GO; ! 315: return (-1); ! 316: case 9: ! 317: return (unit >= 4 ? 3 : 1); /* fujitsu hack */ ! 318: case 4: ! 319: return (2); /* CDC 76MB hack */ ! 320: case 7: ! 321: return (3); /* Fixed Fujitsu hack */ ! 322: case 15: ! 323: return (4); /* fuji 330m hack */ ! 324: case 19: ! 325: return (0); /* CDC 300 MB hack */ ! 326: } ! 327: } ! 328: ! 329: upcinit(ctl) ! 330: int ctl; ! 331: { ! 332: register struct scctl *sc; ! 333: register struct updevice *reg; ! 334: ! 335: if (ctl < 0 || ctl >= sccnt) ! 336: return (0); ! 337: sc = &scctl[ctl]; ! 338: if (sc->addr) ! 339: return (1); ! 340: if ((reg = (struct updevice *)ubaddr(&scaddr[ctl])) == 0 ! 341: || ubbadaddr(scaddr[ctl].ubno, ®->upcs1, sizeof(short))) { ! 342: printf("sc%d absent\n", ctl); ! 343: return (0); ! 344: } ! 345: reg->upcs2 = UPCS2_CLR; ! 346: sc->addr = reg; ! 347: sc->ubno = scaddr[ctl].ubno; ! 348: if (upwstart == 0) { ! 349: timeout(upwatch, (caddr_t)0, HZ); ! 350: upwstart++; ! 351: } ! 352: return (1); ! 353: } ! 354: ! 355: upstrategy(bp) ! 356: register struct buf *bp; ! 357: { ! 358: register struct updisk *up; ! 359: register struct upst *st; ! 360: register int unit; ! 361: register int part; ! 362: long sz; ! 363: int s; ! 364: ! 365: sz = (bp->b_bcount+SECTOR-1)/SECTOR; ! 366: unit = UNIT(bp->b_dev); ! 367: up = &updisk[unit]; ! 368: if (up->ctl == 0) { ! 369: bp->b_flags |= B_ERROR; ! 370: iodone(bp); ! 371: return; ! 372: } ! 373: st = &upst[up->type]; ! 374: part = PART(bp->b_dev); ! 375: if (bp->b_blkno < 0 || bp->b_blkno+sz > st->sizes[part].nblocks) { ! 376: if (bp->b_blkno == st->sizes[part].nblocks) ! 377: bp->b_resid = bp->b_bcount; ! 378: else { /* partial read too hard for now */ ! 379: bp->b_error = ENXIO; ! 380: bp->b_flags |= B_ERROR; ! 381: } ! 382: iodone(bp); ! 383: return; ! 384: } ! 385: bp->b_cylin = bp->b_blkno/st->nspc + st->sizes[part].cyloff; ! 386: bp->b_ubm = (struct buf *)ubmbuf(up->ctl->ubno, bp, USLP); ! 387: s = spl6(); ! 388: disksort(&up->actf, &up->actl, bp); ! 389: if ((up->flags & UACTIVE) == 0) { ! 390: upustart(up); ! 391: if (up->ctl->actf && (up->ctl->flags & CACTIVE) == 0) ! 392: upstart(up->ctl); ! 393: } ! 394: splx(s); ! 395: } ! 396: ! 397: /* ! 398: * unit start: ! 399: * if there's a block for this drive, start seeking there ! 400: * ! 401: * up->upcs = UP_IE cancels a pending command in the SC21 ! 402: * why not up->cs |= UP_IE? ! 403: */ ! 404: upustart(up) ! 405: register struct updisk *up; ! 406: { ! 407: register struct buf *bp; ! 408: register struct updevice *reg; ! 409: register struct scctl *sc; ! 410: register struct upst *st; ! 411: int sn, csn; ! 412: int didie = 0; ! 413: ! 414: sc = up->ctl; ! 415: if ((bp = up->actf) == NULL) ! 416: return (0); ! 417: #ifndef NOUPSEEK ! 418: if (sc->flags & CACTIVE) { /* can't start seek till xfer done */ ! 419: sc->softas |= 1<<up->unit; ! 420: return (0); ! 421: } ! 422: #endif ! 423: reg = sc->addr; ! 424: reg->upcs2 = up->unit; ! 425: if ((reg->upds & UPDS_VV) == 0) { ! 426: reg->upcs1 = UP_IE|UP_DCLR|UP_GO; ! 427: reg->upcs1 = UP_IE|UP_PRESET|UP_GO; ! 428: reg->upof = UPOF_FMT22; ! 429: didie = 1; ! 430: } ! 431: if ((reg->upds & (UPDS_DPR|UPDS_MOL)) != (UPDS_DPR|UPDS_MOL)) { ! 432: up->flags |= UWOL; ! 433: return (didie); ! 434: } ! 435: if ((up->flags & UACTIVE) == 0) { /* start seek if didn't already */ ! 436: up->flags |= UACTIVE; ! 437: #ifndef NOUPSEEK ! 438: st = &upst[up->type]; ! 439: sn = bp->b_blkno%st->nspc; ! 440: sn = (sn + st->nsect - st->sdist) % st->nsect; /* sector to seek to */ ! 441: csn = sn - (reg->upla>>6); ! 442: if (csn < 0) ! 443: csn += st->nsect; ! 444: if (bp->b_cylin != reg->updc /* seek if off cylinder */ ! 445: || csn > st->rdist) { /* or not close enough */ ! 446: reg->updc = bp->b_cylin; ! 447: reg->upda = sn; ! 448: reg->upcs1 = UP_IE|UP_SEARCH|UP_GO; ! 449: return (1); ! 450: } ! 451: #endif ! 452: } ! 453: if ((up->flags & URXFR) == 0) { /* seek done, put on ctl queue */ ! 454: up->next = NULL; ! 455: if (sc->actf == NULL) ! 456: sc->actf = up; ! 457: else ! 458: sc->actl->next = up; ! 459: sc->actl = up; ! 460: up->flags |= URXFR; ! 461: } ! 462: return (didie); ! 463: } ! 464: ! 465: /* ! 466: * Start up a transfer on a drive. ! 467: */ ! 468: upstart(sc) ! 469: register struct scctl *sc; ! 470: { ! 471: register struct buf *bp; ! 472: register struct updisk *up; ! 473: register struct updevice *reg; ! 474: register struct upst *st; ! 475: register c; ! 476: uaddr_t uad; ! 477: int sn, tn; ! 478: ! 479: loop: ! 480: if ((up = sc->actf) == NULL) ! 481: return (0); ! 482: if ((bp = up->actf) == NULL) { ! 483: sc->actf = up->next; ! 484: goto loop; ! 485: } ! 486: sc->flags |= CACTIVE; ! 487: st = &upst[up->type]; ! 488: sn = bp->b_blkno%st->nspc; ! 489: tn = sn/st->nsect; ! 490: sn %= st->nsect; ! 491: reg = sc->addr; ! 492: reg->upcs2 = up->unit; ! 493: c = 0; ! 494: while ((reg->upds&UPDS_DRY) == 0) { ! 495: if (++c > 512) ! 496: break; ! 497: upwaitdry++; ! 498: } ! 499: if ((reg->upds & UPDS_DREADY) != UPDS_DREADY) { ! 500: printf("up%d: not ready", UNIT(bp->b_dev)); ! 501: if ((reg->upds & UPDS_DREADY) != UPDS_DREADY) { ! 502: printf("\n"); ! 503: sc->flags &=~ (CACTIVE|CWAITING); ! 504: sc->errcnt = 0; ! 505: up->actf = bp->av_forw; ! 506: up->flags &=~ (UACTIVE|URXFR); ! 507: bp->b_flags |= B_ERROR; ! 508: iodone(bp); ! 509: goto loop; ! 510: } ! 511: printf(" (flakey)\n"); /* inscrutable */ ! 512: } ! 513: reg->updc = bp->b_cylin; ! 514: reg->upda = (tn << 8) + sn; ! 515: reg->upwc = -bp->b_bcount / sizeof(short); ! 516: if (bp->b_flags & B_READ) ! 517: c = UP_IE|UP_RCOM|UP_GO; ! 518: else ! 519: c = UP_IE|UP_WCOM|UP_GO; ! 520: bp->b_ubm = (struct buf *)ubinspath(ubmapath(sc->ubno), (ubm_t)bp->b_ubm); ! 521: uad = ubadbuf(sc->ubno, bp, (ubm_t)bp->b_ubm); ! 522: reg->upba = uad; ! 523: reg->upcs1 = c|((uad>>8)&0x300); ! 524: return (1); ! 525: } ! 526: ! 527: /* ! 528: * Handle a disk interrupt. ! 529: */ ! 530: sc0int(ctl) ! 531: int ctl; ! 532: { ! 533: register struct updevice *reg; ! 534: register struct scctl *sc; ! 535: register struct updisk *up; ! 536: register struct buf *bp; ! 537: register int unit, i, as; ! 538: int needie; ! 539: ! 540: if (ctl < 0 || ctl >= sccnt) { ! 541: printf("sc%d bad intr\n"); ! 542: return; ! 543: } ! 544: sc = &scctl[ctl]; ! 545: if ((reg = sc->addr) == 0) { ! 546: printf("sc%d: stray intr\n"); ! 547: return; ! 548: } ! 549: needie = 1; ! 550: as = (reg->upas & 0377) | sc->softas; ! 551: sc->softas = 0; ! 552: if ((sc->flags & CACTIVE) == 0) { /* must be a seek */ ! 553: if (reg->upcs1 & UP_TRE) ! 554: reg->upcs1 = UP_TRE; ! 555: goto doattn; ! 556: } ! 557: up = sc->actf; ! 558: bp = up->actf; ! 559: reg->upcs2 = up->unit; ! 560: if ((reg->upds&UPDS_ERR) || (reg->upcs1&UP_TRE)) { ! 561: i = 0; ! 562: while ((reg->upds & UPDS_DRY) == 0) { ! 563: if (++i > 512) ! 564: break; ! 565: upwaitdry++; ! 566: } ! 567: if (reg->uper1&UPER1_WLE) { ! 568: printf("up%d: write locked\n", UNIT(bp->b_dev)); ! 569: bp->b_flags |= B_ERROR; ! 570: } else if (++sc->errcnt > 27) { ! 571: harderr(bp, "up"); ! 572: printf("cs2=%o er1=%o er2=%o\n", ! 573: reg->upcs2&0177777, reg->uper1&0177777, reg->uper2&0177777); ! 574: bp->b_flags |= B_ERROR; ! 575: } else { ! 576: /* ! 577: * soft ecc, try to correct ! 578: */ ! 579: sc->flags &=~ (CACTIVE|CWAITING); /* force retry */ ! 580: if ((reg->uper1&(UPER1_DCK|UPER1_ECH))==UPER1_DCK) ! 581: if (upecc(up)) ! 582: return; /* probably wrong */ ! 583: } ! 584: /* ! 585: * `hard' error. clear and try again ! 586: */ ! 587: reg->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO; ! 588: needie = 0; ! 589: if ((sc->errcnt&07) == 4 && (sc->flags & CACTIVE) == 0) { ! 590: reg->upcs1 = UP_RECAL|UP_IE|UP_GO; ! 591: sc->recal = 0; ! 592: goto nextrecal; ! 593: } ! 594: } ! 595: /* ! 596: * Advance recalibration finite state machine ! 597: * if recalibrate in progress, through ! 598: * RECAL ! 599: * SEEK ! 600: * OFFSET (optional) ! 601: * RETRY ! 602: */ ! 603: switch (sc->recal) { ! 604: case 1: ! 605: reg->updc = bp->b_cylin; ! 606: reg->upcs1 = UP_SEEK|UP_IE|UP_GO; ! 607: goto nextrecal; ! 608: case 2: ! 609: if (sc->errcnt < 16 || (bp->b_flags&B_READ) == 0) ! 610: goto donerecal; ! 611: reg->upof = up_offset[sc->errcnt & 017] | UPOF_FMT22; ! 612: reg->upcs1 = UP_IE|UP_OFFSET|UP_GO; ! 613: nextrecal: ! 614: sc->recal++; ! 615: sc->flags |= CACTIVE; ! 616: return; ! 617: ! 618: donerecal: ! 619: case 3: ! 620: sc->recal = 0; ! 621: sc->flags &=~ CACTIVE; ! 622: break; ! 623: } ! 624: if (sc->flags & CACTIVE) { /* `active' means we're done */ ! 625: if (sc->errcnt >= 16) { ! 626: reg->upof = UPOF_FMT22; ! 627: reg->upcs1 = UP_RTC|UP_GO|UP_IE; ! 628: while (reg->upds & UPDS_PIP) ! 629: DELAY(25); ! 630: needie = 0; ! 631: } ! 632: sc->flags &=~ (CACTIVE|CWAITING); ! 633: sc->errcnt = 0; ! 634: sc->actf = up->next; ! 635: up->flags &=~ (UACTIVE|URXFR); ! 636: up->actf = bp->av_forw; ! 637: bp->b_resid = (-reg->upwc * sizeof(short)); ! 638: ubmfree(sc->ubno, (ubm_t)bp->b_ubm); ! 639: iodone(bp); ! 640: if (up->actf) ! 641: if (upustart(up)) ! 642: needie = 0; ! 643: } ! 644: as |= reg->upas; ! 645: as &= ~(1<<up->unit); ! 646: doattn: ! 647: /* ! 648: * Process other units which need attention. ! 649: */ ! 650: for (unit = 0, i = 1; unit < NSCUP && as; i <<= 1, unit++) { ! 651: if ((as & i) == 0) ! 652: continue; ! 653: as &= ~i; ! 654: reg->upas = i; ! 655: if ((up = sc->drives[unit]) != NULL && upustart(up)) ! 656: needie = 0; ! 657: } ! 658: if (sc->actf && (sc->flags & CACTIVE) == 0) ! 659: if (upstart(sc)) ! 660: needie = 0; ! 661: if (needie) ! 662: reg->upcs1 = UP_IE; /* why bother? */ ! 663: } ! 664: ! 665: upread(dev) ! 666: dev_t dev; ! 667: { ! 668: physio(upstrategy, &upbuf[UNIT(dev)], dev, B_READ, minphys); ! 669: } ! 670: ! 671: upwrite(dev) ! 672: dev_t dev; ! 673: { ! 674: physio(upstrategy, &upbuf[UNIT(dev)], dev, B_WRITE, minphys); ! 675: } ! 676: ! 677: /* ! 678: * correct an ECC error and restart the transfer ! 679: * the error is (upec1-1) bits into the current sector; ! 680: * at that point, the bits set in upec2 are wrong. ! 681: * ! 682: * should be able just to set the GO bit and proceed, ! 683: * but emulex insists we do DCLR first, or so the book says, ! 684: * because DCK sets ERR in upds ! 685: */ ! 686: upecc(up) ! 687: register struct updisk *up; ! 688: { ! 689: register struct updevice *reg; ! 690: register struct scctl *sc; ! 691: register struct buf *bp; ! 692: register int i; ! 693: int nxf; ! 694: unsigned int mask; ! 695: uaddr_t uad, lastua; ! 696: int xc, xa; ! 697: ! 698: if ((bp = up->actf) == NULL || (sc = up->ctl) == NULL) ! 699: panic("upecc"); ! 700: reg = sc->addr; ! 701: ubmflush(sc->ubno, ubmpath((ubm_t)bp->b_ubm)); ! 702: lastua = reg->upba + ((reg->upcs1&0x300)<<8); ! 703: nxf = bp->b_bcount + (reg->upwc * sizeof(short)); ! 704: i = reg->upec1 - 1; /* -1 makes 0 origin */ ! 705: uad = lastua - (nxf > SECTOR ? SECTOR : nxf) + ((i&~07)>>3); ! 706: mask = reg->upec2; ! 707: mask <<= i&07; ! 708: for (; uad < lastua && mask; mask >>= 8, uad++) ! 709: ubputc(sc->ubno, uad, ubgetc(sc->ubno, uad)^mask); ! 710: printf("up%d%o: soft ecc sec %ld\n", UNIT(bp->b_dev), PART(bp->b_dev), ! 711: bp->b_blkno + nxf/SECTOR - 1); ! 712: sc->flags |= CACTIVE; /* either complete or continuing */ ! 713: if (reg->upwc == 0) ! 714: return (0); ! 715: #ifdef notdef ! 716: reg->uper1 = 0; ! 717: reg->upcs1 |= UP_GO; ! 718: #else /* clear wretched emulex error */ ! 719: xc = reg->updc; ! 720: xa = reg->upda; ! 721: /* ba, wc undisturbed by DCLR */ ! 722: reg->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO; ! 723: reg->updc = xc; ! 724: reg->upda = xa; ! 725: reg->upba = lastua; ! 726: i = (lastua >> 8) & 0x300; ! 727: i |= UP_IE|UP_GO|UP_RCOM; ! 728: reg->upcs1 = i; ! 729: #endif ! 730: return (1); ! 731: } ! 732: ! 733: /* ! 734: * check for offline drives and hung controllers ! 735: */ ! 736: ! 737: upwatch() ! 738: { ! 739: register struct scctl *sc; ! 740: register struct updisk *up; ! 741: register struct updevice *reg; ! 742: register struct buf *bp; ! 743: register int ounit; ! 744: register int s; ! 745: ! 746: s = spl6(); ! 747: timeout(upwatch, (caddr_t)0, 15*HZ); ! 748: for (up = &updisk[upcnt-1]; up >= updisk; up--) { ! 749: if ((up->flags & UWOL) == 0) ! 750: continue; ! 751: reg = up->ctl->addr; ! 752: ounit = reg->upcs2 & UPCS2_SEL; ! 753: reg->upcs2 = up->unit; ! 754: if ((reg->upds & (UPDS_DPR|UPDS_MOL)) != (UPDS_DPR|UPDS_MOL)) { ! 755: if ((up->flags & UWAITOL) == 0) { ! 756: up->flags |= UWAITOL; ! 757: reg->upcs2 = ounit; ! 758: continue; ! 759: } ! 760: printf("up%d offline\n", up - updisk); ! 761: while ((bp = up->actf) != NULL) { ! 762: bp->b_flags |= B_ERROR; ! 763: up->actf = bp->av_forw; ! 764: ubmfree(up->ctl->ubno, (ubm_t)bp->b_ubm); ! 765: iodone(bp); ! 766: } ! 767: } ! 768: up->flags &=~ (UWAITOL|UWOL); ! 769: upustart(up); ! 770: reg->upcs2 = ounit; ! 771: } ! 772: for (sc = &scctl[sccnt-1]; sc >= scctl; sc--) { ! 773: if (sc->flags & CACTIVE) { ! 774: if ((sc->flags & CWAITING) == 0) ! 775: sc->flags |= CWAITING; ! 776: else { ! 777: sc->addr->upcs2 = UPCS2_CLR; ! 778: printf("sc%d hung, kicked\n", sc - scctl); ! 779: sc->flags &=~ (CWAITING|CACTIVE); ! 780: } ! 781: } ! 782: if (sc->actf && (sc->flags & CACTIVE) == 0) ! 783: upstart(sc); ! 784: } ! 785: splx(s); ! 786: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.