![[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] / 41BSD / sys / dev|
Return to up.c CVS log | Up to [CSRG BSD Unix] / 41BSD / sys / dev |
1.1 ! root 1: /* up.c 4.3 11/13/80 */ ! 2: ! 3: #include "../conf/up.h" ! 4: #if NUP > 0 ! 5: /* ! 6: * UNIBUS disk driver with overlapped seeks and ECC recovery. ! 7: */ ! 8: #define DELAY(N) { register int d; d = N; while (--d > 0); } ! 9: ! 10: #include "../h/param.h" ! 11: #include "../h/systm.h" ! 12: #include "../h/dk.h" ! 13: #include "../h/buf.h" ! 14: #include "../h/conf.h" ! 15: #include "../h/dir.h" ! 16: #include "../h/user.h" ! 17: #include "../h/map.h" ! 18: #include "../h/pte.h" ! 19: #include "../h/mba.h" ! 20: #include "../h/mtpr.h" ! 21: #include "../h/uba.h" ! 22: #include "../h/vm.h" ! 23: ! 24: #define ushort unsigned short ! 25: ! 26: struct device ! 27: { ! 28: ushort upcs1; /* control and status register 1 */ ! 29: short upwc; /* word count register */ ! 30: ushort upba; /* UNIBUS address register */ ! 31: ushort upda; /* desired address register */ ! 32: ushort upcs2; /* control and status register 2 */ ! 33: ushort upds; /* drive Status */ ! 34: ushort uper1; /* error register 1 */ ! 35: ushort upas; /* attention summary */ ! 36: ushort upla; /* look ahead */ ! 37: ushort updb; /* data buffer */ ! 38: ushort upmr; /* maintenance */ ! 39: ushort updt; /* drive type */ ! 40: ushort upsn; /* serial number */ ! 41: ushort upof; /* offset register */ ! 42: ushort updc; /* desired cylinder address register */ ! 43: ushort upcc; /* current cylinder */ ! 44: ushort uper2; /* error register 2 */ ! 45: ushort uper3; /* error register 3 */ ! 46: ushort upec1; /* burst error bit position */ ! 47: ushort upec2; /* burst error bit pattern */ ! 48: }; ! 49: ! 50: /* ! 51: * Software extension to the upas register, so we can ! 52: * postpone starting SEARCH commands until the controller ! 53: * is not transferring. ! 54: */ ! 55: int upsoftas; ! 56: ! 57: /* ! 58: * If upseek then we don't issue SEARCH commands but rather just ! 59: * settle for a SEEK to the correct cylinder. ! 60: */ ! 61: int upseek; ! 62: ! 63: #define NSECT 32 ! 64: #define NTRAC 19 ! 65: ! 66: /* ! 67: * Constants controlling on-cylinder SEARCH usage. ! 68: * ! 69: * upSDIST/2 msec time needed to start transfer ! 70: * upRDIST/2 msec tolerable rotational latency when on-cylinder ! 71: * ! 72: * If we are no closer than upSDIST sectors and no further than upSDIST+upRDIST ! 73: * and in the driver then we take it as it is. Otherwise we do a SEARCH ! 74: * requesting an interrupt upSDIST sectors in advance. ! 75: */ ! 76: #define _upSDIST 2 /* 1.0 msec */ ! 77: #define _upRDIST 4 /* 2.0 msec */ ! 78: ! 79: int upSDIST = _upSDIST; ! 80: int upRDIST = _upRDIST; ! 81: ! 82: /* ! 83: * To fill a 300M drive: ! 84: * A is designed to be used as a root. ! 85: * B is suitable for a swap area. ! 86: * H is the primary storage area. ! 87: * On systems with RP06'es, we normally use only 291346 blocks of the H ! 88: * area, and use DEF or G to cover the rest of the drive. The C system ! 89: * covers the whole drive and can be used for pack-pack copying. ! 90: * ! 91: * Note: sizes here are for AMPEX drives with 815 cylinders. ! 92: * CDC drives can make the F,G, and H areas larger as they have 823 cylinders. ! 93: */ ! 94: struct size ! 95: { ! 96: daddr_t nblocks; ! 97: int cyloff; ! 98: } up_sizes[8] = { ! 99: 15884, 0, /* A=cyl 0 thru 26 */ ! 100: 33440, 27, /* B=cyl 27 thru 81 */ ! 101: 495520, 0, /* C=cyl 0 thru 814 */ ! 102: 15884, 562, /* D=cyl 562 thru 588 */ ! 103: 55936, 589, /* E=cyl 589 thru 680 */ ! 104: 81472, 681, /* F=cyl 681 thru 814 */ ! 105: 153824, 562, /* G=cyl 562 thru 814 */ ! 106: 291346, 82, /* H=cyl 82 thru 561 */ ! 107: }; ! 108: ! 109: /* ! 110: * The following defines are used in offset positioning ! 111: * when trying to recover disk errors, with the constants being ! 112: * +/- microinches. Note that header compare inhibit (HCI) is not ! 113: * tried (this makes sense only during read, in any case.) ! 114: * ! 115: * NB: Not all drives/controllers emulate all of these. ! 116: */ ! 117: #define P400 020 ! 118: #define M400 0220 ! 119: #define P800 040 ! 120: #define M800 0240 ! 121: #define P1200 060 ! 122: #define M1200 0260 ! 123: #define HCI 020000 ! 124: ! 125: int up_offset[16] = ! 126: { ! 127: P400, M400, P400, M400, ! 128: P800, M800, P800, M800, ! 129: P1200, M1200, P1200, M1200, ! 130: 0, 0, 0, 0, ! 131: }; ! 132: ! 133: /* ! 134: * Each drive has a table uputab[i]. On this table are sorted the ! 135: * pending requests implementing an elevator algorithm (see dsort.c.) ! 136: * In the upustart() routine, each drive is independently advanced ! 137: * until it is on the desired cylinder for the next transfer and near ! 138: * the desired sector. The drive is then chained onto the uptab ! 139: * table, and the transfer is initiated by the upstart() routine. ! 140: * When the transfer is completed the driver reinvokes the upustart() ! 141: * routine to set up the next transfer. ! 142: */ ! 143: struct buf uptab; ! 144: struct buf uputab[NUP]; ! 145: ! 146: struct buf rupbuf; /* Buffer for raw i/o */ ! 147: ! 148: /* Drive commands, placed in upcs1 */ ! 149: #define GO 01 /* Go bit, set in all commands */ ! 150: #define PRESET 020 /* Preset drive at init or after errors */ ! 151: #define OFFSET 014 /* Offset heads to try to recover error */ ! 152: #define RTC 016 /* Return to center-line after OFFSET */ ! 153: #define SEARCH 030 /* Search for cylinder+sector */ ! 154: #define SEEK 04 /* Seek to cylinder */ ! 155: #define RECAL 06 /* Recalibrate, needed after seek error */ ! 156: #define DCLR 010 /* Drive clear, after error */ ! 157: #define WCOM 060 /* Write */ ! 158: #define RCOM 070 /* Read */ ! 159: ! 160: /* Other bits of upcs1 */ ! 161: #define IE 0100 /* Controller wide interrupt enable */ ! 162: #define TRE 040000 /* Transfer error */ ! 163: #define RDY 0200 /* Transfer terminated */ ! 164: ! 165: /* Drive status bits of upds */ ! 166: #define PIP 020000 /* Positioning in progress */ ! 167: #define ERR 040000 /* Error has occurred, DCLR necessary */ ! 168: #define VV 0100 /* Volume is valid, set by PRESET */ ! 169: #define DPR 0400 /* Drive has been preset */ ! 170: #define MOL 010000 /* Drive is online, heads loaded, etc */ ! 171: #define DRY 0200 /* Drive ready */ ! 172: ! 173: /* Bits of upcs2 */ ! 174: #define CLR 040 /* Controller clear */ ! 175: /* Bits of uper1 */ ! 176: #define DCK 0100000 /* Ecc error occurred */ ! 177: #define ECH 0100 /* Ecc error was unrecoverable */ ! 178: #define WLE 04000 /* Attempt to write read-only drive */ ! 179: ! 180: /* Bits of upof; the offset bits above are also in this register */ ! 181: #define FMT22 010000 /* 16 bits/word, must be always set */ ! 182: ! 183: #define b_cylin b_resid ! 184: ! 185: int up_ubinfo; /* Information about UBA usage saved here */ ! 186: ! 187: int up_wticks; /* Ticks waiting for interrupt */ ! 188: int upwstart; /* Have started guardian */ ! 189: int upwatch(); ! 190: ! 191: #ifdef INTRLVE ! 192: daddr_t dkblock(); ! 193: #endif ! 194: ! 195: /* ! 196: * Queue an i/o request for a drive, checking first that it is in range. ! 197: * ! 198: * A unit start is issued if the drive is inactive, causing ! 199: * a SEARCH for the correct cylinder/sector. If the drive is ! 200: * already nearly on the money and the controller is not transferring ! 201: * we kick it to start the transfer. ! 202: */ ! 203: upstrategy(bp) ! 204: register struct buf *bp; ! 205: { ! 206: register struct buf *dp; ! 207: register unit, xunit; ! 208: long sz, bn; ! 209: ! 210: if (upwstart == 0) { ! 211: timeout(upwatch, (caddr_t)0, HZ); ! 212: upwstart++; ! 213: } ! 214: xunit = minor(bp->b_dev) & 077; ! 215: sz = bp->b_bcount; ! 216: sz = (sz+511) >> 9; /* transfer size in 512 byte sectors */ ! 217: unit = dkunit(bp); ! 218: if (unit >= NUP || ! 219: bp->b_blkno < 0 || ! 220: (bn = dkblock(bp))+sz > up_sizes[xunit&07].nblocks) { ! 221: bp->b_flags |= B_ERROR; ! 222: iodone(bp); ! 223: return; ! 224: } ! 225: if (DK_N+unit <= DK_NMAX) ! 226: dk_mspw[DK_N+unit] = .0000020345; ! 227: bp->b_cylin = bn/(NSECT*NTRAC) + up_sizes[xunit&07].cyloff; ! 228: dp = &uputab[unit]; ! 229: (void) spl5(); ! 230: disksort(dp, bp); ! 231: if (dp->b_active == 0) { ! 232: (void) upustart(unit); ! 233: if (uptab.b_actf && uptab.b_active == 0) ! 234: (void) upstart(); ! 235: } ! 236: (void) spl0(); ! 237: } ! 238: ! 239: /* ! 240: * Start activity on specified drive; called when drive is inactive ! 241: * and new transfer request arrives and also when upas indicates that ! 242: * a SEARCH command is complete. ! 243: */ ! 244: upustart(unit) ! 245: register unit; ! 246: { ! 247: register struct buf *bp, *dp; ! 248: register struct device *upaddr = UPADDR; ! 249: daddr_t bn; ! 250: int sn, cn, csn; ! 251: int didie = 0; ! 252: ! 253: /* ! 254: * Other drivers tend to say something like ! 255: * upaddr->upcs1 = IE; ! 256: * upaddr->upas = 1<<unit; ! 257: * here, but some controllers will cancel a command ! 258: * happens to be sitting in the cs1 if you clear the go ! 259: * bit by storing there (so the first is not safe). ! 260: * ! 261: * Thus we keep careful track of when we re-enable IE ! 262: * after an interrupt and do it only if we didn't issue ! 263: * a command which re-enabled it as a matter of course. ! 264: * We clear bits in upas in the interrupt routine, when ! 265: * no transfers are active. ! 266: */ ! 267: if (unit >= NUP) ! 268: goto out; ! 269: if (unit+DK_N <= DK_NMAX) ! 270: dk_busy &= ~(1<<(unit+DK_N)); ! 271: dp = &uputab[unit]; ! 272: if ((bp = dp->b_actf) == NULL) ! 273: goto out; ! 274: /* ! 275: * Most controllers don't start SEARCH commands when transfers are ! 276: * in progress. In fact, some tend to get confused when given ! 277: * SEARCH'es during transfers, generating interrupts with neither ! 278: * RDY nor a bit in the upas register. Thus we defer ! 279: * until an interrupt when a transfer is pending. ! 280: */ ! 281: if (uptab.b_active) { ! 282: upsoftas |= 1<<unit; ! 283: return (0); ! 284: } ! 285: if (dp->b_active) ! 286: goto done; ! 287: dp->b_active = 1; ! 288: if ((upaddr->upcs2 & 07) != unit) ! 289: upaddr->upcs2 = unit; ! 290: /* ! 291: * If we have changed packs or just initialized, ! 292: * then the volume will not be valid; if so, clear ! 293: * the drive, preset it and put in 16bit/word mode. ! 294: */ ! 295: if ((upaddr->upds & VV) == 0) { ! 296: upaddr->upcs1 = IE|DCLR|GO; ! 297: upaddr->upcs1 = IE|PRESET|GO; ! 298: upaddr->upof = FMT22; ! 299: didie = 1; ! 300: } ! 301: if ((upaddr->upds & (DPR|MOL)) != (DPR|MOL)) ! 302: goto done; ! 303: /* ! 304: * Do enough of the disk address decoding to determine ! 305: * which cylinder and sector the request is on. ! 306: * If we are on the correct cylinder and the desired sector ! 307: * lies between upSDIST and upSDIST+upRDIST sectors ahead of us, then ! 308: * we don't bother to SEARCH but just begin the transfer asap. ! 309: * Otherwise ask for a interrupt upSDIST sectors ahead. ! 310: */ ! 311: bn = dkblock(bp); ! 312: cn = bp->b_cylin; ! 313: sn = bn%(NSECT*NTRAC); ! 314: sn = (sn+NSECT-upSDIST)%NSECT; ! 315: ! 316: if (cn - upaddr->updc) ! 317: goto search; /* Not on-cylinder */ ! 318: else if (upseek) ! 319: goto done; /* Ok just to be on-cylinder */ ! 320: csn = (upaddr->upla>>6) - sn - 1; ! 321: if (csn < 0) ! 322: csn += NSECT; ! 323: if (csn > NSECT-upRDIST) ! 324: goto done; ! 325: ! 326: search: ! 327: upaddr->updc = cn; ! 328: if (upseek) ! 329: upaddr->upcs1 = IE|SEEK|GO; ! 330: else { ! 331: upaddr->upda = sn; ! 332: upaddr->upcs1 = IE|SEARCH|GO; ! 333: } ! 334: didie = 1; ! 335: /* ! 336: * Mark this unit busy. ! 337: */ ! 338: unit += DK_N; ! 339: if (unit <= DK_NMAX) { ! 340: dk_busy |= 1<<unit; ! 341: dk_seek[unit]++; ! 342: } ! 343: goto out; ! 344: ! 345: done: ! 346: /* ! 347: * This unit is ready to go so ! 348: * link it onto the chain of ready disks. ! 349: */ ! 350: dp->b_forw = NULL; ! 351: if (uptab.b_actf == NULL) ! 352: uptab.b_actf = dp; ! 353: else ! 354: uptab.b_actl->b_forw = dp; ! 355: uptab.b_actl = dp; ! 356: ! 357: out: ! 358: return (didie); ! 359: } ! 360: ! 361: /* ! 362: * Start a transfer; call from top level at spl5() or on interrupt. ! 363: */ ! 364: upstart() ! 365: { ! 366: register struct buf *bp, *dp; ! 367: register unit; ! 368: register struct device *upaddr; ! 369: daddr_t bn; ! 370: int dn, sn, tn, cn, cmd; ! 371: ! 372: loop: ! 373: /* ! 374: * Pick a drive off the queue of ready drives, and ! 375: * perform the first transfer on its queue. ! 376: * ! 377: * Looping here is completely for the sake of drives which ! 378: * are not present and on-line, for which we completely clear the ! 379: * request queue. ! 380: */ ! 381: if ((dp = uptab.b_actf) == NULL) ! 382: return (0); ! 383: if ((bp = dp->b_actf) == NULL) { ! 384: uptab.b_actf = dp->b_forw; ! 385: goto loop; ! 386: } ! 387: /* ! 388: * Mark the controller busy, and multi-part disk address. ! 389: * Select the unit on which the i/o is to take place. ! 390: */ ! 391: uptab.b_active++; ! 392: unit = minor(bp->b_dev) & 077; ! 393: dn = dkunit(bp); ! 394: bn = dkblock(bp); ! 395: cn = up_sizes[unit&07].cyloff; ! 396: cn += bn/(NSECT*NTRAC); ! 397: sn = bn%(NSECT*NTRAC); ! 398: tn = sn/NSECT; ! 399: sn %= NSECT; ! 400: upaddr = UPADDR; ! 401: if ((upaddr->upcs2 & 07) != dn) ! 402: upaddr->upcs2 = dn; ! 403: up_ubinfo = ubasetup(bp, 1); ! 404: /* ! 405: * If drive is not present and on-line, then ! 406: * get rid of this with an error and loop to get ! 407: * rid of the rest of its queued requests. ! 408: * (Then on to any other ready drives.) ! 409: */ ! 410: if ((upaddr->upds & (DPR|MOL)) != (DPR|MOL)) { ! 411: printf("!DPR || !MOL, unit %d, ds %o", dn, upaddr->upds); ! 412: if ((upaddr->upds & (DPR|MOL)) != (DPR|MOL)) { ! 413: printf("-- hard\n"); ! 414: uptab.b_active = 0; ! 415: uptab.b_errcnt = 0; ! 416: dp->b_actf = bp->av_forw; ! 417: dp->b_active = 0; ! 418: bp->b_flags |= B_ERROR; ! 419: iodone(bp); ! 420: /* A funny place to do this ... */ ! 421: ubafree(up_ubinfo), up_ubinfo = 0; ! 422: goto loop; ! 423: } ! 424: printf("-- came back\n"); ! 425: } ! 426: /* ! 427: * If this is a retry, then with the 16'th retry we ! 428: * begin to try offsetting the heads to recover the data. ! 429: */ ! 430: if (uptab.b_errcnt >= 16 && (bp->b_flags&B_WRITE) == 0) { ! 431: upaddr->upof = up_offset[uptab.b_errcnt & 017] | FMT22; ! 432: upaddr->upcs1 = IE|OFFSET|GO; ! 433: while (upaddr->upds & PIP) ! 434: DELAY(25); ! 435: } ! 436: /* ! 437: * Now set up the transfer, retrieving the high ! 438: * 2 bits of the UNIBUS address from the information ! 439: * returned by ubasetup() for the cs1 register bits 8 and 9. ! 440: */ ! 441: upaddr->updc = cn; ! 442: upaddr->upda = (tn << 8) + sn; ! 443: upaddr->upba = up_ubinfo; ! 444: upaddr->upwc = -bp->b_bcount / sizeof (short); ! 445: cmd = (up_ubinfo >> 8) & 0x300; ! 446: if (bp->b_flags & B_READ) ! 447: cmd |= IE|RCOM|GO; ! 448: else ! 449: cmd |= IE|WCOM|GO; ! 450: upaddr->upcs1 = cmd; ! 451: /* ! 452: * This is a controller busy situation. ! 453: * Record in dk slot NUP+DK_N (after last drive) ! 454: * unless there aren't that many slots reserved for ! 455: * us in which case we record this as a drive busy ! 456: * (if there is room for that). ! 457: */ ! 458: unit = dn+DK_N; ! 459: if (unit <= DK_NMAX) { ! 460: dk_busy |= 1<<unit; ! 461: dk_xfer[unit]++; ! 462: dk_wds[unit] += bp->b_bcount>>6; ! 463: } ! 464: return (1); ! 465: } ! 466: ! 467: /* ! 468: * Handle a device interrupt. ! 469: * ! 470: * If the transferring drive needs attention, service it ! 471: * retrying on error or beginning next transfer. ! 472: * Service all other ready drives, calling ustart to transfer ! 473: * their blocks to the ready queue in uptab, and then restart ! 474: * the controller if there is anything to do. ! 475: */ ! 476: upintr() ! 477: { ! 478: register struct buf *bp, *dp; ! 479: register unit; ! 480: register struct device *upaddr = UPADDR; ! 481: int as = upaddr->upas & 0377; ! 482: int oupsoftas; ! 483: int needie = 1; ! 484: ! 485: (void) spl6(); ! 486: up_wticks = 0; ! 487: if (uptab.b_active) { ! 488: /* ! 489: * The drive is transferring, thus the hardware ! 490: * (say the designers) will only interrupt when the transfer ! 491: * completes; check for it anyways. ! 492: */ ! 493: if ((upaddr->upcs1 & RDY) == 0) { ! 494: printf("!RDY: cs1 %o, ds %o, wc %d\n", upaddr->upcs1, ! 495: upaddr->upds, upaddr->upwc); ! 496: printf("as=%d act %d %d %d\n", as, uptab.b_active, ! 497: uputab[0].b_active, uputab[1].b_active); ! 498: } ! 499: /* ! 500: * Mark drive not busy, and check for an ! 501: * error condition which may have resulted from the transfer. ! 502: */ ! 503: dp = uptab.b_actf; ! 504: bp = dp->b_actf; ! 505: unit = dkunit(bp); ! 506: if (DK_N+unit <= DK_NMAX) ! 507: dk_busy &= ~(1<<(DK_N+unit)); ! 508: if ((upaddr->upcs2 & 07) != unit) ! 509: upaddr->upcs2 = unit; ! 510: if ((upaddr->upds&ERR) || (upaddr->upcs1&TRE)) { ! 511: /* ! 512: * An error occurred, indeed. Select this unit ! 513: * to get at the drive status (a SEARCH may have ! 514: * intervened to change the selected unit), and ! 515: * wait for the command which caused the interrupt ! 516: * to complete (DRY). ! 517: */ ! 518: while ((upaddr->upds & DRY) == 0) ! 519: DELAY(25); ! 520: /* ! 521: * After 28 retries (16 w/o servo offsets, and then ! 522: * 12 with servo offsets), or if we encountered ! 523: * an error because the drive is write-protected, ! 524: * give up. Print an error message on the last 2 ! 525: * retries before a hard failure. ! 526: */ ! 527: if (++uptab.b_errcnt > 28 || upaddr->uper1&WLE) ! 528: bp->b_flags |= B_ERROR; ! 529: else ! 530: uptab.b_active = 0; /* To force retry */ ! 531: if (uptab.b_errcnt > 27) ! 532: deverror(bp, (int)upaddr->upcs2, ! 533: (int)upaddr->uper1); ! 534: /* ! 535: * If this was a correctible ECC error, let upecc ! 536: * do the dirty work to correct it. If upecc ! 537: * starts another READ for the rest of the data ! 538: * then it returns 1 (having set uptab.b_active). ! 539: * Otherwise we are done and fall through to ! 540: * finish up. ! 541: */ ! 542: if ((upaddr->uper1&(DCK|ECH))==DCK && upecc(upaddr, bp)) ! 543: return; ! 544: /* ! 545: * Clear the drive and, every 4 retries, recalibrate ! 546: * to hopefully help clear up seek positioning problems. ! 547: */ ! 548: upaddr->upcs1 = TRE|IE|DCLR|GO; ! 549: needie = 0; ! 550: if ((uptab.b_errcnt&07) == 4) { ! 551: upaddr->upcs1 = RECAL|GO|IE; ! 552: while(upaddr->upds & PIP) ! 553: DELAY(25); ! 554: } ! 555: } ! 556: /* ! 557: * If we are still noted as active, then no ! 558: * (further) retries are necessary. ! 559: * ! 560: * Make sure the correct unit is selected, ! 561: * return it to centerline if necessary, and mark ! 562: * this i/o complete, starting the next transfer ! 563: * on this drive with the upustart routine (if any). ! 564: */ ! 565: if (uptab.b_active) { ! 566: if (uptab.b_errcnt >= 16) { ! 567: upaddr->upcs1 = RTC|GO|IE; ! 568: while (upaddr->upds & PIP) ! 569: DELAY(25); ! 570: needie = 0; ! 571: } ! 572: uptab.b_active = 0; ! 573: uptab.b_errcnt = 0; ! 574: uptab.b_actf = dp->b_forw; ! 575: dp->b_active = 0; ! 576: dp->b_errcnt = 0; ! 577: dp->b_actf = bp->av_forw; ! 578: bp->b_resid = (-upaddr->upwc * sizeof(short)); ! 579: if (bp->b_resid) ! 580: printf("resid %d ds %o er? %o %o %o\n", ! 581: bp->b_resid, upaddr->upds, ! 582: upaddr->uper1, upaddr->uper2, upaddr->uper3); ! 583: iodone(bp); ! 584: if(dp->b_actf) ! 585: if (upustart(unit)) ! 586: needie = 0; ! 587: } ! 588: as &= ~(1<<unit); ! 589: upsoftas &= ~(1<<unit); ! 590: ubafree(up_ubinfo), up_ubinfo = 0; ! 591: } else { ! 592: if (upaddr->upcs1 & TRE) ! 593: upaddr->upcs1 = TRE; ! 594: } ! 595: /* ! 596: * If we have a unit with an outstanding SEARCH, ! 597: * and the hardware indicates the unit requires attention, ! 598: * the bring the drive to the ready queue. ! 599: * Finally, if the controller is not transferring ! 600: * start it if any drives are now ready to transfer. ! 601: */ ! 602: as |= upsoftas; ! 603: oupsoftas = upsoftas; ! 604: upsoftas = 0; ! 605: for (unit = 0; unit < NUP; unit++) ! 606: if ((as|oupsoftas) & (1<<unit)) { ! 607: if (as & (1<<unit)) ! 608: upaddr->upas = 1<<unit; ! 609: if (upustart(unit)) ! 610: needie = 0; ! 611: } ! 612: if (uptab.b_actf && uptab.b_active == 0) ! 613: if (upstart()) ! 614: needie = 0; ! 615: if (needie) ! 616: upaddr->upcs1 = IE; ! 617: } ! 618: ! 619: upread(dev) ! 620: { ! 621: ! 622: physio(upstrategy, &rupbuf, dev, B_READ, minphys); ! 623: } ! 624: ! 625: upwrite(dev) ! 626: { ! 627: ! 628: physio(upstrategy, &rupbuf, dev, B_WRITE, minphys); ! 629: } ! 630: ! 631: /* ! 632: * Correct an ECC error, and restart the i/o to complete ! 633: * the transfer if necessary. This is quite complicated because ! 634: * the transfer may be going to an odd memory address base and/or ! 635: * across a page boundary. ! 636: */ ! 637: upecc(up, bp) ! 638: register struct device *up; ! 639: register struct buf *bp; ! 640: { ! 641: struct uba_regs *ubp = (struct uba_regs *)UBA0; ! 642: register int i; ! 643: caddr_t addr; ! 644: int reg, bit, byte, npf, mask, o, cmd, ubaddr; ! 645: int bn, cn, tn, sn; ! 646: ! 647: /* ! 648: * Npf is the number of sectors transferred before the sector ! 649: * containing the ECC error, and reg is the UBA register ! 650: * mapping (the first part of) the transfer. ! 651: * O is offset within a memory page of the first byte transferred. ! 652: */ ! 653: npf = btop((up->upwc * sizeof(short)) + bp->b_bcount) - 1; ! 654: reg = btop(up_ubinfo&0x3ffff) + npf; ! 655: o = (int)bp->b_un.b_addr & PGOFSET; ! 656: printf("%D ", bp->b_blkno+npf); ! 657: prdev("ECC", bp->b_dev); ! 658: mask = up->upec2; ! 659: if (mask == 0) { ! 660: up->upof = FMT22; /* == RTC ???? */ ! 661: return (0); ! 662: } ! 663: /* ! 664: * Flush the buffered data path, and compute the ! 665: * byte and bit position of the error. The variable i ! 666: * is the byte offset in the transfer, the variable byte ! 667: * is the offset from a page boundary in main memory. ! 668: */ ! 669: ubp->uba_dpr[(up_ubinfo>>28)&0x0f] |= BNE; ! 670: i = up->upec1 - 1; /* -1 makes 0 origin */ ! 671: bit = i&07; ! 672: i = (i&~07)>>3; ! 673: byte = i + o; ! 674: /* ! 675: * Correct while possible bits remain of mask. Since mask ! 676: * contains 11 bits, we continue while the bit offset is > -11. ! 677: * Also watch out for end of this block and the end of the whole ! 678: * transfer. ! 679: */ ! 680: while (i < 512 && (int)ptob(npf)+i < bp->b_bcount && bit > -11) { ! 681: addr = ptob(ubp->uba_map[reg+btop(byte)].pg_pfnum)+ ! 682: (byte & PGOFSET); ! 683: putmemc(addr, getmemc(addr)^(mask<<bit)); ! 684: byte++; ! 685: i++; ! 686: bit -= 8; ! 687: } ! 688: uptab.b_active++; /* Either complete or continuing... */ ! 689: if (up->upwc == 0) ! 690: return (0); ! 691: /* ! 692: * Have to continue the transfer... clear the drive, ! 693: * and compute the position where the transfer is to continue. ! 694: * We have completed npf+1 sectors of the transfer already; ! 695: * restart at offset o of next sector (i.e. in UBA register reg+1). ! 696: */ ! 697: up->upcs1 = TRE|IE|DCLR|GO; ! 698: bn = dkblock(bp); ! 699: cn = bp->b_cylin; ! 700: sn = bn%(NSECT*NTRAC) + npf + 1; ! 701: tn = sn/NSECT; ! 702: sn %= NSECT; ! 703: cn += tn/NTRAC; ! 704: tn %= NTRAC; ! 705: up->updc = cn; ! 706: up->upda = (tn << 8) | sn; ! 707: ubaddr = (int)ptob(reg+1) + o; ! 708: up->upba = ubaddr; ! 709: cmd = (ubaddr >> 8) & 0x300; ! 710: cmd |= IE|GO|RCOM; ! 711: up->upcs1 = cmd; ! 712: return (1); ! 713: } ! 714: ! 715: /* ! 716: * Reset driver after UBA init. ! 717: * Cancel software state of all pending transfers ! 718: * and restart all units and the controller. ! 719: */ ! 720: upreset() ! 721: { ! 722: int unit; ! 723: ! 724: printf(" up"); ! 725: uptab.b_active = 0; ! 726: uptab.b_actf = uptab.b_actl = 0; ! 727: if (up_ubinfo) { ! 728: printf("<%d>", (up_ubinfo>>28)&0xf); ! 729: ubafree(up_ubinfo), up_ubinfo = 0; ! 730: } ! 731: UPADDR->upcs2 = CLR; /* clear controller */ ! 732: for (unit = 0; unit < NUP; unit++) { ! 733: uputab[unit].b_active = 0; ! 734: (void) upustart(unit); ! 735: } ! 736: (void) upstart(); ! 737: } ! 738: ! 739: /* ! 740: * Wake up every second and if an interrupt is pending ! 741: * but nothing has happened increment a counter. ! 742: * If nothing happens for 20 seconds, reset the controller ! 743: * and begin anew. ! 744: */ ! 745: upwatch() ! 746: { ! 747: int i; ! 748: ! 749: timeout(upwatch, (caddr_t)0, HZ); ! 750: if (uptab.b_active == 0) { ! 751: for (i = 0; i < NUP; i++) ! 752: if (uputab[i].b_active) ! 753: goto active; ! 754: up_wticks = 0; /* idling */ ! 755: return; ! 756: } ! 757: active: ! 758: up_wticks++; ! 759: if (up_wticks >= 20) { ! 760: up_wticks = 0; ! 761: printf("LOST INTERRUPT RESET"); ! 762: upreset(); ! 763: printf("\n"); ! 764: } ! 765: } ! 766: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.