1 /* hp.c 6.7 85/03/19 */ 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+ML11 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 #include "../machine/pte.h" 22 23 #include "param.h" 24 #include "systm.h" 25 #include "dk.h" 26 #include "buf.h" 27 #include "conf.h" 28 #include "dir.h" 29 #include "user.h" 30 #include "map.h" 31 #include "../vax/mtpr.h" 32 #include "vm.h" 33 #include "cmap.h" 34 #include "dkbad.h" 35 #include "ioctl.h" 36 #include "uio.h" 37 #include "syslog.h" 38 39 #include "../vax/dkio.h" 40 #include "mbareg.h" 41 #include "mbavar.h" 42 #include "hpreg.h" 43 44 /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */ 45 struct size { 46 daddr_t nblocks; 47 int cyloff; 48 } rp06_sizes[8] = { 49 15884, 0, /* A=cyl 0 thru 37 */ 50 33440, 38, /* B=cyl 38 thru 117 */ 51 340670, 0, /* C=cyl 0 thru 814 */ 52 15884, 118, /* D=cyl 118 thru 155 */ 53 55936, 156, /* E=cyl 156 thru 289 */ 54 219384, 290, /* F=cyl 290 thru 814 */ 55 291280, 118, /* G=cyl 118 thru 814 */ 56 0, 0, 57 }, rp05_sizes[8] = { 58 15884, 0, /* A=cyl 0 thru 37 */ 59 33440, 38, /* B=cyl 38 thru 117 */ 60 171798, 0, /* C=cyl 0 thru 410 */ 61 15884, 118, /* D=cyl 118 thru 155 */ 62 55936, 156, /* E=cyl 156 thru 289 */ 63 50512, 290, /* F=cyl 290 thru 410 */ 64 122408, 118, /* G=cyl 118 thru 410 */ 65 0, 0, 66 }, rm03_sizes[8] = { 67 15884, 0, /* A=cyl 0 thru 99 */ 68 33440, 100, /* B=cyl 100 thru 308 */ 69 131680, 0, /* C=cyl 0 thru 822 */ 70 15884, 309, /* D=cyl 309 thru 408 */ 71 55936, 409, /* E=cyl 409 thru 758 */ 72 10144, 759, /* F=cyl 759 thru 822 */ 73 82144, 309, /* G=cyl 309 thru 822 */ 74 0, 0, 75 }, rm05_sizes[8] = { 76 15884, 0, /* A=cyl 0 thru 26 */ 77 33440, 27, /* B=cyl 27 thru 81 */ 78 500384, 0, /* C=cyl 0 thru 822 */ 79 15884, 562, /* D=cyl 562 thru 588 */ 80 55936, 589, /* E=cyl 589 thru 680 */ 81 86240, 681, /* F=cyl 681 thru 822 */ 82 158592, 562, /* G=cyl 562 thru 822 */ 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 15884, 115, /* D=cyl 115 thru 151 */ 89 55936, 152, /* E=cyl 152 thru 280 */ 90 120559, 281, /* F=cyl 281 thru 558 */ 91 192603, 115, /* G=cyl 115 thru 558 */ 92 0, 0, 93 }, rp07_sizes[8] = { 94 15884, 0, /* A=cyl 0 thru 9 */ 95 66880, 10, /* B=cyl 10 thru 51 */ 96 1008000, 0, /* C=cyl 0 thru 629 */ 97 15884, 235, /* D=cyl 235 thru 244 */ 98 307200, 245, /* E=cyl 245 thru 436 */ 99 308650, 437, /* F=cyl 437 thru 629 */ 100 631850, 235, /* G=cyl 235 thru 629 */ 101 291346, 52, /* H=cyl 52 thru 234 */ 102 }, cdc9775_sizes[8] = { 103 15884, 0, /* A=cyl 0 thru 12 */ 104 66880, 13, /* B=cyl 13 thru 65 */ 105 1077760, 0, /* C=cyl 0 thru 841 */ 106 15884, 294, /* D=cyl 294 thru 306 */ 107 307200, 307, /* E=cyl 307 thru 546 */ 108 377440, 547, /* F=cyl 547 thru 841 */ 109 701280, 294, /* G=cyl 294 thru 841 */ 110 291346, 66, /* H=cyl 66 thru 293 */ 111 }, cdc9730_sizes[8] = { 112 15884, 0, /* A=cyl 0 thru 49 */ 113 33440, 50, /* B=cyl 50 thru 154 */ 114 263360, 0, /* C=cyl 0 thru 822 */ 115 15884, 155, /* D=cyl 155 thru 204 */ 116 55936, 205, /* E=cyl 205 thru 379 */ 117 141664, 380, /* F=cyl 380 thru 822 */ 118 213664, 155, /* G=cyl 155 thru 822 */ 119 0, 0, 120 }, capricorn_sizes[8] = { 121 15884, 0, /* A=cyl 0 thru 31 */ 122 33440, 32, /* B=cyl 32 thru 97 */ 123 524288, 0, /* C=cyl 0 thru 1023 */ 124 15884, 668, /* D=cyl 668 thru 699 */ 125 55936, 700, /* E=cyl 700 thru 809 */ 126 109472, 810, /* F=cyl 810 thru 1023 */ 127 182176, 668, /* G=cyl 668 thru 1023 */ 128 291346, 98, /* H=cyl 98 thru 667 */ 129 }, eagle_sizes[8] = { 130 15884, 0, /* A=cyl 0 thru 16 */ 131 66880, 17, /* B=cyl 17 thru 86 */ 132 808320, 0, /* C=cyl 0 thru 841 */ 133 15884, 391, /* D=cyl 391 thru 407 */ 134 307200, 408, /* E=cyl 408 thru 727 */ 135 109296, 728, /* F=cyl 728 thru 841 */ 136 432816, 391, /* G=cyl 391 thru 841 */ 137 291346, 87, /* H=cyl 87 thru 390 */ 138 }, ampex_sizes[8] = { 139 15884, 0, /* A=cyl 0 thru 26 */ 140 33440, 27, /* B=cyl 27 thru 81 */ 141 495520, 0, /* C=cyl 0 thru 814 */ 142 15884, 562, /* D=cyl 562 thru 588 */ 143 55936, 589, /* E=cyl 589 thru 680 */ 144 81312, 681, /* F=cyl 681 thru 814 */ 145 153664, 562, /* G=cyl 562 thru 814 */ 146 291346, 82, /* H=cyl 82 thru 561 */ 147 }; 148 /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */ 149 150 /* 151 * Table for converting Massbus drive types into 152 * indices into the partition tables. Slots are 153 * left for those drives devined from other means 154 * (e.g. SI, AMPEX, etc.). 155 */ 156 short hptypes[] = { 157 #define HPDT_RM03 0 158 MBDT_RM03, 159 #define HPDT_RM05 1 160 MBDT_RM05, 161 #define HPDT_RP06 2 162 MBDT_RP06, 163 #define HPDT_RM80 3 164 MBDT_RM80, 165 #define HPDT_RP04 4 166 MBDT_RP04, 167 #define HPDT_RP05 5 168 MBDT_RP05, 169 #define HPDT_RP07 6 170 MBDT_RP07, 171 #define HPDT_ML11A 7 172 MBDT_ML11A, 173 #define HPDT_ML11B 8 174 MBDT_ML11B, 175 #define HPDT_9775 9 176 -1, 177 #define HPDT_9730 10 178 -1, 179 #define HPDT_CAPRICORN 11 180 -1, 181 #define HPDT_EAGLE 12 182 -1, 183 #define HPDT_9300 13 184 -1, 185 #define HPDT_RM02 14 186 MBDT_RM02, /* beware, actually capricorn or eagle */ 187 0 188 }; 189 struct mba_device *hpinfo[NHP]; 190 int hpattach(),hpustart(),hpstart(),hpdtint(); 191 struct mba_driver hpdriver = 192 { hpattach, 0, hpustart, hpstart, hpdtint, 0, 193 hptypes, "hp", 0, hpinfo }; 194 195 /* 196 * These variable are all measured in sectors. 197 * Sdist is how much to "lead" in the search for a desired sector 198 * (i.e. if want N, search for N-sdist.) 199 * Maxdist and mindist define the region right before our desired sector within 200 * which we don't bother searching. We don't search when we are already less 201 * then maxdist and more than mindist sectors "before" our desired sector. 202 * Maxdist should be >= sdist. 203 * 204 * Beware, sdist, mindist and maxdist are not well tuned 205 * for many of the drives listed in this table. 206 * Try patching things with something i/o intensive 207 * running and watch iostat. 208 */ 209 struct hpst { 210 short nsect; /* # sectors/track */ 211 short ntrak; /* # tracks/cylinder */ 212 short nspc; /* # sector/cylinders */ 213 short ncyl; /* # cylinders */ 214 struct size *sizes; /* partition tables */ 215 short sdist; /* seek distance metric */ 216 short maxdist; /* boundaries of non-searched area */ 217 short mindist; /* preceding the target sector */ 218 } hpst[] = { 219 { 32, 5, 32*5, 823, rm03_sizes, 7, 4, 1 }, /* RM03 */ 220 { 32, 19, 32*19, 823, rm05_sizes, 7, 4, 1 }, /* RM05 */ 221 { 22,19, 22*19, 815, rp06_sizes, 7, 4, 1 }, /* RP06 */ 222 { 31, 14, 31*14, 559, rm80_sizes, 7, 4, 1 }, /* RM80 */ 223 { 22, 19, 22*19, 411, rp05_sizes, 7, 4, 1 }, /* RP04 */ 224 { 22, 19, 22*19, 411, rp05_sizes, 7, 4, 1 }, /* RP05 */ 225 { 50, 32, 50*32, 630, rp07_sizes, 15, 8, 3 }, /* RP07 */ 226 { 1, 1, 1, 1, 0, 0, 0, 0 }, /* ML11A */ 227 { 1, 1, 1, 1, 0, 0, 0, 0 }, /* ML11B */ 228 { 32, 40, 32*40, 843, cdc9775_sizes, 7, 4, 1 }, /* 9775 */ 229 { 32, 10, 32*10, 823, cdc9730_sizes, 7, 4, 1 }, /* 9730 */ 230 { 32, 16, 32*16, 1024, capricorn_sizes,10,4, 3 }, /* Capricorn */ 231 { 48, 20, 48*20, 842, eagle_sizes, 15, 8, 3 }, /* EAGLE */ 232 { 32, 19, 32*19, 815, ampex_sizes, 7, 4, 1 }, /* 9300 */ 233 }; 234 235 u_char hp_offset[16] = { 236 HPOF_P400, HPOF_M400, HPOF_P400, HPOF_M400, 237 HPOF_P800, HPOF_M800, HPOF_P800, HPOF_M800, 238 HPOF_P1200, HPOF_M1200, HPOF_P1200, HPOF_M1200, 239 0, 0, 0, 0, 240 }; 241 242 struct buf rhpbuf[NHP]; 243 struct buf bhpbuf[NHP]; 244 struct dkbad hpbad[NHP]; 245 246 struct hpsoftc { 247 u_char sc_hpinit; /* drive initialized */ 248 u_char sc_recal; /* recalibrate state */ 249 u_char sc_hdr; /* next i/o includes header */ 250 u_char sc_doseeks; /* perform explicit seeks */ 251 daddr_t sc_mlsize; /* ML11 size */ 252 int sc_pgdone; /* amount sucessfully transfered */ 253 daddr_t sc_badbn; /* replacement block number */ 254 } hpsoftc[NHP]; 255 256 #define b_cylin b_resid 257 258 /* #define ML11 0 to remove ML11 support */ 259 #define ML11 (hptypes[mi->mi_type] == MBDT_ML11A) 260 #define RP06 (hptypes[mi->mi_type] <= MBDT_RP06) 261 #define RM80 (hptypes[mi->mi_type] == MBDT_RM80) 262 263 #define MASKREG(reg) ((reg)&0xffff) 264 #define HPWAIT(mi, addr) (((addr)->hpds & HPDS_DRY) || hpwait(mi)) 265 266 #ifdef INTRLVE 267 daddr_t dkblock(); 268 #endif 269 270 /*ARGSUSED*/ 271 hpattach(mi, slave) 272 register struct mba_device *mi; 273 { 274 275 mi->mi_type = hpmaptype(mi); 276 if (!ML11 && mi->mi_dk >= 0) { 277 struct hpst *st = &hpst[mi->mi_type]; 278 279 dk_mspw[mi->mi_dk] = 1.0 / 60 / (st->nsect * 256); 280 } 281 } 282 283 /* 284 * Map apparent MASSBUS drive type into manufacturer 285 * specific configuration. For SI controllers this is done 286 * based on codes in the serial number register. For 287 * EMULEX controllers, the track and sector attributes are 288 * used when the drive type is an RM02 (not supported by DEC). 289 */ 290 hpmaptype(mi) 291 register struct mba_device *mi; 292 { 293 register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; 294 register int type = mi->mi_type; 295 296 /* 297 * Model-byte processing for SI controllers. 298 * NB: Only deals with RM03 and RM05 emulations. 299 */ 300 if (type == HPDT_RM03 || type == HPDT_RM05) { 301 int hpsn = hpaddr->hpsn; 302 303 if ((hpsn & SIMB_LU) != mi->mi_drive) 304 return (type); 305 switch ((hpsn & SIMB_MB) & ~(SIMB_S6|SIRM03|SIRM05)) { 306 307 case SI9775D: 308 printf("hp%d: 9775 (direct)\n", mi->mi_unit); 309 type = HPDT_9775; 310 break; 311 312 case SI9730D: 313 printf("hp%d: 9730 (direct)\n", mi->mi_unit); 314 type = HPDT_9730; 315 break; 316 317 /* 318 * Beware, since the only SI controller we 319 * have has a 9300 instead of a 9766, we map the 320 * drive type into the 9300. This means that 321 * on a 9766 you lose the last 8 cylinders (argh). 322 */ 323 case SI9766: 324 printf("hp%d: 9300\n", mi->mi_unit); 325 type = HPDT_9300; 326 break; 327 328 case SI9762: 329 printf("hp%d: 9762\n", mi->mi_unit); 330 type = HPDT_RM03; 331 break; 332 333 case SICAPD: 334 printf("hp%d: capricorn\n", mi->mi_unit); 335 type = HPDT_CAPRICORN; 336 break; 337 338 case SI9751D: 339 printf("hp%d: eagle\n", mi->mi_unit); 340 type = HPDT_EAGLE; 341 break; 342 } 343 return (type); 344 } 345 346 /* 347 * EMULEX SC750 or SC780. Poke the holding register. 348 */ 349 if (type == HPDT_RM02) { 350 int ntracks, nsectors; 351 352 hpaddr->hpof = HPOF_FMT22; 353 mbclrattn(mi); 354 hpaddr->hpcs1 = HP_NOP; 355 hpaddr->hphr = HPHR_MAXTRAK; 356 ntracks = MASKREG(hpaddr->hphr) + 1; 357 if (ntracks == 16) { 358 printf("hp%d: capricorn\n", mi->mi_unit); 359 type = HPDT_CAPRICORN; 360 goto done; 361 } 362 if (ntracks == 19) { 363 printf("hp%d: 9300\n", mi->mi_unit); 364 type = HPDT_9300; 365 goto done; 366 } 367 hpaddr->hpcs1 = HP_NOP; 368 hpaddr->hphr = HPHR_MAXSECT; 369 nsectors = MASKREG(hpaddr->hphr) + 1; 370 if (ntracks == 20 && nsectors == 48) { 371 type = HPDT_EAGLE; 372 printf("hp%d: eagle\n", mi->mi_unit); 373 goto done; 374 } 375 printf("hp%d: ntracks %d, nsectors %d: unknown device\n", 376 mi->mi_unit, ntracks, nsectors); 377 done: 378 hpaddr->hpcs1 = HP_DCLR|HP_GO; 379 mbclrattn(mi); /* conservative */ 380 return (type); 381 } 382 383 /* 384 * Map all ML11's to the same type. Also calculate 385 * transfer rates based on device characteristics. 386 */ 387 if (type == HPDT_ML11A || type == HPDT_ML11B) { 388 register struct hpsoftc *sc = &hpsoftc[mi->mi_unit]; 389 register int trt; 390 391 sc->sc_mlsize = hpaddr->hpmr & HPMR_SZ; 392 if ((hpaddr->hpmr & HPMR_ARRTYP) == 0) 393 sc->sc_mlsize >>= 2; 394 if (mi->mi_dk >= 0) { 395 trt = (hpaddr->hpmr & HPMR_TRT) >> 8; 396 dk_mspw[mi->mi_dk] = 1.0 / (1<<(20-trt)); 397 } 398 type = HPDT_ML11A; 399 } 400 return (type); 401 } 402 403 hpopen(dev) 404 dev_t dev; 405 { 406 register int unit = minor(dev) >> 3; 407 register struct mba_device *mi; 408 409 if (unit >= NHP || (mi = hpinfo[unit]) == 0 || mi->mi_alive == 0) 410 return (ENXIO); 411 return (0); 412 } 413 414 hpstrategy(bp) 415 register struct buf *bp; 416 { 417 register struct mba_device *mi; 418 register struct hpst *st; 419 register int unit; 420 long sz, bn; 421 int xunit = minor(bp->b_dev) & 07; 422 int s; 423 424 sz = bp->b_bcount; 425 sz = (sz+511) >> 9; 426 unit = dkunit(bp); 427 if (unit >= NHP) 428 goto bad; 429 mi = hpinfo[unit]; 430 if (mi == 0 || mi->mi_alive == 0) 431 goto bad; 432 st = &hpst[mi->mi_type]; 433 if (ML11) { 434 struct hpsoftc *sc = &hpsoftc[unit]; 435 436 if (bp->b_blkno < 0 || 437 dkblock(bp)+sz > sc->sc_mlsize) 438 goto bad; 439 bp->b_cylin = 0; 440 } else { 441 if (bp->b_blkno < 0 || 442 (bn = dkblock(bp))+sz > st->sizes[xunit].nblocks) 443 goto bad; 444 bp->b_cylin = bn/st->nspc + st->sizes[xunit].cyloff; 445 } 446 s = spl5(); 447 disksort(&mi->mi_tab, bp); 448 if (mi->mi_tab.b_active == 0) 449 mbustart(mi); 450 splx(s); 451 return; 452 453 bad: 454 bp->b_flags |= B_ERROR; 455 iodone(bp); 456 return; 457 } 458 459 hpustart(mi) 460 register struct mba_device *mi; 461 { 462 register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; 463 register struct buf *bp = mi->mi_tab.b_actf; 464 register struct hpst *st; 465 struct hpsoftc *sc = &hpsoftc[mi->mi_unit]; 466 daddr_t bn; 467 int sn, tn, dist; 468 469 st = &hpst[mi->mi_type]; 470 hpaddr->hpcs1 = 0; 471 if ((hpaddr->hpcs1&HP_DVA) == 0) 472 return (MBU_BUSY); 473 if ((hpaddr->hpds & HPDS_VV) == 0 || !sc->sc_hpinit) { 474 struct buf *bbp = &bhpbuf[mi->mi_unit]; 475 476 sc->sc_hpinit = 1; 477 hpaddr->hpcs1 = HP_DCLR|HP_GO; 478 if (mi->mi_mba->mba_drv[0].mbd_as & (1<<mi->mi_drive)) 479 printf("DCLR attn\n"); 480 hpaddr->hpcs1 = HP_PRESET|HP_GO; 481 if (!ML11) 482 hpaddr->hpof = HPOF_FMT22; 483 mbclrattn(mi); 484 if (!ML11) { 485 bbp->b_flags = B_READ|B_BUSY; 486 bbp->b_dev = bp->b_dev; 487 bbp->b_bcount = 512; 488 bbp->b_un.b_addr = (caddr_t)&hpbad[mi->mi_unit]; 489 bbp->b_blkno = st->ncyl*st->nspc - st->nsect; 490 bbp->b_cylin = st->ncyl - 1; 491 mi->mi_tab.b_actf = bbp; 492 bbp->av_forw = bp; 493 bp = bbp; 494 } 495 } 496 if (mi->mi_tab.b_active || mi->mi_hd->mh_ndrive == 1) 497 return (MBU_DODATA); 498 if (ML11) 499 return (MBU_DODATA); 500 if ((hpaddr->hpds & HPDS_DREADY) != HPDS_DREADY) 501 return (MBU_DODATA); 502 bn = dkblock(bp); 503 sn = bn % st->nspc; 504 tn = sn / st->nsect; 505 sn = sn % st->nsect; 506 if (bp->b_cylin == MASKREG(hpaddr->hpdc)) { 507 if (sc->sc_doseeks) 508 return (MBU_DODATA); 509 dist = sn - (MASKREG(hpaddr->hpla) >> 6) - 1; 510 if (dist < 0) 511 dist += st->nsect; 512 if (dist > st->maxdist || dist < st->mindist) 513 return (MBU_DODATA); 514 } else 515 hpaddr->hpdc = bp->b_cylin; 516 if (sc->sc_doseeks) 517 hpaddr->hpcs1 = HP_SEEK|HP_GO; 518 else { 519 sn = (sn + st->nsect - st->sdist) % st->nsect; 520 hpaddr->hpda = (tn << 8) + sn; 521 hpaddr->hpcs1 = HP_SEARCH|HP_GO; 522 } 523 return (MBU_STARTED); 524 } 525 526 hpstart(mi) 527 register struct mba_device *mi; 528 { 529 register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; 530 register struct buf *bp = mi->mi_tab.b_actf; 531 register struct hpst *st = &hpst[mi->mi_type]; 532 struct hpsoftc *sc = &hpsoftc[mi->mi_unit]; 533 daddr_t bn; 534 int sn, tn; 535 536 if (bp->b_flags & B_BAD) 537 bn = sc->sc_badbn; 538 else 539 bn = dkblock(bp) + sc->sc_pgdone; 540 if (ML11) 541 hpaddr->hpda = bn; 542 else { 543 sn = bn%st->nspc; 544 tn = sn/st->nsect; 545 sn %= st->nsect; 546 hpaddr->hpdc = bp->b_cylin; 547 hpaddr->hpda = (tn << 8) + sn; 548 } 549 if (sc->sc_hdr) { 550 if (bp->b_flags & B_READ) 551 return (HP_RHDR|HP_GO); 552 else 553 return (HP_WHDR|HP_GO); 554 } 555 return (0); 556 } 557 558 hpdtint(mi, mbsr) 559 register struct mba_device *mi; 560 int mbsr; 561 { 562 register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; 563 register struct buf *bp = mi->mi_tab.b_actf; 564 register struct hpst *st; 565 register int er1, er2; 566 struct hpsoftc *sc = &hpsoftc[mi->mi_unit]; 567 int retry = 0, i; 568 569 st = &hpst[mi->mi_type]; 570 if (hpaddr->hpds&HPDS_ERR || mbsr&MBSR_EBITS) { 571 er1 = hpaddr->hper1; 572 er2 = hpaddr->hper2; 573 if (HPWAIT(mi, hpaddr) == 0) 574 goto hard; 575 #ifdef HPDEBUG 576 if (hpdebug) { 577 int dc = hpaddr->hpdc, da = hpaddr->hpda; 578 579 printf("hperr: bp %x cyl %d blk %d pgdone %d as %o ", 580 bp, bp->b_cylin, bp->b_blkno, sc->sc_pgdone, 581 hpaddr->hpas&0xff); 582 printf("dc %x da %x\n",MASKREG(dc), MASKREG(da)); 583 printf("errcnt %d ", mi->mi_tab.b_errcnt); 584 printf("mbsr=%b ", mbsr, mbsr_bits); 585 printf("er1=%b er2=%b\n", MASKREG(er1), HPER1_BITS, 586 MASKREG(er2), HPER2_BITS); 587 DELAY(1000000); 588 } 589 #endif 590 if (er1 & HPER1_HCRC) { 591 er1 &= ~(HPER1_HCE|HPER1_FER); 592 er2 &= ~HPER2_BSE; 593 } 594 if (er1 & HPER1_WLE) { 595 log(KERN_RECOV, "hp%d: write locked\n", dkunit(bp)); 596 bp->b_flags |= B_ERROR; 597 } else if (sc->sc_hdr) { 598 goto hard; 599 } else if (RM80 && er2&HPER2_SSE) { 600 (void) hpecc(mi, SSE); 601 return (MBD_RESTARTED); 602 } else if ((er2 & HPER2_BSE) && !ML11) { 603 if (hpecc(mi, BSE)) 604 return (MBD_RESTARTED); 605 goto hard; 606 } else if (MASKREG(er1) == HPER1_FER && RP06) { 607 if (hpecc(mi, BSE)) 608 return (MBD_RESTARTED); 609 goto hard; 610 } else if ((er1 & (HPER1_DCK | HPER1_ECH)) == HPER1_DCK && 611 mi->mi_tab.b_errcnt > 7) { 612 if (hpecc(mi, ECC)) 613 return (MBD_RESTARTED); 614 /* else done */ 615 } else if (++mi->mi_tab.b_errcnt > 27 || 616 (ML11 && mi->mi_tab.b_errcnt > 15) || 617 mbsr & MBSR_HARD || 618 er1 & HPER1_HARD || 619 (!ML11 && (er2 & HPER2_HARD))) { 620 /* 621 * HCRC means the header is screwed up and the sector 622 * might well exist in the bad sector table, 623 * better check.... 624 */ 625 if ((er1 & HPER1_HCRC) && !ML11 && hpecc(mi, BSE)) 626 return (MBD_RESTARTED); 627 hard: 628 if (bp->b_flags & B_BAD) 629 bp->b_blkno = sc->sc_badbn; 630 else { 631 bp->b_blkno = dkblock(bp) + btop(bp->b_bcount - 632 MASKREG(-mi->mi_mba->mba_bcr)); 633 if (er1 & (HPER1_DCK | HPER1_ECH)) 634 bp->b_blkno--; 635 } 636 harderr(bp, "hp"); 637 if (mbsr & (MBSR_EBITS &~ (MBSR_DTABT|MBSR_MBEXC))) 638 printf("mbsr=%b ", mbsr, mbsr_bits); 639 printf("er1=%b er2=%b", 640 MASKREG(hpaddr->hper1), HPER1_BITS, 641 MASKREG(hpaddr->hper2), HPER2_BITS); 642 if (hpaddr->hpmr) 643 printf(" mr=%o", MASKREG(hpaddr->hpmr)); 644 if (hpaddr->hpmr2) 645 printf(" mr2=%o", MASKREG(hpaddr->hpmr2)); 646 if (sc->sc_hdr) 647 printf(" (hdr i/o)"); 648 printf("\n"); 649 bp->b_flags |= B_ERROR; 650 bp->b_flags &= ~B_BAD; 651 } else 652 retry = 1; 653 hpaddr->hpcs1 = HP_DCLR|HP_GO; 654 if ((mi->mi_tab.b_errcnt & 07) == 4) { 655 hpaddr->hpcs1 = HP_RECAL|HP_GO; 656 sc->sc_recal = 1; 657 return (MBD_RESTARTED); 658 } 659 } 660 #ifdef HPDEBUG 661 else 662 if (hpdebug && sc->sc_recal) { 663 printf("recal %d ", sc->sc_recal); 664 printf("errcnt %d\n", mi->mi_tab.b_errcnt); 665 printf("mbsr=%b ", mbsr, mbsr_bits); 666 printf("er1=%b er2=%b\n", 667 hpaddr->hper1, HPER1_BITS, 668 hpaddr->hper2, HPER2_BITS); 669 } 670 #endif 671 HPWAIT(mi, hpaddr); 672 switch (sc->sc_recal) { 673 674 case 1: 675 hpaddr->hpdc = bp->b_cylin; 676 hpaddr->hpcs1 = HP_SEEK|HP_GO; 677 sc->sc_recal++; 678 return (MBD_RESTARTED); 679 case 2: 680 retry = 1; 681 break; 682 } 683 sc->sc_recal = 0; 684 if (retry) { 685 if (mi->mi_tab.b_errcnt >= 16 && (bp->b_flags & B_READ)) { 686 hpaddr->hpof = 687 hp_offset[mi->mi_tab.b_errcnt & 017]|HPOF_FMT22; 688 hpaddr->hpcs1 = HP_OFFSET|HP_GO; 689 HPWAIT(mi, hpaddr); 690 mbclrattn(mi); 691 } 692 return (MBD_RETRY); 693 } 694 if (mi->mi_tab.b_errcnt >= 16) { 695 /* 696 * This is fast and occurs rarely; we don't 697 * bother with interrupts. 698 */ 699 hpaddr->hpcs1 = HP_RTC|HP_GO; 700 HPWAIT(mi, hpaddr); 701 mbclrattn(mi); 702 } 703 if ((bp->b_flags & B_BAD) && hpecc(mi, CONT)) 704 return (MBD_RESTARTED); 705 sc->sc_hdr = 0; 706 sc->sc_pgdone = 0; 707 bp->b_resid = MASKREG(-mi->mi_mba->mba_bcr); 708 if (!ML11) { 709 hpaddr->hpof = HPOF_FMT22; 710 hpaddr->hpcs1 = HP_RELEASE|HP_GO; 711 } 712 return (MBD_DONE); 713 } 714 715 /* 716 * Wait (for a bit) for a drive to come ready; 717 * returns nonzero on success. 718 */ 719 hpwait(mi) 720 register struct mba_device *mi; 721 { 722 register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; 723 register i = 100000; 724 725 while ((hpaddr->hpds & HPDS_DRY) == 0 && --i) 726 DELAY(10); 727 if (i == 0) 728 printf("hp%d: intr, not ready\n", mi->mi_unit); 729 return (i); 730 } 731 732 hpread(dev, uio) 733 dev_t dev; 734 struct uio *uio; 735 { 736 register int unit = minor(dev) >> 3; 737 738 if (unit >= NHP) 739 return (ENXIO); 740 return (physio(hpstrategy, &rhpbuf[unit], dev, B_READ, minphys, uio)); 741 } 742 743 hpwrite(dev, uio) 744 dev_t dev; 745 struct uio *uio; 746 { 747 register int unit = minor(dev) >> 3; 748 749 if (unit >= NHP) 750 return (ENXIO); 751 return (physio(hpstrategy, &rhpbuf[unit], dev, B_WRITE, minphys, uio)); 752 } 753 754 /*ARGSUSED*/ 755 hpioctl(dev, cmd, data, flag) 756 dev_t dev; 757 int cmd; 758 caddr_t data; 759 int flag; 760 { 761 762 switch (cmd) { 763 764 case DKIOCHDR: /* do header read/write */ 765 hpsoftc[minor(dev) >> 3].sc_hdr = 1; 766 return (0); 767 768 default: 769 return (ENXIO); 770 } 771 } 772 773 hpecc(mi, flag) 774 register struct mba_device *mi; 775 int flag; 776 { 777 register struct mba_regs *mbp = mi->mi_mba; 778 register struct hpdevice *rp = (struct hpdevice *)mi->mi_drv; 779 register struct buf *bp = mi->mi_tab.b_actf; 780 register struct hpst *st = &hpst[mi->mi_type]; 781 struct hpsoftc *sc = &hpsoftc[mi->mi_unit]; 782 int npf, o; 783 int bn, cn, tn, sn; 784 int bcr; 785 786 bcr = MASKREG(-mbp->mba_bcr); 787 if (bp->b_flags & B_BAD) 788 npf = bp->b_error; 789 else 790 npf = btop(bp->b_bcount - bcr); 791 o = (int)bp->b_un.b_addr & PGOFSET; 792 bn = dkblock(bp); 793 cn = bp->b_cylin; 794 sn = bn%(st->nspc) + npf; 795 tn = sn/st->nsect; 796 sn %= st->nsect; 797 cn += tn/st->ntrak; 798 tn %= st->ntrak; 799 switch (flag) { 800 case ECC: { 801 register int i; 802 caddr_t addr; 803 struct pte mpte; 804 int bit, byte, mask; 805 806 npf--; /* because block in error is previous block */ 807 bn--; 808 if (bp->b_flags & B_BAD) 809 bn = sc->sc_badbn; 810 log(KERN_RECOV, "hp%d%c: soft ecc sn%d\n", dkunit(bp), 811 'a'+(minor(bp->b_dev)&07), bn); 812 mask = MASKREG(rp->hpec2); 813 i = MASKREG(rp->hpec1) - 1; /* -1 makes 0 origin */ 814 bit = i&07; 815 i = (i&~07)>>3; 816 byte = i + o; 817 while (i < 512 && (int)ptob(npf)+i < bp->b_bcount && bit > -11) { 818 mpte = mbp->mba_map[npf+btop(byte)]; 819 addr = ptob(mpte.pg_pfnum) + (byte & PGOFSET); 820 putmemc(addr, getmemc(addr)^(mask<<bit)); 821 byte++; 822 i++; 823 bit -= 8; 824 } 825 if (bcr == 0) 826 return (0); 827 npf++; 828 break; 829 } 830 831 case SSE: 832 rp->hpof |= HPOF_SSEI; 833 if (bp->b_flags & B_BAD) { 834 bn = sc->sc_badbn; 835 goto fixregs; 836 } 837 mbp->mba_bcr = -(bp->b_bcount - (int)ptob(npf)); 838 break; 839 840 case BSE: 841 if (rp->hpof & HPOF_SSEI) 842 sn++; 843 #ifdef HPBDEBUG 844 if (hpbdebug) 845 printf("hpecc, BSE: bn %d cn %d tn %d sn %d\n", bn, cn, tn, sn); 846 #endif 847 if (bp->b_flags & B_BAD) 848 return (0); 849 if ((bn = isbad(&hpbad[mi->mi_unit], cn, tn, sn)) < 0) 850 return (0); 851 bp->b_flags |= B_BAD; 852 bp->b_error = npf + 1; 853 rp->hpof &= ~HPOF_SSEI; 854 bn = st->ncyl*st->nspc - st->nsect - 1 - bn; 855 sc->sc_badbn = bn; 856 fixregs: 857 cn = bn/st->nspc; 858 sn = bn%st->nspc; 859 tn = sn/st->nsect; 860 sn %= st->nsect; 861 mbp->mba_bcr = -512; 862 #ifdef HPBDEBUG 863 if (hpbdebug) 864 printf("revector to cn %d tn %d sn %d\n", cn, tn, sn); 865 #endif 866 break; 867 868 case CONT: 869 #ifdef HPBDEBUG 870 if (hpbdebug) 871 printf("hpecc, CONT: bn %d cn %d tn %d sn %d\n", bn,cn,tn,sn); 872 #endif 873 bp->b_flags &= ~B_BAD; 874 mbp->mba_bcr = -(bp->b_bcount - (int)ptob(npf)); 875 if (MASKREG(mbp->mba_bcr) == 0) 876 return (0); 877 break; 878 } 879 rp->hpcs1 = HP_DCLR|HP_GO; 880 if (rp->hpof & HPOF_SSEI) 881 sn++; 882 rp->hpdc = cn; 883 rp->hpda = (tn<<8) + sn; 884 mbp->mba_sr = -1; 885 mbp->mba_var = (int)ptob(npf) + o; 886 rp->hpcs1 = bp->b_flags&B_READ ? HP_RCOM|HP_GO : HP_WCOM|HP_GO; 887 mi->mi_tab.b_errcnt = 0; /* error has been corrected */ 888 sc->sc_pgdone = npf; 889 return (1); 890 } 891 892 #define DBSIZE 20 893 894 hpdump(dev) 895 dev_t dev; 896 { 897 register struct mba_device *mi; 898 register struct mba_regs *mba; 899 struct hpdevice *hpaddr; 900 char *start; 901 int num, unit; 902 register struct hpst *st; 903 904 num = maxfree; 905 start = 0; 906 unit = minor(dev) >> 3; 907 if (unit >= NHP) 908 return (ENXIO); 909 #define phys(a,b) ((b)((int)(a)&0x7fffffff)) 910 mi = phys(hpinfo[unit],struct mba_device *); 911 if (mi == 0 || mi->mi_alive == 0) 912 return (ENXIO); 913 mba = phys(mi->mi_hd, struct mba_hd *)->mh_physmba; 914 mba->mba_cr = MBCR_INIT; 915 hpaddr = (struct hpdevice *)&mba->mba_drv[mi->mi_drive]; 916 if ((hpaddr->hpds & HPDS_VV) == 0) { 917 hpaddr->hpcs1 = HP_DCLR|HP_GO; 918 hpaddr->hpcs1 = HP_PRESET|HP_GO; 919 hpaddr->hpof = HPOF_FMT22; 920 } 921 st = &hpst[mi->mi_type]; 922 if (dumplo < 0 || dumplo + num >= st->sizes[minor(dev)&07].nblocks) 923 return (EINVAL); 924 while (num > 0) { 925 register struct pte *hpte = mba->mba_map; 926 register int i; 927 int blk, cn, sn, tn; 928 daddr_t bn; 929 930 blk = num > DBSIZE ? DBSIZE : num; 931 bn = dumplo + btop(start); 932 cn = bn/st->nspc + st->sizes[minor(dev)&07].cyloff; 933 sn = bn%st->nspc; 934 tn = sn/st->nsect; 935 sn = sn%st->nsect; 936 hpaddr->hpdc = cn; 937 hpaddr->hpda = (tn << 8) + sn; 938 for (i = 0; i < blk; i++) 939 *(int *)hpte++ = (btop(start)+i) | PG_V; 940 mba->mba_sr = -1; 941 mba->mba_bcr = -(blk*NBPG); 942 mba->mba_var = 0; 943 hpaddr->hpcs1 = HP_WCOM | HP_GO; 944 while ((hpaddr->hpds & HPDS_DRY) == 0) 945 DELAY(10); 946 if (hpaddr->hpds&HPDS_ERR) 947 return (EIO); 948 start += blk*NBPG; 949 num -= blk; 950 } 951 return (0); 952 } 953 954 hpsize(dev) 955 dev_t dev; 956 { 957 int unit = minor(dev) >> 3; 958 struct mba_device *mi; 959 struct hpst *st; 960 961 if (unit >= NHP || (mi = hpinfo[unit]) == 0 || mi->mi_alive == 0) 962 return (-1); 963 st = &hpst[mi->mi_type]; 964 return ((int)st->sizes[minor(dev) & 07].nblocks); 965 } 966 #endif 967