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