![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ik.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / tahoevba|
Return to ik.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / tahoevba |
1.1 ! root 1: /* ! 2: * @(#)ik.c 7.1 (Berkeley) 5/31/88 ! 3: */ ! 4: ! 5: #include "ik.h" ! 6: #if NIK > 0 ! 7: /* ! 8: * PS300/IKON DR-11W Device Driver. ! 9: */ ! 10: #include "param.h" ! 11: #include "buf.h" ! 12: #include "cmap.h" ! 13: #include "conf.h" ! 14: #include "dir.h" ! 15: #include "dkstat.h" ! 16: #include "map.h" ! 17: #include "systm.h" ! 18: #include "user.h" ! 19: #include "vmmac.h" ! 20: #include "proc.h" ! 21: #include "uio.h" ! 22: #include "kernel.h" ! 23: #include "syslog.h" ! 24: ! 25: #include "../tahoe/mtpr.h" ! 26: #include "../tahoe/pte.h" ! 27: ! 28: #include "../tahoevba/vbavar.h" ! 29: #include "../tahoevba/ikreg.h" ! 30: #include "../tahoevba/psreg.h" ! 31: #include "../tahoevba/psproto.h" ! 32: ! 33: int ikprobe(), ikattach(), iktimer(); ! 34: struct vba_device *ikinfo[NIK]; ! 35: long ikstd[] = { 0 }; ! 36: struct vba_driver ikdriver = { ikprobe, 0, ikattach, 0, ikstd, "ik", ikinfo }; ! 37: ! 38: #define splik() spl4() ! 39: /* ! 40: * Devices are organized in pairs with the odd valued ! 41: * device being used for ``diagnostic'' purposes. That ! 42: * is diagnostic devices don't get auto-attach'd and ! 43: * detach'd on open-close. ! 44: */ ! 45: #define IKUNIT(dev) (minor(dev) >> 1) ! 46: #define IKDIAG(dev) (minor(dev) & 01) /* is a diagnostic unit */ ! 47: ! 48: struct ik_softc { ! 49: uid_t is_uid; /* uid of open processes */ ! 50: u_short is_timeout; /* current timeout (seconds) */ ! 51: u_short is_error; /* internal error codes */ ! 52: u_short is_flags; ! 53: #define IKF_ATTACHED 0x1 /* unit is attached (not used yet) */ ! 54: union { ! 55: u_short w[2]; ! 56: u_long l; ! 57: } is_nameaddr; /* address of last symbol lookup */ ! 58: caddr_t is_buf[PS_MAXDMA];/* i/o buffer XXX */ ! 59: } ik_softc[NIK]; ! 60: ! 61: struct buf iktab[NIK]; /* unit command queue headers */ ! 62: struct buf rikbuf[NIK]; /* buffers for read/write operations */ ! 63: struct buf cikbuf[NIK]; /* buffers for control operations */ ! 64: ! 65: /* buf overlay definitions */ ! 66: #define b_command b_resid ! 67: ! 68: int ikdiotimo = PS_DIOTIMO; /* dio polling timeout */ ! 69: int iktimeout = PS_TIMEOUT; /* attention/dma timeout (in hz) */ ! 70: ! 71: ikprobe(reg, vi) ! 72: caddr_t reg; ! 73: struct vba_device *vi; ! 74: { ! 75: register int br, cvec; /* r12, r11 */ ! 76: register struct ikdevice *ik; ! 77: ! 78: #ifdef lint ! 79: br = 0; cvec = br; br = cvec; ! 80: ikintr(0); ! 81: #endif ! 82: if (badaddr(reg, 2)) ! 83: return (0); ! 84: ik = (struct ikdevice *)reg; ! 85: ik->ik_vec = --vi->ui_hd->vh_lastiv; ! 86: /* ! 87: * Use extended non-privileged address modifier ! 88: * to avoid address overlap with 24-bit devices. ! 89: */ ! 90: ik->ik_mod = 0xf1; /* address modifier */ ! 91: /* ! 92: * Try and reset the PS300. Since this ! 93: * won't work if it's powered off, we ! 94: * can't use sucess/failure to decide ! 95: * if the device is present. ! 96: */ ! 97: br = 0; ! 98: (void) psreset(ik, IKCSR_IENA); ! 99: if (br == 0) /* XXX */ ! 100: br = 0x18, cvec = ik->ik_vec; /* XXX */ ! 101: return (sizeof (struct ikdevice)); ! 102: } ! 103: ! 104: /* ! 105: * Perform a ``hard'' reset. ! 106: */ ! 107: psreset(ik, iena) ! 108: register struct ikdevice *ik; ! 109: { ! 110: ! 111: ik->ik_csr = IKCSR_MCLR|iena; ! 112: DELAY(10000); ! 113: ik->ik_csr = IKCSR_FNC3|iena; ! 114: if (!iena) ! 115: return (dioread(ik) == PS_RESET); ! 116: return (1); ! 117: } ! 118: ! 119: ikattach(vi) ! 120: struct vba_device *vi; ! 121: { ! 122: ! 123: ik_softc[vi->ui_unit].is_uid = -1; ! 124: } ! 125: ! 126: /* ! 127: * Open a PS300 and attach. We allow multiple ! 128: * processes with the same uid to share a unit. ! 129: */ ! 130: /*ARGSUSED*/ ! 131: ikopen(dev, flag) ! 132: dev_t dev; ! 133: int flag; ! 134: { ! 135: register int unit = IKUNIT(dev); ! 136: register struct ik_softc *sc; ! 137: struct vba_device *vi; ! 138: struct ikdevice *ik; ! 139: int reset; ! 140: ! 141: if (unit >= NIK || (vi = ikinfo[unit]) == 0 || vi->ui_alive == 0) ! 142: return (ENXIO); ! 143: sc = &ik_softc[unit]; ! 144: if (sc->is_uid != (uid_t)-1 && sc->is_uid != u.u_uid) ! 145: return (EBUSY); ! 146: if (sc->is_uid == (uid_t)-1) { ! 147: sc->is_timeout = 0; ! 148: timeout(iktimer, (caddr_t)unit, hz); ! 149: /* ! 150: * Perform PS300 attach for first process. ! 151: */ ! 152: if (!IKDIAG(dev)) { ! 153: reset = 0; ! 154: again: ! 155: if (ikcommand(dev, PS_ATTACH, 1)) { ! 156: /* ! 157: * If attach fails, perform a hard ! 158: * reset once, then retry the command. ! 159: */ ! 160: ik = (struct ikdevice *)ikinfo[unit]->ui_addr; ! 161: if (!reset++ && psreset(ik, 0)) ! 162: goto again; ! 163: untimeout(iktimer, (caddr_t)unit); ! 164: return (EIO); ! 165: } ! 166: } ! 167: sc->is_uid = u.u_uid; ! 168: } ! 169: return (0); ! 170: } ! 171: ! 172: /*ARGSUSED*/ ! 173: ikclose(dev, flag) ! 174: dev_t dev; ! 175: int flag; ! 176: { ! 177: int unit = IKUNIT(dev); ! 178: register struct ik_softc *sc = &ik_softc[unit]; ! 179: ! 180: if (!IKDIAG(dev)) ! 181: (void) ikcommand(dev, PS_DETACH, 1); /* auto detach */ ! 182: sc->is_uid = -1; ! 183: untimeout(iktimer, (caddr_t)unit); ! 184: } ! 185: ! 186: ikread(dev, uio) ! 187: dev_t dev; ! 188: struct uio *uio; ! 189: { ! 190: ! 191: return (ikrw(dev, uio, B_READ)); ! 192: } ! 193: ! 194: ikwrite(dev, uio) ! 195: dev_t dev; ! 196: struct uio *uio; ! 197: { ! 198: ! 199: return (ikrw(dev, uio, B_WRITE)); ! 200: } ! 201: ! 202: /* ! 203: * Take read/write request and perform physical i/o ! 204: * transaction with PS300. This involves constructing ! 205: * a physical i/o request vector based on the uio ! 206: * vector, performing the dma, and, finally, moving ! 207: * the data to it's final destination (because of CCI ! 208: * VERSAbus bogosities). ! 209: */ ! 210: ikrw(dev, uio, rw) ! 211: dev_t dev; ! 212: register struct uio *uio; ! 213: int rw; ! 214: { ! 215: int error, unit = IKUNIT(dev), s, wrcmd; ! 216: register struct buf *bp; ! 217: register struct iovec *iov; ! 218: register struct psalist *ap; ! 219: struct ik_softc *sc = &ik_softc[unit]; ! 220: ! 221: if (unit >= NIK) ! 222: return (ENXIO); ! 223: bp = &rikbuf[unit]; ! 224: error = 0, iov = uio->uio_iov, wrcmd = PS_WRPHY; ! 225: for (; !error && uio->uio_iovcnt; iov++, uio->uio_iovcnt--) { ! 226: /* ! 227: * Hack way to set PS300 address w/o doing an lseek ! 228: * and specify write physical w/ refresh synchronization. ! 229: */ ! 230: if (iov->iov_len == 0) { ! 231: if ((int)iov->iov_base&PSIO_SYNC) ! 232: wrcmd = PS_WRPHY_SYNC; ! 233: uio->uio_offset = (int)iov->iov_base & ~PSIO_SYNC; ! 234: continue; ! 235: } ! 236: if (iov->iov_len > PS_MAXDMA) { ! 237: sc->is_error = PSERROR_INVALBC, error = EINVAL; ! 238: continue; ! 239: } ! 240: if ((int)uio->uio_offset&01) { ! 241: sc->is_error = PSERROR_BADADDR, error = EINVAL; ! 242: continue; ! 243: } ! 244: s = splbio(); ! 245: while (bp->b_flags&B_BUSY) { ! 246: bp->b_flags |= B_WANTED; ! 247: sleep((caddr_t)bp, PRIBIO+1); ! 248: } ! 249: splx(s); ! 250: bp->b_flags = B_BUSY | rw; ! 251: /* ! 252: * Construct address descriptor in buffer. ! 253: */ ! 254: ap = (struct psalist *)sc->is_buf; ! 255: ap->nblocks = 1; ! 256: /* work-around dr300 word swapping */ ! 257: ap->addr[0] = uio->uio_offset & 0xffff; ! 258: ap->addr[1] = uio->uio_offset >> 16; ! 259: ap->wc = (iov->iov_len + 1) >> 1; ! 260: if (rw == B_WRITE) { ! 261: error = copyin(iov->iov_base, (caddr_t)&ap[1], ! 262: (unsigned)iov->iov_len); ! 263: if (!error) ! 264: error = ikcommand(dev, wrcmd, ! 265: iov->iov_len + sizeof (*ap)); ! 266: } else { ! 267: caddr_t cp; ! 268: int len; ! 269: ! 270: error = ikcommand(dev, PS_RDPHY, sizeof (*ap)); ! 271: cp = (caddr_t)&ap[1], len = iov->iov_len; ! 272: for (; len > 0; len -= NBPG, cp += NBPG) ! 273: mtpr(P1DC, cp); ! 274: if (!error) ! 275: error = copyout((caddr_t)&ap[1], iov->iov_base, ! 276: (unsigned)iov->iov_len); ! 277: } ! 278: (void) splbio(); ! 279: if (bp->b_flags&B_WANTED) ! 280: wakeup((caddr_t)bp); ! 281: splx(s); ! 282: uio->uio_resid -= iov->iov_len; ! 283: uio->uio_offset += iov->iov_len; ! 284: bp->b_flags &= ~(B_BUSY|B_WANTED); ! 285: } ! 286: return (error); ! 287: } ! 288: ! 289: /* ! 290: * Perform a PS300 command. ! 291: */ ! 292: ikcommand(dev, com, count) ! 293: dev_t dev; ! 294: int com, count; ! 295: { ! 296: register struct buf *bp; ! 297: register int s; ! 298: ! 299: bp = &cikbuf[IKUNIT(dev)]; ! 300: s = splik(); ! 301: while (bp->b_flags&B_BUSY) { ! 302: if (bp->b_flags&B_DONE) ! 303: break; ! 304: bp->b_flags |= B_WANTED; ! 305: sleep((caddr_t)bp, PRIBIO); ! 306: } ! 307: bp->b_flags = B_BUSY|B_READ; ! 308: splx(s); ! 309: bp->b_dev = dev; ! 310: bp->b_command = com; ! 311: bp->b_bcount = count; ! 312: ikstrategy(bp); ! 313: biowait(bp); ! 314: if (bp->b_flags&B_WANTED) ! 315: wakeup((caddr_t)bp); ! 316: bp->b_flags &= B_ERROR; ! 317: return (geterror(bp)); ! 318: } ! 319: ! 320: /* ! 321: * Physio strategy routine ! 322: */ ! 323: ikstrategy(bp) ! 324: register struct buf *bp; ! 325: { ! 326: register struct buf *dp; ! 327: ! 328: /* ! 329: * Put request at end of controller queue. ! 330: */ ! 331: dp = &iktab[IKUNIT(bp->b_dev)]; ! 332: bp->av_forw = NULL; ! 333: (void) splik(); ! 334: if (dp->b_actf != NULL) { ! 335: dp->b_actl->av_forw = bp; ! 336: dp->b_actl = bp; ! 337: } else ! 338: dp->b_actf = dp->b_actl = bp; ! 339: if (!dp->b_active) ! 340: ikstart(dp); ! 341: (void) spl0(); ! 342: } ! 343: ! 344: /* ! 345: * Start the next command on the controller's queue. ! 346: */ ! 347: ikstart(dp) ! 348: register struct buf *dp; ! 349: { ! 350: register struct buf *bp; ! 351: register struct ikdevice *ik; ! 352: register struct ik_softc *sc; ! 353: u_short bc, csr; ! 354: u_int addr; ! 355: int unit; ! 356: ! 357: loop: ! 358: /* ! 359: * Pull a request off the controller queue ! 360: */ ! 361: if ((bp = dp->b_actf) == NULL) { ! 362: dp->b_active = 0; ! 363: return; ! 364: } ! 365: /* ! 366: * Mark controller busy and process this request. ! 367: */ ! 368: dp->b_active = 1; ! 369: unit = IKUNIT(bp->b_dev); ! 370: sc = &ik_softc[unit]; ! 371: ik = (struct ikdevice *)ikinfo[unit]->ui_addr; ! 372: switch ((int)bp->b_command) { ! 373: ! 374: case PS_ATTACH: /* logical unit attach */ ! 375: case PS_DETACH: /* logical unit detach */ ! 376: case PS_LOOKUP: /* name lookup */ ! 377: case PS_RDPHY: /* physical i/o read */ ! 378: case PS_WRPHY: /* physical i/o write */ ! 379: case PS_WRPHY_SYNC: /* physical i/o write w/ sync */ ! 380: /* ! 381: * Handshake command and, optionally, ! 382: * byte count and byte swap flag. ! 383: */ ! 384: if (sc->is_error = diowrite(ik, (u_short)bp->b_command)) ! 385: goto bad; ! 386: if (bp->b_command < PS_DETACH) { ! 387: if (sc->is_error = diowrite(ik, (u_short)bp->b_bcount)) ! 388: goto bad; ! 389: if (sc->is_error = diowrite(ik, (u_short)0 /* !swab */)) ! 390: goto bad; ! 391: } ! 392: /* ! 393: * Set timeout and wait for an attention interrupt. ! 394: */ ! 395: sc->is_timeout = iktimeout; ! 396: return; ! 397: ! 398: case PS_DMAOUT: /* dma data host->PS300 */ ! 399: bc = bp->b_bcount; ! 400: csr = IKCSR_CYCLE; ! 401: break; ! 402: ! 403: case PS_DMAIN: /* dma data PS300->host */ ! 404: bc = bp->b_bcount; ! 405: csr = IKCSR_CYCLE|IKCSR_FNC1; ! 406: break; ! 407: ! 408: default: ! 409: log(LOG_ERR, "ik%d: bad cmd %x\n", unit, bp->b_command); ! 410: sc->is_error = PSERROR_BADCMD; ! 411: goto bad; ! 412: } ! 413: /* initiate dma transfer */ ! 414: addr = vtoph((struct proc *)0, (unsigned)sc->is_buf); ! 415: ik->ik_bahi = addr >> 17; ! 416: ik->ik_balo = (addr >> 1) & 0xffff; ! 417: ik->ik_wc = ((bc + 1) >> 1) - 1; /* round & convert */ ! 418: ik->ik_pulse = IKPULSE_RATTF|IKPULSE_RDMAF; ! 419: sc->is_timeout = iktimeout; ! 420: ik->ik_csr = IKCSR_IENA|IKCSR_GO|csr; ! 421: return; ! 422: bad: ! 423: bp->b_flags |= B_ERROR; ! 424: dp->b_actf = bp->av_forw; /* remove from queue */ ! 425: biodone(bp); ! 426: goto loop; ! 427: } ! 428: ! 429: #define FETCHWORD(i) { \ ! 430: v = dioread(ik); \ ! 431: if (v == -1) { \ ! 432: sc->is_error = PSERROR_NAMETIMO; \ ! 433: goto bad; \ ! 434: } \ ! 435: sc->is_nameaddr.w[i] = v; \ ! 436: } ! 437: ! 438: /* ! 439: * Process a device interrupt. ! 440: */ ! 441: ikintr(ikon) ! 442: int ikon; ! 443: { ! 444: register struct ikdevice *ik; ! 445: register struct buf *bp, *dp; ! 446: struct ik_softc *sc; ! 447: register u_short data; ! 448: int v; ! 449: ! 450: /* should go by controller, but for now... */ ! 451: if (ikinfo[ikon] == 0) ! 452: return; ! 453: ik = (struct ikdevice *)ikinfo[ikon]->ui_addr; ! 454: /* ! 455: * Discard all non-attention interrupts. The ! 456: * interrupts we're throwing away should all be ! 457: * associated with DMA completion. ! 458: */ ! 459: data = ik->ik_data; ! 460: if ((ik->ik_csr&(IKCSR_ATTF|IKCSR_STATC)) != IKCSR_ATTF) { ! 461: ik->ik_pulse = IKPULSE_RATTF|IKPULSE_RDMAF|IKPULSE_SIENA; ! 462: return; ! 463: } ! 464: /* ! 465: * Fetch attention code immediately. ! 466: */ ! 467: ik->ik_csr = IKCSR_RATTF|IKCSR_RDMAF|IKCSR_FNC1; ! 468: ik->ik_pulse = IKPULSE_FNC2; ! 469: /* ! 470: * Get device and block structures, and a pointer ! 471: * to the vba_device for the device. We receive an ! 472: * unsolicited interrupt whenever the PS300 is power ! 473: * cycled (so ignore it in that case). ! 474: */ ! 475: dp = &iktab[ikon]; ! 476: if ((bp = dp->b_actf) == NULL) { ! 477: if (PS_CODE(data) != PS_RESET) /* power failure */ ! 478: log(LOG_WARNING, "ik%d: spurious interrupt, code %x\n", ! 479: ikon, data); ! 480: goto enable; ! 481: } ! 482: sc = &ik_softc[IKUNIT(bp->b_dev)]; ! 483: sc->is_timeout = 0; /* disable timer */ ! 484: switch (PS_CODE(data)) { ! 485: ! 486: case PS_LOOKUP: /* name lookup */ ! 487: if (data == PS_LOOKUP) { /* dma name */ ! 488: bp->b_command = PS_DMAOUT; ! 489: goto opcont; ! 490: } ! 491: if (data == PS_DMAOK(PS_LOOKUP)) { ! 492: /* reenable interrupt and wait for address */ ! 493: sc->is_timeout = iktimeout; ! 494: goto enable; ! 495: } ! 496: /* ! 497: * Address should be present, extract it one ! 498: * word at a time from the PS300 (yech). ! 499: */ ! 500: if (data != PS_ADROK(PS_LOOKUP)) ! 501: goto bad; ! 502: FETCHWORD(0); ! 503: FETCHWORD(1); ! 504: goto opdone; ! 505: ! 506: case PS_WRPHY_SYNC: /* physical i/o write w/ sync */ ! 507: if (data == PS_WRPHY_SYNC) { /* start dma transfer */ ! 508: bp->b_command = PS_DMAOUT; ! 509: goto opcont; ! 510: } ! 511: if (data != PS_DMAOK(PS_WRPHY_SYNC)) ! 512: goto bad; ! 513: goto opdone; ! 514: ! 515: case PS_WRPHY: /* physical i/o write */ ! 516: if (data == PS_WRPHY) { /* start dma transfer */ ! 517: bp->b_command = PS_DMAOUT; ! 518: goto opcont; ! 519: } ! 520: if (data != PS_DMAOK(PS_WRPHY)) ! 521: goto bad; ! 522: goto opdone; ! 523: ! 524: case PS_ATTACH: /* attach unit */ ! 525: case PS_DETACH: /* detach unit */ ! 526: case PS_ABORT: /* abort code from ps300 */ ! 527: if (data != bp->b_command) ! 528: goto bad; ! 529: goto opdone; ! 530: ! 531: case PS_RDPHY: /* physical i/o read */ ! 532: if (data == PS_RDPHY) { /* dma address list */ ! 533: bp->b_command = PS_DMAOUT; ! 534: goto opcont; ! 535: } ! 536: if (data == PS_ADROK(PS_RDPHY)) { ! 537: /* collect read byte count and start dma */ ! 538: bp->b_bcount = dioread(ik); ! 539: if (bp->b_bcount == -1) ! 540: goto bad; ! 541: bp->b_command = PS_DMAIN; ! 542: goto opcont; ! 543: } ! 544: if (data == PS_DMAOK(PS_RDPHY)) ! 545: goto opdone; ! 546: goto bad; ! 547: } ! 548: bad: ! 549: sc->is_error = data; ! 550: bp->b_flags |= B_ERROR; ! 551: opdone: ! 552: dp->b_actf = bp->av_forw; /* remove from queue */ ! 553: biodone(bp); ! 554: opcont: ! 555: ikstart(dp); ! 556: enable: ! 557: ik->ik_pulse = IKPULSE_SIENA; /* explicitly reenable */ ! 558: } ! 559: ! 560: /* ! 561: * Watchdog timer. ! 562: */ ! 563: iktimer(unit) ! 564: int unit; ! 565: { ! 566: register struct ik_softc *sc = &ik_softc[unit]; ! 567: ! 568: if (sc->is_timeout && --sc->is_timeout == 0) { ! 569: register struct buf *dp, *bp; ! 570: int s; ! 571: ! 572: log(LOG_ERR, "ik%d: timeout\n", unit); ! 573: s = splik(); ! 574: /* should abort current command */ ! 575: dp = &iktab[unit]; ! 576: if (bp = dp->b_actf) { ! 577: sc->is_error = PSERROR_CMDTIMO; ! 578: bp->b_flags |= B_ERROR; ! 579: dp->b_actf = bp->av_forw; /* remove from queue */ ! 580: biodone(bp); ! 581: ikstart(dp); ! 582: } ! 583: splx(s); ! 584: } ! 585: timeout(iktimer, (caddr_t)unit, hz); ! 586: } ! 587: ! 588: /* ! 589: * Handshake read from DR300. ! 590: */ ! 591: dioread(ik) ! 592: register struct ikdevice *ik; ! 593: { ! 594: register int t; ! 595: u_short data; ! 596: ! 597: for (t = ikdiotimo; t > 0; t--) ! 598: if ((ik->ik_csr&(IKCSR_ATTF|IKCSR_STATC)) == IKCSR_ATTF) { ! 599: data = ik->ik_data; ! 600: ik->ik_csr = IKCSR_RATTF|IKCSR_RDMAF|IKCSR_FNC1; ! 601: ik->ik_pulse = IKPULSE_FNC2; ! 602: return (data); ! 603: } ! 604: return (-1); ! 605: } ! 606: ! 607: /* ! 608: * Handshake write to DR300. ! 609: * ! 610: * Interrupts are enabled before completing the work ! 611: * so the caller should either be at splik or be ! 612: * prepared to take the interrupt immediately. ! 613: */ ! 614: diowrite(ik, v) ! 615: register struct ikdevice *ik; ! 616: u_short v; ! 617: { ! 618: register int t; ! 619: register u_short csr; ! 620: ! 621: top: ! 622: /* ! 623: * Deposit data and generate dr300 attention ! 624: */ ! 625: ik->ik_data = v; ! 626: ik->ik_csr = IKCSR_RDMAF|IKCSR_RATTF; ! 627: ik->ik_pulse = IKPULSE_FNC2; ! 628: for (t = ikdiotimo; t > 0; t--) { ! 629: csr = ik->ik_csr; ! 630: #define IKCSR_DONE (IKCSR_STATA|IKCSR_STATC) ! 631: if ((csr&IKCSR_DONE) == IKCSR_DONE) { ! 632: /* ! 633: * Done, complete handshake by notifying dr300. ! 634: */ ! 635: ik->ik_csr = IKCSR_IENA; /* ~IKCSR_FNC1 */ ! 636: ik->ik_pulse = IKPULSE_FNC2; ! 637: return (0); ! 638: } ! 639: /* beware of potential deadlock with dioread */ ! 640: if ((csr&(IKCSR_ATTF|IKCSR_STATC)) == IKCSR_ATTF) ! 641: goto top; ! 642: } ! 643: ik->ik_csr = IKCSR_IENA; ! 644: return (PSERROR_DIOTIMO); ! 645: } ! 646: ! 647: /*ARGSUSED*/ ! 648: ikioctl(dev, cmd, data, flag) ! 649: dev_t dev; ! 650: int cmd; ! 651: caddr_t data; ! 652: int flag; ! 653: { ! 654: int error = 0, unit = IKUNIT(dev), s; ! 655: register struct ik_softc *sc = &ik_softc[unit]; ! 656: ! 657: switch (cmd) { ! 658: ! 659: case PSIOGETERROR: /* get error code for last operation */ ! 660: *(int *)data = sc->is_error; ! 661: break; ! 662: ! 663: case PSIOLOOKUP: { /* PS300 name lookup */ ! 664: register struct pslookup *lp = (struct pslookup *)data; ! 665: register struct buf *bp; ! 666: ! 667: if (lp->pl_len > PS_MAXNAMELEN) ! 668: return (EINVAL); ! 669: bp = &rikbuf[unit]; ! 670: s = splbio(); ! 671: while (bp->b_flags&B_BUSY) { ! 672: bp->b_flags |= B_WANTED; ! 673: sleep((caddr_t)bp, PRIBIO+1); ! 674: } ! 675: splx(s); ! 676: bp->b_flags = B_BUSY | B_WRITE; ! 677: error = copyin(lp->pl_name, (caddr_t)sc->is_buf, ! 678: (unsigned)lp->pl_len); ! 679: if (error == 0) { ! 680: if (lp->pl_len&1) ! 681: sc->is_buf[lp->pl_len] = '\0'; ! 682: error = ikcommand(dev, PS_LOOKUP, lp->pl_len); ! 683: } ! 684: s = splbio(); ! 685: if (bp->b_flags&B_WANTED) ! 686: wakeup((caddr_t)bp); ! 687: splx(s); ! 688: bp->b_flags &= ~(B_BUSY|B_WANTED); ! 689: lp->pl_addr = sc->is_nameaddr.l; ! 690: break; ! 691: } ! 692: default: ! 693: return (ENOTTY); ! 694: } ! 695: return (error); ! 696: } ! 697: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.