1 /* 2 * Copyright (c) 1982 Regents of the University of California. 3 * All rights reserved. The Berkeley software License Agreement 4 * specifies the terms and conditions for redistribution. 5 * 6 * @(#)up.c 6.9 (Berkeley) 09/17/85 7 */ 8 9 #include "up.h" 10 #if NSC > 0 11 /* 12 * UNIBUS disk driver with: 13 * overlapped seeks, 14 * ECC recovery, and 15 * bad sector forwarding. 16 * 17 * TODO: 18 * Check that offset recovery code works 19 */ 20 #include "../machine/pte.h" 21 22 #include "param.h" 23 #include "systm.h" 24 #include "dk.h" 25 #include "dkbad.h" 26 #include "buf.h" 27 #include "conf.h" 28 #include "dir.h" 29 #include "user.h" 30 #include "map.h" 31 #include "vm.h" 32 #include "cmap.h" 33 #include "uio.h" 34 #include "kernel.h" 35 #include "syslog.h" 36 37 #include "../vax/cpu.h" 38 #include "../vax/nexus.h" 39 #include "ubavar.h" 40 #include "ubareg.h" 41 #include "upreg.h" 42 43 struct up_softc { 44 int sc_softas; 45 int sc_ndrive; 46 int sc_wticks; 47 int sc_recal; 48 } up_softc[NSC]; 49 50 #define upunit(dev) (minor(dev) >> 3) 51 52 /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */ 53 struct size { 54 daddr_t nblocks; 55 int cyloff; 56 } up9300_sizes[8] = { 57 15884, 0, /* A=cyl 0 thru 26 */ 58 33440, 27, /* B=cyl 27 thru 81 */ 59 495520, 0, /* C=cyl 0 thru 814 */ 60 15884, 562, /* D=cyl 562 thru 588 */ 61 55936, 589, /* E=cyl 589 thru 680 */ 62 81376, 681, /* F=cyl 681 thru 814 */ 63 153728, 562, /* G=cyl 562 thru 814 */ 64 291346, 82, /* H=cyl 82 thru 561 */ 65 }, up9766_sizes[8] = { 66 15884, 0, /* A=cyl 0 thru 26 */ 67 33440, 27, /* B=cyl 27 thru 81 */ 68 500384, 0, /* C=cyl 0 thru 822 */ 69 15884, 562, /* D=cyl 562 thru 588 */ 70 55936, 589, /* E=cyl 589 thru 680 */ 71 86240, 681, /* F=cyl 681 thru 822 */ 72 158592, 562, /* G=cyl 562 thru 822 */ 73 291346, 82, /* H=cyl 82 thru 561 */ 74 }, up160_sizes[8] = { 75 15884, 0, /* A=cyl 0 thru 49 */ 76 33440, 50, /* B=cyl 50 thru 154 */ 77 263360, 0, /* C=cyl 0 thru 822 */ 78 15884, 155, /* D=cyl 155 thru 204 */ 79 55936, 205, /* E=cyl 205 thru 379 */ 80 141664, 380, /* F=cyl 380 thru 822 */ 81 213664, 155, /* G=cyl 155 thru 822 */ 82 0, 0, 83 }, upam_sizes[8] = { 84 15884, 0, /* A=cyl 0 thru 31 */ 85 33440, 32, /* B=cyl 32 thru 97 */ 86 524288, 0, /* C=cyl 0 thru 1023 */ 87 15884, 668, /* D=cyl 668 thru 699 */ 88 55936, 700, /* E=cyl 700 thru 809 */ 89 109472, 810, /* F=cyl 810 thru 1023 */ 90 182176, 668, /* G=cyl 668 thru 1023 */ 91 291346, 98, /* H=cyl 98 thru 667 */ 92 }, up980_sizes[8] = { 93 15884, 0, /* A=cyl 0 thru 99 */ 94 33440, 100, /* B=cyl 100 thru 308 */ 95 131680, 0, /* C=cyl 0 thru 822 */ 96 15884, 309, /* D=cyl 309 thru 408 */ 97 55936, 409, /* E=cyl 409 thru 758 */ 98 10080, 759, /* F=cyl 759 thru 822 */ 99 82080, 309, /* G=cyl 309 thru 822 */ 100 0, 0, 101 }, upeagle_sizes[8] = { 102 15884, 0, /* A=cyl 0 thru 16 */ 103 66880, 17, /* B=cyl 17 thru 86 */ 104 808320, 0, /* C=cyl 0 thru 841 */ 105 15884, 391, /* D=cyl 391 thru 407 */ 106 307200, 408, /* E=cyl 408 thru 727 */ 107 109296, 728, /* F=cyl 728 thru 841 */ 108 432816, 391, /* G=cyl 391 thru 841 */ 109 291346, 87, /* H=cyl 87 thru 390 */ 110 }; 111 /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */ 112 113 int upprobe(), upslave(), upattach(), updgo(), upintr(); 114 struct uba_ctlr *upminfo[NSC]; 115 struct uba_device *updinfo[NUP]; 116 #define UPIPUNITS 8 117 struct uba_device *upip[NSC][UPIPUNITS]; /* fuji w/fixed head gives n,n+4 */ 118 119 u_short upstd[] = { 0776700, 0774400, 0776300, 0 }; 120 struct uba_driver scdriver = 121 { upprobe, upslave, upattach, updgo, upstd, "up", updinfo, "sc", upminfo }; 122 struct buf uputab[NUP]; 123 char upinit[NUP]; 124 125 struct upst { 126 short nsect; /* # sectors/track */ 127 short ntrak; /* # tracks/cylinder */ 128 short nspc; /* # sectors/cylinder */ 129 short ncyl; /* # cylinders */ 130 struct size *sizes; /* partition tables */ 131 short sdist; /* seek distance metric */ 132 short rdist; /* rotational distance metric */ 133 } upst[] = { 134 { 32, 19, 32*19, 815, up9300_sizes, 3, 4 }, /* 9300 */ 135 { 32, 19, 32*19, 823, up9766_sizes, 3, 4 }, /* 9766 */ 136 { 32, 10, 32*10, 823, up160_sizes, 3, 4 }, /* fuji 160m */ 137 { 32, 16, 32*16, 1024, upam_sizes, 7, 8 }, /* Capricorn */ 138 { 32, 5, 32*5, 823, up980_sizes, 3, 4 }, /* DM980 */ 139 { 48, 20, 48*20, 842, upeagle_sizes, 15, 8 }, /* EAGLE */ 140 { 0, 0, 0, 0, 0, 0, 0 } 141 }; 142 143 u_char up_offset[16] = { 144 UPOF_P400, UPOF_M400, UPOF_P400, UPOF_M400, 145 UPOF_P800, UPOF_M800, UPOF_P800, UPOF_M800, 146 UPOF_P1200, UPOF_M1200, UPOF_P1200, UPOF_M1200, 147 0, 0, 0, 0 148 }; 149 150 struct buf rupbuf[NUP]; 151 struct buf bupbuf[NUP]; 152 struct dkbad upbad[NUP]; 153 154 #define b_cylin b_resid 155 156 int upwstart, upwatch(); /* Have started guardian */ 157 int upseek; 158 int upwaitdry; 159 160 /*ARGSUSED*/ 161 upprobe(reg) 162 caddr_t reg; 163 { 164 register int br, cvec; 165 166 #ifdef lint 167 br = 0; cvec = br; br = cvec; upintr(0); 168 #endif 169 ((struct updevice *)reg)->upcs1 = UP_IE|UP_RDY; 170 DELAY(10); 171 ((struct updevice *)reg)->upcs1 = 0; 172 return (sizeof (struct updevice)); 173 } 174 175 upslave(ui, reg) 176 struct uba_device *ui; 177 caddr_t reg; 178 { 179 register struct updevice *upaddr = (struct updevice *)reg; 180 181 upaddr->upcs1 = 0; /* conservative */ 182 upaddr->upcs2 = ui->ui_slave; 183 upaddr->upcs1 = UP_NOP|UP_GO; 184 if (upaddr->upcs2&UPCS2_NED) { 185 upaddr->upcs1 = UP_DCLR|UP_GO; 186 return (0); 187 } 188 return (1); 189 } 190 191 upattach(ui) 192 register struct uba_device *ui; 193 { 194 195 if (upwstart == 0) { 196 timeout(upwatch, (caddr_t)0, hz); 197 upwstart++; 198 } 199 if (ui->ui_dk >= 0) 200 dk_mspw[ui->ui_dk] = .0000020345; 201 upip[ui->ui_ctlr][ui->ui_slave] = ui; 202 up_softc[ui->ui_ctlr].sc_ndrive++; 203 ui->ui_type = upmaptype(ui); 204 } 205 206 upmaptype(ui) 207 register struct uba_device *ui; 208 { 209 register struct updevice *upaddr = (struct updevice *)ui->ui_addr; 210 int type = ui->ui_type; 211 register struct upst *st; 212 213 upaddr->upcs1 = 0; 214 upaddr->upcs2 = ui->ui_slave; 215 upaddr->uphr = UPHR_MAXTRAK; 216 for (st = upst; st->nsect != 0; st++) 217 if (upaddr->uphr == st->ntrak - 1) { 218 type = st - upst; 219 break; 220 } 221 if (st->nsect == 0) 222 printf("up%d: uphr=%x\n", ui->ui_slave, upaddr->uphr); 223 if (type == 0) { 224 upaddr->uphr = UPHR_MAXCYL; 225 if (upaddr->uphr == 822) 226 type++; 227 } 228 upaddr->upcs2 = UPCS2_CLR; 229 return (type); 230 } 231 232 upopen(dev) 233 dev_t dev; 234 { 235 register int unit = upunit(dev); 236 register struct uba_device *ui; 237 238 if (unit >= NUP || (ui = updinfo[unit]) == 0 || ui->ui_alive == 0) 239 return (ENXIO); 240 return (0); 241 } 242 243 upstrategy(bp) 244 register struct buf *bp; 245 { 246 register struct uba_device *ui; 247 register struct upst *st; 248 register int unit; 249 register struct buf *dp; 250 int xunit = minor(bp->b_dev) & 07; 251 long bn, sz; 252 int s; 253 254 sz = (bp->b_bcount+511) >> 9; 255 unit = upunit(bp->b_dev); 256 if (unit >= NUP) { 257 bp->b_error = ENXIO; 258 goto bad; 259 } 260 ui = updinfo[unit]; 261 if (ui == 0 || ui->ui_alive == 0) { 262 bp->b_error = ENXIO; 263 goto bad; 264 } 265 st = &upst[ui->ui_type]; 266 if (bp->b_blkno < 0 || 267 (bn = bp->b_blkno)+sz > st->sizes[xunit].nblocks) { 268 if (bp->b_blkno == st->sizes[xunit].nblocks) { 269 bp->b_resid = bp->b_bcount; 270 goto done; 271 } 272 bp->b_error = EINVAL; 273 goto bad; 274 } 275 bp->b_cylin = bn/st->nspc + st->sizes[xunit].cyloff; 276 s = spl5(); 277 dp = &uputab[ui->ui_unit]; 278 disksort(dp, bp); 279 if (dp->b_active == 0) { 280 (void) upustart(ui); 281 bp = &ui->ui_mi->um_tab; 282 if (bp->b_actf && bp->b_active == 0) 283 (void) upstart(ui->ui_mi); 284 } 285 splx(s); 286 return; 287 288 bad: 289 bp->b_flags |= B_ERROR; 290 done: 291 iodone(bp); 292 return; 293 } 294 295 /* 296 * Unit start routine. 297 * Seek the drive to be where the data is 298 * and then generate another interrupt 299 * to actually start the transfer. 300 * If there is only one drive on the controller, 301 * or we are very close to the data, don't 302 * bother with the search. If called after 303 * searching once, don't bother to look where 304 * we are, just queue for transfer (to avoid 305 * positioning forever without transferrring.) 306 */ 307 upustart(ui) 308 register struct uba_device *ui; 309 { 310 register struct buf *bp, *dp; 311 register struct uba_ctlr *um; 312 register struct updevice *upaddr; 313 register struct upst *st; 314 daddr_t bn; 315 int sn, csn; 316 /* 317 * The SC21 cancels commands if you just say 318 * cs1 = UP_IE 319 * so we are cautious about handling of cs1. 320 * Also don't bother to clear as bits other than in upintr(). 321 */ 322 int didie = 0; 323 324 if (ui == 0) 325 return (0); 326 um = ui->ui_mi; 327 dk_busy &= ~(1<<ui->ui_dk); 328 dp = &uputab[ui->ui_unit]; 329 if ((bp = dp->b_actf) == NULL) 330 goto out; 331 /* 332 * If the controller is active, just remember 333 * that this device would like to be positioned... 334 * if we tried to position now we would confuse the SC21. 335 */ 336 if (um->um_tab.b_active) { 337 up_softc[um->um_ctlr].sc_softas |= 1<<ui->ui_slave; 338 return (0); 339 } 340 /* 341 * If we have already positioned this drive, 342 * then just put it on the ready queue. 343 */ 344 if (dp->b_active) 345 goto done; 346 dp->b_active = 1; 347 upaddr = (struct updevice *)um->um_addr; 348 upaddr->upcs2 = ui->ui_slave; 349 /* 350 * If drive has just come up, 351 * setup the pack. 352 */ 353 if ((upaddr->upds & UPDS_VV) == 0 || upinit[ui->ui_unit] == 0) { 354 struct buf *bbp = &bupbuf[ui->ui_unit]; 355 356 /* SHOULD WARN SYSTEM THAT THIS HAPPENED */ 357 upinit[ui->ui_unit] = 1; 358 upaddr->upcs1 = UP_IE|UP_DCLR|UP_GO; 359 upaddr->upcs1 = UP_IE|UP_PRESET|UP_GO; 360 upaddr->upof = UPOF_FMT22; 361 didie = 1; 362 st = &upst[ui->ui_type]; 363 bbp->b_flags = B_READ|B_BUSY; 364 bbp->b_dev = bp->b_dev; 365 bbp->b_bcount = 512; 366 bbp->b_un.b_addr = (caddr_t)&upbad[ui->ui_unit]; 367 bbp->b_blkno = st->ncyl * st->nspc - st->nsect; 368 bbp->b_cylin = st->ncyl - 1; 369 dp->b_actf = bbp; 370 bbp->av_forw = bp; 371 bp = bbp; 372 } 373 /* 374 * If drive is offline, forget about positioning. 375 */ 376 if ((upaddr->upds & (UPDS_DPR|UPDS_MOL)) != (UPDS_DPR|UPDS_MOL)) 377 goto done; 378 /* 379 * If there is only one drive, 380 * dont bother searching. 381 */ 382 if (up_softc[um->um_ctlr].sc_ndrive == 1) 383 goto done; 384 /* 385 * Figure out where this transfer is going to 386 * and see if we are close enough to justify not searching. 387 */ 388 st = &upst[ui->ui_type]; 389 bn = bp->b_blkno; 390 sn = bn%st->nspc; 391 sn = (sn + st->nsect - st->sdist) % st->nsect; 392 if (bp->b_cylin - upaddr->updc) 393 goto search; /* Not on-cylinder */ 394 else if (upseek) 395 goto done; /* Ok just to be on-cylinder */ 396 csn = (upaddr->upla>>6) - sn - 1; 397 if (csn < 0) 398 csn += st->nsect; 399 if (csn > st->nsect - st->rdist) 400 goto done; 401 search: 402 upaddr->updc = bp->b_cylin; 403 /* 404 * Not on cylinder at correct position, 405 * seek/search. 406 */ 407 if (upseek) 408 upaddr->upcs1 = UP_IE|UP_SEEK|UP_GO; 409 else { 410 upaddr->upda = sn; 411 upaddr->upcs1 = UP_IE|UP_SEARCH|UP_GO; 412 } 413 didie = 1; 414 /* 415 * Mark unit busy for iostat. 416 */ 417 if (ui->ui_dk >= 0) { 418 dk_busy |= 1<<ui->ui_dk; 419 dk_seek[ui->ui_dk]++; 420 } 421 goto out; 422 done: 423 /* 424 * Device is ready to go. 425 * Put it on the ready queue for the controller 426 * (unless its already there.) 427 */ 428 if (dp->b_active != 2) { 429 dp->b_forw = NULL; 430 if (um->um_tab.b_actf == NULL) 431 um->um_tab.b_actf = dp; 432 else 433 um->um_tab.b_actl->b_forw = dp; 434 um->um_tab.b_actl = dp; 435 dp->b_active = 2; 436 } 437 out: 438 return (didie); 439 } 440 441 /* 442 * Start up a transfer on a drive. 443 */ 444 upstart(um) 445 register struct uba_ctlr *um; 446 { 447 register struct buf *bp, *dp; 448 register struct uba_device *ui; 449 register struct updevice *upaddr; 450 struct upst *st; 451 daddr_t bn; 452 int dn, sn, tn, cmd, waitdry; 453 454 loop: 455 /* 456 * Pull a request off the controller queue 457 */ 458 if ((dp = um->um_tab.b_actf) == NULL) 459 return (0); 460 if ((bp = dp->b_actf) == NULL) { 461 um->um_tab.b_actf = dp->b_forw; 462 goto loop; 463 } 464 /* 465 * Mark controller busy, and 466 * determine destination of this request. 467 */ 468 um->um_tab.b_active++; 469 ui = updinfo[upunit(bp->b_dev)]; 470 bn = bp->b_blkno; 471 dn = ui->ui_slave; 472 st = &upst[ui->ui_type]; 473 sn = bn%st->nspc; 474 tn = sn/st->nsect; 475 sn %= st->nsect; 476 upaddr = (struct updevice *)ui->ui_addr; 477 /* 478 * Select drive if not selected already. 479 */ 480 if ((upaddr->upcs2&07) != dn) 481 upaddr->upcs2 = dn; 482 /* 483 * Check that it is ready and online 484 */ 485 waitdry = 0; 486 while ((upaddr->upds&UPDS_DRY) == 0) { 487 printf("up%d: ds wait ds=%o\n",upunit(bp->b_dev),upaddr->upds); 488 if (++waitdry > 512) 489 break; 490 upwaitdry++; 491 } 492 if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) { 493 printf("up%d: not ready", upunit(bp->b_dev)); 494 if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) { 495 printf("\n"); 496 um->um_tab.b_active = 0; 497 um->um_tab.b_errcnt = 0; 498 dp->b_actf = bp->av_forw; 499 dp->b_active = 0; 500 bp->b_flags |= B_ERROR; 501 iodone(bp); 502 goto loop; 503 } 504 /* 505 * Oh, well, sometimes this 506 * happens, for reasons unknown. 507 */ 508 printf(" (flakey)\n"); 509 } 510 /* 511 * Setup for the transfer, and get in the 512 * UNIBUS adaptor queue. 513 */ 514 upaddr->updc = bp->b_cylin; 515 upaddr->upda = (tn << 8) + sn; 516 upaddr->upwc = -bp->b_bcount / sizeof (short); 517 if (bp->b_flags & B_READ) 518 cmd = UP_IE|UP_RCOM|UP_GO; 519 else 520 cmd = UP_IE|UP_WCOM|UP_GO; 521 um->um_cmd = cmd; 522 (void) ubago(ui); 523 return (1); 524 } 525 526 /* 527 * Now all ready to go, stuff the registers. 528 */ 529 updgo(um) 530 struct uba_ctlr *um; 531 { 532 register struct updevice *upaddr = (struct updevice *)um->um_addr; 533 534 um->um_tab.b_active = 2; /* should now be 2 */ 535 upaddr->upba = um->um_ubinfo; 536 upaddr->upcs1 = um->um_cmd|((um->um_ubinfo>>8)&0x300); 537 } 538 539 /* 540 * Handle a disk interrupt. 541 */ 542 upintr(sc21) 543 register sc21; 544 { 545 register struct buf *bp, *dp; 546 register struct uba_ctlr *um = upminfo[sc21]; 547 register struct uba_device *ui; 548 register struct updevice *upaddr = (struct updevice *)um->um_addr; 549 register unit; 550 struct up_softc *sc = &up_softc[um->um_ctlr]; 551 int as = (upaddr->upas & 0377) | sc->sc_softas; 552 int needie = 1, waitdry; 553 554 sc->sc_wticks = 0; 555 sc->sc_softas = 0; 556 /* 557 * If controller wasn't transferring, then this is an 558 * interrupt for attention status on seeking drives. 559 * Just service them. 560 */ 561 if (um->um_tab.b_active != 2 && !sc->sc_recal) { 562 if (upaddr->upcs1 & UP_TRE) 563 upaddr->upcs1 = UP_TRE; 564 goto doattn; 565 } 566 um->um_tab.b_active = 1; 567 /* 568 * Get device and block structures, and a pointer 569 * to the uba_device for the drive. Select the drive. 570 */ 571 dp = um->um_tab.b_actf; 572 bp = dp->b_actf; 573 ui = updinfo[upunit(bp->b_dev)]; 574 dk_busy &= ~(1 << ui->ui_dk); 575 if ((upaddr->upcs2&07) != ui->ui_slave) 576 upaddr->upcs2 = ui->ui_slave; 577 if (bp->b_flags&B_BAD) { 578 if (upecc(ui, CONT)) 579 return; 580 } 581 /* 582 * Check for and process errors on 583 * either the drive or the controller. 584 */ 585 if ((upaddr->upds&UPDS_ERR) || (upaddr->upcs1&UP_TRE)) { 586 waitdry = 0; 587 while ((upaddr->upds & UPDS_DRY) == 0) { 588 if (++waitdry > 512) 589 break; 590 upwaitdry++; 591 } 592 if (upaddr->uper1&UPER1_WLE) { 593 /* 594 * Give up on write locked devices 595 * immediately. 596 */ 597 printf("up%d: write locked\n", upunit(bp->b_dev)); 598 bp->b_flags |= B_ERROR; 599 } else if (++um->um_tab.b_errcnt > 27) { 600 /* 601 * After 28 retries (16 without offset, and 602 * 12 with offset positioning) give up. 603 * If the error was header CRC, the header is 604 * screwed up, and the sector may in fact exist 605 * in the bad sector table, better check... 606 */ 607 if (upaddr->uper1&UPER1_HCRC) { 608 if (upecc(ui, BSE)) 609 return; 610 } 611 hard: 612 harderr(bp, "up"); 613 printf("cn=%d tn=%d sn=%d cs2=%b er1=%b er2=%b\n", 614 upaddr->updc, ((upaddr->upda)>>8)&077, 615 (upaddr->upda)&037, 616 upaddr->upcs2, UPCS2_BITS, 617 upaddr->uper1, UPER1_BITS, 618 upaddr->uper2, UPER2_BITS); 619 bp->b_flags |= B_ERROR; 620 } else if (upaddr->uper2 & UPER2_BSE) { 621 if (upecc(ui, BSE)) 622 return; 623 else 624 goto hard; 625 } else { 626 /* 627 * Retriable error. 628 * If a soft ecc, correct it (continuing 629 * by returning if necessary. 630 * Otherwise fall through and retry the transfer 631 */ 632 if ((upaddr->uper1&(UPER1_DCK|UPER1_ECH))==UPER1_DCK) { 633 if (upecc(ui, ECC)) 634 return; 635 } else 636 um->um_tab.b_active = 0; /* force retry */ 637 } 638 /* 639 * Clear drive error and, every eight attempts, 640 * (starting with the fourth) 641 * recalibrate to clear the slate. 642 */ 643 upaddr->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO; 644 needie = 0; 645 if ((um->um_tab.b_errcnt&07) == 4 && um->um_tab.b_active == 0) { 646 upaddr->upcs1 = UP_RECAL|UP_IE|UP_GO; 647 sc->sc_recal = 0; 648 goto nextrecal; 649 } 650 } 651 /* 652 * Advance recalibration finite state machine 653 * if recalibrate in progress, through 654 * RECAL 655 * SEEK 656 * OFFSET (optional) 657 * RETRY 658 */ 659 switch (sc->sc_recal) { 660 661 case 1: 662 upaddr->updc = bp->b_cylin; 663 upaddr->upcs1 = UP_SEEK|UP_IE|UP_GO; 664 goto nextrecal; 665 case 2: 666 if (um->um_tab.b_errcnt < 16 || (bp->b_flags&B_READ) == 0) 667 goto donerecal; 668 upaddr->upof = up_offset[um->um_tab.b_errcnt & 017] | UPOF_FMT22; 669 upaddr->upcs1 = UP_IE|UP_OFFSET|UP_GO; 670 goto nextrecal; 671 nextrecal: 672 sc->sc_recal++; 673 um->um_tab.b_active = 1; 674 return; 675 donerecal: 676 case 3: 677 sc->sc_recal = 0; 678 um->um_tab.b_active = 0; 679 break; 680 } 681 /* 682 * If still ``active'', then don't need any more retries. 683 */ 684 if (um->um_tab.b_active) { 685 /* 686 * If we were offset positioning, 687 * return to centerline. 688 */ 689 if (um->um_tab.b_errcnt >= 16) { 690 upaddr->upof = UPOF_FMT22; 691 upaddr->upcs1 = UP_RTC|UP_GO|UP_IE; 692 while (upaddr->upds & UPDS_PIP) 693 DELAY(25); 694 needie = 0; 695 } 696 um->um_tab.b_active = 0; 697 um->um_tab.b_errcnt = 0; 698 um->um_tab.b_actf = dp->b_forw; 699 dp->b_active = 0; 700 dp->b_errcnt = 0; 701 dp->b_actf = bp->av_forw; 702 bp->b_resid = (-upaddr->upwc * sizeof(short)); 703 iodone(bp); 704 /* 705 * If this unit has more work to do, 706 * then start it up right away. 707 */ 708 if (dp->b_actf) 709 if (upustart(ui)) 710 needie = 0; 711 } 712 as &= ~(1<<ui->ui_slave); 713 /* 714 * Release unibus resources and flush data paths. 715 */ 716 ubadone(um); 717 doattn: 718 /* 719 * Process other units which need attention. 720 * For each unit which needs attention, call 721 * the unit start routine to place the slave 722 * on the controller device queue. 723 */ 724 while (unit = ffs(as)) { 725 unit--; /* was 1 origin */ 726 as &= ~(1<<unit); 727 upaddr->upas = 1<<unit; 728 if (unit < UPIPUNITS && upustart(upip[sc21][unit])) 729 needie = 0; 730 } 731 /* 732 * If the controller is not transferring, but 733 * there are devices ready to transfer, start 734 * the controller. 735 */ 736 if (um->um_tab.b_actf && um->um_tab.b_active == 0) 737 if (upstart(um)) 738 needie = 0; 739 if (needie) 740 upaddr->upcs1 = UP_IE; 741 } 742 743 upread(dev, uio) 744 dev_t dev; 745 struct uio *uio; 746 { 747 register int unit = upunit(dev); 748 749 if (unit >= NUP) 750 return (ENXIO); 751 return (physio(upstrategy, &rupbuf[unit], dev, B_READ, minphys, uio)); 752 } 753 754 upwrite(dev, uio) 755 dev_t dev; 756 struct uio *uio; 757 { 758 register int unit = upunit(dev); 759 760 if (unit >= NUP) 761 return (ENXIO); 762 return (physio(upstrategy, &rupbuf[unit], dev, B_WRITE, minphys, uio)); 763 } 764 765 /* 766 * Correct an ECC error, and restart the i/o to complete 767 * the transfer if necessary. This is quite complicated because 768 * the transfer may be going to an odd memory address base and/or 769 * across a page boundary. 770 */ 771 upecc(ui, flag) 772 register struct uba_device *ui; 773 int flag; 774 { 775 register struct updevice *up = (struct updevice *)ui->ui_addr; 776 register struct buf *bp = uputab[ui->ui_unit].b_actf; 777 register struct uba_ctlr *um = ui->ui_mi; 778 register struct upst *st; 779 struct uba_regs *ubp = ui->ui_hd->uh_uba; 780 register int i; 781 caddr_t addr; 782 int reg, bit, byte, npf, mask, o, cmd, ubaddr; 783 int bn, cn, tn, sn; 784 785 /* 786 * Npf is the number of sectors transferred before the sector 787 * containing the ECC error, and reg is the UBA register 788 * mapping (the first part of) the transfer. 789 * O is offset within a memory page of the first byte transferred. 790 */ 791 if (flag == CONT) 792 npf = bp->b_error; 793 else 794 npf = btop((up->upwc * sizeof(short)) + bp->b_bcount); 795 reg = btop(um->um_ubinfo&0x3ffff) + npf; 796 o = (int)bp->b_un.b_addr & PGOFSET; 797 mask = up->upec2; 798 #ifdef UPECCDEBUG 799 printf("npf %d reg %x o %d mask %o pos %d\n", npf, reg, o, mask, 800 up->upec1); 801 #endif 802 bn = bp->b_blkno; 803 st = &upst[ui->ui_type]; 804 cn = bp->b_cylin; 805 sn = bn%st->nspc + npf; 806 tn = sn/st->nsect; 807 sn %= st->nsect; 808 cn += tn/st->ntrak; 809 tn %= st->ntrak; 810 ubapurge(um); 811 um->um_tab.b_active=2; 812 /* 813 * action taken depends on the flag 814 */ 815 switch(flag){ 816 case ECC: 817 npf--; 818 reg--; 819 mask = up->upec2; 820 log(LOG_WARNING, "up%d%c: soft ecc sn%d\n", upunit(bp->b_dev), 821 'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf); 822 /* 823 * Flush the buffered data path, and compute the 824 * byte and bit position of the error. The variable i 825 * is the byte offset in the transfer, the variable byte 826 * is the offset from a page boundary in main memory. 827 */ 828 i = up->upec1 - 1; /* -1 makes 0 origin */ 829 bit = i&07; 830 i = (i&~07)>>3; 831 byte = i + o; 832 /* 833 * Correct while possible bits remain of mask. Since mask 834 * contains 11 bits, we continue while the bit offset is > -11. 835 * Also watch out for end of this block and the end of the whole 836 * transfer. 837 */ 838 while (i < 512 && (int)ptob(npf)+i < bp->b_bcount && bit > -11) { 839 struct pte pte; 840 841 pte = ubp->uba_map[reg + btop(byte)]; 842 addr = ptob(pte.pg_pfnum) + (byte & PGOFSET); 843 #ifdef UPECCDEBUG 844 printf("addr %x map reg %x\n", 845 addr, *(int *)(&ubp->uba_map[reg+btop(byte)])); 846 printf("old: %x, ", getmemc(addr)); 847 #endif 848 putmemc(addr, getmemc(addr)^(mask<<bit)); 849 #ifdef UPECCDEBUG 850 printf("new: %x\n", getmemc(addr)); 851 #endif 852 byte++; 853 i++; 854 bit -= 8; 855 } 856 if (up->upwc == 0) 857 return (0); 858 npf++; 859 reg++; 860 break; 861 case BSE: 862 /* 863 * if not in bad sector table, return 0 864 */ 865 if ((bn = isbad(&upbad[ui->ui_unit], cn, tn, sn)) < 0) 866 return(0); 867 /* 868 * flag this one as bad 869 */ 870 bp->b_flags |= B_BAD; 871 bp->b_error = npf + 1; 872 #ifdef UPECCDEBUG 873 printf("BSE: restart at %d\n",npf+1); 874 #endif 875 bn = st->ncyl * st->nspc -st->nsect - 1 - bn; 876 cn = bn / st->nspc; 877 sn = bn % st->nspc; 878 tn = sn / st->nsect; 879 sn %= st->nsect; 880 up->upwc = -(512 / sizeof (short)); 881 #ifdef UPECCDEBUG 882 printf("revector to cn %d tn %d sn %d\n", cn, tn, sn); 883 #endif 884 break; 885 case CONT: 886 #ifdef UPECCDEBUG 887 printf("upecc, CONT: bn %d cn %d tn %d sn %d\n", bn, cn, tn, sn); 888 #endif 889 bp->b_flags &= ~B_BAD; 890 up->upwc = -((bp->b_bcount - (int)ptob(npf)) / sizeof(short)); 891 if (up->upwc == 0) 892 return(0); 893 break; 894 } 895 if (up->upwc == 0) { 896 um->um_tab.b_active = 0; 897 return (0); 898 } 899 /* 900 * Have to continue the transfer... clear the drive, 901 * and compute the position where the transfer is to continue. 902 * We have completed npf+1 sectors of the transfer already; 903 * restart at offset o of next sector (i.e. in UBA register reg+1). 904 */ 905 #ifdef notdef 906 up->uper1 = 0; 907 up->upcs1 |= UP_GO; 908 #else 909 up->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO; 910 up->updc = cn; 911 up->upda = (tn << 8) | sn; 912 ubaddr = (int)ptob(reg) + o; 913 up->upba = ubaddr; 914 cmd = (ubaddr >> 8) & 0x300; 915 cmd |= ((bp->b_flags&B_READ)?UP_RCOM:UP_WCOM)|UP_IE|UP_GO; 916 um->um_tab.b_errcnt = 0; 917 up->upcs1 = cmd; 918 #endif 919 return (1); 920 } 921 922 /* 923 * Reset driver after UBA init. 924 * Cancel software state of all pending transfers 925 * and restart all units and the controller. 926 */ 927 upreset(uban) 928 int uban; 929 { 930 register struct uba_ctlr *um; 931 register struct uba_device *ui; 932 register sc21, unit; 933 934 for (sc21 = 0; sc21 < NSC; sc21++) { 935 if ((um = upminfo[sc21]) == 0 || um->um_ubanum != uban || 936 um->um_alive == 0) 937 continue; 938 printf(" sc%d", sc21); 939 um->um_tab.b_active = 0; 940 um->um_tab.b_actf = um->um_tab.b_actl = 0; 941 up_softc[sc21].sc_recal = 0; 942 up_softc[sc21].sc_wticks = 0; 943 if (um->um_ubinfo) { 944 printf("<%d>", (um->um_ubinfo>>28)&0xf); 945 um->um_ubinfo = 0; 946 } 947 ((struct updevice *)(um->um_addr))->upcs2 = UPCS2_CLR; 948 for (unit = 0; unit < NUP; unit++) { 949 if ((ui = updinfo[unit]) == 0) 950 continue; 951 if (ui->ui_alive == 0 || ui->ui_mi != um) 952 continue; 953 uputab[unit].b_active = 0; 954 (void) upustart(ui); 955 } 956 (void) upstart(um); 957 } 958 } 959 960 /* 961 * Wake up every second and if an interrupt is pending 962 * but nothing has happened increment a counter. 963 * If nothing happens for 20 seconds, reset the UNIBUS 964 * and begin anew. 965 */ 966 upwatch() 967 { 968 register struct uba_ctlr *um; 969 register sc21, unit; 970 register struct up_softc *sc; 971 972 timeout(upwatch, (caddr_t)0, hz); 973 for (sc21 = 0; sc21 < NSC; sc21++) { 974 um = upminfo[sc21]; 975 if (um == 0 || um->um_alive == 0) 976 continue; 977 sc = &up_softc[sc21]; 978 if (um->um_tab.b_active == 0) { 979 for (unit = 0; unit < NUP; unit++) 980 if (uputab[unit].b_active && 981 updinfo[unit]->ui_mi == um) 982 goto active; 983 sc->sc_wticks = 0; 984 continue; 985 } 986 active: 987 sc->sc_wticks++; 988 if (sc->sc_wticks >= 20) { 989 sc->sc_wticks = 0; 990 printf("sc%d: lost interrupt\n", sc21); 991 ubareset(um->um_ubanum); 992 } 993 } 994 } 995 996 #define DBSIZE 20 997 998 updump(dev) 999 dev_t dev; 1000 { 1001 struct updevice *upaddr; 1002 char *start; 1003 int num, blk, unit; 1004 struct size *sizes; 1005 register struct uba_regs *uba; 1006 register struct uba_device *ui; 1007 register short *rp; 1008 struct upst *st; 1009 register int retry; 1010 1011 unit = upunit(dev); 1012 if (unit >= NUP) 1013 return (ENXIO); 1014 #define phys(cast, addr) ((cast)((int)addr & 0x7fffffff)) 1015 ui = phys(struct uba_device *, updinfo[unit]); 1016 if (ui->ui_alive == 0) 1017 return (ENXIO); 1018 uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba; 1019 ubainit(uba); 1020 upaddr = (struct updevice *)ui->ui_physaddr; 1021 DELAY(5000000); 1022 num = maxfree; 1023 upaddr->upcs2 = unit; 1024 DELAY(100); 1025 upaddr->upcs1 = UP_DCLR|UP_GO; 1026 upaddr->upcs1 = UP_PRESET|UP_GO; 1027 upaddr->upof = UPOF_FMT22; 1028 retry = 0; 1029 do { 1030 DELAY(25); 1031 if (++retry > 527) 1032 break; 1033 } while ((upaddr->upds & UP_RDY) == 0); 1034 if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) 1035 return (EFAULT); 1036 start = 0; 1037 st = &upst[ui->ui_type]; 1038 sizes = phys(struct size *, st->sizes); 1039 if (dumplo < 0) 1040 return (EINVAL); 1041 if (dumplo + num >= sizes[minor(dev)&07].nblocks) 1042 num = sizes[minor(dev)&07].nblocks - dumplo; 1043 while (num > 0) { 1044 register struct pte *io; 1045 register int i; 1046 int cn, sn, tn; 1047 daddr_t bn; 1048 1049 blk = num > DBSIZE ? DBSIZE : num; 1050 io = uba->uba_map; 1051 for (i = 0; i < blk; i++) 1052 *(int *)io++ = (btop(start)+i) | (1<<21) | UBAMR_MRV; 1053 *(int *)io = 0; 1054 bn = dumplo + btop(start); 1055 cn = bn/st->nspc + sizes[minor(dev)&07].cyloff; 1056 sn = bn%st->nspc; 1057 tn = sn/st->nsect; 1058 sn = sn%st->nsect; 1059 upaddr->updc = cn; 1060 rp = (short *) &upaddr->upda; 1061 *rp = (tn << 8) + sn; 1062 *--rp = 0; 1063 *--rp = -blk*NBPG / sizeof (short); 1064 *--rp = UP_GO|UP_WCOM; 1065 retry = 0; 1066 do { 1067 DELAY(25); 1068 if (++retry > 527) 1069 break; 1070 } while ((upaddr->upcs1 & UP_RDY) == 0); 1071 if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) { 1072 printf("up%d: not ready", unit); 1073 if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) { 1074 printf("\n"); 1075 return (EIO); 1076 } 1077 printf(" (flakey)\n"); 1078 } 1079 if (upaddr->upds&UPDS_ERR) 1080 return (EIO); 1081 start += blk*NBPG; 1082 num -= blk; 1083 } 1084 return (0); 1085 } 1086 1087 upsize(dev) 1088 dev_t dev; 1089 { 1090 int unit = upunit(dev); 1091 struct uba_device *ui; 1092 struct upst *st; 1093 1094 if (unit >= NUP || (ui = updinfo[unit]) == 0 || ui->ui_alive == 0) 1095 return (-1); 1096 st = &upst[ui->ui_type]; 1097 return (st->sizes[minor(dev) & 07].nblocks); 1098 } 1099 #endif 1100