1 #ifndef lint 2 static char *sccsid = "@(#)uda.c 6.3 (Berkeley) 12/20/84"; 3 #endif lint 4 5 /************************************************************************ 6 * * 7 * Copyright (c) 1983 by * 8 * Digital Equipment Corporation, Maynard, MA * 9 * All rights reserved. * 10 * * 11 ************************************************************************/ 12 /* 13 * uda.c - UDA50A Driver 14 * 15 * Date: Jan 30 1984 16 * 17 * This thing has been beaten beyound belief. It still has two main features. 18 * 1) When this device is on the same unibus as another DMA device 19 * like a versatec or a rk07. the Udstrat routine complains that it still 20 * has a buffered data path that it shouldn't. I don't know why. 21 * 22 * decvax!rich. 23 * 24 */ 25 26 #define DEBUG 27 #define UDADEVNUM (9) /* entry in bdevsw */ 28 #include "ra.h" 29 #if NUDA > 0 || defined(BINARY) 30 /* 31 * UDA50/RAxx disk device driver 32 * 33 * Restrictions: 34 * Unit numbers must be less than 8. 35 * Partitions A and B must be the same size on all RA drives. 36 */ 37 #include "../machine/pte.h" 38 39 #include "param.h" 40 #include "systm.h" 41 #include "buf.h" 42 #include "conf.h" 43 #include "dir.h" 44 #include "user.h" 45 #include "map.h" 46 #include "vm.h" 47 #include "dk.h" 48 #include "cmap.h" 49 #include "uio.h" 50 51 #include "../vax/cpu.h" 52 #include "ubareg.h" 53 #include "ubavar.h" 54 #include "../vax/mtpr.h" 55 56 #define TENSEC (1000) 57 58 #define NRSPL2 3 /* log2 number of response packets */ 59 #define NCMDL2 3 /* log2 number of command packets */ 60 #define NRSP (1<<NRSPL2) 61 #define NCMD (1<<NCMDL2) 62 63 #include "../vaxuba/udareg.h" 64 #include "../vax/mscp.h" 65 66 #ifdef BINARY 67 68 extern struct uda_softc { 69 short sc_state; /* state of controller */ 70 short sc_mapped; /* Unibus map allocated for uda struct? */ 71 int sc_ubainfo; /* Unibus mapping info */ 72 struct uda *sc_uda; /* Unibus address of uda struct */ 73 int sc_ivec; /* interrupt vector address */ 74 short sc_credits; /* transfer credits */ 75 short sc_lastcmd; /* pointer into command ring */ 76 short sc_lastrsp; /* pointer into response ring */ 77 } uda_softc[]; 78 struct uda { 79 struct udaca uda_ca; /* communications area */ 80 struct mscp uda_rsp[NRSP]; /* response packets */ 81 struct mscp uda_cmd[NCMD]; /* command packets */ 82 } uda[]; 83 84 /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */ 85 extern struct size { 86 daddr_t nblocks; 87 daddr_t blkoff; 88 } ra25_sizes[], ra60_sizes[], ra80_sizes[], ra81_sizes[]; 89 90 91 /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */ 92 93 struct ra_info { 94 struct size *ra_sizes; /* Partion tables for drive */ 95 daddr_t radsize; /* Max user size form online pkt */ 96 unsigned ratype; /* Drive type int field */ 97 unsigned rastatus; /* Command status from */ 98 /* last onlin or GTUNT */ 99 } ra_info[]; 100 101 extern struct uba_ctlr *udminfo[]; 102 extern struct uba_device *uddinfo[]; 103 extern struct uba_device *udip[][8]; /* 8 == max number of drives */ 104 extern struct buf rudbuf[]; 105 extern struct buf udutab[]; /* Drive queue */ 106 extern struct buf udwtab[]; /* I/O wait queue, per controller */ 107 extern int udamicro[]; /* to store microcode level */ 108 109 extern int nNRA; 110 extern int nNUDA; 111 112 #else 113 114 struct uda_softc { 115 short sc_state; /* state of controller */ 116 short sc_mapped; /* Unibus map allocated for uda struct? */ 117 int sc_ubainfo; /* Unibus mapping info */ 118 struct uda *sc_uda; /* Unibus address of uda struct */ 119 int sc_ivec; /* interrupt vector address */ 120 short sc_credits; /* transfer credits */ 121 short sc_lastcmd; /* pointer into command ring */ 122 short sc_lastrsp; /* pointer into response ring */ 123 } uda_softc[NUDA]; 124 struct uda { 125 struct udaca uda_ca; /* communications area */ 126 struct mscp uda_rsp[NRSP]; /* response packets */ 127 struct mscp uda_cmd[NCMD]; /* command packets */ 128 } uda[NUDA]; 129 130 /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */ 131 struct size { 132 daddr_t nblocks; 133 daddr_t blkoff; 134 } ra25_sizes[8] = { 135 15884, 0, /* A=blk 0 thru 15883 */ 136 10032, 15884, /* B=blk 15884 thru 49323 */ 137 -1, 0, /* C=blk 0 thru end */ 138 0, 0, /* D=blk 340670 thru 356553 */ 139 0, 0, /* E=blk 356554 thru 412489 */ 140 0, 0, /* F=blk 412490 thru end */ 141 -1, 25916, /* G=blk 49324 thru 131403 */ 142 0, 0, /* H=blk 131404 thru end */ 143 }, ra60_sizes[8] = { 144 15884, 0, /* A=blk 0 thru 15883 */ 145 33440, 15884, /* B=blk 15884 thru 49323 */ 146 -1, 0, /* C=blk 0 thru end */ 147 15884, 242606, /* D=blk 242606 thru 258489 */ 148 307200, 258490, /* E=blk 258490 thru 565689 */ 149 -1, 565690, /* F=blk 565690 thru end */ 150 -1, 242606, /* G=blk 242606 thru end */ 151 193282, 49324, /* H=blk 49324 thru 242605 */ 152 }, ra80_sizes[8] = { 153 15884, 0, /* A=blk 0 thru 15883 */ 154 33440, 15884, /* B=blk 15884 thru 49323 */ 155 -1, 0, /* C=blk 0 thru end */ 156 15884, 242606, /* D=blk 242606 thru 258489 */ 157 307200, 258490, /* E=blk 258490 thru 565689 */ 158 -1, 565690, /* F=blk 565690 thru end */ 159 -1, 242606, /* G=blk 242606 thru end */ 160 193282, 49324, /* H=blk 49324 thru 242605 */ 161 }, ra81_sizes[8] ={ 162 15884, 0, /* A=blk 0 thru 15883 */ 163 33440, 15884, /* B=blk 15884 thru 49323 */ 164 -1, 0, /* C=blk 0 thru end */ 165 15884, 242606, /* D=blk 242606 thru 258489 */ 166 307200, 258490, /* E=blk 258490 thru 565689 */ 167 -1, 565690, /* F=blk 565690 thru end */ 168 -1, 242606, /* G=blk 242606 thru end */ 169 193282, 49324, /* H=blk 49324 thru 242605 */ 170 }; 171 172 struct ra_info { 173 struct size *ra_sizes; /* Partion tables for drive */ 174 daddr_t radsize; /* Max user size form online pkt */ 175 unsigned ratype; /* Drive type int field */ 176 unsigned rastatus; /* Command status from */ 177 /* last onlin or GTUNT */ 178 } ra_info[NRA]; 179 180 181 /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */ 182 struct uba_ctlr *udminfo[NUDA]; 183 struct uba_device *uddinfo[NRA]; 184 struct uba_device *udip[NUDA][8]; /* 8 == max number of drives */ 185 struct buf rudbuf[NRA]; 186 struct buf udutab[NRA]; 187 struct buf udwtab[NUDA]; /* I/O wait queue, per controller */ 188 189 190 int nNRA = NRA; 191 int nNUDA = NUDA; 192 int udamicro[NUDA]; /* to store microcode level */ 193 194 195 #endif 196 197 /* 198 * Controller states 199 */ 200 #define S_IDLE 0 /* hasn't been initialized */ 201 #define S_STEP1 1 /* doing step 1 init */ 202 #define S_STEP2 2 /* doing step 2 init */ 203 #define S_STEP3 3 /* doing step 3 init */ 204 #define S_SCHAR 4 /* doing "set controller characteristics" */ 205 #define S_RUN 5 /* running */ 206 207 208 int udaerror = 0; /* causes hex dump of packets */ 209 int udadebug = 0; 210 int uda_cp_wait = 0; /* Something to wait on for command */ 211 /* packets and or credits. */ 212 int wakeup(); 213 extern int hz; /* Should find the right include */ 214 #ifdef DEBUG 215 #define printd if (udadebug) printf 216 #define printd10 if(udadebug >= 10) printf 217 #endif 218 #define mprintf printf /* temporary JG hack until Rich fixes*/ 219 220 int udprobe(), udslave(), udattach(), udintr(); 221 struct mscp *udgetcp(); 222 223 u_short udstd[] = { 0772150, 0772550, 0777550, 0 }; 224 struct uba_driver udadriver = 225 { udprobe, udslave, udattach, 0, udstd, "ra", uddinfo, "uda", udminfo, 0 }; 226 227 #define b_qsize b_resid /* queue size per drive, in udutab */ 228 #define b_ubinfo b_resid /* Unibus mapping info, per buffer */ 229 230 udprobe(reg, ctlr) 231 caddr_t reg; 232 int ctlr; 233 { 234 register int br, cvec; 235 register struct uda_softc *sc = &uda_softc[ctlr]; 236 struct udadevice *udaddr; 237 238 int cur_time; 239 240 #ifdef lint 241 br = 0; cvec = br; br = cvec; 242 udreset(0); udintr(0); 243 #endif 244 udaddr = (struct udadevice *) reg; 245 246 sc->sc_ivec = (uba_hd[numuba].uh_lastiv -= 4); 247 udaddr->udaip = 0; /* start initialization */ 248 249 cur_time = mfpr(TODR); /* Time of day */ 250 while(cur_time + TENSEC > mfpr(TODR)){ /* wait for at most 10 secs */ 251 if((udaddr->udasa & UDA_STEP1) != 0) 252 break; 253 } 254 if(cur_time + TENSEC <= mfpr(TODR)) 255 return(0); /* Not a uda or it won't init as it */ 256 /* should within ten seconds. */ 257 udaddr->udasa=UDA_ERR|(NCMDL2<<11)|(NRSPL2<<8)|UDA_IE|(sc->sc_ivec/4); 258 while((udaddr->udasa&UDA_STEP2)==0) 259 DELAY(1000); /* intr should have */ 260 /* have happened by now */ 261 262 return(sizeof (struct udadevice)); 263 } 264 265 udslave(ui, reg) 266 struct uba_device *ui; 267 caddr_t reg; 268 { 269 register struct uba_ctlr *um = udminfo[ui->ui_ctlr]; 270 register struct uda_softc *sc = &uda_softc[ui->ui_ctlr]; 271 struct udadevice *udaddr; 272 struct mscp *mp; 273 int i; /* Something to write into to start */ 274 /* the uda polling */ 275 276 277 #ifdef lint 278 ui = ui; reg = reg; i = i; 279 #endif 280 udaddr = (struct udadevice *)um->um_addr; 281 if(sc->sc_state != S_RUN){ 282 if(!udinit(ui->ui_ctlr)) 283 return(0); 284 } 285 /* Here we will wait for the controller */ 286 /* to come into the run state or go idle. If we go idle we are in */ 287 /* touble and I don't yet know what to do so I will punt */ 288 while(sc->sc_state != S_RUN && sc->sc_state != S_IDLE); /* spin */ 289 if(sc->sc_state == S_IDLE){ /* The Uda failed to initialize */ 290 printf("UDA failed to init\n"); 291 return(0); 292 } 293 /* The controller is up so let see if the drive is there! */ 294 if(0 == (mp = udgetcp(um))){ /* ditto */ 295 printf("UDA can't get command packet\n"); 296 return(0); 297 } 298 mp->mscp_opcode = M_OP_GTUNT; /* This should give us the drive type*/ 299 mp->mscp_unit = ui->ui_slave; 300 mp->mscp_cmdref = (long) ui->ui_slave; 301 #ifdef DEBUG 302 printd("uda%d Get unit status slave %d\n",ui->ui_ctlr,ui->ui_slave); 303 #endif 304 ra_info[ui->ui_unit].rastatus = 0; /* set to zero */ 305 udip[ui->ui_ctlr][ui->ui_slave] = ui; 306 *((long *) mp->mscp_dscptr ) |= UDA_OWN | UDA_INT;/* maybe we should poll*/ 307 i = udaddr->udaip; 308 while(!ra_info[ui->ui_unit].rastatus); /* Wait for some status */ 309 udip[ui->ui_ctlr][ui->ui_slave] = 0; 310 if(!ra_info[ui->ui_unit].ratype) /* packet from a GTUNT */ 311 return(0); /* Failed No such drive */ 312 else 313 return(1); /* Got it and it is there */ 314 } 315 316 udattach(ui) 317 register struct uba_device *ui; 318 { 319 register struct uba_ctlr *um = ui->ui_mi ; 320 struct udadevice *udaddr = (struct udadevice *) um->um_addr; 321 struct mscp *mp; 322 int i; /* Something to write into to start */ 323 /* the uda polling */ 324 #ifdef lint 325 i = i; 326 #endif 327 if (ui->ui_dk >= 0) 328 dk_mspw[ui->ui_dk] = 1.0 / (60 * 31 * 256); /* approx */ 329 ui->ui_flags = 0; 330 udip[ui->ui_ctlr][ui->ui_slave] = ui; 331 /* check to see if the drive is a available if it is bring it online */ 332 /* if not then just return. open will try an online later */ 333 if(ra_info[ui->ui_unit].rastatus != M_ST_AVLBL) 334 return; /* status was set by a GTUNT */ 335 if(0 == (mp = udgetcp(um))){ /* ditto */ 336 printf("UDA can't get command packet\n"); 337 return; 338 } 339 mp->mscp_opcode = M_OP_ONLIN; 340 mp->mscp_unit = ui->ui_slave; 341 mp->mscp_cmdref = (long) ui->ui_slave; 342 #ifdef DEBUG 343 printd("uda%d ONLIN slave %d\n",ui->ui_ctlr,ui->ui_slave); 344 #endif 345 *((long *) mp->mscp_dscptr ) |= UDA_OWN | UDA_INT; 346 i = udaddr->udaip; 347 while(ui->ui_flags == 0 && ra_info[ui->ui_unit].ratype != 0); 348 } 349 350 /* 351 * Open a UDA. Initialize the device and 352 * set the unit online. 353 */ 354 udopen(dev, flag) 355 dev_t dev; 356 int flag; 357 { 358 register int unit; 359 register struct uba_device *ui; 360 register struct uda_softc *sc; 361 register struct mscp *mp; 362 register struct uba_ctlr *um; 363 struct udadevice *udaddr; 364 int s,i; 365 extern quota; 366 367 #ifdef lint 368 flag = flag; i = i; 369 #endif 370 unit = minor(dev) >> 3; 371 if (unit >= nNRA || (ui = uddinfo[unit]) == 0 || ui->ui_alive == 0) 372 return (ENXIO); 373 sc = &uda_softc[ui->ui_ctlr]; 374 s = spl5(); 375 if (sc->sc_state != S_RUN) { 376 if (sc->sc_state == S_IDLE) 377 if(!udinit(ui->ui_ctlr)){ 378 printf("uda: Controller failed to init\n"); 379 return(ENXIO); 380 } 381 /* wait for initialization to complete */ 382 timeout(wakeup,(caddr_t)ui->ui_mi,11*hz); /* to be sure*/ 383 sleep((caddr_t)ui->ui_mi, 0); 384 if (sc->sc_state != S_RUN) 385 { 386 (void) splx(s); /* added by Rich */ 387 return (EIO); 388 } 389 } 390 /* check to see if the device is really there. */ 391 /* this code was taken from Fred Canters 11 driver */ 392 um = ui->ui_mi; 393 udaddr = (struct udadevice *) um->um_addr; 394 (void) splx(s); 395 if(ui->ui_flags == 0){ 396 s = spl5(); 397 while(0 ==(mp = udgetcp(um))){ 398 uda_cp_wait++; 399 sleep(&uda_cp_wait,PSWP+1); 400 uda_cp_wait--; 401 } 402 (void) splx(s); 403 mp->mscp_opcode = M_OP_ONLIN; 404 mp->mscp_unit = ui->ui_slave; 405 mp->mscp_cmdref = (long) & ra_info[ui->ui_unit].ratype; 406 /* need to sleep on something */ 407 #ifdef DEBUG 408 printd("uda: bring unit %d online\n",ui->ui_unit); 409 #endif 410 *((long *) mp->mscp_dscptr ) |= UDA_OWN | UDA_INT ; 411 i = udaddr->udaip; 412 timeout(wakeup,(caddr_t) mp->mscp_cmdref,10 * hz); 413 /* make sure we wake up */ 414 sleep((caddr_t) mp->mscp_cmdref,PSWP+1); /*wakeup in udrsp() */ 415 } 416 if(ui->ui_flags == 0){ 417 return(ENXIO); /* Didn't go online */ 418 } 419 return (0); 420 } 421 422 /* 423 * Initialize a UDA. Set up UBA mapping registers, 424 * initialize data structures, and start hardware 425 * initialization sequence. 426 */ 427 udinit(d) 428 int d; 429 { 430 register struct uda_softc *sc; 431 register struct uda *ud; 432 struct udadevice *udaddr; 433 struct uba_ctlr *um; 434 435 sc = &uda_softc[d]; 436 um = udminfo[d]; 437 um->um_tab.b_active++; 438 ud = &uda[d]; 439 udaddr = (struct udadevice *)um->um_addr; 440 if (sc->sc_mapped == 0) { 441 /* 442 * Map the communications area and command 443 * and response packets into Unibus address 444 * space. 445 */ 446 sc->sc_ubainfo = uballoc(um->um_ubanum, (caddr_t)ud, 447 sizeof (struct uda), 0); 448 sc->sc_uda = (struct uda *)(sc->sc_ubainfo & 0x3ffff); 449 sc->sc_mapped = 1; 450 } 451 452 /* 453 * Start the hardware initialization sequence. 454 */ 455 456 udaddr->udaip = 0; /* start initialization */ 457 458 while((udaddr->udasa & UDA_STEP1) == 0){ 459 if(udaddr->udasa & UDA_ERR) 460 return(0); /* CHECK */ 461 } 462 udaddr->udasa=UDA_ERR|(NCMDL2<<11)|(NRSPL2<<8)|UDA_IE|(sc->sc_ivec/4); 463 /* 464 * Initialization continues in interrupt routine. 465 */ 466 sc->sc_state = S_STEP1; 467 sc->sc_credits = 0; 468 return(1); 469 } 470 471 udstrategy(bp) 472 register struct buf *bp; 473 { 474 register struct uba_device *ui; 475 register struct uba_ctlr *um; 476 register struct buf *dp; 477 register int unit; 478 register struct size *rasizes; 479 int xunit = minor(bp->b_dev) & 07; 480 daddr_t sz, maxsz; 481 int s; 482 483 sz = (bp->b_bcount+511) >> 9; 484 unit = dkunit(bp); 485 if (unit >= nNRA) 486 goto bad; 487 rasizes = ra_info[unit].ra_sizes; 488 ui = uddinfo[unit]; 489 um = ui->ui_mi; 490 if (ui == 0 || ui->ui_alive == 0) 491 goto bad; 492 if ((maxsz = rasizes[xunit].nblocks) < 0) 493 maxsz = ra_info[unit].radsize - rasizes[xunit].blkoff; 494 if (bp->b_blkno < 0 || bp->b_blkno+sz > maxsz || 495 rasizes[xunit].blkoff >= ra_info[unit].radsize) 496 goto bad; 497 s = spl5(); 498 /* 499 * Link the buffer onto the drive queue 500 */ 501 dp = &udutab[ui->ui_unit]; 502 if (dp->b_actf == 0) 503 dp->b_actf = bp; 504 else 505 dp->b_actl->av_forw = bp; 506 dp->b_actl = bp; 507 bp->av_forw = 0; 508 /* 509 * Link the drive onto the controller queue 510 */ 511 if (dp->b_active == 0) { 512 dp->b_forw = NULL; 513 if (um->um_tab.b_actf == NULL) 514 um->um_tab.b_actf = dp; 515 else 516 um->um_tab.b_actl->b_forw = dp; 517 um->um_tab.b_actl = dp; 518 dp->b_active = 1; 519 } 520 if (um->um_tab.b_active == 0) { 521 #if defined(VAX750) 522 if (cpu == VAX_750 523 && udwtab[um->um_ctlr].av_forw == &udwtab[um->um_ctlr]) { 524 if (um->um_ubinfo != 0) { 525 printd("udastrat: ubinfo 0x%x\n",um->um_ubinfo); 526 } else 527 um->um_ubinfo = 528 uballoc(um->um_ubanum, (caddr_t)0, 0, 529 UBA_NEEDBDP); 530 } 531 #endif 532 (void) udstart(um); 533 } 534 splx(s); 535 return; 536 537 bad: 538 bp->b_flags |= B_ERROR; 539 iodone(bp); 540 return; 541 } 542 543 udstart(um) 544 register struct uba_ctlr *um; 545 { 546 register struct buf *bp, *dp; 547 register struct mscp *mp; 548 register struct uda_softc *sc; 549 register struct uba_device *ui; 550 struct size *rasizes; 551 struct udadevice *udaddr; 552 struct uda *ud = &uda[um->um_ctlr]; 553 int i; 554 555 sc = &uda_softc[um->um_ctlr]; 556 557 loop: 558 if ((dp = um->um_tab.b_actf) == NULL) { 559 /* 560 * Release uneeded UBA resources and return 561 */ 562 um->um_tab.b_active = 0; 563 /* Check for response ring transitions lost in the 564 * Race condition 565 */ 566 for (i = sc->sc_lastrsp;; i++) { 567 i %= NRSP; 568 if (ud->uda_ca.ca_rspdsc[i]&UDA_OWN) 569 break; 570 udrsp(um, ud, sc, i); 571 ud->uda_ca.ca_rspdsc[i] |= UDA_OWN; 572 } 573 sc->sc_lastrsp = i; 574 return (0); 575 } 576 if ((bp = dp->b_actf) == NULL) { 577 /* 578 * No more requests for this drive, remove 579 * from controller queue and look at next drive. 580 * We know we're at the head of the controller queue. 581 */ 582 dp->b_active = 0; 583 um->um_tab.b_actf = dp->b_forw; 584 goto loop; /* Need to check for loop */ 585 } 586 um->um_tab.b_active++; 587 udaddr = (struct udadevice *)um->um_addr; 588 if ((udaddr->udasa&UDA_ERR) || sc->sc_state != S_RUN) { 589 harderr(bp, "ra"); 590 mprintf("Uda%d udasa %o, state %d\n",um->um_ctlr , udaddr->udasa&0xffff, sc->sc_state); 591 udinit(um->um_ctlr); 592 /* SHOULD REQUEUE OUTSTANDING REQUESTS, LIKE UDRESET */ 593 return (0); 594 } 595 ui = uddinfo[dkunit(bp)]; 596 rasizes = ra_info[ui->ui_unit].ra_sizes; 597 if (ui->ui_flags == 0) { /* not online */ 598 if ((mp = udgetcp(um)) == NULL){ 599 return (0); 600 } 601 mp->mscp_opcode = M_OP_ONLIN; 602 mp->mscp_unit = ui->ui_slave; 603 dp->b_active = 2; 604 um->um_tab.b_actf = dp->b_forw; /* remove from controller q */ 605 #ifdef DEBUG 606 printd("uda: bring unit %d online\n", ui->ui_slave); 607 #endif 608 *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT; 609 if (udaddr->udasa&UDA_ERR) 610 printf("Uda (%d) Error (%x)\n",um->um_ctlr , udaddr->udasa&0xffff); 611 i = udaddr->udaip; 612 goto loop; 613 } 614 switch (cpu) { 615 case VAX_780: 616 i = UBA_NEEDBDP|UBA_CANTWAIT; 617 break; 618 619 case VAX_750: 620 i = um->um_ubinfo|UBA_HAVEBDP|UBA_CANTWAIT; 621 break; 622 623 case VAX_730: 624 i = UBA_CANTWAIT; 625 break; 626 } 627 if ((i = ubasetup(um->um_ubanum, bp, i)) == 0) { 628 if(dp->b_qsize != 0){ 629 return(0); /* When a command completes and */ 630 /* frees a bdp udstart will be called */ 631 } 632 if ((mp = udgetcp(um)) == NULL){ 633 return (0); 634 } 635 mp->mscp_opcode = M_OP_GTUNT; 636 mp->mscp_unit = ui->ui_slave; 637 *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT; 638 if (udaddr->udasa&UDA_ERR) 639 printf("Uda(%d) udasa (%x)\n",um->um_ctlr, udaddr->udasa&0xffff); 640 i = udaddr->udaip; /* initiate polling */ 641 return(1); /* wait for interrupt */ 642 } 643 if ((mp = udgetcp(um)) == NULL) { 644 ubarelse(um->um_ubanum,&i); 645 return(0); 646 } 647 mp->mscp_cmdref = (long)bp; /* pointer to get back */ 648 mp->mscp_opcode = bp->b_flags&B_READ ? M_OP_READ : M_OP_WRITE; 649 mp->mscp_unit = ui->ui_slave; 650 mp->mscp_lbn = bp->b_blkno + rasizes[minor(bp->b_dev)&7].blkoff; 651 mp->mscp_bytecnt = bp->b_bcount; 652 mp->mscp_buffer = (i & 0x3ffff) | (((i>>28)&0xf)<<24); 653 #if defined(VAX750) 654 if (cpu == VAX_750) 655 i &= 0xfffffff; /* mask off bdp */ 656 #endif 657 bp->b_ubinfo = i; /* save mapping info */ 658 *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT; 659 if (udaddr->udasa&UDA_ERR) 660 printf("Uda(%d) udasa (%x)\n",um->um_ctlr , udaddr->udasa&0xffff); 661 i = udaddr->udaip; /* initiate polling */ 662 dp->b_qsize++; 663 if (ui->ui_dk >= 0) { 664 dk_busy |= 1<<ui->ui_dk; 665 dk_xfer[ui->ui_dk]++; 666 dk_wds[ui->ui_dk] += bp->b_bcount>>6; 667 } 668 669 /* 670 * Move drive to the end of the controller queue 671 */ 672 if (dp->b_forw != NULL) { 673 um->um_tab.b_actf = dp->b_forw; 674 um->um_tab.b_actl->b_forw = dp; 675 um->um_tab.b_actl = dp; 676 dp->b_forw = NULL; 677 } 678 /* 679 * Move buffer to I/O wait queue 680 */ 681 dp->b_actf = bp->av_forw; 682 dp = &udwtab[um->um_ctlr]; 683 bp->av_forw = dp; 684 bp->av_back = dp->av_back; 685 dp->av_back->av_forw = bp; 686 dp->av_back = bp; 687 goto loop; 688 } 689 690 /* 691 * UDA interrupt routine. 692 */ 693 udintr(d) 694 int d; 695 { 696 register struct uba_ctlr *um = udminfo[d]; 697 register struct udadevice *udaddr = (struct udadevice *)um->um_addr; 698 struct buf *bp; 699 register int i; 700 register struct uda_softc *sc = &uda_softc[d]; 701 register struct uda *ud = &uda[d]; 702 struct uda *uud; 703 struct mscp *mp; 704 705 #ifdef DEBUG 706 printd10("udintr: state %d, udasa %o\n", sc->sc_state, udaddr->udasa); 707 #endif 708 switch (sc->sc_state) { 709 case S_IDLE: 710 printf("uda%d: random interrupt ignored\n", d); 711 return; 712 713 case S_STEP1: 714 #define STEP1MASK 0174377 715 #define STEP1GOOD (UDA_STEP2|UDA_IE|(NCMDL2<<3)|NRSPL2) 716 if ((udaddr->udasa&STEP1MASK) != STEP1GOOD) { 717 sc->sc_state = S_IDLE; 718 wakeup((caddr_t)um); 719 return; 720 } 721 udaddr->udasa = ((int)&sc->sc_uda->uda_ca.ca_ringbase)| 722 (cpu == VAX_780 ? UDA_PI : 0); 723 sc->sc_state = S_STEP2; 724 return; 725 726 case S_STEP2: 727 #define STEP2MASK 0174377 728 #define STEP2GOOD (UDA_STEP3|UDA_IE|(sc->sc_ivec/4)) 729 if ((udaddr->udasa&STEP2MASK) != STEP2GOOD) { 730 sc->sc_state = S_IDLE; 731 wakeup((caddr_t)um); 732 return; 733 } 734 udaddr->udasa = ((int)&sc->sc_uda->uda_ca.ca_ringbase)>>16; 735 sc->sc_state = S_STEP3; 736 return; 737 738 case S_STEP3: 739 #define STEP3MASK 0174000 740 #define STEP3GOOD UDA_STEP4 741 if ((udaddr->udasa&STEP3MASK) != STEP3GOOD) { 742 sc->sc_state = S_IDLE; 743 wakeup((caddr_t)um); 744 return; 745 } 746 udamicro[d] = udaddr->udasa; 747 #ifdef DEBUG 748 printd("Uda%d Version %d model %d\n",d,udamicro[d]&0xF, 749 (udamicro[d]>>4) & 0xF); 750 /* 751 * Requesting the error status (|= 2) 752 * may hang older controllers. 753 */ 754 udaddr->udasa = UDA_GO | (udaerror? 2 : 0); 755 #endif 756 udaddr->udasa = UDA_GO; 757 sc->sc_state = S_SCHAR; 758 759 /* 760 * Initialize the data structures. 761 */ 762 uud = sc->sc_uda; 763 for (i = 0; i < NRSP; i++) { 764 ud->uda_ca.ca_rspdsc[i] = UDA_OWN|UDA_INT| 765 (long)&uud->uda_rsp[i].mscp_cmdref; 766 ud->uda_rsp[i].mscp_dscptr = &ud->uda_ca.ca_rspdsc[i]; 767 ud->uda_rsp[i].mscp_header.uda_msglen = mscp_msglen; 768 } 769 for (i = 0; i < NCMD; i++) { 770 ud->uda_ca.ca_cmddsc[i] = UDA_INT| 771 (long)&uud->uda_cmd[i].mscp_cmdref; 772 ud->uda_cmd[i].mscp_dscptr = &ud->uda_ca.ca_cmddsc[i]; 773 ud->uda_cmd[i].mscp_header.uda_msglen = mscp_msglen; 774 } 775 bp = &udwtab[d]; 776 bp->av_forw = bp->av_back = bp; 777 sc->sc_lastcmd = 1; 778 sc->sc_lastrsp = 0; 779 mp = &uda[um->um_ctlr].uda_cmd[0]; 780 mp->mscp_unit = mp->mscp_modifier = 0; 781 mp->mscp_flags = 0; 782 mp->mscp_bytecnt = mp->mscp_buffer = 0; 783 mp->mscp_errlgfl = mp->mscp_copyspd = 0; 784 mp->mscp_opcode = M_OP_STCON; 785 mp->mscp_cntflgs = M_CF_ATTN|M_CF_MISC|M_CF_THIS; 786 *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT; 787 i = udaddr->udaip; /* initiate polling */ 788 return; 789 790 case S_SCHAR: 791 case S_RUN: 792 break; 793 794 default: 795 printf("uda%d: interrupt in unknown state %d ignored\n", 796 d, sc->sc_state); 797 return; 798 } 799 800 if (udaddr->udasa&UDA_ERR) { 801 printf("uda(%d): fatal error (%o)\n", d, udaddr->udasa&0xffff); 802 udaddr->udaip = 0; 803 wakeup((caddr_t)um); 804 } 805 806 /* 807 * Check for a buffer purge request. 808 */ 809 if (ud->uda_ca.ca_bdp) { 810 /* 811 * THIS IS A KLUDGE. 812 * Maybe we should change the entire 813 * UBA interface structure. 814 */ 815 int s = spl6(); /* was spl7 but I don't like turning */ 816 /* off machine checks */ 817 i = um->um_ubinfo; 818 #ifdef DEBUG 819 printd("uda: purge bdp %d\n", ud->uda_ca.ca_bdp); 820 #endif 821 um->um_ubinfo = ud->uda_ca.ca_bdp<<28; 822 ubapurge(um); 823 um->um_ubinfo = i; 824 (void) splx(s); 825 ud->uda_ca.ca_bdp = 0; 826 udaddr->udasa = 0; /* signal purge complete */ 827 } 828 829 /* 830 * Check for response ring transition. 831 */ 832 if (ud->uda_ca.ca_rspint) { 833 ud->uda_ca.ca_rspint = 0; 834 for (i = sc->sc_lastrsp;; i++) { 835 i %= NRSP; 836 if (ud->uda_ca.ca_rspdsc[i]&UDA_OWN) 837 break; 838 udrsp(um, ud, sc, i); 839 ud->uda_ca.ca_rspdsc[i] |= UDA_OWN; 840 } 841 sc->sc_lastrsp = i; 842 } 843 844 /* 845 * Check for command ring transition. 846 */ 847 if (ud->uda_ca.ca_cmdint) { 848 #ifdef DEBUG 849 printd("uda: command ring transition\n"); 850 #endif 851 ud->uda_ca.ca_cmdint = 0; 852 } 853 if(uda_cp_wait) 854 wakeup(&uda_cp_wait); 855 (void) udstart(um); 856 } 857 858 /* 859 * Process a response packet 860 */ 861 udrsp(um, ud, sc, i) 862 register struct uba_ctlr *um; 863 register struct uda *ud; 864 register struct uda_softc *sc; 865 int i; 866 { 867 register struct mscp *mp; 868 struct uba_device *ui; 869 struct buf *dp, *bp,nullbp; 870 int st; 871 872 mp = &ud->uda_rsp[i]; 873 mp->mscp_header.uda_msglen = mscp_msglen; 874 sc->sc_credits += mp->mscp_header.uda_credits & 0xf; /* just 4 bits?*/ 875 if ((mp->mscp_header.uda_credits & 0xf0) > 0x10) /* Check */ 876 return; 877 #ifdef DEBUG 878 printd10("udarsp, opcode 0x%x status 0x%x\n",mp->mscp_opcode,mp->mscp_status); 879 #endif 880 /* 881 * If it's an error log message (datagram), 882 * pass it on for more extensive processing. 883 */ 884 if ((mp->mscp_header.uda_credits & 0xf0) == 0x10) { /* check */ 885 uderror(um, (struct mslg *)mp); 886 return; 887 } 888 st = mp->mscp_status&M_ST_MASK; 889 /* The controller interrupts as drive 0 */ 890 /* this means that you must check for controller interrupts */ 891 /* before you check to see if there is a drive 0 */ 892 if((M_OP_STCON|M_OP_END) == mp->mscp_opcode){ 893 if (st == M_ST_SUCC) 894 sc->sc_state = S_RUN; 895 else 896 sc->sc_state = S_IDLE; 897 um->um_tab.b_active = 0; 898 wakeup((caddr_t)um); 899 return; 900 } 901 if (mp->mscp_unit >= 8) 902 return; 903 if ((ui = udip[um->um_ctlr][mp->mscp_unit]) == 0) 904 return; 905 switch (mp->mscp_opcode) { 906 907 case M_OP_ONLIN|M_OP_END: 908 ra_info[ui->ui_unit].rastatus = st; 909 ra_info[ui->ui_unit].ratype = mp->mscp_mediaid; 910 dp = &udutab[ui->ui_unit]; 911 if (st == M_ST_SUCC) { 912 /* 913 * Link the drive onto the controller queue 914 */ 915 dp->b_forw = NULL; 916 if (um->um_tab.b_actf == NULL) 917 um->um_tab.b_actf = dp; 918 else 919 um->um_tab.b_actl->b_forw = dp; 920 um->um_tab.b_actl = dp; 921 ui->ui_flags = 1; /* mark it online */ 922 ra_info[ui->ui_unit].radsize=(daddr_t)mp->mscp_untsize; 923 #ifdef DEBUG 924 printd("uda: unit %d online\n", mp->mscp_unit); 925 #endif 926 #define F_to_C(x,i) ( ((x)->mscp_mediaid) >> (i*5+7) & 0x1f ? ( ( (((x)->mscp_mediaid) >>( i*5 + 7)) & 0x1f) + 'A' - 1): ' ') 927 /* this mess decodes the Media type identifier */ 928 #ifdef DEBUG 929 printd("uda: unit %d online %x %c%c %c%c%c%d\n" 930 ,mp->mscp_unit, mp->mscp_mediaid 931 ,F_to_C(mp,4),F_to_C(mp,3),F_to_C(mp,2) 932 ,F_to_C(mp,1),F_to_C(mp,0) 933 ,mp->mscp_mediaid & 0x7f); 934 #endif 935 switch(mp->mscp_mediaid & 0x7f){ 936 case 25: 937 ra_info[ui->ui_unit].ra_sizes = ra25_sizes; 938 break; 939 case 60: 940 ra_info[ui->ui_unit].ra_sizes = ra60_sizes; 941 break; 942 case 80: 943 ra_info[ui->ui_unit].ra_sizes = ra80_sizes; 944 break; 945 case 81: 946 ra_info[ui->ui_unit].ra_sizes = ra81_sizes; 947 break; 948 default: 949 ui->ui_flags = 0; /* mark it offline */ 950 ra_info[ui->ui_unit].ratype = 0; 951 printf("Don't have a parition table for "); 952 printf("a %c%c %c%c%c%d\n" 953 ,F_to_C(mp,4),F_to_C(mp,3),F_to_C(mp,2) 954 ,F_to_C(mp,1),F_to_C(mp,0) 955 ,mp->mscp_mediaid & 0x7f); 956 while (bp = dp->b_actf) { 957 dp->b_actf = bp->av_forw; 958 bp->b_flags |= B_ERROR; 959 iodone(bp); 960 } 961 } 962 dp->b_active = 1; 963 } else { 964 if(dp->b_actf){ 965 harderr(dp->b_actf,"ra"); 966 } else { 967 nullbp.b_blkno = 0; 968 nullbp.b_dev = makedev(UDADEVNUM,ui->ui_unit); 969 harderr(&nullbp, "ra"); 970 } 971 printf("OFFLINE\n"); 972 while (bp = dp->b_actf) { 973 dp->b_actf = bp->av_forw; 974 bp->b_flags |= B_ERROR; 975 iodone(bp); 976 } 977 } 978 if(mp->mscp_cmdref!=NULL){/* Seems to get lost sometimes */ 979 wakeup((caddr_t *) mp->mscp_cmdref); 980 } 981 break; 982 983 /* 984 * The AVAILABLE ATTENTION messages occurs when the 985 * unit becomes available after spinup, 986 * marking the unit offline will force an online command 987 * prior to using the unit. 988 */ 989 case M_OP_AVATN: 990 #ifdef DEBUG 991 printd("uda: unit %d attention\n", mp->mscp_unit); 992 #endif 993 ui->ui_flags = 0; /* it went offline and we didn't notice */ 994 ra_info[ui->ui_unit].ratype = mp->mscp_mediaid; 995 break; 996 997 case M_OP_END: 998 /* 999 * An endcode without an opcode (0200) is an invalid command. 1000 * The mscp specification states that this would be a protocol 1001 * type error, such as illegal opcodes. The mscp spec. also 1002 * states that parameter error type of invalid commands should 1003 * return the normal end message for the command. This does not appear 1004 * to be the case. An invalid logical block number returned an endcode 1005 * of 0200 instead of the 0241 (read) that was expected. 1006 */ 1007 1008 printf("endcd=%o, stat=%o\n", mp->mscp_opcode, mp->mscp_status); 1009 break; 1010 case M_OP_READ|M_OP_END: 1011 case M_OP_WRITE|M_OP_END: 1012 bp = (struct buf *)mp->mscp_cmdref; 1013 ubarelse(um->um_ubanum, (int *)&bp->b_ubinfo); 1014 /* 1015 * Unlink buffer from I/O wait queue. 1016 */ 1017 bp->av_back->av_forw = bp->av_forw; 1018 bp->av_forw->av_back = bp->av_back; 1019 #if defined(VAX750) 1020 if (cpu == VAX_750 1021 && udwtab[um->um_ctlr].av_forw == &udwtab[um->um_ctlr]) { 1022 if (um->um_ubinfo == 0) 1023 printf("udintr: um_ubinfo == 0\n"); 1024 else 1025 ubarelse(um->um_ubanum, &um->um_ubinfo); 1026 } 1027 #endif 1028 dp = &udutab[ui->ui_unit]; 1029 dp->b_qsize--; 1030 if (ui->ui_dk >= 0) 1031 if (dp->b_qsize == 0) 1032 dk_busy &= ~(1<<ui->ui_dk); 1033 if (st == M_ST_OFFLN || st == M_ST_AVLBL) { 1034 ui->ui_flags = 0; /* mark unit offline */ 1035 /* 1036 * Link the buffer onto the front of the drive queue 1037 */ 1038 if ((bp->av_forw = dp->b_actf) == 0) 1039 dp->b_actl = bp; 1040 dp->b_actf = bp; 1041 /* 1042 * Link the drive onto the controller queue 1043 */ 1044 if (dp->b_active == 0) { 1045 dp->b_forw = NULL; 1046 if (um->um_tab.b_actf == NULL) 1047 um->um_tab.b_actf = dp; 1048 else 1049 um->um_tab.b_actl->b_forw = dp; 1050 um->um_tab.b_actl = dp; 1051 dp->b_active = 1; 1052 } 1053 #if defined(VAX750) 1054 if (cpu == VAX750 && um->um_ubinfo == 0) 1055 um->um_ubinfo = 1056 uballoc(um->um_ubanum, (caddr_t)0, 0, 1057 UBA_NEEDBDP); 1058 #endif 1059 return; 1060 } 1061 if (st != M_ST_SUCC) { 1062 harderr(bp, "ra"); 1063 #ifdef DEBUG 1064 printd("status %o\n", mp->mscp_status); 1065 #endif 1066 bp->b_flags |= B_ERROR; 1067 } 1068 bp->b_resid = bp->b_bcount - mp->mscp_bytecnt; 1069 iodone(bp); 1070 break; 1071 1072 case M_OP_GTUNT|M_OP_END: 1073 #ifdef DEBUG 1074 printd("GTUNT end packet status = 0x%x media id 0x%x\n" 1075 ,st,mp->mscp_mediaid); 1076 #endif 1077 ra_info[ui->ui_unit].rastatus = st; 1078 ra_info[ui->ui_unit].ratype = mp->mscp_mediaid; 1079 break; 1080 1081 default: 1082 printf("uda: unknown packet\n"); 1083 uderror(um, (struct mslg *)mp); 1084 } 1085 } 1086 1087 1088 /* 1089 * Process an error log message 1090 * 1091 * For now, just log the error on the console. 1092 * Only minimal decoding is done, only "useful" 1093 * information is printed. Eventually should 1094 * send message to an error logger. 1095 */ 1096 uderror(um, mp) 1097 register struct uba_ctlr *um; 1098 register struct mslg *mp; 1099 { 1100 register i; 1101 1102 1103 if(!(mp->mslg_flags & (M_LF_SUCC | M_LF_CONT))) 1104 printf("uda%d: hard error\n"); 1105 1106 mprintf("uda%d: %s error, ", um->um_ctlr, 1107 mp->mslg_flags & ( M_LF_SUCC | M_LF_CONT ) ? "soft" : "hard"); 1108 switch (mp->mslg_format) { 1109 case M_FM_CNTERR: 1110 mprintf("controller error, event 0%o\n", mp->mslg_event); 1111 break; 1112 1113 case M_FM_BUSADDR: 1114 mprintf("host memory access error, event 0%o, addr 0%o\n", 1115 mp->mslg_event, mp->mslg_busaddr); 1116 break; 1117 1118 case M_FM_DISKTRN: 1119 mprintf("disk transfer error, unit %d, grp 0x%x, hdr 0x%x, event 0%o\n", 1120 mp->mslg_unit, mp->mslg_group, mp->mslg_hdr, 1121 mp->mslg_event); 1122 break; 1123 1124 case M_FM_SDI: 1125 mprintf("SDI error, unit %d, event 0%o, hdr 0x%x\n", 1126 mp->mslg_unit, mp->mslg_event, mp->mslg_hdr); 1127 for(i = 0; i < 12;i++) 1128 mprintf("\t0x%x",mp->mslg_sdistat[i] & 0xff); 1129 mprintf("\n"); 1130 break; 1131 1132 case M_FM_SMLDSK: 1133 mprintf("small disk error, unit %d, event 0%o, cyl %d\n", 1134 mp->mslg_unit, mp->mslg_event, mp->mslg_sdecyl); 1135 break; 1136 1137 default: 1138 mprintf("unknown error, unit %d, format 0%o, event 0%o\n", 1139 mp->mslg_unit, mp->mslg_format, mp->mslg_event); 1140 } 1141 1142 if (udaerror) { 1143 register long *p = (long *)mp; 1144 1145 for (i = 0; i < mp->mslg_header.uda_msglen; i += sizeof(*p)) 1146 printf("%x ", *p++); 1147 printf("\n"); 1148 } 1149 } 1150 1151 1152 /* 1153 * Find an unused command packet 1154 */ 1155 struct mscp * 1156 udgetcp(um) 1157 struct uba_ctlr *um; 1158 { 1159 register struct mscp *mp; 1160 register struct udaca *cp; 1161 register struct uda_softc *sc; 1162 register int i; 1163 int s; 1164 1165 s = spl5(); 1166 cp = &uda[um->um_ctlr].uda_ca; 1167 sc = &uda_softc[um->um_ctlr]; 1168 /* 1169 * If no credits, can't issue any commands 1170 * until some outstanding commands complete. 1171 */ 1172 i = sc->sc_lastcmd; 1173 if(((cp->ca_cmddsc[i]&(UDA_OWN|UDA_INT))==UDA_INT)&& 1174 (sc->sc_credits >= 2)) { 1175 sc->sc_credits--; /* committed to issuing a command */ 1176 cp->ca_cmddsc[i] &= ~UDA_INT; 1177 mp = &uda[um->um_ctlr].uda_cmd[i]; 1178 mp->mscp_unit = mp->mscp_modifier = 0; 1179 mp->mscp_opcode = mp->mscp_flags = 0; 1180 mp->mscp_bytecnt = mp->mscp_buffer = 0; 1181 mp->mscp_errlgfl = mp->mscp_copyspd = 0; 1182 sc->sc_lastcmd = (i + 1) % NCMD; 1183 (void) splx(s); 1184 return(mp); 1185 } 1186 (void) splx(s); 1187 return(NULL); 1188 } 1189 1190 udread(dev, uio) 1191 dev_t dev; 1192 struct uio *uio; 1193 { 1194 register int unit = minor(dev) >> 3; 1195 1196 if (unit >= nNRA) 1197 return (ENXIO); 1198 return (physio(udstrategy, &rudbuf[unit], dev, B_READ, minphys, uio)); 1199 } 1200 1201 udwrite(dev, uio) 1202 dev_t dev; 1203 struct uio *uio; 1204 { 1205 register int unit = minor(dev) >> 3; 1206 1207 if (unit >= nNRA) 1208 return (ENXIO); 1209 return (physio(udstrategy, &rudbuf[unit], dev, B_WRITE, minphys, uio)); 1210 } 1211 1212 udreset(uban) 1213 int uban; 1214 { 1215 register struct uba_ctlr *um; 1216 register struct uba_device *ui; 1217 register struct buf *bp, *dp; 1218 register int unit; 1219 struct buf *nbp; 1220 int d; 1221 1222 for (d = 0; d < NUDA; d++) { 1223 if ((um = udminfo[d]) == 0 || um->um_ubanum != uban || 1224 um->um_alive == 0) 1225 continue; 1226 printf(" uda%d", d); 1227 um->um_tab.b_active = 0; 1228 um->um_tab.b_actf = um->um_tab.b_actl = 0; 1229 uda_softc[d].sc_state = S_IDLE; 1230 uda_softc[d].sc_mapped = 0; /* Rich */ 1231 for (unit = 0; unit < nNRA; unit++) { 1232 if ((ui = uddinfo[unit]) == 0) 1233 continue; 1234 if (ui->ui_alive == 0 || ui->ui_mi != um) 1235 continue; 1236 udutab[unit].b_active = 0; 1237 udutab[unit].b_qsize = 0; 1238 } 1239 for (bp = udwtab[d].av_forw; bp != &udwtab[d]; bp = nbp) { 1240 nbp = bp->av_forw; 1241 bp->b_ubinfo = 0; 1242 /* 1243 * Link the buffer onto the drive queue 1244 */ 1245 dp = &udutab[dkunit(bp)]; 1246 if (dp->b_actf == 0) 1247 dp->b_actf = bp; 1248 else 1249 dp->b_actl->av_forw = bp; 1250 dp->b_actl = bp; 1251 bp->av_forw = 0; 1252 /* 1253 * Link the drive onto the controller queue 1254 */ 1255 if (dp->b_active == 0) { 1256 dp->b_forw = NULL; 1257 if (um->um_tab.b_actf == NULL) 1258 um->um_tab.b_actf = dp; 1259 else 1260 um->um_tab.b_actl->b_forw = dp; 1261 um->um_tab.b_actl = dp; 1262 dp->b_active = 1; 1263 } 1264 } 1265 udinit(d); 1266 } 1267 } 1268 1269 #define DBSIZE 32 1270 1271 #define ca_Rspdsc ca_rspdsc[0] 1272 #define ca_Cmddsc ca_rspdsc[1] 1273 #define uda_Rsp uda_rsp[0] 1274 #define uda_Cmd uda_cmd[0] 1275 1276 struct uda udad[NUDA]; 1277 1278 uddump(dev) 1279 dev_t dev; 1280 { 1281 struct udadevice *udaddr; 1282 struct uda *ud_ubaddr; 1283 char *start; 1284 int num, blk, unit; 1285 int maxsz; 1286 int blkoff; 1287 register struct uba_regs *uba; 1288 register struct uba_device *ui; 1289 register struct uda *udp; 1290 register struct pte *io; 1291 register int i; 1292 struct size *rasizes; 1293 unit = minor(dev) >> 3; 1294 if (unit >= nNRA) 1295 return (ENXIO); 1296 #define phys(cast, addr) ((cast)((int)addr & 0x7fffffff)) 1297 ui = phys(struct uba_device *, uddinfo[unit]); 1298 if (ui->ui_alive == 0) 1299 return (ENXIO); 1300 uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba; 1301 ubainit(uba); 1302 udaddr = (struct udadevice *)ui->ui_physaddr; 1303 DELAY(2000000); 1304 udp = phys(struct uda *, &udad[ui->ui_ctlr]); 1305 1306 num = btoc(sizeof(struct uda)) + 1; 1307 io = &uba->uba_map[NUBMREG-num]; 1308 for(i = 0; i<num; i++) 1309 *(int *)io++ = UBAMR_MRV|(btop(udp)+i); 1310 ud_ubaddr = (struct uda *)(((int)udp & PGOFSET)|((NUBMREG-num)<<9)); 1311 1312 udaddr->udaip = 0; 1313 while ((udaddr->udasa & UDA_STEP1) == 0) 1314 if(udaddr->udasa & UDA_ERR) return(EFAULT); 1315 udaddr->udasa = UDA_ERR; 1316 while ((udaddr->udasa & UDA_STEP2) == 0) 1317 if(udaddr->udasa & UDA_ERR) return(EFAULT); 1318 udaddr->udasa = (short)&ud_ubaddr->uda_ca.ca_ringbase; 1319 while ((udaddr->udasa & UDA_STEP3) == 0) 1320 if(udaddr->udasa & UDA_ERR) return(EFAULT); 1321 udaddr->udasa = (short)(((int)&ud_ubaddr->uda_ca.ca_ringbase) >> 16); 1322 while ((udaddr->udasa & UDA_STEP4) == 0) 1323 if(udaddr->udasa & UDA_ERR) return(EFAULT); 1324 udaddr->udasa = UDA_GO; 1325 udp->uda_ca.ca_Rspdsc = (long)&ud_ubaddr->uda_Rsp.mscp_cmdref; 1326 udp->uda_ca.ca_Cmddsc = (long)&ud_ubaddr->uda_Cmd.mscp_cmdref; 1327 udp->uda_Cmd.mscp_cntflgs = 0; 1328 udp->uda_Cmd.mscp_version = 0; 1329 if (udcmd(M_OP_STCON, udp, udaddr) == 0) { 1330 return(EFAULT); 1331 } 1332 udp->uda_Cmd.mscp_unit = ui->ui_slave; 1333 if (udcmd(M_OP_ONLIN, udp, udaddr) == 0) { 1334 return(EFAULT); 1335 } 1336 1337 num = maxfree; 1338 start = 0; 1339 rasizes = ra_info[ui->ui_unit].ra_sizes; 1340 maxsz = rasizes[minor(dev)&07].nblocks; 1341 blkoff = rasizes[minor(dev)&07].blkoff; 1342 if(maxsz < 0) 1343 maxsz = ra_info[unit].radsize-blkoff; 1344 if (dumplo < 0 || dumplo + num >= maxsz) 1345 return (EINVAL); 1346 blkoff += dumplo; 1347 while (num > 0) { 1348 blk = num > DBSIZE ? DBSIZE : num; 1349 io = uba->uba_map; 1350 for (i = 0; i < blk; i++) 1351 *(int *)io++ = (btop(start)+i) | UBAMR_MRV; 1352 *(int *)io = 0; 1353 udp->uda_Cmd.mscp_lbn = btop(start) + blkoff; 1354 udp->uda_Cmd.mscp_unit = ui->ui_slave; 1355 udp->uda_Cmd.mscp_bytecnt = blk*NBPG; 1356 udp->uda_Cmd.mscp_buffer = 0; 1357 if (udcmd(M_OP_WRITE, udp, udaddr) == 0) { 1358 return(EIO); 1359 } 1360 start += blk*NBPG; 1361 num -= blk; 1362 } 1363 return (0); 1364 } 1365 1366 1367 udcmd(op, udp, udaddr) 1368 int op; 1369 register struct uda *udp; 1370 struct udadevice *udaddr; 1371 { 1372 int i; 1373 1374 #ifdef lint 1375 i = i; 1376 #endif 1377 1378 udp->uda_Cmd.mscp_opcode = op; 1379 udp->uda_Rsp.mscp_header.uda_msglen = mscp_msglen; 1380 udp->uda_Cmd.mscp_header.uda_msglen = mscp_msglen; 1381 udp->uda_ca.ca_Rspdsc |= UDA_OWN|UDA_INT; 1382 udp->uda_ca.ca_Cmddsc |= UDA_OWN|UDA_INT; 1383 if (udaddr->udasa&UDA_ERR) 1384 printf("Udaerror udasa (%x)\n", udaddr->udasa&0xffff); 1385 i = udaddr->udaip; 1386 for (;;) { 1387 if (udp->uda_ca.ca_cmdint) 1388 udp->uda_ca.ca_cmdint = 0; 1389 if (udp->uda_ca.ca_rspint) 1390 break; 1391 } 1392 udp->uda_ca.ca_rspint = 0; 1393 if (udp->uda_Rsp.mscp_opcode != (op|M_OP_END) || 1394 (udp->uda_Rsp.mscp_status&M_ST_MASK) != M_ST_SUCC) { 1395 printf("error: com %d opc 0x%x stat 0x%x\ndump ", 1396 op, 1397 udp->uda_Rsp.mscp_opcode, 1398 udp->uda_Rsp.mscp_status); 1399 return(0); 1400 } 1401 return(1); 1402 } 1403 1404 udsize(dev) 1405 dev_t dev; 1406 { 1407 int unit = minor(dev) >> 3; 1408 struct uba_device *ui; 1409 struct size *rasizes; 1410 1411 if (unit >= nNRA || (ui = uddinfo[unit]) == 0 || ui->ui_alive == 0 1412 || ui->ui_flags == 0) 1413 return (-1); 1414 rasizes = ra_info[ui->ui_unit].ra_sizes; 1415 return (rasizes[minor(dev) & 07].nblocks); 1416 } 1417 1418 #endif 1419