![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to va.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxuba|
Return to va.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxuba |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: * ! 6: * @(#)va.c 7.3 (Berkeley) 2/17/90 ! 7: */ ! 8: ! 9: #include "va.h" ! 10: #if NVA > 0 ! 11: /* ! 12: * Varian printer plotter ! 13: */ ! 14: #include "machine/pte.h" ! 15: ! 16: #include "param.h" ! 17: #include "user.h" ! 18: #include "buf.h" ! 19: #include "systm.h" ! 20: #include "map.h" ! 21: #include "ioctl.h" ! 22: #include "vcmd.h" ! 23: #include "uio.h" ! 24: #include "kernel.h" ! 25: ! 26: #include "ubareg.h" ! 27: #include "ubavar.h" ! 28: ! 29: int vadebug = 0; ! 30: #define dprintf if(vadebug)printf ! 31: ! 32: unsigned minvaph(); ! 33: ! 34: #define VAPRI (PZERO-1) ! 35: ! 36: struct vadevice { ! 37: u_short vaba; /* buffer address */ ! 38: short vawc; /* word count (2's complement) */ ! 39: union { ! 40: short Vacsw; /* control status as word */ ! 41: struct { /* control status as bytes */ ! 42: char Vacsl; ! 43: char Vacsh; ! 44: } vacsr; ! 45: } vacs; ! 46: short vadata; /* programmed i/o data buffer */ ! 47: }; ! 48: ! 49: #define vacsw vacs.Vacsw ! 50: #define vacsh vacs.vacsr.Vacsh ! 51: #define vacsl vacs.vacsr.Vacsl ! 52: ! 53: /* vacsw bits */ ! 54: #define VA_ERROR 0100000 /* some error has occurred */ ! 55: #define VA_NPRTIMO 0001000 /* DMA timeout error */ ! 56: #define VA_NOTREADY 0000400 /* something besides NPRTIMO */ ! 57: #define VA_DONE 0000200 ! 58: #define VA_IENABLE 0000100 /* interrupt enable */ ! 59: #define VA_DMAGO 0000010 /* DMA go bit */ ! 60: #define VA_DMAGO 0000010 /* DMA go bit */ ! 61: #define VA_SUPPLIESLOW 0000004 ! 62: #define VA_BOTOFFORM 0000002 ! 63: #define VA_BYTEREVERSE 0000001 /* reverse byte order in words */ ! 64: ! 65: /* vacsh command bytes */ ! 66: #define VAPLOT 0000340 ! 67: #define VAPRINT 0000100 ! 68: #define VAPRINTPLOT 0000160 ! 69: #define VAAUTOSTEP 0000244 ! 70: #define VANOAUTOSTEP 0000045 ! 71: #define VAFORMFEED 0000263 ! 72: #define VASLEW 0000265 ! 73: #define VASTEP 0000064 ! 74: ! 75: struct va_softc { ! 76: u_char sc_openf; /* exclusive open flag */ ! 77: u_char sc_iostate; /* kind of I/O going on */ ! 78: #define VAS_IDLE 0 /* no I/O, free */ ! 79: #define VAS_PIO 1 /* programmed I/O */ ! 80: #define VAS_DMA 2 /* DMA, block pio */ ! 81: #define VAS_WANT 4 /* wakeup when iostate changes */ ! 82: short sc_tocnt; /* time out counter */ ! 83: short sc_info; /* csw passed from vaintr */ ! 84: int sc_state; /* print/plot state of device */ ! 85: } va_softc[NVA]; ! 86: ! 87: #define VAUNIT(dev) (minor(dev)) ! 88: ! 89: struct buf rvabuf[NVA]; ! 90: ! 91: int vaprobe(), vaslave(), vaattach(), vadgo(); ! 92: struct uba_device *vadinfo[NVA]; ! 93: struct uba_ctlr *vaminfo[NVA]; ! 94: struct buf vabhdr[NVA]; ! 95: u_short vastd[] = { 0764000, 0 }; ! 96: struct uba_driver vadriver = ! 97: { vaprobe, vaslave, vaattach, vadgo, vastd, "vz", vadinfo, "va", vaminfo }; ! 98: ! 99: vaprobe(reg) ! 100: caddr_t reg; ! 101: { ! 102: register int br, cvec; /* value-result */ ! 103: register struct vadevice *vaaddr = (struct vadevice *)reg; ! 104: ! 105: #ifdef lint ! 106: br = 0; cvec = br; br = cvec; ! 107: vaintr(0); ! 108: #endif ! 109: #ifndef UCBVAX ! 110: vaaddr->vacsl = VA_IENABLE; ! 111: vaaddr->vaba = 0; ! 112: vaaddr->vacsh = VAPLOT; ! 113: vaaddr->vacsl = VA_IENABLE|VA_DMAGO; ! 114: vaaddr->vawc = -1; ! 115: DELAY(10000); ! 116: vaaddr->vacsl = 0; ! 117: vaaddr->vawc = 0; ! 118: #else ! 119: br=0x14; ! 120: cvec=0170; ! 121: #endif ! 122: return (sizeof (struct vadevice)); ! 123: } ! 124: ! 125: /*ARGSUSED*/ ! 126: vaslave(ui, reg) ! 127: struct uba_device *ui; ! 128: caddr_t reg; ! 129: { ! 130: ! 131: ui->ui_dk = 0; ! 132: return (ui->ui_unit <= 0); ! 133: } ! 134: ! 135: /*ARGSUSED*/ ! 136: vaattach(ui) ! 137: struct uba_device *ui; ! 138: { ! 139: ! 140: ui->ui_mi->um_tab.b_actf = &vabhdr[ui->ui_unit]; ! 141: } ! 142: ! 143: vaopen(dev) ! 144: dev_t dev; ! 145: { ! 146: register struct va_softc *sc; ! 147: register struct vadevice *vaaddr; ! 148: register struct uba_device *ui; ! 149: int error; ! 150: int unit = VAUNIT(dev); ! 151: ! 152: if (unit >= NVA || (sc = &va_softc[unit])->sc_openf || ! 153: (ui = vadinfo[unit]) == 0 || ui->ui_alive == 0) ! 154: return (ENXIO); ! 155: vaaddr = (struct vadevice *)ui->ui_addr; ! 156: sc->sc_openf = 1; ! 157: vaaddr->vawc = 0; ! 158: sc->sc_state = 0; ! 159: sc->sc_tocnt = 0; ! 160: sc->sc_iostate = VAS_IDLE; ! 161: vaaddr->vacsl = VA_IENABLE; ! 162: vatimo(dev); ! 163: error = vacmd(dev, VPRINT); ! 164: if (error) ! 165: vaclose(dev); ! 166: return (error); ! 167: } ! 168: ! 169: vastrategy(bp) ! 170: register struct buf *bp; ! 171: { ! 172: register struct uba_device *ui; ! 173: register struct uba_ctlr *um; ! 174: int s; ! 175: ! 176: dprintf("vastrategy(%x)\n", bp); ! 177: ui = vadinfo[VAUNIT(bp->b_dev)]; ! 178: if (ui == 0 || ui->ui_alive == 0) { ! 179: bp->b_flags |= B_ERROR; ! 180: iodone(bp); ! 181: return; ! 182: } ! 183: s = spl4(); ! 184: um = ui->ui_mi; ! 185: bp->b_actf = NULL; ! 186: if (um->um_tab.b_actf->b_actf == NULL) ! 187: um->um_tab.b_actf->b_actf = bp; ! 188: else { ! 189: printf("bp = 0x%x, um->um_tab.b_actf->b_actf = 0x%x\n", ! 190: bp, um->um_tab.b_actf->b_actf); ! 191: panic("vastrategy"); ! 192: um->um_tab.b_actf->b_actl->b_forw = bp; ! 193: } ! 194: um->um_tab.b_actf->b_actl = bp; ! 195: bp = um->um_tab.b_actf; ! 196: dprintf("vastrategy: bp=%x actf=%x active=%d\n", ! 197: bp, bp->b_actf, bp->b_active); ! 198: if (bp->b_actf && bp->b_active == 0) ! 199: (void) vastart(um); ! 200: splx(s); ! 201: } ! 202: ! 203: int vablock = 16384; ! 204: ! 205: unsigned ! 206: minvaph(bp) ! 207: struct buf *bp; ! 208: { ! 209: ! 210: if (bp->b_bcount > vablock) ! 211: bp->b_bcount = vablock; ! 212: } ! 213: ! 214: /*ARGSUSED*/ ! 215: vawrite(dev, uio) ! 216: dev_t dev; ! 217: struct uio *uio; ! 218: { ! 219: ! 220: if (VAUNIT(dev) > NVA) ! 221: return (ENXIO); ! 222: return (physio(vastrategy, &rvabuf[VAUNIT(dev)], dev, B_WRITE, ! 223: minvaph, uio)); ! 224: } ! 225: ! 226: vastart(um) ! 227: register struct uba_ctlr *um; ! 228: { ! 229: struct buf *bp; ! 230: struct vadevice *vaaddr; ! 231: register struct va_softc *sc; ! 232: int unit; ! 233: ! 234: dprintf("vastart(%x), bp=%x\n", um, um->um_tab.b_actf->b_actf); ! 235: if ((bp = um->um_tab.b_actf->b_actf) == NULL) ! 236: return; ! 237: unit = VAUNIT(bp->b_dev); ! 238: sc = &va_softc[unit]; ! 239: sc->sc_tocnt = 0; ! 240: while (sc->sc_iostate&VAS_PIO) { ! 241: sc->sc_iostate |= VAS_WANT; ! 242: sleep((caddr_t)&sc->sc_iostate, VAPRI); ! 243: } ! 244: sc->sc_iostate |= VAS_DMA; ! 245: vaaddr = (struct vadevice *)um->um_addr; ! 246: vaaddr->vacsl = 0; ! 247: vaaddr->vawc = -(bp->b_bcount / 2); ! 248: um->um_cmd = VA_DMAGO | VA_IENABLE; ! 249: (void) ubago(vadinfo[unit]); ! 250: } ! 251: ! 252: vadgo(um) ! 253: register struct uba_ctlr *um; ! 254: { ! 255: register struct vadevice *vaaddr = (struct vadevice *)um->um_addr; ! 256: register struct buf *bp; ! 257: ! 258: bp = um->um_tab.b_actf; ! 259: va_softc[VAUNIT(bp->b_actf->b_dev)].sc_tocnt = 0; ! 260: bp->b_active++; ! 261: vaaddr->vaba = um->um_ubinfo; ! 262: vaaddr->vacsl = ((um->um_ubinfo >> 12) & 0x30) | um->um_cmd; ! 263: } ! 264: ! 265: /*ARGSUSED*/ ! 266: vaioctl(dev, cmd, data, flag) ! 267: register caddr_t data; ! 268: { ! 269: register struct va_softc *sc = &va_softc[VAUNIT(dev)]; ! 270: ! 271: switch (cmd) { ! 272: ! 273: case VGETSTATE: ! 274: *(int *)data = sc->sc_state; ! 275: break; ! 276: ! 277: case VSETSTATE: ! 278: return (vacmd(dev, *(int *)data)); ! 279: ! 280: default: ! 281: return (ENOTTY); ! 282: } ! 283: return (0); ! 284: } ! 285: ! 286: vacmd(dev, vcmd) ! 287: dev_t dev; ! 288: int vcmd; ! 289: { ! 290: register struct va_softc *sc = &va_softc[VAUNIT(dev)]; ! 291: int error = 0; ! 292: int s, cmd; ! 293: ! 294: s = spl4(); ! 295: while (sc->sc_iostate&VAS_DMA) { ! 296: sc->sc_iostate |= VAS_WANT; ! 297: sleep((caddr_t)&sc->sc_iostate, VAPRI); ! 298: } ! 299: sc->sc_iostate |= VAS_PIO; ! 300: sc->sc_tocnt = 0; ! 301: cmd = 0; ! 302: switch (vcmd) { ! 303: ! 304: case VPLOT: ! 305: /* Must turn on plot AND autostep modes. */ ! 306: if (vadopio(dev, VAPLOT)) ! 307: error = EIO; ! 308: cmd = VAAUTOSTEP; ! 309: break; ! 310: ! 311: case VPRINT: ! 312: cmd = VAPRINT; ! 313: break; ! 314: ! 315: case VPRINTPLOT: ! 316: cmd = VAPRINTPLOT; ! 317: break; ! 318: } ! 319: sc->sc_state = (sc->sc_state & ~(VPLOT|VPRINT|VPRINTPLOT)) | vcmd; ! 320: if (cmd && vadopio(dev, cmd)) ! 321: error = EIO; ! 322: sc->sc_iostate &= ~VAS_PIO; ! 323: if (sc->sc_iostate&VAS_WANT) { ! 324: sc->sc_iostate &= ~VAS_WANT; ! 325: wakeup((caddr_t)&sc->sc_iostate); ! 326: } ! 327: splx(s); ! 328: return (error); ! 329: } ! 330: ! 331: vadopio(dev, cmd) ! 332: dev_t dev; ! 333: int cmd; ! 334: { ! 335: register struct vadevice *vaaddr = ! 336: (struct vadevice *)vaminfo[VAUNIT(dev)]->um_addr; ! 337: register struct va_softc *sc = &va_softc[VAUNIT(dev)]; ! 338: ! 339: sc->sc_info = 0; ! 340: vaaddr->vacsh = cmd; ! 341: while ((sc->sc_info&(VA_DONE|VA_ERROR)) == 0) ! 342: sleep((caddr_t)&sc->sc_info, VAPRI); ! 343: return (sc->sc_info&VA_ERROR); ! 344: } ! 345: ! 346: vatimo(dev) ! 347: dev_t dev; ! 348: { ! 349: register struct va_softc *sc = &va_softc[VAUNIT(dev)]; ! 350: ! 351: if (sc->sc_openf) ! 352: timeout(vatimo, (caddr_t)dev, hz/2); ! 353: if (++sc->sc_tocnt < 2) ! 354: return; ! 355: sc->sc_tocnt = 0; ! 356: dprintf("vatimo: calling vaintr\n"); ! 357: vaintr(dev); ! 358: } ! 359: ! 360: /*ARGSUSED*/ ! 361: vaintr(dev) ! 362: dev_t dev; ! 363: { ! 364: register struct uba_ctlr *um; ! 365: struct vadevice *vaaddr; ! 366: struct buf *bp; ! 367: register int unit = VAUNIT(dev), e; ! 368: register struct va_softc *sc = &va_softc[unit]; ! 369: ! 370: um = vaminfo[unit]; ! 371: vaaddr = (struct vadevice *)um->um_addr; ! 372: e = vaaddr->vacsw; ! 373: dprintf("vaintr: um=0x%x, e=0x%x, b_active %d\n", ! 374: um, e, um->um_tab.b_actf->b_active); ! 375: if ((e&(VA_DONE|VA_ERROR)) == 0) ! 376: return; ! 377: vaaddr->vacsl = 0; ! 378: if ((e&VA_ERROR) && (e&VA_NPRTIMO)) ! 379: printf("va%d: npr timeout\n", unit); ! 380: if (sc->sc_iostate&VAS_PIO) { ! 381: sc->sc_info = e; ! 382: wakeup((caddr_t)&sc->sc_info); ! 383: return; ! 384: } ! 385: if (um->um_tab.b_actf->b_active) { ! 386: bp = um->um_tab.b_actf->b_actf; ! 387: if (e&VA_ERROR) ! 388: bp->b_flags |= B_ERROR; ! 389: if (sc->sc_state&VPRINTPLOT) { ! 390: sc->sc_state = (sc->sc_state & ~VPRINTPLOT) | VPLOT; ! 391: vaaddr->vacsh = VAAUTOSTEP; ! 392: return; ! 393: } ! 394: ubadone(um); ! 395: um->um_tab.b_actf->b_active = 0; ! 396: um->um_tab.b_actf->b_actf = bp->b_forw; ! 397: bp->b_active = 0; ! 398: bp->b_errcnt = 0; ! 399: bp->b_resid = 0; ! 400: iodone(bp); ! 401: } ! 402: if (um->um_tab.b_actf->b_actf == 0) { ! 403: sc->sc_iostate &= ~VAS_DMA; ! 404: if (sc->sc_iostate&VAS_WANT) { ! 405: sc->sc_iostate &= ~VAS_WANT; ! 406: wakeup((caddr_t)&sc->sc_iostate); ! 407: } ! 408: return; ! 409: } ! 410: if (um->um_tab.b_actf->b_active == 0) ! 411: vastart(um); ! 412: } ! 413: ! 414: vaclose(dev) ! 415: dev_t dev; ! 416: { ! 417: register struct va_softc *sc = &va_softc[VAUNIT(dev)]; ! 418: register struct vadevice *vaaddr = ! 419: (struct vadevice *)vadinfo[VAUNIT(dev)]->ui_addr; ! 420: ! 421: sc->sc_openf = 0; ! 422: sc->sc_state = 0; ! 423: if (sc->sc_iostate != VAS_IDLE) ! 424: wakeup((caddr_t)&sc->sc_iostate); ! 425: sc->sc_iostate = VAS_IDLE; ! 426: vaaddr->vacsl = 0; ! 427: vaaddr->vawc = 0; ! 428: } ! 429: ! 430: vareset(uban) ! 431: int uban; ! 432: { ! 433: register int va11; ! 434: register struct uba_ctlr *um; ! 435: register struct vadevice *vaaddr; ! 436: register struct va_softc *sc; ! 437: ! 438: for (va11 = 0; va11 < NVA; va11++, sc++) { ! 439: if ((um = vaminfo[va11]) == 0 || um->um_ubanum != uban || ! 440: um->um_alive == 0) ! 441: continue; ! 442: sc = &va_softc[um->um_ctlr]; ! 443: if (sc->sc_openf == 0) ! 444: continue; ! 445: printf(" va%d", va11); ! 446: vaaddr = (struct vadevice *)um->um_addr; ! 447: vaaddr->vacsl = VA_IENABLE; ! 448: if (sc->sc_state & VPLOT) { ! 449: vaaddr->vacsh = VAPLOT; ! 450: DELAY(10000); ! 451: vaaddr->vacsh = VAAUTOSTEP; ! 452: } else if (sc->sc_state & VPRINTPLOT) ! 453: vaaddr->vacsh = VPRINTPLOT; ! 454: else ! 455: vaaddr->vacsh = VAPRINTPLOT; ! 456: DELAY(10000); ! 457: sc->sc_iostate = VAS_IDLE; ! 458: um->um_tab.b_actf->b_active = 0; ! 459: um->um_tab.b_actf->b_actf = um->um_tab.b_actf->b_actl = 0; ! 460: if (um->um_ubinfo) { ! 461: printf("<%d>", (um->um_ubinfo >> 28) & 0xf); ! 462: um->um_ubinfo = 0; ! 463: } ! 464: (void) vastart(um); ! 465: } ! 466: } ! 467: ! 468: vaselect() ! 469: { ! 470: ! 471: return (1); ! 472: } ! 473: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.