![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev|
Return to hp.c CVS log | Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev |
1.1 ! root 1: /* hp.c 4.41 81/07/09 */ ! 2: ! 3: #ifdef HPDEBUG ! 4: int hpdebug; ! 5: #endif ! 6: #ifdef HPBDEBUG ! 7: int hpbdebug; ! 8: #endif ! 9: ! 10: #include "hp.h" ! 11: #if NHP > 0 ! 12: /* ! 13: * HP disk driver for RP0x+RMxx ! 14: * ! 15: * TODO: ! 16: * check RM80 skip sector handling when ECC's occur later ! 17: * check offset recovery handling ! 18: * see if DCLR and/or RELEASE set attention status ! 19: * print bits of mr && mr2 symbolically ! 20: */ ! 21: ! 22: #include "../h/param.h" ! 23: #include "../h/systm.h" ! 24: #include "../h/dk.h" ! 25: #include "../h/buf.h" ! 26: #include "../h/conf.h" ! 27: #include "../h/dir.h" ! 28: #include "../h/user.h" ! 29: #include "../h/map.h" ! 30: #include "../h/pte.h" ! 31: #include "../h/mbareg.h" ! 32: #include "../h/mbavar.h" ! 33: #include "../h/mtpr.h" ! 34: #include "../h/vm.h" ! 35: #include "../h/cmap.h" ! 36: #include "../h/dkbad.h" ! 37: ! 38: #include "../h/hpreg.h" ! 39: ! 40: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */ ! 41: struct size { ! 42: daddr_t nblocks; ! 43: int cyloff; ! 44: } hp6_sizes[8] = { ! 45: 15884, 0, /* A=cyl 0 thru 37 */ ! 46: 33440, 38, /* B=cyl 38 thru 117 */ ! 47: 340670, 0, /* C=cyl 0 thru 814 */ ! 48: 0, 0, ! 49: 0, 0, ! 50: 0, 0, ! 51: #ifndef NOBADSECT ! 52: 291280, 118, /* G=cyl 118 thru 814 */ ! 53: #else ! 54: 291346, 118, ! 55: #endif ! 56: 0, 0, ! 57: }, rm3_sizes[8] = { ! 58: 15884, 0, /* A=cyl 0 thru 99 */ ! 59: 33440, 100, /* B=cyl 100 thru 309 */ ! 60: 131680, 0, /* C=cyl 0 thru 822 */ ! 61: 0, 0, ! 62: 0, 0, ! 63: 0, 0, ! 64: #ifndef NOBADSECT ! 65: 81984, 310, /* G=cyl 310 thru 822 */ ! 66: #else ! 67: 82080, 310, ! 68: #endif ! 69: 0, 0, ! 70: }, rm5_sizes[8] = { ! 71: 15884, 0, /* A=cyl 0 thru 26 */ ! 72: 33440, 27, /* B=cyl 27 thru 81 */ ! 73: 500384, 0, /* C=cyl 0 thru 822 */ ! 74: 15884, 562, /* D=cyl 562 thru 588 */ ! 75: 55936, 589, /* E=cyl 589 thru 680 */ ! 76: #ifndef NOBADSECT ! 77: 86240, 681, /* F=cyl 681 thru 822 */ ! 78: 158592, 562, /* G=cyl 562 thru 822 */ ! 79: #else ! 80: 86636, 681, ! 81: 158688, 562, ! 82: #endif ! 83: 291346, 82, /* H=cyl 82 thru 561 */ ! 84: }, rm80_sizes[8] = { ! 85: 15884, 0, /* A=cyl 0 thru 36 */ ! 86: 33440, 37, /* B=cyl 37 thru 114 */ ! 87: 242606, 0, /* C=cyl 0 thru 558 */ ! 88: 0, 0, ! 89: 0, 0, ! 90: 0, 0, ! 91: 82080, 115, /* G=cyl 115 thru 304 */ ! 92: 110143, 305, /* H=cyl 305 thru 558 */ ! 93: }, hp7_sizes[8] = { ! 94: 15844, 0, /* A=cyl 0 thru 9 */ ! 95: 64000, 10, /* B=cyl 10 thru 49 */ ! 96: 1008000,0, /* C=cyl 0 thru 629 */ ! 97: 15884, 330, /* D=cyl 330 thru 339 */ ! 98: 256000, 340, /* E=cyl 340 thru 499 */ ! 99: 207850, 500, /* F=cyl 500 thru 629 */ ! 100: 479850, 330, /* G=cyl 330 thru 629 */ ! 101: 448000, 50, /* H=cyl 50 thru 329 */ ! 102: }; ! 103: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */ ! 104: ! 105: #define _hpSDIST 2 ! 106: #define _hpRDIST 3 ! 107: ! 108: int hpSDIST = _hpSDIST; ! 109: int hpRDIST = _hpRDIST; ! 110: ! 111: short hptypes[] = ! 112: { MBDT_RM03, MBDT_RM05, MBDT_RP06, MBDT_RM80, MBDT_RP05, MBDT_RP07, 0 }; ! 113: struct mba_device *hpinfo[NHP]; ! 114: int hpattach(),hpustart(),hpstart(),hpdtint(); ! 115: struct mba_driver hpdriver = ! 116: { hpattach, 0, hpustart, hpstart, hpdtint, 0, ! 117: hptypes, "hp", 0, hpinfo }; ! 118: ! 119: struct hpst { ! 120: short nsect; ! 121: short ntrak; ! 122: short nspc; ! 123: short ncyl; ! 124: struct size *sizes; ! 125: } hpst[] = { ! 126: 32, 5, 32*5, 823, rm3_sizes, /* RM03 */ ! 127: 32, 19, 32*19, 823, rm5_sizes, /* RM05 */ ! 128: 22, 19, 22*19, 815, hp6_sizes, /* RP06 */ ! 129: 31, 14, 31*14, 559, rm80_sizes, /* RM80 */ ! 130: 22, 19, 22*19, 411, hp6_sizes, /* RP05 */ ! 131: 50, 32, 50*32, 630, hp7_sizes, /* RP07 */ ! 132: }; ! 133: ! 134: u_char hp_offset[16] = { ! 135: HPOF_P400, HPOF_M400, HPOF_P400, HPOF_M400, ! 136: HPOF_P800, HPOF_M800, HPOF_P800, HPOF_M800, ! 137: HPOF_P1200, HPOF_M1200, HPOF_P1200, HPOF_M1200, ! 138: 0, 0, 0, 0, ! 139: }; ! 140: ! 141: struct buf rhpbuf[NHP]; ! 142: #ifndef NOBADSECT ! 143: struct buf bhpbuf[NHP]; ! 144: struct dkbad hpbad[NHP]; ! 145: #endif ! 146: char hpinit[NHP]; ! 147: char hprecal[NHP]; ! 148: ! 149: #define b_cylin b_resid ! 150: ! 151: #ifdef INTRLVE ! 152: daddr_t dkblock(); ! 153: #endif ! 154: ! 155: int hpseek; ! 156: ! 157: /*ARGSUSED*/ ! 158: hpattach(mi, slave) ! 159: struct mba_device *mi; ! 160: { ! 161: register struct hpst *st = &hpst[mi->mi_type]; ! 162: ! 163: if (mi->mi_dk >= 0) ! 164: dk_mspw[mi->mi_dk] = 1.0 / 60 / (st->nsect * 256); ! 165: } ! 166: ! 167: hpstrategy(bp) ! 168: register struct buf *bp; ! 169: { ! 170: register struct mba_device *mi; ! 171: register struct hpst *st; ! 172: register int unit; ! 173: long sz, bn; ! 174: int xunit = minor(bp->b_dev) & 07; ! 175: ! 176: sz = bp->b_bcount; ! 177: sz = (sz+511) >> 9; ! 178: unit = dkunit(bp); ! 179: if (unit >= NHP) ! 180: goto bad; ! 181: mi = hpinfo[unit]; ! 182: if (mi == 0 || mi->mi_alive == 0) ! 183: goto bad; ! 184: st = &hpst[mi->mi_type]; ! 185: if (bp->b_blkno < 0 || ! 186: (bn = dkblock(bp))+sz > st->sizes[xunit].nblocks) ! 187: goto bad; ! 188: bp->b_cylin = bn/st->nspc + st->sizes[xunit].cyloff; ! 189: (void) spl5(); ! 190: disksort(&mi->mi_tab, bp); ! 191: if (mi->mi_tab.b_active == 0) ! 192: mbustart(mi); ! 193: (void) spl0(); ! 194: return; ! 195: ! 196: bad: ! 197: bp->b_flags |= B_ERROR; ! 198: iodone(bp); ! 199: return; ! 200: } ! 201: ! 202: hpustart(mi) ! 203: register struct mba_device *mi; ! 204: { ! 205: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; ! 206: register struct buf *bp = mi->mi_tab.b_actf; ! 207: register struct hpst *st = &hpst[mi->mi_type]; ! 208: daddr_t bn; ! 209: int sn, dist; ! 210: ! 211: hpaddr->hpcs1 = 0; ! 212: if ((hpaddr->hpcs1&HP_DVA) == 0) ! 213: return (MBU_BUSY); ! 214: if ((hpaddr->hpds & HPDS_VV) == 0 || hpinit[mi->mi_unit] == 0) { ! 215: #ifndef NOBADSECT ! 216: struct buf *bbp = &bhpbuf[mi->mi_unit]; ! 217: #endif ! 218: ! 219: hpinit[mi->mi_unit] = 1; ! 220: hpaddr->hpcs1 = HP_DCLR|HP_GO; ! 221: if (mi->mi_mba->mba_drv[0].mbd_as & (1<<mi->mi_drive)) ! 222: printf("DCLR attn\n"); ! 223: hpaddr->hpcs1 = HP_PRESET|HP_GO; ! 224: hpaddr->hpof = HPOF_FMT22; ! 225: mbclrattn(mi); ! 226: #ifndef NOBADSECT ! 227: bbp->b_flags = B_READ|B_BUSY; ! 228: bbp->b_dev = bp->b_dev; ! 229: bbp->b_bcount = 512; ! 230: bbp->b_un.b_addr = (caddr_t)&hpbad[mi->mi_unit]; ! 231: bbp->b_blkno = st->ncyl*st->nspc - st->nsect; ! 232: bbp->b_cylin = st->ncyl - 1; ! 233: mi->mi_tab.b_actf = bbp; ! 234: bbp->av_forw = bp; ! 235: bp = bbp; ! 236: #endif ! 237: } ! 238: if (mi->mi_tab.b_active || mi->mi_hd->mh_ndrive == 1) ! 239: return (MBU_DODATA); ! 240: if ((hpaddr->hpds & HPDS_DREADY) != HPDS_DREADY) ! 241: return (MBU_DODATA); ! 242: bn = dkblock(bp); ! 243: sn = bn%st->nspc; ! 244: sn = (sn+st->nsect-hpSDIST)%st->nsect; ! 245: if (bp->b_cylin == (hpaddr->hpdc & 0xffff)) { ! 246: if (hpseek) ! 247: return (MBU_DODATA); ! 248: dist = ((hpaddr->hpla & 0xffff)>>6) - st->nsect + 1; ! 249: if (dist < 0) ! 250: dist += st->nsect; ! 251: if (dist > st->nsect - hpRDIST) ! 252: return (MBU_DODATA); ! 253: } else ! 254: hpaddr->hpdc = bp->b_cylin; ! 255: if (hpseek) ! 256: hpaddr->hpcs1 = HP_SEEK|HP_GO; ! 257: else { ! 258: hpaddr->hpda = sn; ! 259: hpaddr->hpcs1 = HP_SEARCH|HP_GO; ! 260: } ! 261: return (MBU_STARTED); ! 262: } ! 263: ! 264: hpstart(mi) ! 265: register struct mba_device *mi; ! 266: { ! 267: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; ! 268: register struct buf *bp = mi->mi_tab.b_actf; ! 269: register struct hpst *st = &hpst[mi->mi_type]; ! 270: daddr_t bn; ! 271: int sn, tn; ! 272: ! 273: bn = dkblock(bp); ! 274: sn = bn%st->nspc; ! 275: tn = sn/st->nsect; ! 276: sn %= st->nsect; ! 277: hpaddr->hpdc = bp->b_cylin; ! 278: hpaddr->hpda = (tn << 8) + sn; ! 279: return(0); ! 280: } ! 281: ! 282: hpdtint(mi, mbsr) ! 283: register struct mba_device *mi; ! 284: int mbsr; ! 285: { ! 286: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; ! 287: register struct buf *bp = mi->mi_tab.b_actf; ! 288: int retry = 0; ! 289: ! 290: #ifndef NOBADSECT ! 291: if (bp->b_flags&B_BAD) { ! 292: if (hpecc(mi, CONT)) ! 293: return(MBD_RESTARTED); ! 294: } ! 295: #endif ! 296: if (hpaddr->hpds&HPDS_ERR || mbsr&MBSR_EBITS) { ! 297: #ifdef HPDEBUG ! 298: if (hpdebug) { ! 299: int dc = hpaddr->hpdc, da = hpaddr->hpda; ! 300: ! 301: printf("hperr: bp %x cyl %d blk %d as %o ", ! 302: bp, bp->b_cylin, bp->b_blkno, ! 303: hpaddr->hpas&0xff); ! 304: printf("dc %x da %x\n",dc&0xffff, da&0xffff); ! 305: printf("errcnt %d ", mi->mi_tab.b_errcnt); ! 306: printf("mbsr=%b ", mbsr, mbsr_bits); ! 307: printf("er1=%b er2=%b\n", ! 308: hpaddr->hper1, HPER1_BITS, ! 309: hpaddr->hper2, HPER2_BITS); ! 310: DELAY(1000000); ! 311: } ! 312: #endif ! 313: if (hpaddr->hper1&HPER1_WLE) { ! 314: printf("hp%d: write locked\n", dkunit(bp)); ! 315: bp->b_flags |= B_ERROR; ! 316: } else if (++mi->mi_tab.b_errcnt > 27 || ! 317: mbsr & MBSR_HARD || ! 318: hpaddr->hper1 & HPER1_HARD || ! 319: hpaddr->hper2 & HPER2_HARD) { ! 320: hard: ! 321: harderr(bp, "hp"); ! 322: if (mbsr & (MBSR_EBITS &~ (MBSR_DTABT|MBSR_MBEXC))) ! 323: printf("mbsr=%b ", mbsr, mbsr_bits); ! 324: printf("er1=%b er2=%b", ! 325: hpaddr->hper1, HPER1_BITS, ! 326: hpaddr->hper2, HPER2_BITS); ! 327: if (hpaddr->hpmr) ! 328: printf(" mr=%o", hpaddr->hpmr&0xffff); ! 329: if (hpaddr->hpmr2) ! 330: printf(" mr2=%o", hpaddr->hpmr2&0xffff); ! 331: printf("\n"); ! 332: bp->b_flags |= B_ERROR; ! 333: hprecal[mi->mi_unit] = 0; ! 334: } else if (hpaddr->hper2 & HPER2_BSE) { ! 335: #ifndef NOBADSECT ! 336: if (hpecc(mi, BSE)) ! 337: return(MBD_RESTARTED); ! 338: else ! 339: #endif ! 340: goto hard; ! 341: } else if (hptypes[mi->mi_type] == MBDT_RM80 && ! 342: hpaddr->hper2&HPER2_SSE) { ! 343: (void) hpecc(mi, SSE); ! 344: return (MBD_RESTARTED); ! 345: } else if ((hpaddr->hper1&(HPER1_DCK|HPER1_ECH))==HPER1_DCK) { ! 346: if (hpecc(mi, ECC)) ! 347: return (MBD_RESTARTED); ! 348: /* else done */ ! 349: } else ! 350: retry = 1; ! 351: hpaddr->hpcs1 = HP_DCLR|HP_GO; ! 352: if ((mi->mi_tab.b_errcnt&07) == 4) { ! 353: hpaddr->hpcs1 = HP_RECAL|HP_GO; ! 354: hprecal[mi->mi_unit] = 1; ! 355: return(MBD_RESTARTED); ! 356: } ! 357: if (retry) ! 358: return (MBD_RETRY); ! 359: } ! 360: #ifdef HPDEBUG ! 361: else ! 362: if (hpdebug && hprecal[mi->mi_unit]) { ! 363: printf("recal %d ", hprecal[mi->mi_unit]); ! 364: printf("errcnt %d\n", mi->mi_tab.b_errcnt); ! 365: printf("mbsr=%b ", mbsr, mbsr_bits); ! 366: printf("er1=%b er2=%b\n", ! 367: hpaddr->hper1, HPER1_BITS, ! 368: hpaddr->hper2, HPER2_BITS); ! 369: } ! 370: #endif ! 371: switch (hprecal[mi->mi_unit]) { ! 372: ! 373: case 1: ! 374: hpaddr->hpdc = bp->b_cylin; ! 375: hpaddr->hpcs1 = HP_SEEK|HP_GO; ! 376: hprecal[mi->mi_unit]++; ! 377: return (MBD_RESTARTED); ! 378: case 2: ! 379: if (mi->mi_tab.b_errcnt < 16 || ! 380: (bp->b_flags & B_READ) == 0) ! 381: goto donerecal; ! 382: hpaddr->hpof = hp_offset[mi->mi_tab.b_errcnt & 017]|HPOF_FMT22; ! 383: hpaddr->hpcs1 = HP_OFFSET|HP_GO; ! 384: hprecal[mi->mi_unit]++; ! 385: return (MBD_RESTARTED); ! 386: donerecal: ! 387: case 3: ! 388: hprecal[mi->mi_unit] = 0; ! 389: return (MBD_RETRY); ! 390: } ! 391: bp->b_resid = -(mi->mi_mba->mba_bcr) & 0xffff; ! 392: if (mi->mi_tab.b_errcnt >= 16) { ! 393: /* ! 394: * This is fast and occurs rarely; we don't ! 395: * bother with interrupts. ! 396: */ ! 397: hpaddr->hpcs1 = HP_RTC|HP_GO; ! 398: while (hpaddr->hpds & HPDS_PIP) ! 399: ; ! 400: mbclrattn(mi); ! 401: } ! 402: hpaddr->hpof = HPOF_FMT22; ! 403: hpaddr->hpcs1 = HP_RELEASE|HP_GO; ! 404: return (MBD_DONE); ! 405: } ! 406: ! 407: hpread(dev) ! 408: dev_t dev; ! 409: { ! 410: register int unit = minor(dev) >> 3; ! 411: ! 412: if (unit >= NHP) ! 413: u.u_error = ENXIO; ! 414: else ! 415: physio(hpstrategy, &rhpbuf[unit], dev, B_READ, minphys); ! 416: } ! 417: ! 418: hpwrite(dev) ! 419: dev_t dev; ! 420: { ! 421: register int unit = minor(dev) >> 3; ! 422: ! 423: if (unit >= NHP) ! 424: u.u_error = ENXIO; ! 425: else ! 426: physio(hpstrategy, &rhpbuf[unit], dev, B_WRITE, minphys); ! 427: } ! 428: ! 429: hpecc(mi, flag) ! 430: register struct mba_device *mi; ! 431: int flag; ! 432: { ! 433: register struct mba_regs *mbp = mi->mi_mba; ! 434: register struct hpdevice *rp = (struct hpdevice *)mi->mi_drv; ! 435: register struct buf *bp = mi->mi_tab.b_actf; ! 436: register struct hpst *st = &hpst[mi->mi_type]; ! 437: int npf, o; ! 438: int bn, cn, tn, sn; ! 439: int bcr; ! 440: ! 441: bcr = mbp->mba_bcr & 0xffff; ! 442: if (bcr) ! 443: bcr |= 0xffff0000; /* sxt */ ! 444: #ifndef NOBADSECT ! 445: if (flag == CONT) ! 446: npf = bp->b_error; ! 447: else ! 448: #endif ! 449: npf = btop(bcr + bp->b_bcount); ! 450: o = (int)bp->b_un.b_addr & PGOFSET; ! 451: bn = dkblock(bp); ! 452: cn = bp->b_cylin; ! 453: sn = bn%(st->nspc) + npf; ! 454: tn = sn/st->nsect; ! 455: sn %= st->nsect; ! 456: cn += tn/st->ntrak; ! 457: tn %= st->ntrak; ! 458: switch (flag) { ! 459: case ECC: ! 460: { ! 461: register int i; ! 462: caddr_t addr; ! 463: struct pte mpte; ! 464: int bit, byte, mask; ! 465: ! 466: npf--; /* because block in error is previous block */ ! 467: printf("hp%d%c: soft ecc sn%d\n", dkunit(bp), ! 468: 'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf); ! 469: mask = rp->hpec2&0xffff; ! 470: i = (rp->hpec1&0xffff) - 1; /* -1 makes 0 origin */ ! 471: bit = i&07; ! 472: i = (i&~07)>>3; ! 473: byte = i + o; ! 474: while (i < 512 && (int)ptob(npf)+i < bp->b_bcount && bit > -11) { ! 475: mpte = mbp->mba_map[npf+btop(byte)]; ! 476: addr = ptob(mpte.pg_pfnum) + (byte & PGOFSET); ! 477: putmemc(addr, getmemc(addr)^(mask<<bit)); ! 478: byte++; ! 479: i++; ! 480: bit -= 8; ! 481: } ! 482: if (bcr == 0) ! 483: return (0); ! 484: npf++; ! 485: break; ! 486: } ! 487: ! 488: case SSE: ! 489: rp->hpof |= HPOF_SSEI; ! 490: mbp->mba_bcr = -(bp->b_bcount - (int)ptob(npf)); ! 491: break; ! 492: ! 493: #ifndef NOBADSECT ! 494: case BSE: ! 495: #ifdef HPBDEBUG ! 496: if (hpbdebug) ! 497: printf("hpecc, BSE: bn %d cn %d tn %d sn %d\n", bn, cn, tn, sn); ! 498: #endif ! 499: if ((bn = isbad(&hpbad[mi->mi_unit], cn, tn, sn)) < 0) ! 500: return(0); ! 501: bp->b_flags |= B_BAD; ! 502: bp->b_error = npf + 1; ! 503: bn = st->ncyl*st->nspc - st->nsect - 1 - bn; ! 504: cn = bn/st->nspc; ! 505: sn = bn%st->nspc; ! 506: tn = sn/st->nsect; ! 507: sn %= st->nsect; ! 508: mbp->mba_bcr = -512; ! 509: #ifdef HPBDEBUG ! 510: if (hpbdebug) ! 511: printf("revector to cn %d tn %d sn %d\n", cn, tn, sn); ! 512: #endif ! 513: break; ! 514: ! 515: case CONT: ! 516: #ifdef HPBDEBUG ! 517: if (hpbdebug) ! 518: printf("hpecc, CONT: bn %d cn %d tn %d sn %d\n", bn,cn,tn,sn); ! 519: #endif ! 520: npf = bp->b_error; ! 521: bp->b_flags &= ~B_BAD; ! 522: mbp->mba_bcr = -(bp->b_bcount - (int)ptob(npf)); ! 523: if ((mbp->mba_bcr & 0xffff) == 0) ! 524: return(0); ! 525: break; ! 526: #endif ! 527: } ! 528: rp->hpcs1 = HP_DCLR|HP_GO; ! 529: if (rp->hpof&HPOF_SSEI) ! 530: sn++; ! 531: rp->hpdc = cn; ! 532: rp->hpda = (tn<<8) + sn; ! 533: mbp->mba_sr = -1; ! 534: mbp->mba_var = (int)ptob(npf) + o; ! 535: rp->hpcs1 = bp->b_flags&B_READ ? HP_RCOM|HP_GO : HP_WCOM|HP_GO; ! 536: mi->mi_tab.b_errcnt = 0; /* error has been corrected */ ! 537: return (1); ! 538: } ! 539: ! 540: #define DBSIZE 20 ! 541: ! 542: hpdump(dev) ! 543: dev_t dev; ! 544: { ! 545: register struct mba_device *mi; ! 546: register struct mba_regs *mba; ! 547: struct hpdevice *hpaddr; ! 548: char *start; ! 549: int num, unit; ! 550: register struct hpst *st; ! 551: ! 552: num = maxfree; ! 553: start = 0; ! 554: unit = minor(dev) >> 3; ! 555: if (unit >= NHP) ! 556: return (ENXIO); ! 557: #define phys(a,b) ((b)((int)(a)&0x7fffffff)) ! 558: mi = phys(hpinfo[unit],struct mba_device *); ! 559: if (mi == 0 || mi->mi_alive == 0) ! 560: return (ENXIO); ! 561: mba = phys(mi->mi_hd, struct mba_hd *)->mh_physmba; ! 562: mba->mba_cr = MBCR_INIT; ! 563: hpaddr = (struct hpdevice *)&mba->mba_drv[mi->mi_drive]; ! 564: if ((hpaddr->hpds & HPDS_VV) == 0) { ! 565: hpaddr->hpcs1 = HP_DCLR|HP_GO; ! 566: hpaddr->hpcs1 = HP_PRESET|HP_GO; ! 567: hpaddr->hpof = HPOF_FMT22; ! 568: } ! 569: st = &hpst[mi->mi_type]; ! 570: if (dumplo < 0 || dumplo + num >= st->sizes[minor(dev)&07].nblocks) ! 571: return (EINVAL); ! 572: while (num > 0) { ! 573: register struct pte *hpte = mba->mba_map; ! 574: register int i; ! 575: int blk, cn, sn, tn; ! 576: daddr_t bn; ! 577: ! 578: blk = num > DBSIZE ? DBSIZE : num; ! 579: bn = dumplo + btop(start); ! 580: cn = bn/st->nspc + st->sizes[minor(dev)&07].cyloff; ! 581: sn = bn%st->nspc; ! 582: tn = sn/st->nsect; ! 583: sn = sn%st->nsect; ! 584: hpaddr->hpdc = cn; ! 585: hpaddr->hpda = (tn << 8) + sn; ! 586: for (i = 0; i < blk; i++) ! 587: *(int *)hpte++ = (btop(start)+i) | PG_V; ! 588: mba->mba_sr = -1; ! 589: mba->mba_bcr = -(blk*NBPG); ! 590: mba->mba_var = 0; ! 591: hpaddr->hpcs1 = HP_WCOM | HP_GO; ! 592: while ((hpaddr->hpds & HPDS_DRY) == 0) ! 593: ; ! 594: if (hpaddr->hpds&HPDS_ERR) ! 595: return (EIO); ! 596: start += blk*NBPG; ! 597: num -= blk; ! 598: } ! 599: return (0); ! 600: } ! 601: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.