1 /* uda.c 4.8 82/08/22 */ 2 3 #include "ra.h" 4 #if NUDA > 0 5 /* 6 * UDA50/RAxx disk device driver 7 * 8 * Restrictions: 9 * Unit numbers must be less than 8. 10 * 11 * TO DO: 12 * write dump code 13 * test on 750 14 */ 15 16 #include "../h/param.h" 17 #include "../h/systm.h" 18 #include "../h/buf.h" 19 #include "../h/conf.h" 20 #include "../h/dir.h" 21 #include "../h/user.h" 22 #include "../h/pte.h" 23 #include "../h/map.h" 24 #include "../h/vm.h" 25 #include "../h/ubareg.h" 26 #include "../h/ubavar.h" 27 #include "../h/dk.h" 28 #include "../h/cpu.h" 29 #include "../h/cmap.h" 30 #include "../h/uio.h" 31 32 int udadebug; 33 #define printd if(udadebug&1)printf 34 35 int udaerror = 0; /* set to cause hex dump of error log packets */ 36 37 /* 38 * Parameters for the communications area 39 */ 40 41 #define NRSPL2 3 /* log2 number of response packets */ 42 #define NCMDL2 3 /* log2 number of command packets */ 43 #define NRSP (1<<NRSPL2) 44 #define NCMD (1<<NCMDL2) 45 46 #include "../h/udareg.h" 47 #include "../h/mscp.h" 48 49 struct uda_softc { 50 short sc_state; /* state of controller */ 51 short sc_mapped; /* Unibus map allocated for uda struct? */ 52 int sc_ubainfo; /* Unibus mapping info */ 53 struct uda *sc_uda; /* Unibus address of uda struct */ 54 int sc_ivec; /* interrupt vector address */ 55 short sc_credits; /* transfer credits */ 56 short sc_lastcmd; /* pointer into command ring */ 57 short sc_lastrsp; /* pointer into response ring */ 58 } uda_softc[NUDA]; 59 60 /* 61 * Controller states 62 */ 63 #define S_IDLE 0 /* hasn't been initialized */ 64 #define S_STEP1 1 /* doing step 1 init */ 65 #define S_STEP2 2 /* doing step 2 init */ 66 #define S_STEP3 3 /* doing step 3 init */ 67 #define S_SCHAR 4 /* doing "set controller characteristics" */ 68 #define S_RUN 5 /* running */ 69 70 struct uda { 71 struct udaca uda_ca; /* communications area */ 72 struct mscp uda_rsp[NRSP]; /* response packets */ 73 struct mscp uda_cmd[NCMD]; /* command packets */ 74 } uda[NUDA]; 75 76 /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */ 77 struct size { 78 daddr_t nblocks; 79 daddr_t blkoff; 80 } ra_sizes[8] ={ 81 15884, 0, /* A=blk 0 thru 15883 */ 82 33440, 15884, /* B=blk 15884 thru 49323 */ 83 -1, 0, /* C=blk 0 thru end */ 84 15884, 340670, /* D=blk 340670 thru 356553 */ 85 55936, 356554, /* E=blk 356554 thru 412489 */ 86 -1, 412490, /* F=blk 412490 thru end */ 87 82080, 49324, /* G=blk 49324 thru 131403 */ 88 -1, 131404, /* H=blk 131404 thru end */ 89 }; 90 /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */ 91 92 daddr_t radsize[NRA]; /* disk size, from ONLINE end packet */ 93 94 int udprobe(), udslave(), udattach(), udintr(); 95 struct mscp *udgetcp(); 96 struct uba_ctlr *udminfo[NUDA]; 97 struct uba_device *uddinfo[NRA]; 98 struct uba_device *udip[NUDA][8]; /* 8 == max number of drives */ 99 100 u_short udstd[] = { 0772150, 0 }; 101 struct uba_driver udadriver = 102 { udprobe, udslave, udattach, 0, udstd, "ra", uddinfo, "uda", udminfo, 0 }; 103 struct buf rudbuf[NRA]; 104 struct buf udutab[NRA]; 105 struct buf udwtab[NUDA]; /* I/O wait queue, per controller */ 106 107 #define b_qsize b_resid /* queue size per drive, in udutab */ 108 #define b_ubinfo b_resid /* Unibus mapping info, per buffer */ 109 110 udprobe(reg, ctlr) 111 caddr_t reg; 112 int ctlr; 113 { 114 register int br, cvec; 115 register struct uda_softc *sc = &uda_softc[ctlr]; 116 117 #ifdef lint 118 br = 0; cvec = br; br = cvec; reg = reg; 119 udread(0, 0); udwrite(0, 0); udreset(0); udintr(0); 120 #endif 121 /* SHOULD CHECK THAT IT REALLY IS A UDA */ 122 br = 0x15; 123 cvec = sc->sc_ivec = (uba_hd[numuba].uh_lastiv -= 4); 124 return(sizeof (struct udadevice)); 125 } 126 127 udslave(ui, reg) 128 struct uba_device *ui; 129 caddr_t reg; 130 { 131 /* 132 * TOO HARD TO FIND OUT IF DISK IS THERE UNTIL 133 * INITIALIZED. WE'LL FIND OUT WHEN WE FIRST 134 * TRY TO ACCESS IT. 135 */ 136 #ifdef lint 137 ui = ui; reg = reg; 138 #endif 139 return(1); 140 } 141 142 udattach(ui) 143 register struct uba_device *ui; 144 { 145 146 if (ui->ui_dk > 0) 147 dk_mspw[ui->ui_dk] = 1.0 / (60 * 31 * 256); /* approx */ 148 ui->ui_flags = 0; 149 udip[ui->ui_ctlr][ui->ui_slave] = ui; 150 radsize[ui->ui_unit] = (daddr_t)0xffffff; /* max possible size */ 151 } 152 153 /* 154 * Open a UDA. Initialize the device and 155 * set the unit online. 156 */ 157 udopen(dev, flag) 158 dev_t dev; 159 int flag; 160 { 161 register int unit; 162 register struct uba_device *ui; 163 register struct uda_softc *sc; 164 int s; 165 166 #ifdef lint 167 flag = flag; 168 #endif 169 unit = minor(dev) >> 3; 170 if (unit >= NRA || (ui = uddinfo[unit]) == 0 || ui->ui_alive == 0) { 171 u.u_error = ENXIO; 172 return; 173 } 174 sc = &uda_softc[ui->ui_ctlr]; 175 s = spl5(); 176 if (sc->sc_state != S_RUN) { 177 if (sc->sc_state == S_IDLE) 178 udinit(ui->ui_ctlr); 179 /* wait for initialization to complete */ 180 sleep((caddr_t)ui->ui_mi, 0); 181 if (sc->sc_state != S_RUN) { 182 u.u_error = EIO; 183 return; 184 } 185 } 186 splx(s); 187 /* SHOULD PROBABLY FORCE AN ONLINE ATTEMPT 188 TO SEE IF DISK IS REALLY THERE */ 189 } 190 191 /* 192 * Initialize a UDA. Set up UBA mapping registers, 193 * initialize data structures, and start hardware 194 * initialization sequence. 195 */ 196 udinit(d) 197 int d; 198 { 199 register struct uda_softc *sc; 200 register struct uda *ud; 201 struct udadevice *udaddr; 202 struct uba_ctlr *um; 203 204 sc = &uda_softc[d]; 205 um = udminfo[d]; 206 um->um_tab.b_active++; 207 ud = &uda[d]; 208 udaddr = (struct udadevice *)um->um_addr; 209 if (sc->sc_mapped == 0) { 210 /* 211 * Map the communications area and command 212 * and response packets into Unibus address 213 * space. 214 */ 215 sc->sc_ubainfo = uballoc(um->um_ubanum, (caddr_t)ud, 216 sizeof (struct uda), 0); 217 sc->sc_uda = (struct uda *)(sc->sc_ubainfo & 0x3ffff); 218 sc->sc_mapped = 1; 219 } 220 221 /* 222 * Start the hardware initialization sequence. 223 */ 224 udaddr->udaip = 0; /* start initialization */ 225 while ((udaddr->udasa & UDA_STEP1) == 0) 226 ; 227 udaddr->udasa = UDA_ERR|(NCMDL2<<11)|(NRSPL2<<8)|UDA_IE|(sc->sc_ivec/4); 228 /* 229 * Initialization continues in interrupt routine. 230 */ 231 sc->sc_state = S_STEP1; 232 sc->sc_credits = 0; 233 } 234 235 udstrategy(bp) 236 register struct buf *bp; 237 { 238 register struct uba_device *ui; 239 register struct uba_ctlr *um; 240 register struct buf *dp; 241 register int unit; 242 int xunit = minor(bp->b_dev) & 07; 243 daddr_t sz, maxsz; 244 int s; 245 246 sz = (bp->b_bcount+511) >> 9; 247 unit = dkunit(bp); 248 if (unit >= NRA) 249 goto bad; 250 ui = uddinfo[unit]; 251 um = ui->ui_mi; 252 if (ui == 0 || ui->ui_alive == 0) 253 goto bad; 254 if ((maxsz = ra_sizes[xunit].nblocks) < 0) 255 maxsz = radsize[unit] - ra_sizes[xunit].blkoff; 256 if (bp->b_blkno < 0 || bp->b_blkno+sz > maxsz || 257 ra_sizes[xunit].blkoff >= radsize[unit]) 258 goto bad; 259 s = spl5(); 260 /* 261 * Link the buffer onto the drive queue 262 */ 263 dp = &udutab[ui->ui_unit]; 264 if (dp->b_actf == 0) 265 dp->b_actf = bp; 266 else 267 dp->b_actl->av_forw = bp; 268 dp->b_actl = bp; 269 bp->av_forw = 0; 270 /* 271 * Link the drive onto the controller queue 272 */ 273 if (dp->b_active == 0) { 274 dp->b_forw = NULL; 275 if (um->um_tab.b_actf == NULL) 276 um->um_tab.b_actf = dp; 277 else 278 um->um_tab.b_actl->b_forw = dp; 279 um->um_tab.b_actl = dp; 280 dp->b_active = 1; 281 } 282 if (um->um_tab.b_active == 0) { 283 #if defined(VAX750) 284 if (cpu == VAX_750) { 285 if (um->um_ubinfo != 0) 286 printf("uda: ubinfo %x\n",um->um_ubinfo); 287 else 288 um->um_ubinfo = 289 uballoc(um->um_ubanum, (caddr_t)0, 0, 290 UBA_NEEDBDP); 291 } 292 #endif 293 (void) udstart(um); 294 } 295 splx(s); 296 return; 297 298 bad: 299 bp->b_flags |= B_ERROR; 300 iodone(bp); 301 return; 302 } 303 304 udstart(um) 305 register struct uba_ctlr *um; 306 { 307 register struct buf *bp, *dp; 308 register struct mscp *mp; 309 register struct uda_softc *sc; 310 register struct uba_device *ui; 311 struct udadevice *udaddr; 312 int i; 313 314 sc = &uda_softc[um->um_ctlr]; 315 316 loop: 317 if ((dp = um->um_tab.b_actf) == NULL) { 318 /* 319 * Release uneeded UBA resources and return 320 */ 321 um->um_tab.b_active = 0; 322 #if defined(VAX750) 323 if (cpu == VAX_750) { 324 if (um->um_ubinfo == 0) 325 printf("uda: um_ubinfo == 0\n"); 326 else 327 ubarelse(um->um_ubanum, &um->um_ubinfo); 328 } 329 #endif 330 return (0); 331 } 332 if ((bp = dp->b_actf) == NULL) { 333 /* 334 * No more requests for this drive, remove 335 * from controller queue and look at next drive. 336 * We know we're at the head of the controller queue. 337 */ 338 dp->b_active = 0; 339 um->um_tab.b_actf = dp->b_forw; 340 goto loop; 341 } 342 um->um_tab.b_active++; 343 udaddr = (struct udadevice *)um->um_addr; 344 if ((udaddr->udasa&UDA_ERR) || sc->sc_state != S_RUN) { 345 harderr(bp, "ra"); 346 printf("udasa %o, state %d\n", udaddr->udasa&0xffff, sc->sc_state); 347 udinit(um->um_ctlr); 348 /* SHOULD REQUEUE OUTSTANDING REQUESTS, LIKE UDRESET */ 349 return (0); 350 } 351 ui = uddinfo[dkunit(bp)]; 352 /* 353 * If no credits, can't issue any commands 354 * until some outstanding commands complete. 355 */ 356 if (sc->sc_credits < 2) 357 return (0); 358 if ((mp = udgetcp(um)) == NULL) 359 return (0); 360 sc->sc_credits--; /* committed to issuing a command */ 361 if (ui->ui_flags == 0) { /* not online */ 362 mp->mscp_opcode = M_OP_ONLIN; 363 mp->mscp_unit = ui->ui_slave; 364 dp->b_active = 2; 365 um->um_tab.b_actf = dp->b_forw; /* remove from controller q */ 366 printd("uda: bring unit %d online\n", ui->ui_slave); 367 *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT; 368 i = udaddr->udaip; 369 goto loop; 370 } 371 switch (cpu) { 372 case VAX_780: 373 i = UBA_NEEDBDP|UBA_CANTWAIT; 374 break; 375 376 case VAX_750: 377 i = um->um_ubinfo|UBA_HAVEBDP|UBA_CANTWAIT; 378 break; 379 380 case VAX_730: 381 i = UBA_CANTWAIT; 382 break; 383 } 384 if ((i = ubasetup(um->um_ubanum, bp, i)) == 0) { 385 mp->mscp_opcode = M_OP_GTUNT; 386 mp->mscp_unit = ui->ui_slave; 387 *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT; 388 i = udaddr->udaip; /* initiate polling */ 389 return(1); /* wait for interrupt */ 390 } 391 mp->mscp_cmdref = (long)bp; /* pointer to get back */ 392 mp->mscp_opcode = bp->b_flags&B_READ ? M_OP_READ : M_OP_WRITE; 393 mp->mscp_unit = ui->ui_slave; 394 mp->mscp_lbn = bp->b_blkno + ra_sizes[minor(bp->b_dev)&7].blkoff; 395 mp->mscp_bytecnt = bp->b_bcount; 396 mp->mscp_buffer = (i & 0x3ffff) | (((i>>28)&0xf)<<24); 397 #if defined(VAX750) 398 if (cpu == VAX_750) 399 i &= 0xfffffff; /* mask off bdp */ 400 #endif 401 bp->b_ubinfo = i; /* save mapping info */ 402 *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT; 403 i = udaddr->udaip; /* initiate polling */ 404 if (ui->ui_dk >= 0) { 405 dk_busy |= 1<<ui->ui_dk; 406 dp->b_qsize++; 407 dk_xfer[ui->ui_dk]++; 408 dk_wds[ui->ui_dk] += bp->b_bcount>>6; 409 } 410 411 /* 412 * Move drive to the end of the controller queue 413 */ 414 if (dp->b_forw != NULL) { 415 um->um_tab.b_actf = dp->b_forw; 416 um->um_tab.b_actl->b_forw = dp; 417 um->um_tab.b_actl = dp; 418 dp->b_forw = NULL; 419 } 420 /* 421 * Move buffer to I/O wait queue 422 */ 423 dp->b_actf = bp->av_forw; 424 dp = &udwtab[um->um_ctlr]; 425 bp->av_forw = dp; 426 bp->av_back = dp->av_back; 427 dp->av_back->av_forw = bp; 428 dp->av_back = bp; 429 goto loop; 430 } 431 432 /* 433 * UDA interrupt routine. 434 */ 435 udintr(d) 436 int d; 437 { 438 register struct uba_ctlr *um = udminfo[d]; 439 register struct udadevice *udaddr = (struct udadevice *)um->um_addr; 440 struct buf *bp; 441 register int i; 442 register struct uda_softc *sc = &uda_softc[d]; 443 register struct uda *ud = &uda[d]; 444 struct uda *uud; 445 struct mscp *mp; 446 447 printd("udintr: state %d, udasa %o\n", sc->sc_state, udaddr->udasa); 448 switch (sc->sc_state) { 449 case S_IDLE: 450 printf("uda%d: random interrupt ignored\n", d); 451 return; 452 453 case S_STEP1: 454 #define STEP1MASK 0174377 455 #define STEP1GOOD (UDA_STEP2|UDA_IE|(NCMDL2<<3)|NRSPL2) 456 if ((udaddr->udasa&STEP1MASK) != STEP1GOOD) { 457 sc->sc_state = S_IDLE; 458 wakeup((caddr_t)um); 459 return; 460 } 461 udaddr->udasa = ((int)&sc->sc_uda->uda_ca.ca_ringbase)| 462 (cpu == VAX_780 ? UDA_PI : 0); 463 sc->sc_state = S_STEP2; 464 return; 465 466 case S_STEP2: 467 #define STEP2MASK 0174377 468 #define STEP2GOOD (UDA_STEP3|UDA_IE|(sc->sc_ivec/4)) 469 if ((udaddr->udasa&STEP2MASK) != STEP2GOOD) { 470 sc->sc_state = S_IDLE; 471 wakeup((caddr_t)um); 472 return; 473 } 474 udaddr->udasa = ((int)&sc->sc_uda->uda_ca.ca_ringbase)>>16; 475 sc->sc_state = S_STEP3; 476 return; 477 478 case S_STEP3: 479 #define STEP3MASK 0174000 480 #define STEP3GOOD UDA_STEP4 481 if ((udaddr->udasa&STEP3MASK) != STEP3GOOD) { 482 sc->sc_state = S_IDLE; 483 wakeup((caddr_t)um); 484 return; 485 } 486 udaddr->udasa = UDA_GO; 487 sc->sc_state = S_SCHAR; 488 489 /* 490 * Initialize the data structures. 491 */ 492 uud = sc->sc_uda; 493 for (i = 0; i < NRSP; i++) { 494 ud->uda_ca.ca_rspdsc[i] = UDA_OWN|UDA_INT| 495 (long)&uud->uda_rsp[i].mscp_cmdref; 496 ud->uda_rsp[i].mscp_dscptr = &ud->uda_ca.ca_rspdsc[i]; 497 ud->uda_rsp[i].mscp_header.uda_msglen = sizeof (struct mscp); 498 } 499 for (i = 0; i < NCMD; i++) { 500 ud->uda_ca.ca_cmddsc[i] = UDA_INT| 501 (long)&uud->uda_cmd[i].mscp_cmdref; 502 ud->uda_cmd[i].mscp_dscptr = &ud->uda_ca.ca_cmddsc[i]; 503 ud->uda_cmd[i].mscp_header.uda_msglen = sizeof (struct mscp); 504 } 505 bp = &udwtab[d]; 506 bp->av_forw = bp->av_back = bp; 507 sc->sc_lastcmd = 0; 508 sc->sc_lastrsp = 0; 509 if ((mp = udgetcp(um)) == NULL) { 510 sc->sc_state = S_IDLE; 511 wakeup((caddr_t)um); 512 return; 513 } 514 mp->mscp_opcode = M_OP_STCON; 515 mp->mscp_cntflgs = M_CF_ATTN|M_CF_MISC|M_CF_THIS; 516 *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT; 517 i = udaddr->udaip; /* initiate polling */ 518 return; 519 520 case S_SCHAR: 521 case S_RUN: 522 break; 523 524 default: 525 printf("uda%d: interrupt in unknown state %d ignored\n", 526 d, sc->sc_state); 527 return; 528 } 529 530 if (udaddr->udasa&UDA_ERR) { 531 printf("uda%d: fatal error (%o)\n", d, udaddr->udasa&0xffff); 532 udaddr->udaip = 0; 533 wakeup((caddr_t)um); 534 } 535 536 /* 537 * Check for a buffer purge request. 538 */ 539 if (ud->uda_ca.ca_bdp) { 540 /* 541 * THIS IS A KLUDGE. 542 * Maybe we should change the entire 543 * UBA interface structure. 544 */ 545 int s = spl7(); 546 547 i = um->um_ubinfo; 548 printd("uda: purge bdp %d\n", ud->uda_ca.ca_bdp); 549 um->um_ubinfo = ud->uda_ca.ca_bdp<<28; 550 ubapurge(um); 551 um->um_ubinfo = i; 552 (void) splx(s); 553 ud->uda_ca.ca_bdp = 0; 554 udaddr->udasa = 0; /* signal purge complete */ 555 } 556 557 /* 558 * Check for response ring transition. 559 */ 560 if (ud->uda_ca.ca_rspint) { 561 ud->uda_ca.ca_rspint = 0; 562 for (i = sc->sc_lastrsp;; i++) { 563 i %= NRSP; 564 if (ud->uda_ca.ca_rspdsc[i]&UDA_OWN) 565 break; 566 udrsp(um, ud, sc, i); 567 ud->uda_ca.ca_rspdsc[i] |= UDA_OWN; 568 } 569 sc->sc_lastrsp = i; 570 } 571 572 /* 573 * Check for command ring transition. 574 */ 575 if (ud->uda_ca.ca_cmdint) { 576 printd("uda: command ring transition\n"); 577 ud->uda_ca.ca_cmdint = 0; 578 } 579 (void) udstart(um); 580 } 581 582 /* 583 * Process a response packet 584 */ 585 udrsp(um, ud, sc, i) 586 register struct uba_ctlr *um; 587 register struct uda *ud; 588 register struct uda_softc *sc; 589 int i; 590 { 591 register struct mscp *mp; 592 struct uba_device *ui; 593 struct buf *dp, *bp; 594 int st; 595 596 mp = &ud->uda_rsp[i]; 597 mp->mscp_header.uda_msglen = sizeof (struct mscp); 598 sc->sc_credits += mp->mscp_header.uda_credits & 0xf; 599 if ((mp->mscp_header.uda_credits & 0xf0) > 0x10) 600 return; 601 /* 602 * If it's an error log message (datagram), 603 * pass it on for more extensive processing. 604 */ 605 if ((mp->mscp_header.uda_credits & 0xf0) == 0x10) { 606 uderror(um, (struct mslg *)mp); 607 return; 608 } 609 if (mp->mscp_unit >= 8) 610 return; 611 if ((ui = udip[um->um_ctlr][mp->mscp_unit]) == 0) 612 return; 613 st = mp->mscp_status&M_ST_MASK; 614 switch (mp->mscp_opcode) { 615 case M_OP_STCON|M_OP_END: 616 if (st == M_ST_SUCC) 617 sc->sc_state = S_RUN; 618 else 619 sc->sc_state = S_IDLE; 620 um->um_tab.b_active = 0; 621 wakeup((caddr_t)um); 622 break; 623 624 case M_OP_ONLIN|M_OP_END: 625 /* 626 * Link the drive onto the controller queue 627 */ 628 dp = &udutab[ui->ui_unit]; 629 dp->b_forw = NULL; 630 if (um->um_tab.b_actf == NULL) 631 um->um_tab.b_actf = dp; 632 else 633 um->um_tab.b_actl->b_forw = dp; 634 um->um_tab.b_actl = dp; 635 if (st == M_ST_SUCC) { 636 ui->ui_flags = 1; /* mark it online */ 637 radsize[ui->ui_unit] = (daddr_t)mp->mscp_untsize; 638 printd("uda: unit %d online\n", mp->mscp_unit); 639 } else { 640 harderr(dp->b_actf, "ra"); 641 printf("OFFLINE\n"); 642 while (bp = dp->b_actf) { 643 dp->b_actf = bp->av_forw; 644 bp->b_flags |= B_ERROR; 645 iodone(bp); 646 } 647 } 648 dp->b_active = 1; 649 break; 650 651 case M_OP_AVATN: 652 printd("uda: unit %d attention\n", mp->mscp_unit); 653 ui->ui_flags = 0; /* it went offline and we didn't notice */ 654 break; 655 656 case M_OP_READ|M_OP_END: 657 case M_OP_WRITE|M_OP_END: 658 bp = (struct buf *)mp->mscp_cmdref; 659 ubarelse(um->um_ubanum, (int *)&bp->b_ubinfo); 660 /* 661 * Unlink buffer from I/O wait queue. 662 */ 663 bp->av_back->av_forw = bp->av_forw; 664 bp->av_forw->av_back = bp->av_back; 665 dp = &udutab[ui->ui_unit]; 666 if (ui->ui_dk >= 0) 667 if (--dp->b_qsize == 0) 668 dk_busy &= ~(1<<ui->ui_dk); 669 if (st == M_ST_OFFLN || st == M_ST_AVLBL) { 670 ui->ui_flags = 0; /* mark unit offline */ 671 /* 672 * Link the buffer onto the front of the drive queue 673 */ 674 if ((bp->av_forw = dp->b_actf) == 0) 675 dp->b_actl = bp; 676 dp->b_actf = bp; 677 /* 678 * Link the drive onto the controller queue 679 */ 680 if (dp->b_active == 0) { 681 dp->b_forw = NULL; 682 if (um->um_tab.b_actf == NULL) 683 um->um_tab.b_actf = dp; 684 else 685 um->um_tab.b_actl->b_forw = dp; 686 um->um_tab.b_actl = dp; 687 dp->b_active = 1; 688 } 689 return; 690 } 691 if (st != M_ST_SUCC) { 692 harderr(bp, "ra"); 693 printf("status %o\n", mp->mscp_status); 694 bp->b_flags |= B_ERROR; 695 } 696 bp->b_resid = bp->b_bcount - mp->mscp_bytecnt; 697 iodone(bp); 698 break; 699 700 case M_OP_GTUNT|M_OP_END: 701 break; 702 703 default: 704 printf("uda: unknown packet\n"); 705 } 706 } 707 708 709 /* 710 * Process an error log message 711 * 712 * For now, just log the error on the console. 713 * Only minimal decoding is done, only "useful" 714 * information is printed. Eventually should 715 * send message to an error logger. 716 */ 717 uderror(um, mp) 718 register struct uba_ctlr *um; 719 register struct mslg *mp; 720 { 721 printf("uda%d: %s error, ", um->um_ctlr, 722 mp->mslg_flags&M_LF_SUCC ? "soft" : "hard"); 723 switch (mp->mslg_format) { 724 case M_FM_CNTERR: 725 printf("controller error, event 0%o\n", mp->mslg_event); 726 break; 727 728 case M_FM_BUSADDR: 729 printf("host memory access error, event 0%o, addr 0%o\n", 730 mp->mslg_event, *((long *)&mp->mslg_busaddr[0])); 731 break; 732 733 case M_FM_DISKTRN: 734 printf("disk transfer error, unit %d\n", mp->mslg_unit); 735 break; 736 737 case M_FM_SDI: 738 printf("SDI error, unit %d, event 0%o\n", mp->mslg_unit, 739 mp->mslg_event); 740 break; 741 742 case M_FM_SMLDSK: 743 printf("small disk error, unit %d, event 0%o, cyl %d\n", 744 mp->mslg_unit, mp->mslg_event, mp->mslg_sdecyl); 745 break; 746 747 default: 748 printf("unknown error, unit %d, format 0%o, event 0%o\n", 749 mp->mslg_unit, mp->mslg_format, mp->mslg_event); 750 } 751 752 if (udaerror) { 753 register long *p = (long *)mp; 754 register int i; 755 756 for (i = 0; i < mp->mslg_header.uda_msglen; i += sizeof(*p)) 757 printf("%x ", *p++); 758 printf("\n"); 759 } 760 } 761 762 763 /* 764 * Find an unused command packet 765 */ 766 struct mscp * 767 udgetcp(um) 768 struct uba_ctlr *um; 769 { 770 register struct mscp *mp; 771 register struct udaca *cp; 772 register struct uda_softc *sc; 773 register int i; 774 775 cp = &uda[um->um_ctlr].uda_ca; 776 sc = &uda_softc[um->um_ctlr]; 777 i = sc->sc_lastcmd; 778 if ((cp->ca_cmddsc[i] & (UDA_OWN|UDA_INT)) == UDA_INT) { 779 cp->ca_cmddsc[i] &= ~UDA_INT; 780 mp = &uda[um->um_ctlr].uda_cmd[i]; 781 mp->mscp_unit = mp->mscp_modifier = 0; 782 mp->mscp_opcode = mp->mscp_flags = 0; 783 mp->mscp_bytecnt = mp->mscp_buffer = 0; 784 mp->mscp_errlgfl = mp->mscp_copyspd = 0; 785 sc->sc_lastcmd = (i + 1) % NCMD; 786 return(mp); 787 } 788 return(NULL); 789 } 790 791 udread(dev, uio) 792 dev_t dev; 793 struct uio *uio; 794 { 795 register int unit = minor(dev) >> 3; 796 797 if (unit >= NRA) 798 u.u_error = ENXIO; 799 else 800 physio(udstrategy, &rudbuf[unit], dev, B_READ, minphys, uio); 801 } 802 803 udwrite(dev, uio) 804 dev_t dev; 805 struct uio *uio; 806 { 807 register int unit = minor(dev) >> 3; 808 809 if (unit >= NRA) 810 u.u_error = ENXIO; 811 else 812 physio(udstrategy, &rudbuf[unit], dev, B_WRITE, minphys, uio); 813 } 814 815 udreset(uban) 816 int uban; 817 { 818 register struct uba_ctlr *um; 819 register struct uba_device *ui; 820 register struct buf *bp, *dp; 821 register int unit; 822 struct buf *nbp; 823 int d; 824 825 for (d = 0; d < NUDA; d++) { 826 if ((um = udminfo[d]) == 0 || um->um_ubanum != uban || 827 um->um_alive == 0) 828 continue; 829 printf(" uda%d", d); 830 um->um_tab.b_active = 0; 831 um->um_tab.b_actf = um->um_tab.b_actl = 0; 832 uda_softc[d].sc_state = S_IDLE; 833 for (unit = 0; unit < NRA; unit++) { 834 if ((ui = uddinfo[unit]) == 0) 835 continue; 836 if (ui->ui_alive == 0 || ui->ui_mi != um) 837 continue; 838 udutab[unit].b_active = 0; 839 udutab[unit].b_qsize = 0; 840 } 841 for (bp = udwtab[d].av_forw; bp != &udwtab[d]; bp = nbp) { 842 nbp = bp->av_forw; 843 ubarelse(uban, (int *)&bp->b_ubinfo); 844 /* 845 * Link the buffer onto the drive queue 846 */ 847 dp = &udutab[dkunit(bp)]; 848 if (dp->b_actf == 0) 849 dp->b_actf = bp; 850 else 851 dp->b_actl->av_forw = bp; 852 dp->b_actl = bp; 853 bp->av_forw = 0; 854 /* 855 * Link the drive onto the controller queue 856 */ 857 if (dp->b_active == 0) { 858 dp->b_forw = NULL; 859 if (um->um_tab.b_actf == NULL) 860 um->um_tab.b_actf = dp; 861 else 862 um->um_tab.b_actl->b_forw = dp; 863 um->um_tab.b_actl = dp; 864 dp->b_active = 1; 865 } 866 } 867 udinit(d); 868 } 869 } 870 871 uddump() 872 { 873 return(ENXIO); 874 } 875