![[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 [Research Unix] / researchv8dc / sys / dev|
Return to uda.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 ! root 1: #include "ra.h" ! 2: #if NUDA > 0 ! 3: /* ! 4: * UDA50/RAxx disk device driver ! 5: * this should really be two drivers! ! 6: * can only handle unit numbers less than 8 for now ! 7: */ ! 8: ! 9: #include "../h/param.h" ! 10: #include "../h/systm.h" ! 11: #include "../h/buf.h" ! 12: #include "../h/conf.h" ! 13: #include "../h/dir.h" ! 14: #include "../h/user.h" ! 15: #include "../h/pte.h" ! 16: #include "../h/map.h" ! 17: #include "../h/vm.h" ! 18: #include "../h/ubareg.h" ! 19: #include "../h/ubavar.h" ! 20: #include "../h/dk.h" ! 21: #include "../h/cpu.h" ! 22: #include "../h/cmap.h" ! 23: #include "../h/trace.h" ! 24: #include "../h/file.h" ! 25: ! 26: int udadebug = 0; ! 27: #define printd if(udadebug&1)printf ! 28: ! 29: /* ! 30: * Parameters for the communications area ! 31: */ ! 32: ! 33: #define NRSPL2 5 ! 34: #define NCMDL2 5 ! 35: #define NRSP (1<<NRSPL2) ! 36: #define NCMD (1<<NCMDL2) ! 37: ! 38: #include "../h/udareg.h" ! 39: #include "../h/udaioc.h" ! 40: #include "../h/mscp.h" ! 41: ! 42: #define SECTOR 512 /* size of an MSCP logical block */ ! 43: #define MAXUNIT 8 /* largest unit number we can handle */ ! 44: ! 45: struct uda_softc { ! 46: short sc_state; /* state of controller */ ! 47: short sc_flags; ! 48: struct udadevice *sc_addr; ! 49: int sc_ubainfo; /* Unibus mapping info */ ! 50: struct uda *sc_uda; /* Unibus address of uda struct */ ! 51: int sc_ivec; /* interrupt vector address */ ! 52: short sc_credits; /* transfer credits */ ! 53: short sc_lastcmd; /* pointer into command ring */ ! 54: short sc_lastrsp; /* pointer into response ring */ ! 55: short sc_ctime; /* controller timeout interval */ ! 56: } uda_softc[NUDA]; ! 57: ! 58: /* ! 59: * sc_flags ! 60: */ ! 61: ! 62: #define SCCRED 01 /* someone waiting for credits */ ! 63: #define SCMAP 02 /* control structure is mapped */ ! 64: #define SCFIRST 04 /* allow packets without credit */ ! 65: ! 66: /* ! 67: * Controller states ! 68: */ ! 69: #define S_IDLE 0 /* hasn't been initialized */ ! 70: #define S_STEP1 1 /* doing step 1 init */ ! 71: #define S_STEP2 2 /* doing step 2 init */ ! 72: #define S_STEP3 3 /* doing step 3 init */ ! 73: #define S_SCHAR 4 /* doing "set controller characteristics" */ ! 74: #define S_RUN 5 /* running */ ! 75: ! 76: /* ! 77: * communication area, per controller ! 78: * mapped into UNIBUS space ! 79: */ ! 80: ! 81: struct uda { ! 82: struct udaca uda_ca; /* communications area */ ! 83: struct mscp uda_rsp[NRSP]; /* response packets */ ! 84: struct mscp uda_cmd[NCMD]; /* command packets */ ! 85: } uda[NUDA]; ! 86: ! 87: /* ! 88: * a word to the wise: ! 89: * part of the minor device number selects a drive number ! 90: * this is not necessarily the same as the physical unit number ! 91: * in an attempt to clear this up, the former is referred to ! 92: * as the `dev unit,' the latter as the `real unit' ! 93: * most places use the real unit ! 94: */ ! 95: #define NPART 8 /* 8 disk partitions */ ! 96: #define PART(x) ((x) & 07) /* minor device -> partition */ ! 97: #define DUNIT(x) (((x) >> 3) & 07) /* minor device -> dev unit */ ! 98: ! 99: #define HUGE 0x7fffffff ! 100: ! 101: struct size { ! 102: daddr_t nblocks; ! 103: daddr_t blkoff; ! 104: } ra_sizes[NPART] ={ ! 105: 10240, 0, /* like emulex */ ! 106: 20480, 10240, /* ra81 has 891072 blocks */ ! 107: 249848, 30720, ! 108: 249848, 280568, ! 109: 249848, 530416, ! 110: 110808, 780264, ! 111: 749544, 30720, /* slices 2,3,4 */ ! 112: HUGE, 0, /* whole drive */ ! 113: }; ! 114: ! 115: /* device flags (ui_flags) */ ! 116: #define DUP 1 /* up */ ! 117: #define DGTUNIT 2 /* needs GTUNIT */ ! 118: ! 119: #define ui_offl ui_type ! 120: #define MAXOFFL 10 ! 121: ! 122: /* per unit stuff */ ! 123: struct ud_unit ud_units[MAXUNIT]; /* per real unit */ ! 124: int ud_open[NRA]; /* per dev unit */ ! 125: ! 126: char ud_rflags; /* replacement flags. should be per controller */ ! 127: #define RPLOCK 01 /* someone is doing a replacement */ ! 128: #define RPWANT 02 /* somebody else wants to */ ! 129: #define RPDONE 04 /* replacement finished */ ! 130: ! 131: int ud_rret; /* status returned from replacement */ ! 132: ! 133: int udprobe(), udslave(), udattach(), udintr(); ! 134: struct mscp *udgetcp(); ! 135: struct uba_ctlr *udminfo[NUDA]; ! 136: struct uba_device *uddinfo[NRA]; /* per dev unit */ ! 137: struct uba_device *udip[NUDA][MAXUNIT]; /* (ctlr, realunit) -> device */ ! 138: ! 139: u_short udstd[] = { 0777550, 0 }; ! 140: struct uba_driver udadriver = ! 141: { udprobe, udslave, udattach, 0, udstd, "ra", uddinfo, "uda", udminfo, 0 }; ! 142: struct buf rudbuf[NRA]; /* raw io buffer header */ ! 143: struct buf rctbuf[NRA]; /* buffer for RCT io */ ! 144: struct buf udutab[NRA]; /* drive queues */ ! 145: struct buf udwtab[NUDA]; /* I/O wait queue, per controller */ ! 146: ! 147: #define b_qsize b_resid /* queue size per drive, in udutab */ ! 148: #define b_ubinfo b_resid /* Unibus mapping info, per buffer */ ! 149: ! 150: udprobe(reg, ctlr) ! 151: caddr_t reg; ! 152: int ctlr; ! 153: { register int br, cvec; ! 154: register struct uda_softc *sc = &uda_softc[ctlr]; ! 155: ! 156: #ifdef lint ! 157: br = 0; cvec = br; br = cvec; reg = reg; ! 158: udread(0); udwrite(0); udreset(0); udintr(0); ! 159: #endif ! 160: /* SHOULD CHECK THAT IT REALLY IS A UDA */ ! 161: br = 0x15; ! 162: cvec = sc->sc_ivec = (uba_hd[numuba].uh_lastiv -= 4); ! 163: sc->sc_addr = (struct udadevice *)reg; ! 164: return(1); ! 165: } ! 166: ! 167: udslave(ui, reg) ! 168: struct uba_device *ui; ! 169: caddr_t reg; ! 170: { ! 171: /* ! 172: * TOO HARD TO FIND OUT IF DISK IS THERE UNTIL ! 173: * INITIALIZED. WE'LL FIND OUT WHEN WE FIRST ! 174: * TRY TO ACCESS IT. ! 175: */ ! 176: #ifdef lint ! 177: ui = ui; reg = reg; ! 178: #endif ! 179: return(1); ! 180: } ! 181: ! 182: udattach(ui) ! 183: register struct uba_device *ui; ! 184: { ! 185: ! 186: if (ui->ui_dk > 0) ! 187: dk_mspw[ui->ui_dk] = 1.0 / (60 * 51 * 256); /* approx */ ! 188: ui->ui_flags = 0; ! 189: udip[ui->ui_ctlr][ui->ui_slave] = ui; ! 190: printf("\n"); /* we're expected to babble */ ! 191: ud_units[ui->ui_unit].radsize = (daddr_t)HUGE; ! 192: } ! 193: ! 194: udopen(dev) ! 195: dev_t dev; ! 196: { ! 197: register int unit; ! 198: ! 199: unit = DUNIT(minor(dev)); ! 200: if (unit >= NRA) { ! 201: u.u_error = ENXIO; ! 202: return; ! 203: } ! 204: ud_open[unit] |= 1 << PART(minor(dev)); ! 205: } ! 206: ! 207: udclose(dev) ! 208: dev_t dev; ! 209: { ! 210: register int unit; ! 211: register struct mscp *mp; ! 212: struct uba_device *ui; ! 213: struct uba_ctlr *um; ! 214: struct uda_softc *sc; ! 215: ! 216: unit = DUNIT(minor(dev)); ! 217: ud_open[unit] &=~ (1 << PART(minor(dev))); ! 218: if (ud_open[unit]) ! 219: return; ! 220: /* ! 221: * last close on this drive ! 222: * put it offline ! 223: */ ! 224: ui = uddinfo[unit]; ! 225: if (ui->ui_flags == 0) ! 226: return; ! 227: um = ui->ui_mi; ! 228: sc = &uda_softc[um->um_ctlr]; ! 229: if (udcredit(sc, 1) == 0) ! 230: return; ! 231: if ((mp = udgetcp(um)) == NULL) ! 232: return; ! 233: mp->mscp_opcode = M_OP_AVAIL; ! 234: mp->mscp_unit = ui->ui_slave; ! 235: mp->mscp_modifier = 0; ! 236: mp->mscp_cmdref = (long)mp; /* any old number */ ! 237: udsend(mp, sc); ! 238: ui->ui_flags = 0; /* drive is offline now */ ! 239: } ! 240: ! 241: /* ! 242: * Initialize a UDA. Set up UBA mapping registers, ! 243: * initialize data structures, and perform hardware ! 244: * initialization sequence. ! 245: */ ! 246: ! 247: udinit(d) ! 248: { ! 249: register struct uda_softc *sc; ! 250: register struct uba_ctlr *um; ! 251: register struct buf *bp; ! 252: register struct mscp *mp; ! 253: register int i; ! 254: int s; ! 255: ! 256: sc = &uda_softc[d]; ! 257: um = udminfo[d]; ! 258: um->um_tab.b_active++; ! 259: if ((sc->sc_flags & SCMAP) == 0) { ! 260: sc->sc_ubainfo = uballoc(um->um_ubanum, (caddr_t)&uda[d], ! 261: sizeof (struct uda), 0); ! 262: sc->sc_uda = (struct uda *)(sc->sc_ubainfo & 0x3ffff); ! 263: sc->sc_flags |= SCMAP; ! 264: } ! 265: for (i = 0; i < NRA; i++) ! 266: if (uddinfo[i] && uddinfo[i]->ui_mi == um) ! 267: uddinfo[i]->ui_flags = 0; ! 268: if (udhwinit(d) == 0) ! 269: return; ! 270: sc->sc_state = S_SCHAR; ! 271: bp = &udwtab[d]; ! 272: bp->av_forw = bp->av_back = bp; ! 273: sc->sc_lastcmd = 0; ! 274: sc->sc_lastrsp = 0; ! 275: s = spl5(); ! 276: if ((mp = udgetcp(um)) == NULL) ! 277: panic("uda: no packets"); ! 278: mp->mscp_opcode = M_OP_STCON; ! 279: mp->mscp_cntflgs = M_CF_ATTN|M_CF_MISC|M_CF_THIS; ! 280: sc->sc_flags |= SCFIRST; ! 281: udsend(mp, sc); ! 282: splx(s); ! 283: return; ! 284: } ! 285: ! 286: /* ! 287: * hardware initialization handshake ! 288: * for simplicity, don't bother with init interrupts ! 289: * returns nonzero if ok ! 290: */ ! 291: ! 292: #define UDA_STEPS (UDA_ERR|UDA_STEP4|UDA_STEP3|UDA_STEP2|UDA_STEP1) ! 293: ! 294: udhwinit(d) ! 295: int d; ! 296: { ! 297: register struct uda_softc *sc; ! 298: register struct udadevice *udaddr; ! 299: register int i; ! 300: register struct uda *ud; ! 301: register struct uda *uud; ! 302: time_t out; ! 303: ! 304: sc = &uda_softc[d]; ! 305: udaddr = sc->sc_addr; ! 306: out = time + 1; ! 307: udaddr->udaip = 0; /* start initialization */ ! 308: while((udaddr->udasa & UDA_STEP1) == 0 && time <= out) ! 309: ; ! 310: if((udaddr->udasa & UDA_STEPS) != UDA_STEP1) { ! 311: porterror(udaddr->udasa, d); ! 312: return (0); ! 313: } ! 314: sc->sc_state = S_STEP1; ! 315: sc->sc_credits = 0; ! 316: udaddr->udasa = UDA_ERR|(NCMDL2<<11)|(NRSPL2<<8)|(sc->sc_ivec/4); ! 317: /* no diagnostic wrap, no interrupts during initialization */ ! 318: out = time + 11; ! 319: while((udaddr->udasa & UDA_STEP2) == 0 && time <= out) ! 320: ; ! 321: if((udaddr->udasa & UDA_STEPS) != UDA_STEP2) { ! 322: porterror(udaddr->udasa, d); ! 323: return (0); ! 324: } ! 325: sc->sc_state = S_STEP2; ! 326: /* assert that &ringbase & 03 == 0 */ ! 327: udaddr->udasa = (short)&sc->sc_uda->uda_ca.ca_ringbase | UDA_PI; ! 328: out = time + 11; ! 329: while((udaddr->udasa & UDA_STEP3) == 0 && time <= out) ! 330: ; ! 331: if((udaddr->udasa & UDA_STEPS) != UDA_STEP3) { ! 332: porterror(udaddr->udasa, d); ! 333: return (0); ! 334: } ! 335: sc->sc_state = S_STEP3; ! 336: udaddr->udasa = ((long)&sc->sc_uda->uda_ca.ca_ringbase) >> 16; ! 337: out = time + 11; ! 338: while((udaddr->udasa & UDA_STEP4) == 0 && time <= out) ! 339: ; ! 340: if((udaddr->udasa & UDA_STEPS) != UDA_STEP4) { ! 341: porterror(udaddr->udasa, d); ! 342: return (0); ! 343: } ! 344: udaddr->udasa = (3<<2)|UDA_LF; ! 345: /* (3+1) double words per burst, last fail packets */ ! 346: uud = sc->sc_uda; ! 347: ud = &uda[d]; ! 348: for (i = 0; i < NRSP; i++) { ! 349: ud->uda_ca.ca_rspdsc[i] = UDA_OWN|UDA_INT| ! 350: (long)&uud->uda_rsp[i].mscp_cmdref; ! 351: ud->uda_rsp[i].mscp_dscptr = &ud->uda_ca.ca_rspdsc[i]; ! 352: ud->uda_rsp[i].mscp_header.uda_msglen = ! 353: sizeof(struct mscp); ! 354: } ! 355: for (i = 0; i < NCMD; i++) { ! 356: ud->uda_ca.ca_cmddsc[i] = UDA_INT| ! 357: (long)&uud->uda_cmd[i].mscp_cmdref; ! 358: ud->uda_cmd[i].mscp_dscptr = &ud->uda_ca.ca_cmddsc[i]; ! 359: ud->uda_cmd[i].mscp_header.uda_msglen = ! 360: sizeof(struct mscp); ! 361: } ! 362: udaddr->udasa = UDA_GO; /* finish init */ ! 363: return (1); ! 364: } ! 365: ! 366: static char *pmesg[] = { ! 367: "(error 0?)", ! 368: "data read", ! 369: "data write", ! 370: "parity", ! 371: "ram parity", ! 372: "rom parity", ! 373: "ring read", ! 374: "ring write", ! 375: "interrupt master", ! 376: "host timeout", ! 377: "credit limit", ! 378: "unibus master", ! 379: "diag controller", ! 380: "instruction loop timeout", ! 381: "invalid connection id", ! 382: "interrupt write", ! 383: "maint region", ! 384: "maint load", ! 385: "ram", ! 386: "init sequence", ! 387: "protocol incompat", ! 388: "purge/poll", ! 389: }; ! 390: ! 391: porterror(sa, d) ! 392: short sa; ! 393: int d; ! 394: { ! 395: register struct uda_softc *sc; ! 396: int n; ! 397: ! 398: sc = &uda_softc[d]; ! 399: printf("uda%d port error, sa x%x ", d, sa); ! 400: if(!(sa & UDA_ERR)) { ! 401: printf("(time out?), state %d\n", sc->sc_state); ! 402: sc->sc_state = S_IDLE; ! 403: return; ! 404: } ! 405: n = (sa & 0x3ff); ! 406: if(n > sizeof(pmesg)/sizeof(pmesg[0])) ! 407: printf("(?)\n"); ! 408: else ! 409: printf("%s\n", pmesg[n]); ! 410: sc->sc_state = S_IDLE; ! 411: } ! 412: ! 413: udstrategy(bp) ! 414: register struct buf *bp; ! 415: { ! 416: register struct uba_device *ui; ! 417: register struct uba_ctlr *um; ! 418: register struct buf *dp; ! 419: register int unit; ! 420: int part = PART(minor(bp->b_dev)); ! 421: daddr_t sz, maxsz; ! 422: int s; ! 423: ! 424: sz = (bp->b_bcount+(SECTOR-1)) / SECTOR; ! 425: unit = dkunit(bp); ! 426: if (unit >= NRA) { ! 427: bp->b_flags |= B_ERROR; ! 428: iodone(bp); ! 429: return; ! 430: } ! 431: ui = uddinfo[unit]; ! 432: um = ui->ui_mi; ! 433: if (ui == 0 || ui->ui_alive == 0) { ! 434: bp->b_flags |= B_ERROR; ! 435: iodone(bp); ! 436: return; ! 437: } ! 438: maxsz = ud_units[unit].radsize - ra_sizes[part].blkoff; ! 439: if (maxsz > ra_sizes[part].nblocks) ! 440: maxsz = ra_sizes[part].nblocks; ! 441: if (bp != &rctbuf[unit]) { ! 442: if (bp->b_blkno == maxsz) { ! 443: bp->b_resid = bp->b_bcount; ! 444: iodone(bp); ! 445: return; ! 446: } ! 447: if (bp->b_blkno < 0 || bp->b_blkno+sz > maxsz) { ! 448: bp->b_flags |= B_ERROR; ! 449: iodone(bp); ! 450: return; ! 451: } ! 452: } ! 453: s = spl5(); ! 454: /* ! 455: * Link the buffer onto the drive queue ! 456: */ ! 457: dp = &udutab[ui->ui_unit]; ! 458: if (dp->b_actf == 0) ! 459: dp->b_actf = bp; ! 460: else ! 461: dp->b_actl->av_forw = bp; ! 462: dp->b_actl = bp; ! 463: bp->av_forw = NULL; ! 464: /* ! 465: * Link the drive onto the controller queue (why bother?) ! 466: */ ! 467: if (dp->b_active == 0) { ! 468: dp->b_forw = NULL; ! 469: if (um->um_tab.b_actf == NULL) ! 470: um->um_tab.b_actf = dp; ! 471: else ! 472: um->um_tab.b_actl->b_forw = dp; ! 473: um->um_tab.b_actl = dp; ! 474: dp->b_active = 1; ! 475: } ! 476: if (um->um_tab.b_active == 0) ! 477: (void) udstart(um); ! 478: splx(s); ! 479: } ! 480: ! 481: udstart(um) ! 482: register struct uba_ctlr *um; ! 483: { ! 484: register struct buf *bp, *dp; ! 485: register struct mscp *mp; ! 486: register struct udadevice *udaddr; ! 487: register struct uda_softc *sc; ! 488: register struct uba_device *ui; ! 489: int i; ! 490: ! 491: sc = &uda_softc[um->um_ctlr]; ! 492: ! 493: loop: ! 494: if ((dp = um->um_tab.b_actf) == NULL) { ! 495: /* ! 496: * Release uneeded UBA resources and return ! 497: */ ! 498: um->um_tab.b_active = 0; ! 499: return (0); ! 500: } ! 501: if ((bp = dp->b_actf) == NULL) { ! 502: /* ! 503: * No more requests for this drive, remove ! 504: * from controller queue and look at next drive. ! 505: * We know we're at the head of the controller queue. ! 506: */ ! 507: dp->b_active = 0; ! 508: um->um_tab.b_actf = dp->b_forw; ! 509: goto loop; ! 510: } ! 511: um->um_tab.b_active++; ! 512: udaddr = sc->sc_addr; ! 513: if ((udaddr->udasa&UDA_ERR) || sc->sc_state != S_RUN) { ! 514: if(sc->sc_state != S_IDLE) { ! 515: harderr(bp, "ra"); ! 516: printf("uda%d udasa x%x, state %d\n", ! 517: um->um_ctlr, udaddr->udasa&0xffff, sc->sc_state); ! 518: } ! 519: udinit(um->um_ctlr); ! 520: /* SHOULD REQUEUE OUTSTANDING REQUESTS, LIKE UDRESET */ ! 521: return (0); ! 522: } ! 523: ui = uddinfo[dkunit(bp)]; ! 524: /* ! 525: * get a packet, fill it in, and send it ! 526: */ ! 527: if (udcredit(sc, 0) == 0) ! 528: return (0); ! 529: if ((mp = udgetcp(um)) == NULL) ! 530: return (0); ! 531: if (ui->ui_flags == 0) { /* not online */ ! 532: if (++ui->ui_offl > MAXOFFL) { ! 533: ui->ui_offl = 0; ! 534: printf("uda%d ra%d offline\n", um->um_ctlr, ui->ui_slave); ! 535: bp->b_flags |= B_ERROR; ! 536: iodone(bp); ! 537: dp->b_actf = bp->av_forw; ! 538: if (dp->b_forw) { ! 539: um->um_tab.b_actf = dp->b_forw; ! 540: um->um_tab.b_actl->b_forw = dp; ! 541: um->um_tab.b_actl = dp; ! 542: dp->b_forw = NULL; ! 543: } ! 544: goto loop; ! 545: } ! 546: mp->mscp_opcode = M_OP_ONLIN; ! 547: mp->mscp_unit = ui->ui_slave; ! 548: dp->b_active = 2; /* MAGIC */ ! 549: um->um_tab.b_actf = dp->b_forw; /* remove from controller q */ ! 550: printd("uda: bring unit %d online\n", ui->ui_slave); ! 551: udsend(mp, sc); ! 552: goto loop; ! 553: } ! 554: ui->ui_offl = 0; ! 555: if(ui->ui_flags & DGTUNIT) { ! 556: mp->mscp_opcode = M_OP_GTUNT; ! 557: mp->mscp_unit = ui->ui_slave; ! 558: udsend(mp, sc); ! 559: ui->ui_flags &= ~DGTUNIT; ! 560: goto loop; ! 561: } ! 562: if ((i = ubasetup(um->um_ubanum, bp, UBA_WANTBDP|UBA_CANTWAIT)) == 0) { ! 563: /* this is issued just to get an interrupt */ ! 564: /* to try ubasetup again, a doubtful procedure */ ! 565: mp->mscp_opcode = M_OP_GTUNT; ! 566: mp->mscp_unit = ui->ui_slave; ! 567: udsend(mp, sc); ! 568: return(1); /* wait for interrupt */ ! 569: } ! 570: mp->mscp_cmdref = (long)bp; /* pointer to get back */ ! 571: mp->mscp_opcode = bp->b_flags&B_READ ? M_OP_READ : M_OP_WRITE; ! 572: mp->mscp_unit = ui->ui_slave; ! 573: mp->mscp_lbn = bp->b_blkno + ra_sizes[PART(minor(bp->b_dev))].blkoff; ! 574: mp->mscp_bytecnt = bp->b_bcount; ! 575: /* address; datapath number in high byte */ ! 576: mp->mscp_buffer = (i & 0x3ffff) | (((i>>28)&0xf)<<24); ! 577: bp->b_ubinfo = i; /* save mapping info */ ! 578: udsend(mp, sc); ! 579: if (ui->ui_dk >= 0) { ! 580: dk_busy |= 1<<ui->ui_dk; ! 581: dp->b_qsize++; ! 582: dk_xfer[ui->ui_dk]++; ! 583: dk_wds[ui->ui_dk] += bp->b_bcount>>6; ! 584: /* the way initialization is done now, this is useless */ ! 585: } ! 586: ! 587: /* ! 588: * Move drive to the end of the controller queue ! 589: */ ! 590: if (dp->b_forw != NULL) { ! 591: um->um_tab.b_actf = dp->b_forw; ! 592: um->um_tab.b_actl->b_forw = dp; ! 593: um->um_tab.b_actl = dp; ! 594: dp->b_forw = NULL; ! 595: } ! 596: /* ! 597: * Move buffer to I/O wait queue ! 598: */ ! 599: dp->b_actf = bp->av_forw; ! 600: dp = &udwtab[um->um_ctlr]; ! 601: bp->av_forw = dp; ! 602: bp->av_back = dp->av_back; ! 603: dp->av_back->av_forw = bp; ! 604: dp->av_back = bp; ! 605: goto loop; ! 606: } ! 607: ! 608: /* ! 609: * UDA interrupt routine. ! 610: */ ! 611: udintr(d) ! 612: int d; ! 613: { ! 614: register struct uba_ctlr *um; ! 615: register struct udadevice *udaddr; ! 616: register int i; ! 617: register struct uda_softc *sc; ! 618: register struct uda *ud; ! 619: ! 620: if (d < 0 || d >= NUDA) ! 621: panic("udintr"); ! 622: um = udminfo[d]; ! 623: sc = &uda_softc[d]; ! 624: ud = &uda[d]; ! 625: udaddr = sc->sc_addr; ! 626: switch (sc->sc_state) { ! 627: case S_IDLE: ! 628: printf("uda%d: random intr, status x%x\n", udaddr->udasa); ! 629: return; ! 630: ! 631: case S_SCHAR: ! 632: case S_RUN: ! 633: break; ! 634: ! 635: default: ! 636: printf("uda%d: intr in unknown state %d ignored\n", ! 637: d, sc->sc_state); ! 638: porterror(udaddr->udasa, d); ! 639: return; ! 640: } ! 641: ! 642: trace(TR_UDRESP, 0, udaddr->udasa); ! 643: if (udaddr->udasa&UDA_ERR) { ! 644: printf("uda%d: fatal error, udasa x%x\n", ! 645: d, udaddr->udasa&0xffff); ! 646: udaddr->udaip = 0; ! 647: sc->sc_state = S_IDLE; ! 648: } ! 649: if (ud->uda_ca.ca_bdp == 0 ! 650: && ud->uda_ca.ca_rspint == 0 ! 651: && ud->uda_ca.ca_cmdint == 0) ! 652: printf("uda%d: spurious intr\n", um->um_ctlr); ! 653: /* ! 654: * buffer purge request ! 655: */ ! 656: if (ud->uda_ca.ca_bdp) { ! 657: /* ! 658: * THIS IS A KLUDGE. ! 659: * Maybe we should change the entire ! 660: * UBA interface structure. ! 661: */ ! 662: int s = spl7(); ! 663: ! 664: i = um->um_ubinfo; ! 665: printd("uda%d purge bdp %d\n", um->um_ctlr, ud->uda_ca.ca_bdp); ! 666: um->um_ubinfo = ud->uda_ca.ca_bdp<<28; ! 667: ubapurge(um); ! 668: um->um_ubinfo = i; ! 669: (void) splx(s); ! 670: ud->uda_ca.ca_bdp = 0; ! 671: udaddr->udasa = 0; /* signal purge complete */ ! 672: } ! 673: /* ! 674: * response ring transition ! 675: */ ! 676: if (ud->uda_ca.ca_rspint) { ! 677: ud->uda_ca.ca_rspint = 0; ! 678: for (i = sc->sc_lastrsp;; i++) { ! 679: i %= NRSP; ! 680: if (ud->uda_ca.ca_rspdsc[i]&UDA_OWN) ! 681: break; ! 682: udrsp(um, ud, sc, i); ! 683: ud->uda_ca.ca_rspdsc[i] |= UDA_OWN; ! 684: } ! 685: sc->sc_lastrsp = i; ! 686: } ! 687: /* ! 688: * command ring transition ! 689: */ ! 690: if (ud->uda_ca.ca_cmdint) { ! 691: printf("uda%d command ring transition\n", um->um_ctlr); ! 692: ud->uda_ca.ca_cmdint = 0; ! 693: } ! 694: (void) udstart(um); ! 695: } ! 696: ! 697: /* ! 698: * send a packet to the uda ! 699: */ ! 700: ! 701: udsend(mp, sc) ! 702: struct mscp *mp; ! 703: struct uda_softc *sc; ! 704: { ! 705: register short junk; ! 706: ! 707: if ((sc->sc_flags & SCFIRST) == 0) { ! 708: if (sc->sc_credits < 2) ! 709: panic("udsend no credits"); ! 710: sc->sc_credits--; ! 711: } ! 712: trace(TR_UDCMND, mp->mscp_opcode, mp->mscp_cmdref); ! 713: *((long *)mp->mscp_dscptr) |= UDA_OWN | UDA_INT; ! 714: junk = sc->sc_addr->udaip; /* trigger polling */ ! 715: } ! 716: ! 717: /* ! 718: * check whether a packet may be sent ! 719: * wait until possible if desired ! 720: * call at spl6, and stay there until you've sent the packet ! 721: * else your credit may be stolen ! 722: */ ! 723: ! 724: udcredit(sc, wait) ! 725: register struct uda_softc *sc; ! 726: int wait; ! 727: { ! 728: ! 729: if (wait == 0 && sc->sc_credits < 2) ! 730: return (0); ! 731: while (sc->sc_credits < 2) { ! 732: sc->sc_flags |= SCCRED; ! 733: sleep((caddr_t)&sc->sc_credits, PRIBIO); ! 734: } ! 735: return (1); ! 736: } ! 737: ! 738: /* ! 739: * Process a response packet ! 740: */ ! 741: udrsp(um, ud, sc, i) ! 742: register struct uba_ctlr *um; ! 743: register struct uda *ud; ! 744: register struct uda_softc *sc; ! 745: int i; ! 746: { ! 747: register struct mscp *mp; ! 748: register struct uba_device *ui; ! 749: register struct buf *dp, *bp; ! 750: register int st; ! 751: struct ud_unit *up; ! 752: ! 753: mp = &ud->uda_rsp[i]; ! 754: st = mp->mscp_status; ! 755: trace(TR_UDRESP, mp->mscp_cmdref, mp->mscp_status); ! 756: printd("udrsp: 0x%x,st=x%x\n", mp->mscp_opcode, st); ! 757: mp->mscp_header.uda_msglen = sizeof (struct mscp); ! 758: sc->sc_credits += mp->mscp_header.uda_credits & 0xf; ! 759: sc->sc_flags &=~ SCFIRST; ! 760: if (sc->sc_flags & SCCRED) { ! 761: sc->sc_flags &=~ SCCRED; ! 762: wakeup((caddr_t)&sc->sc_credits); ! 763: } ! 764: if((mp->mscp_header.uda_credits & 0xf0) > 0x10) /* credits only */ ! 765: return; ! 766: /* ! 767: * If it's an error log message (datagram), ! 768: * pass it on for more extensive processing. ! 769: */ ! 770: if ((mp->mscp_header.uda_credits & 0xf0) == 0x10) { ! 771: uderror(um, (struct mslg *)mp); ! 772: return; ! 773: } ! 774: if (mp->mscp_unit >= MAXUNIT) ! 775: return; ! 776: ui = udip[um->um_ctlr][mp->mscp_unit]; ! 777: switch (mp->mscp_opcode) { ! 778: case M_OP_STCON|M_OP_END: ! 779: if ((st & M_ST_MASK) == M_ST_SUCC) { ! 780: sc->sc_state = S_RUN; ! 781: printf("uda%d run\n", um->um_ctlr); ! 782: } ! 783: else { ! 784: sc->sc_state = S_IDLE; ! 785: printf("uda%d: can't set ctlr char, status x%x\n", ! 786: um->um_ctlr, st); ! 787: } ! 788: sc->sc_ctime = mp->mscp_un.mscp_setcntchar.Mscp_hsttmo; ! 789: um->um_tab.b_active = 0; ! 790: break; ! 791: ! 792: case M_OP_ONLIN|M_OP_END: ! 793: /* ! 794: * Link the drive onto the controller queue ! 795: */ ! 796: if(ui == 0) { ! 797: bad: ! 798: printf("uda%d ra%d op x%x st x%x unexpected\n", ! 799: um->um_ctlr, mp->mscp_unit, mp->mscp_opcode, st); ! 800: return; ! 801: } ! 802: dp = &udutab[ui->ui_unit]; ! 803: dp->b_forw = NULL; ! 804: if (um->um_tab.b_actf == NULL) ! 805: um->um_tab.b_actf = dp; ! 806: else ! 807: um->um_tab.b_actl->b_forw = dp; ! 808: um->um_tab.b_actl = dp; ! 809: if ((st & M_ST_MASK) == M_ST_SUCC) { ! 810: ui->ui_flags = DUP; /* mark it online */ ! 811: ud_units[ui->ui_unit].radsize = (daddr_t)mp->mscp_untsize; ! 812: } else { ! 813: printf("uda%d ra%d online failed; status x%x\n", ! 814: um->um_ctlr, mp->mscp_unit, st); ! 815: while (bp = dp->b_actf) { ! 816: dp->b_actf = bp->av_forw; ! 817: bp->b_flags |= B_ERROR; ! 818: iodone(bp); ! 819: } ! 820: } ! 821: ui->ui_flags |= DGTUNIT; ! 822: dp->b_active = 1; ! 823: break; ! 824: ! 825: case M_OP_AVATN: /* is this the only kind of attn? */ ! 826: if(ui == 0) ! 827: goto bad; ! 828: ui->ui_flags = 0; /* it went offline, get status */ ! 829: break; ! 830: ! 831: case M_OP_READ|M_OP_END: ! 832: case M_OP_WRITE|M_OP_END: ! 833: if(ui == 0) ! 834: goto bad; ! 835: for (bp = udwtab[um->um_ctlr].b_actf; bp; bp = bp->av_forw) ! 836: if (bp == (struct buf *)mp->mscp_cmdref) ! 837: break; ! 838: if (bp == NULL) { ! 839: printf("uda%d ra%d: unknown cmdref x%x\n", ! 840: um->um_ctlr, mp->mscp_unit, mp->mscp_cmdref); ! 841: return; ! 842: } ! 843: ubarelse(um->um_ubanum, (int *)&bp->b_resid); ! 844: /* ! 845: * Unlink buffer from I/O wait queue. ! 846: */ ! 847: bp->av_back->av_forw = bp->av_forw; ! 848: bp->av_forw->av_back = bp->av_back; ! 849: dp = &udutab[ui->ui_unit]; ! 850: /* do we have drive queues just to gather statistics? */ ! 851: if (ui->ui_dk >= 0) ! 852: if (--dp->b_qsize == 0) ! 853: dk_busy &= ~(1<<ui->ui_dk); ! 854: if (st == M_ST_OFFLN || st == M_ST_AVLBL) { ! 855: ui->ui_flags = DGTUNIT; /* mark unit offline, GTUNT */ ! 856: /* ! 857: * Link the buffer onto the front of the drive queue ! 858: */ ! 859: if ((bp->av_forw = dp->b_actf) == 0) ! 860: dp->b_actl = bp; ! 861: dp->b_actf = bp; ! 862: /* ! 863: * Link the drive onto the controller queue ! 864: */ ! 865: if (dp->b_active == 0) { ! 866: dp->b_forw = NULL; ! 867: if (um->um_tab.b_actf == NULL) ! 868: um->um_tab.b_actf = dp; ! 869: else ! 870: um->um_tab.b_actl->b_forw = dp; ! 871: um->um_tab.b_actl = dp; ! 872: dp->b_active = 1; ! 873: } ! 874: return; ! 875: } ! 876: if ((st & M_ST_MASK) != M_ST_SUCC) { ! 877: harderr(bp, "ra"); ! 878: printf("uda%d; status x%x\n", um->um_ctlr, st); ! 879: bp->b_flags |= B_ERROR; ! 880: } ! 881: bp->b_resid = bp->b_bcount - mp->mscp_bytecnt; ! 882: iodone(bp); ! 883: break; ! 884: ! 885: case M_OP_GTUNT|M_OP_END: ! 886: if(ui == 0) ! 887: goto bad; ! 888: up = ud_units + ui->ui_unit; ! 889: ui->ui_flags &= ~DGTUNIT; ! 890: up->rctsize = mp->mscp_rctsize; ! 891: up->medium = mp->mscp_mediaid; ! 892: up->tracksz = mp->mscp_track; ! 893: up->groupsz = mp->mscp_group; ! 894: up->cylsz = mp->mscp_cylinder; ! 895: up->rbns = mp->mscp_rbns; ! 896: up->copies = mp->mscp_rctcpys; ! 897: break; ! 898: ! 899: case M_OP_REPLC|M_OP_END: ! 900: if (ui == 0) ! 901: goto bad; ! 902: ud_rret = 0; ! 903: if ((st & M_ST_MASK) != M_ST_SUCC) { ! 904: printf("uda%d ra%d bad replace, status x%x\n", ! 905: um->um_ctlr, mp->mscp_unit, st); ! 906: ud_rret = EIO; ! 907: } ! 908: ud_rflags |= RPDONE; ! 909: wakeup((caddr_t)&ud_rret); ! 910: break; ! 911: ! 912: case M_OP_AVAIL|M_OP_END: ! 913: break; ! 914: ! 915: default: ! 916: printf("uda%d ra%d unknown packet type x%x\n", ! 917: um->um_ctlr, mp->mscp_unit, mp->mscp_opcode); ! 918: } ! 919: } ! 920: ! 921: ! 922: /* ! 923: * Process an error log message ! 924: * ! 925: * For now, just log the error on the console. ! 926: * Only minimal decoding is done, only "useful" ! 927: * information is printed. Eventually should ! 928: * send message to an error logger. ! 929: */ ! 930: ! 931: static char *events[] = { ! 932: "ok", ! 933: "inv cmd", ! 934: "op aborted", ! 935: "offline", ! 936: "available", ! 937: "med fmt", ! 938: "write prot", ! 939: "comp err", ! 940: "data err", ! 941: "host buf access err", ! 942: "cntl err", ! 943: "drive err", ! 944: }; ! 945: #define MAXEVT 0xb ! 946: ! 947: uderror(um, mp) ! 948: register struct uba_ctlr *um; ! 949: register struct mslg *mp; ! 950: { ! 951: register u_short *sp; /* for sdi crap */ ! 952: ! 953: printf("uda%d ra%d seq %d: %s err; fmt x%x ev x%x fl x%x\n", ! 954: um->um_ctlr, mp->mslg_unit, mp->mslg_seqnum, ! 955: mp->mslg_flags&(M_LF_SUCC|M_LF_CONT) ? "soft" : "hard", ! 956: mp->mslg_format, mp->mslg_event, mp->mslg_flags); ! 957: if ((mp->mslg_event & M_ST_MASK) <= MAXEVT) ! 958: printf("%s; ", events[mp->mslg_event & M_ST_MASK]); ! 959: switch (mp->mslg_format) { ! 960: case M_FM_CNTERR: ! 961: /* now the thing should be marked disastrously bad */ ! 962: printf("oops\n"); ! 963: break; ! 964: ! 965: case M_FM_BUSADDR: ! 966: printf("host mem access; addr x%x\n", ! 967: *((long *)&mp->mslg_busaddr[0])); ! 968: break; ! 969: ! 970: case M_FM_DISKTRN: ! 971: printf("%sbn %d; lev x%x, retry x%x\n", ! 972: (mp->mslg_hdr & 0xf0000000) == 0 ? "l" : "r", ! 973: mp->mslg_hdr & 0x0fffffff, ! 974: mp->mslg_level, mp->mslg_retry); ! 975: break; ! 976: ! 977: case M_FM_SDI: ! 978: printf("%sbn %d;", ! 979: (mp->mslg_hdr & 0xf0000000) == 0 ? "l" : "r", ! 980: mp->mslg_hdr & 0x0fffffff); ! 981: /* ! 982: * print the bytes in the same order used ! 983: * by the dec diagnostics ! 984: */ ! 985: sp = (u_short *)&mp->mslg_sdi[3]; ! 986: while (sp > (u_short *)mp->mslg_sdi) ! 987: printf(" %x", *--sp); ! 988: printf(" xx\n"); ! 989: break; ! 990: ! 991: case M_FM_SMLDSK: ! 992: printf("cyl %d\n", mp->mslg_sdecyl); ! 993: break; ! 994: } ! 995: } ! 996: ! 997: /* ! 998: * Find an unused command packet ! 999: * more exactly, return the next command packet if possible, ! 1000: * return NULL if we can't ! 1001: * the device insists that entries in the ring be used in sequence ! 1002: */ ! 1003: struct mscp * ! 1004: udgetcp(um) ! 1005: struct uba_ctlr *um; ! 1006: { ! 1007: register struct mscp *mp; ! 1008: register struct udaca *cp; ! 1009: register struct uda_softc *sc; ! 1010: register int i; ! 1011: ! 1012: cp = &uda[um->um_ctlr].uda_ca; ! 1013: sc = &uda_softc[um->um_ctlr]; ! 1014: i = sc->sc_lastcmd; ! 1015: if ((cp->ca_cmddsc[i] & (UDA_OWN|UDA_INT)) == UDA_INT) { ! 1016: cp->ca_cmddsc[i] &= ~UDA_INT; ! 1017: mp = &uda[um->um_ctlr].uda_cmd[i]; ! 1018: mp->mscp_unit = mp->mscp_modifier = 0; ! 1019: mp->mscp_opcode = mp->mscp_flags = 0; ! 1020: mp->mscp_bytecnt = mp->mscp_buffer = 0; ! 1021: mp->mscp_errlgfl = mp->mscp_copyspd = 0; ! 1022: sc->sc_lastcmd = (i + 1) % NCMD; ! 1023: return(mp); ! 1024: } ! 1025: return(NULL); ! 1026: } ! 1027: ! 1028: udaphys(bp) ! 1029: struct buf *bp; ! 1030: { ! 1031: if(bp->b_bcount > 65536) ! 1032: bp->b_bcount = 65536; ! 1033: } ! 1034: ! 1035: udread(dev) ! 1036: dev_t dev; ! 1037: { ! 1038: int unit = DUNIT(minor(dev)); ! 1039: ! 1040: if (unit >= NRA) ! 1041: u.u_error = ENXIO; ! 1042: else ! 1043: physio(udstrategy, &rudbuf[unit], dev, B_READ, udaphys); ! 1044: } ! 1045: ! 1046: udwrite(dev) ! 1047: dev_t dev; ! 1048: { ! 1049: int unit = DUNIT(minor(dev)); ! 1050: ! 1051: if (unit >= NRA) ! 1052: u.u_error = ENXIO; ! 1053: else ! 1054: physio(udstrategy, &rudbuf[unit], dev, B_WRITE, udaphys); ! 1055: } ! 1056: ! 1057: udioctl(dev, cmd, addr, flag) ! 1058: dev_t dev; ! 1059: caddr_t addr; ! 1060: { ! 1061: register int unit; ! 1062: register union arg { ! 1063: struct ud_rctbuf r; ! 1064: struct ud_repl b; ! 1065: } *uap; ! 1066: register struct ud_unit *uu; ! 1067: register int i; ! 1068: ! 1069: unit = DUNIT(minor(dev)); ! 1070: if (unit >= NRA) { ! 1071: u.u_error = ENXIO; ! 1072: return; ! 1073: } ! 1074: if ((uddinfo[unit]->ui_flags & (DGTUNIT | DUP)) != DUP) { ! 1075: /* should bring it online here */ ! 1076: u.u_error = EIO; ! 1077: return; ! 1078: } ! 1079: uu = &ud_units[unit]; ! 1080: uap = (union arg *)addr; ! 1081: switch(cmd) { ! 1082: default: ! 1083: u.u_error = ENOTTY; ! 1084: return; ! 1085: ! 1086: case UIOCHAR: ! 1087: if (copyout((caddr_t)uu, addr, sizeof(struct ud_unit))) ! 1088: u.u_error = EFAULT; ! 1089: return; ! 1090: ! 1091: case UIORRCT: ! 1092: if(uap->r.lbn < 0 || uap->r.lbn > uu->rctsize) { ! 1093: u.u_error = EIO; ! 1094: return; ! 1095: } ! 1096: /* ! 1097: * try different copies until one works ! 1098: */ ! 1099: for (i = 0; i < uu->copies; i++) { ! 1100: u.u_count = SECTOR; /* block size on disk */ ! 1101: u.u_offset = (uap->r.lbn + uu->radsize) * (daddr_t)SECTOR; ! 1102: u.u_offset += i * uu->rctsize * (daddr_t)SECTOR; ! 1103: u.u_base = uap->r.buf; ! 1104: u.u_segflg = 0; ! 1105: u.u_error = 0; ! 1106: physio(udstrategy, &rctbuf[unit], dev, B_READ, udaphys); ! 1107: if (u.u_error == 0) ! 1108: break; ! 1109: } ! 1110: return; ! 1111: ! 1112: case UIOWRCT: ! 1113: if ((flag & FWRITE) == 0) { ! 1114: u.u_error = EBADF; ! 1115: return; ! 1116: } ! 1117: if(uap->r.lbn < 0 || uap->r.lbn > uu->rctsize) { ! 1118: u.u_error = EIO; ! 1119: return; ! 1120: } ! 1121: /* ! 1122: * write every copy we can ! 1123: * should do read-after-write crap ! 1124: */ ! 1125: for (i = 0; i < uu->copies; i++) { ! 1126: u.u_count = SECTOR; /* block size on disk */ ! 1127: u.u_offset = (uap->r.lbn + uu->radsize) * (daddr_t)SECTOR; ! 1128: u.u_offset += i * uu->rctsize * (daddr_t)SECTOR; ! 1129: u.u_base = uap->r.buf; ! 1130: u.u_segflg = 0; ! 1131: physio(udstrategy, &rctbuf[unit], dev, B_WRITE, udaphys); ! 1132: u.u_error = 0; ! 1133: } ! 1134: return; ! 1135: ! 1136: case UIOREPL: ! 1137: if ((flag & FWRITE) == 0) { ! 1138: u.u_error = EBADF; ! 1139: return; ! 1140: } ! 1141: udreplace(dev, uap->b.lbn, uap->b.replbn, uap->b.prim); ! 1142: return; ! 1143: } ! 1144: } ! 1145: ! 1146: udreplace(dev, badlbn, replbn, prim) ! 1147: int dev; ! 1148: daddr_t badlbn; ! 1149: daddr_t replbn; ! 1150: int prim; ! 1151: { ! 1152: register struct mscp *mp; ! 1153: register struct uba_ctlr *um; ! 1154: register int unit; ! 1155: struct uda_softc *sc; ! 1156: ! 1157: unit = DUNIT(minor(dev)); ! 1158: um = uddinfo[unit]->ui_mi; ! 1159: sc = &uda_softc[um->um_ctlr]; ! 1160: spl6(); ! 1161: while (ud_rflags & RPLOCK) { ! 1162: ud_rflags |= RPWANT; ! 1163: sleep((caddr_t)&ud_rflags, PZERO + 1); ! 1164: } ! 1165: ud_rflags = RPLOCK; ! 1166: printf("uda%d ra%d replace %D with %D\n", ! 1167: um->um_ctlr, unit, badlbn, replbn); ! 1168: udcredit(sc, 1); ! 1169: if ((mp = udgetcp(um)) == NULL) { ! 1170: u.u_error = EIO; ! 1171: goto out; ! 1172: } ! 1173: mp->mscp_cmdref = 42; /* anything you like */ ! 1174: mp->mscp_unit = unit; ! 1175: mp->mscp_opcode = M_OP_REPLC; ! 1176: mp->mscp_rbn = replbn; ! 1177: mp->mscp_lbn = badlbn; ! 1178: mp->mscp_modifier = prim ? M_MD_PRIMR : 0; ! 1179: udsend(mp, sc); ! 1180: while ((ud_rflags & RPDONE) == 0) ! 1181: sleep((caddr_t)&ud_rret, PZERO); ! 1182: u.u_error = ud_rret; ! 1183: out: ! 1184: if (ud_rflags & RPWANT) ! 1185: wakeup((caddr_t)&ud_rflags); ! 1186: ud_rflags = 0; ! 1187: spl0(); ! 1188: } ! 1189: ! 1190: udreset(uban) ! 1191: int uban; ! 1192: { ! 1193: register struct uba_ctlr *um; ! 1194: register struct uba_device *ui; ! 1195: register struct buf *bp, *dp; ! 1196: register int unit; ! 1197: struct buf *nbp; ! 1198: int d; ! 1199: ! 1200: for (d = 0; d < NUDA; d++) { ! 1201: if ((um = udminfo[d]) == 0 || um->um_ubanum != uban || ! 1202: um->um_alive == 0) ! 1203: continue; ! 1204: printf(" uda%d", d); ! 1205: um->um_tab.b_active = 0; ! 1206: um->um_tab.b_actf = um->um_tab.b_actl = 0; ! 1207: uda_softc[d].sc_state = S_IDLE; ! 1208: for (unit = 0; unit < NRA; unit++) { ! 1209: if ((ui = uddinfo[unit]) == 0) ! 1210: continue; ! 1211: if (ui->ui_alive == 0 || ui->ui_mi != um) ! 1212: continue; ! 1213: udutab[unit].b_active = 0; ! 1214: udutab[unit].b_qsize = 0; ! 1215: } ! 1216: for (bp = udwtab[d].av_forw; bp != &udwtab[d]; bp = nbp) { ! 1217: nbp = bp->av_forw; ! 1218: ubarelse(uban, (int *)&bp->b_ubinfo); ! 1219: /* ! 1220: * Link the buffer onto the drive queue ! 1221: */ ! 1222: dp = &udutab[dkunit(bp)]; ! 1223: if (dp->b_actf == 0) ! 1224: dp->b_actf = bp; ! 1225: else ! 1226: dp->b_actl->av_forw = bp; ! 1227: dp->b_actl = bp; ! 1228: bp->av_forw = 0; ! 1229: /* ! 1230: * Link the drive onto the controller queue ! 1231: */ ! 1232: if (dp->b_active == 0) { ! 1233: dp->b_forw = NULL; ! 1234: if (um->um_tab.b_actf == NULL) ! 1235: um->um_tab.b_actf = dp; ! 1236: else ! 1237: um->um_tab.b_actl->b_forw = dp; ! 1238: um->um_tab.b_actl = dp; ! 1239: dp->b_active = 1; ! 1240: } ! 1241: } ! 1242: udinit(d); ! 1243: } ! 1244: } ! 1245: ! 1246: /* ! 1247: * crash dumps ! 1248: */ ! 1249: ! 1250: #define DBSIZE 64 ! 1251: ! 1252: #define ca_Rspdsc ca_rspdsc[0] ! 1253: #define ca_Cmddsc ca_rspdsc[1] ! 1254: #define uda_Rsp uda_rsp[0] ! 1255: #define uda_Cmd uda_cmd[0] ! 1256: ! 1257: uddump(dev) ! 1258: dev_t dev; ! 1259: { ! 1260: struct udadevice *udaddr; ! 1261: struct uda *ud_ubaddr; ! 1262: char *start; ! 1263: int num, blk, unit; ! 1264: int maxsz; ! 1265: int blkoff; ! 1266: register struct uba_regs *uba; ! 1267: register struct uba_device *ui; ! 1268: register struct uda *udp; ! 1269: register struct pte *io; ! 1270: register int i; ! 1271: ! 1272: unit = DUNIT(minor(dev)); ! 1273: if (unit >= NRA) ! 1274: return (ENXIO); ! 1275: #define phys(cast, addr) ((cast)((int)addr & 0x7fffffff)) ! 1276: ui = phys(struct uba_device *, uddinfo[unit]); ! 1277: if (ui->ui_alive == 0) ! 1278: return (ENXIO); ! 1279: uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba; ! 1280: ubainit(uba); ! 1281: udaddr = (struct udadevice *)ui->ui_physaddr; ! 1282: DELAY(2000000); ! 1283: udp = phys(struct uda *, &uda[ui->ui_ctlr]); ! 1284: ! 1285: num = btoc(sizeof(struct uda)) + 1; ! 1286: io = &uba->uba_map[NUBMREG-num]; ! 1287: for(i = 0; i<num; i++) ! 1288: *(int *)io++ = UBAMR_MRV|(btop(udp)+i); ! 1289: ud_ubaddr = (struct uda *)(((int)udp & PGOFSET)|((NUBMREG-num)<<9)); ! 1290: ! 1291: udaddr->udaip = 0; ! 1292: while ((udaddr->udasa & UDA_STEP1) == 0) ! 1293: if(udaddr->udasa & UDA_ERR) return(EFAULT); ! 1294: udaddr->udasa = UDA_ERR; ! 1295: while ((udaddr->udasa & UDA_STEP2) == 0) ! 1296: if(udaddr->udasa & UDA_ERR) return(EFAULT); ! 1297: udaddr->udasa = (short)&ud_ubaddr->uda_ca.ca_ringbase; ! 1298: while ((udaddr->udasa & UDA_STEP3) == 0) ! 1299: if(udaddr->udasa & UDA_ERR) return(EFAULT); ! 1300: udaddr->udasa = (short)(((int)&ud_ubaddr->uda_ca.ca_ringbase) >> 16); ! 1301: while ((udaddr->udasa & UDA_STEP4) == 0) ! 1302: if(udaddr->udasa & UDA_ERR) return(EFAULT); ! 1303: udaddr->udasa = UDA_GO; ! 1304: udp->uda_ca.ca_Rspdsc = (long)&ud_ubaddr->uda_Rsp.mscp_cmdref; ! 1305: udp->uda_ca.ca_Cmddsc = (long)&ud_ubaddr->uda_Cmd.mscp_cmdref; ! 1306: udp->uda_Cmd.mscp_cntflgs = 0; ! 1307: udp->uda_Cmd.mscp_version = 0; ! 1308: if (dudcmd(M_OP_STCON, udp, udaddr) == 0) ! 1309: return(EFAULT); ! 1310: udp->uda_Cmd.mscp_unit = ui->ui_slave; ! 1311: if (dudcmd(M_OP_ONLIN, udp, udaddr) == 0) ! 1312: return(EFAULT); ! 1313: num = physmem; ! 1314: start = 0; ! 1315: maxsz = ra_sizes[PART(minor(dev))].nblocks; ! 1316: blkoff = ra_sizes[PART(minor(dev))].blkoff; ! 1317: if(maxsz < 0) ! 1318: maxsz = ud_units[unit].radsize-blkoff; ! 1319: if (dumplo < 0 || dumplo + num >= maxsz) ! 1320: return (EINVAL); ! 1321: blkoff += dumplo; ! 1322: while (num > 0) { ! 1323: blk = num > DBSIZE ? DBSIZE : num; ! 1324: io = uba->uba_map; ! 1325: for (i = 0; i < blk; i++) ! 1326: *(int *)io++ = (btop(start)+i) | UBAMR_MRV; ! 1327: *(int *)io = 0; ! 1328: udp->uda_Cmd.mscp_lbn = btop(start) + blkoff; ! 1329: udp->uda_Cmd.mscp_unit = ui->ui_slave; ! 1330: udp->uda_Cmd.mscp_bytecnt = blk*NBPG; ! 1331: udp->uda_Cmd.mscp_buffer = 0; ! 1332: if (dudcmd(M_OP_WRITE, udp, udaddr) == 0) { ! 1333: return(EIO); ! 1334: } ! 1335: start += blk*NBPG; ! 1336: num -= blk; ! 1337: } ! 1338: return (0); ! 1339: } ! 1340: ! 1341: static ! 1342: dudcmd(op, udp, udaddr) ! 1343: int op; ! 1344: register struct uda *udp; ! 1345: struct udadevice *udaddr; ! 1346: { ! 1347: int i; ! 1348: ! 1349: udp->uda_Cmd.mscp_opcode = op; ! 1350: udp->uda_Rsp.mscp_header.uda_msglen = sizeof (struct mscp); ! 1351: udp->uda_Cmd.mscp_header.uda_msglen = sizeof (struct mscp); ! 1352: udp->uda_ca.ca_Rspdsc |= UDA_OWN|UDA_INT; ! 1353: udp->uda_ca.ca_Cmddsc |= UDA_OWN|UDA_INT; ! 1354: i = udaddr->udaip; ! 1355: for (;;) { ! 1356: if (udp->uda_ca.ca_cmdint) ! 1357: udp->uda_ca.ca_cmdint = 0; ! 1358: if (udp->uda_ca.ca_rspint) ! 1359: break; ! 1360: } ! 1361: udp->uda_ca.ca_rspint = 0; ! 1362: if (udp->uda_Rsp.mscp_opcode != (op|M_OP_END) || ! 1363: (udp->uda_Rsp.mscp_status&M_ST_MASK) != M_ST_SUCC) { ! 1364: if(udaddr->udasa&UDA_ERR) ! 1365: printf("error: udasa 0x%x\ndump ", udaddr->udasa); ! 1366: printf("error: com %d opc 0x%x stat 0x%x\ndump ", ! 1367: op, ! 1368: udp->uda_Rsp.mscp_opcode, ! 1369: udp->uda_Rsp.mscp_status); ! 1370: return(0); ! 1371: } ! 1372: return(1); ! 1373: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.