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