![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dmf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba|
Return to dmf.c CVS log | Up to [CSRG BSD Unix] / 43BSD / 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: * @(#)dmf.c 7.1 (Berkeley) 6/5/86 ! 7: */ ! 8: ! 9: #include "dmf.h" ! 10: #if NDMF > 0 ! 11: /* ! 12: * DMF32 driver ! 13: * ! 14: * ! 15: * TODO: ! 16: * test with modem ! 17: * load as much as possible into silo ! 18: * use auto XON/XOFF ! 19: * test reset code ! 20: **************************** ! 21: * DMF32 line printer driver ! 22: * ! 23: * the line printer on dmfx is indicated by a minor device code of 128+x ! 24: * ! 25: * the flags field of the config file is interpreted like so: ! 26: * bits meaning ! 27: * ---- ------- ! 28: * 0-7 soft carrier bits for ttys part of dmf32 ! 29: * 8-15 number of cols/line on the line printer ! 30: * if 0, 132 will be used. ! 31: * 16-23 number of lines/page on the line printer ! 32: * if 0, 66 will be used. ! 33: * 24 if 1 DO NOT use the auto format mode of the ! 34: * line printer parallel port ! 35: */ ! 36: #include "../machine/pte.h" ! 37: ! 38: #include "bk.h" ! 39: #include "uba.h" ! 40: #include "param.h" ! 41: #include "conf.h" ! 42: #include "dir.h" ! 43: #include "user.h" ! 44: #include "proc.h" ! 45: #include "ioctl.h" ! 46: #include "tty.h" ! 47: #include "map.h" ! 48: #include "buf.h" ! 49: #include "vm.h" ! 50: #include "bkmac.h" ! 51: #include "clist.h" ! 52: #include "file.h" ! 53: #include "uio.h" ! 54: #include "kernel.h" ! 55: #include "syslog.h" ! 56: ! 57: #include "ubareg.h" ! 58: #include "ubavar.h" ! 59: #include "dmfreg.h" ! 60: ! 61: /* ! 62: * Definition of the driver for the auto-configuration program. ! 63: */ ! 64: int dmfprobe(), dmfattach(), dmfrint(), dmfxint(); ! 65: int dmflint(); ! 66: struct uba_device *dmfinfo[NDMF]; ! 67: u_short dmfstd[] = { 0 }; ! 68: struct uba_driver dmfdriver = ! 69: { dmfprobe, 0, dmfattach, 0, dmfstd, "dmf", dmfinfo }; ! 70: ! 71: int dmf_timeout = 10; /* silo timeout, in ms */ ! 72: int dmf_mindma = 4; /* don't dma below this point */ ! 73: ! 74: /* ! 75: * Local variables for the driver ! 76: */ ! 77: char dmf_speeds[] = ! 78: { 0, 0, 1, 2, 3, 4, 0, 5, 6, 7, 010, 012, 014, 016, 017, 0 }; ! 79: ! 80: #ifndef PORTSELECTOR ! 81: #define ISPEED B9600 ! 82: #define IFLAGS (EVENP|ODDP|ECHO) ! 83: #else ! 84: #define ISPEED B4800 ! 85: #define IFLAGS (EVENP|ODDP) ! 86: #endif ! 87: ! 88: struct tty dmf_tty[NDMF*8]; ! 89: char dmfsoftCAR[NDMF]; ! 90: ! 91: struct dmfl_softc { ! 92: u_int dmfl_state; /* soft state bits */ ! 93: int dmfl_info; /* uba info */ ! 94: u_short dmfl_lines; /* lines per page (66 def.) */ ! 95: u_short dmfl_cols; /* cols per line (132 def.) */ ! 96: u_short dmfl_format; /* fflag for auto form feed */ ! 97: char dmfl_buf[DMFL_BUFSIZ]; ! 98: } dmfl_softc[NDMF]; ! 99: ! 100: /* ! 101: * convert device number into DMF line printer unit number ! 102: */ ! 103: #define DMFL_UNIT(d) (minor(d)&0xF) /* up to 16 DMFs */ ! 104: ! 105: #define ASLP 1 /* waiting for interrupt from dmf */ ! 106: #define OPEN 2 /* line printer is open */ ! 107: #define ERROR 4 /* error while printing, driver ! 108: refuses to do anything till closed */ ! 109: #define MOREIO 8 /* more data for printer */ ! 110: ! 111: #ifndef lint ! 112: int ndmf = NDMF*8; /* used by iostat */ ! 113: #endif ! 114: int dmfact; /* mask of active dmf's */ ! 115: int dmfstart(), ttrstrt(); ! 116: ! 117: /* ! 118: * The clist space is mapped by the driver onto each UNIBUS. ! 119: * The UBACVT macro converts a clist space address for unibus uban ! 120: * into an i/o space address for the DMA routine. ! 121: */ ! 122: int dmf_ubinfo[NUBA]; /* info about allocated unibus map */ ! 123: int cbase[NUBA]; /* base address in unibus map */ ! 124: #define UBACVT(x, uban) (cbase[uban] + ((x)-(char *)cfree)) ! 125: char dmf_dma[NDMF*8]; ! 126: ! 127: /* ! 128: * Routine for configuration to set dmf interrupt. ! 129: */ ! 130: /*ARGSUSED*/ ! 131: dmfprobe(reg, ctlr) ! 132: caddr_t reg; ! 133: struct uba_device *ctlr; ! 134: { ! 135: register int br, cvec; /* these are ``value-result'' */ ! 136: register struct dmfdevice *dmfaddr = (struct dmfdevice *)reg; ! 137: register int i; ! 138: register unsigned int a; ! 139: static char *dmfdevs[]= ! 140: {"parallel","printer","synch","asynch"}; ! 141: unsigned int dmfoptions; ! 142: static int (*intrv[3])() = { (int (*)())0, (int (*)())0, (int (*)())0 }; ! 143: ! 144: #ifdef lint ! 145: br = 0; cvec = br; br = cvec; ! 146: dmfxint(0); dmfrint(0); ! 147: dmfsrint(); dmfsxint(); dmfdaint(); dmfdbint(); dmflint(0); ! 148: #endif ! 149: /* ! 150: * Pick the usual size DMF vector here (don't decrement it here). ! 151: * grab configuration; note that the DMF32 ! 152: * doesn't seem to put the right bits in this ! 153: * register until AFTER the interrupt vector is set. ! 154: */ ! 155: br = 0x15; ! 156: cvec = (uba_hd[numuba].uh_lastiv - 4*8); ! 157: dmfaddr->dmfccsr0 = (cvec >> 2); ! 158: dmfoptions = dmfaddr->dmfccsr0 & DMFC_CONFMASK; ! 159: ! 160: /* catch a couple of special cases: Able vmz/32n and vmz/lp */ ! 161: if (dmfoptions == DMFC_ASYNC) { ! 162: /* Async portion only */ ! 163: ! 164: cvec = (uba_hd[numuba].uh_lastiv -= 8); ! 165: dmfaddr->dmfccsr0 = (cvec - 2*8) >> 2; ! 166: intrv[0] = ctlr->ui_intr[4]; ! 167: intrv[1] = ctlr->ui_intr[5]; ! 168: ctlr->ui_intr = intrv; ! 169: } else if (dmfoptions == DMFC_LP) { ! 170: /* LP portion only */ ! 171: ! 172: cvec = (uba_hd[numuba].uh_lastiv -= 8); ! 173: ctlr->ui_intr = &ctlr->ui_intr[6]; ! 174: } else if (dmfoptions == (DMFC_LP|DMFC_ASYNC)) { ! 175: /* LP ans Async portions only */ ! 176: ! 177: cvec = (uba_hd[numuba].uh_lastiv -= 2*8); ! 178: ctlr->ui_intr = &ctlr->ui_intr[4]; ! 179: } else { ! 180: /* All other configurations get everything */ ! 181: ! 182: cvec = (uba_hd[numuba].uh_lastiv -= 4*8); ! 183: } ! 184: a = (dmfoptions >> 12) & 0xf; ! 185: printf("dmf%d:", ctlr->ui_unit); ! 186: for (i = 0; a != 0; ++i, a >>= 1) { ! 187: if (a & 1) ! 188: printf(" %s",dmfdevs[i]); ! 189: } ! 190: printf(".\n"); ! 191: ! 192: if (dmfoptions & DMFC_LP) ! 193: dmfaddr->dmfl_ctrl = DMFL_RESET; ! 194: return (sizeof (struct dmfdevice)); ! 195: } ! 196: ! 197: /* ! 198: * Routine called to attach a dmf. ! 199: */ ! 200: dmfattach(ui) ! 201: struct uba_device *ui; ! 202: { ! 203: register int cols = (ui->ui_flags>>8) & 0xff; ! 204: register int lines = (ui->ui_flags>>16) & 0xff; ! 205: ! 206: dmfsoftCAR[ui->ui_unit] = ui->ui_flags & 0xff; ! 207: dmfl_softc[ui->ui_unit].dmfl_cols = cols == 0 ? DMFL_DEFCOLS : cols; ! 208: dmfl_softc[ui->ui_unit].dmfl_lines = lines == 0 ? DMFL_DEFLINES : lines; ! 209: if ((ui->ui_flags >> 24) & 0x1) ! 210: dmfl_softc[ui->ui_unit].dmfl_format = (2 << 8); ! 211: else ! 212: dmfl_softc[ui->ui_unit].dmfl_format = (2 << 8) | DMFL_FORMAT; ! 213: cbase[ui->ui_ubanum] = -1; ! 214: } ! 215: ! 216: ! 217: /* ! 218: * Open a DMF32 line, mapping the clist onto the uba if this ! 219: * is the first dmf on this uba. Turn on this dmf if this is ! 220: * the first use of it. ! 221: */ ! 222: /*ARGSUSED*/ ! 223: dmfopen(dev, flag) ! 224: dev_t dev; ! 225: { ! 226: register struct tty *tp; ! 227: register int unit, dmf; ! 228: register struct dmfdevice *addr; ! 229: register struct uba_device *ui; ! 230: int s; ! 231: ! 232: unit = minor(dev); ! 233: if (unit & 0200) ! 234: return (dmflopen(dev,flag)); ! 235: dmf = unit >> 3; ! 236: if (unit >= NDMF*8 || (ui = dmfinfo[dmf])== 0 || ui->ui_alive == 0) ! 237: return (ENXIO); ! 238: tp = &dmf_tty[unit]; ! 239: if (tp->t_state&TS_XCLUDE && u.u_uid!=0) ! 240: return (EBUSY); ! 241: addr = (struct dmfdevice *)ui->ui_addr; ! 242: tp->t_addr = (caddr_t)addr; ! 243: tp->t_oproc = dmfstart; ! 244: tp->t_state |= TS_WOPEN; ! 245: /* ! 246: * While setting up state for this uba and this dmf, ! 247: * block uba resets which can clear the state. ! 248: */ ! 249: s = spltty(); ! 250: if (cbase[ui->ui_ubanum] == -1) { ! 251: dmf_ubinfo[ui->ui_ubanum] = ! 252: uballoc(ui->ui_ubanum, (caddr_t)cfree, ! 253: nclist*sizeof(struct cblock), 0); ! 254: cbase[ui->ui_ubanum] = UBAI_ADDR(dmf_ubinfo[ui->ui_ubanum]); ! 255: } ! 256: if ((dmfact&(1<<dmf)) == 0) { ! 257: addr->dmfcsr |= DMF_IE; ! 258: dmfact |= (1<<dmf); ! 259: addr->dmfrsp = dmf_timeout; ! 260: } ! 261: splx(s); ! 262: /* ! 263: * If this is first open, initialize tty state to default. ! 264: */ ! 265: if ((tp->t_state&TS_ISOPEN) == 0) { ! 266: ttychars(tp); ! 267: #ifndef PORTSELECTOR ! 268: if (tp->t_ispeed == 0) { ! 269: #else ! 270: tp->t_state |= TS_HUPCLS; ! 271: #endif PORTSELECTOR ! 272: tp->t_ispeed = ISPEED; ! 273: tp->t_ospeed = ISPEED; ! 274: tp->t_flags = IFLAGS; ! 275: #ifndef PORTSELECTOR ! 276: } ! 277: #endif PORTSELECTOR ! 278: dmfparam(unit); ! 279: } ! 280: /* ! 281: * Wait for carrier, then process line discipline specific open. ! 282: */ ! 283: s = spltty(); ! 284: for (;;) { ! 285: if ((dmfmctl(dev, DMF_ON, DMSET) & (DMF_CAR<<8)) || ! 286: (dmfsoftCAR[dmf] & (1<<(unit&07)))) ! 287: tp->t_state |= TS_CARR_ON; ! 288: if (tp->t_state & TS_CARR_ON) ! 289: break; ! 290: tp->t_state |= TS_WOPEN; ! 291: sleep((caddr_t)&tp->t_rawq, TTIPRI); ! 292: } ! 293: splx(s); ! 294: return ((*linesw[tp->t_line].l_open)(dev, tp)); ! 295: } ! 296: ! 297: /* ! 298: * Close a DMF32 line. ! 299: */ ! 300: /*ARGSUSED*/ ! 301: dmfclose(dev, flag) ! 302: dev_t dev; ! 303: int flag; ! 304: { ! 305: register struct tty *tp; ! 306: register unit; ! 307: ! 308: unit = minor(dev); ! 309: if (unit & 0200) { ! 310: dmflclose(dev,flag); ! 311: return; ! 312: } ! 313: ! 314: tp = &dmf_tty[unit]; ! 315: (*linesw[tp->t_line].l_close)(tp); ! 316: (void) dmfmctl(unit, DMF_BRK, DMBIC); ! 317: if (tp->t_state&TS_HUPCLS || (tp->t_state&TS_ISOPEN)==0) ! 318: (void) dmfmctl(unit, DMF_OFF, DMSET); ! 319: ttyclose(tp); ! 320: } ! 321: ! 322: dmfread(dev, uio) ! 323: dev_t dev; ! 324: struct uio *uio; ! 325: { ! 326: register struct tty *tp; ! 327: ! 328: if (minor(dev) & 0200) ! 329: return(ENXIO); ! 330: tp = &dmf_tty[minor(dev)]; ! 331: return ((*linesw[tp->t_line].l_read)(tp, uio)); ! 332: } ! 333: ! 334: dmfwrite(dev, uio) ! 335: dev_t dev; ! 336: struct uio *uio; ! 337: { ! 338: register struct tty *tp; ! 339: ! 340: if (minor(dev) & 0200) ! 341: return (dmflwrite(dev,uio)); ! 342: tp = &dmf_tty[minor(dev)]; ! 343: return ((*linesw[tp->t_line].l_write)(tp, uio)); ! 344: } ! 345: ! 346: /* ! 347: * DMF32 receiver interrupt. ! 348: */ ! 349: dmfrint(dmf) ! 350: int dmf; ! 351: { ! 352: register c; ! 353: register struct tty *tp; ! 354: register struct dmfdevice *addr; ! 355: register struct tty *tp0; ! 356: int unit; ! 357: int overrun = 0; ! 358: register struct uba_device *ui; ! 359: ! 360: ui = dmfinfo[dmf]; ! 361: if (ui == 0 || ui->ui_alive == 0) ! 362: return; ! 363: addr = (struct dmfdevice *)ui->ui_addr; ! 364: tp0 = &dmf_tty[dmf * 8]; ! 365: /* ! 366: * Loop fetching characters from the silo for this ! 367: * dmf until there are no more in the silo. ! 368: */ ! 369: while ((c = addr->dmfrbuf) < 0) { ! 370: ! 371: unit = (c >> 8) & 07; ! 372: tp = tp0 + unit; ! 373: if (c & DMF_DSC) { ! 374: addr->dmfcsr = DMF_IE | DMFIR_TBUF | unit; ! 375: if (addr->dmfrms & DMF_CAR) ! 376: (void)(*linesw[tp->t_line].l_modem)(tp, 1); ! 377: else if ((dmfsoftCAR[dmf] & (1 << unit)) == 0 && ! 378: (*linesw[tp->t_line].l_modem)(tp, 0) == 0) { ! 379: addr->dmfcsr = DMF_IE | DMFIR_LCR | unit; ! 380: addr->dmflctms = DMFLCR_ENA; ! 381: } ! 382: continue; ! 383: } ! 384: if ((tp->t_state&TS_ISOPEN) == 0) { ! 385: wakeup((caddr_t)&tp->t_rawq); ! 386: #ifdef PORTSELECTOR ! 387: if ((tp->t_state & TS_WOPEN) == 0) ! 388: #endif ! 389: continue; ! 390: } ! 391: if (c & (DMF_PE|DMF_DO|DMF_FE)) { ! 392: if (c & DMF_PE) ! 393: if ((tp->t_flags & (EVENP|ODDP)) == EVENP ! 394: || (tp->t_flags & (EVENP|ODDP)) == ODDP) ! 395: continue; ! 396: if ((c & DMF_DO) && overrun == 0) { ! 397: log(LOG_WARNING, "dmf%d: silo overflow\n", dmf); ! 398: overrun = 1; ! 399: } ! 400: if (c & DMF_FE) ! 401: /* ! 402: * At framing error (break) generate ! 403: * a null (in raw mode, for getty), or a ! 404: * interrupt (in cooked/cbreak mode). ! 405: */ ! 406: if (tp->t_flags & RAW) ! 407: c = 0; ! 408: else ! 409: c = tp->t_intrc; ! 410: } ! 411: #if NBK > 0 ! 412: if (tp->t_line == NETLDISC) { ! 413: c &= 0177; ! 414: BKINPUT(c, tp); ! 415: } else ! 416: #endif ! 417: (*linesw[tp->t_line].l_rint)(c, tp); ! 418: } ! 419: } ! 420: ! 421: /* ! 422: * Ioctl for DMF32. ! 423: */ ! 424: /*ARGSUSED*/ ! 425: dmfioctl(dev, cmd, data, flag) ! 426: dev_t dev; ! 427: caddr_t data; ! 428: { ! 429: register struct tty *tp; ! 430: register int unit = minor(dev); ! 431: int error; ! 432: ! 433: if (unit & 0200) ! 434: return (ENOTTY); ! 435: tp = &dmf_tty[unit]; ! 436: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag); ! 437: if (error >= 0) ! 438: return (error); ! 439: error = ttioctl(tp, cmd, data, flag); ! 440: if (error >= 0) { ! 441: if (cmd == TIOCSETP || cmd == TIOCSETN || cmd == TIOCLBIS || ! 442: cmd == TIOCLBIC || cmd == TIOCLSET) ! 443: dmfparam(unit); ! 444: return (error); ! 445: } ! 446: switch (cmd) { ! 447: ! 448: case TIOCSBRK: ! 449: (void) dmfmctl(dev, DMF_BRK, DMBIS); ! 450: break; ! 451: ! 452: case TIOCCBRK: ! 453: (void) dmfmctl(dev, DMF_BRK, DMBIC); ! 454: break; ! 455: ! 456: case TIOCSDTR: ! 457: (void) dmfmctl(dev, DMF_DTR|DMF_RTS, DMBIS); ! 458: break; ! 459: ! 460: case TIOCCDTR: ! 461: (void) dmfmctl(dev, DMF_DTR|DMF_RTS, DMBIC); ! 462: break; ! 463: ! 464: case TIOCMSET: ! 465: (void) dmfmctl(dev, dmtodmf(*(int *)data), DMSET); ! 466: break; ! 467: ! 468: case TIOCMBIS: ! 469: (void) dmfmctl(dev, dmtodmf(*(int *)data), DMBIS); ! 470: break; ! 471: ! 472: case TIOCMBIC: ! 473: (void) dmfmctl(dev, dmtodmf(*(int *)data), DMBIC); ! 474: break; ! 475: ! 476: case TIOCMGET: ! 477: *(int *)data = dmftodm(dmfmctl(dev, 0, DMGET)); ! 478: break; ! 479: ! 480: default: ! 481: return (ENOTTY); ! 482: } ! 483: return (0); ! 484: } ! 485: ! 486: dmtodmf(bits) ! 487: register int bits; ! 488: { ! 489: register int b; ! 490: ! 491: b = bits & 012; ! 492: if (bits & DML_ST) b |= DMF_RATE; ! 493: if (bits & DML_RTS) b |= DMF_RTS; ! 494: if (bits & DML_USR) b |= DMF_USRW; ! 495: return(b); ! 496: } ! 497: ! 498: dmftodm(bits) ! 499: register int bits; ! 500: { ! 501: register int b; ! 502: ! 503: b = (bits & 012) | ((bits >> 7) & 0760) | DML_LE; ! 504: if (bits & DMF_USRR) b |= DML_USR; ! 505: if (bits & DMF_RTS) b |= DML_RTS; ! 506: return(b); ! 507: } ! 508: ! 509: ! 510: /* ! 511: * Set parameters from open or stty into the DMF hardware ! 512: * registers. ! 513: */ ! 514: dmfparam(unit) ! 515: register int unit; ! 516: { ! 517: register struct tty *tp; ! 518: register struct dmfdevice *addr; ! 519: register int lpar, lcr; ! 520: int s; ! 521: ! 522: tp = &dmf_tty[unit]; ! 523: addr = (struct dmfdevice *)tp->t_addr; ! 524: /* ! 525: * Block interrupts so parameters will be set ! 526: * before the line interrupts. ! 527: */ ! 528: s = spltty(); ! 529: addr->dmfcsr = (unit&07) | DMFIR_LCR | DMF_IE; ! 530: if ((tp->t_ispeed)==0) { ! 531: tp->t_state |= TS_HUPCLS; ! 532: (void) dmfmctl(unit, DMF_OFF, DMSET); ! 533: splx(s); ! 534: return; ! 535: } ! 536: lpar = (dmf_speeds[tp->t_ospeed]<<12) | (dmf_speeds[tp->t_ispeed]<<8); ! 537: lcr = DMFLCR_ENA; ! 538: if ((tp->t_ispeed) == B134) ! 539: lpar |= BITS6|PENABLE; ! 540: else if (tp->t_flags & (RAW|LITOUT|PASS8)) ! 541: lpar |= BITS8; ! 542: else { ! 543: lpar |= BITS7|PENABLE; ! 544: /* CHECK FOR XON/XOFF AND SET lcr |= DMF_AUTOX; */ ! 545: } ! 546: if (tp->t_flags&EVENP) ! 547: lpar |= EPAR; ! 548: if ((tp->t_ospeed) == B110) ! 549: lpar |= TWOSB; ! 550: lpar |= (unit&07); ! 551: addr->dmflpr = lpar; ! 552: addr->dmflctms = (addr->dmflctms &~ 0xff) | lcr; ! 553: splx(s); ! 554: } ! 555: ! 556: /* ! 557: * DMF32 transmitter interrupt. ! 558: * Restart the idle line. ! 559: */ ! 560: dmfxint(dmf) ! 561: int dmf; ! 562: { ! 563: int unit0 = dmf * 8; ! 564: struct tty *tp0 = &dmf_tty[unit0]; ! 565: register struct tty *tp; ! 566: register struct dmfdevice *addr; ! 567: register struct uba_device *ui; ! 568: register int t; ! 569: short cntr; ! 570: ! 571: ui = dmfinfo[dmf]; ! 572: addr = (struct dmfdevice *)ui->ui_addr; ! 573: while ((t = addr->dmfcsr) & DMF_TI) { ! 574: if (t & DMF_NXM) ! 575: /* SHOULD RESTART OR SOMETHING... */ ! 576: printf("dmf%d: NXM line %d\n", dmf, t >> 8 & 7); ! 577: t = t >> 8 & 7; ! 578: tp = tp0 + t; ! 579: tp->t_state &= ~TS_BUSY; ! 580: if (tp->t_state&TS_FLUSH) ! 581: tp->t_state &= ~TS_FLUSH; ! 582: else if (dmf_dma[unit0 + t]) { ! 583: /* ! 584: * Do arithmetic in a short to make up ! 585: * for lost 16&17 bits. ! 586: */ ! 587: addr->dmfcsr = DMFIR_TBA | DMF_IE | t; ! 588: cntr = addr->dmftba - ! 589: UBACVT(tp->t_outq.c_cf, ui->ui_ubanum); ! 590: ndflush(&tp->t_outq, (int)cntr); ! 591: } ! 592: if (tp->t_line) ! 593: (*linesw[tp->t_line].l_start)(tp); ! 594: else ! 595: dmfstart(tp); ! 596: } ! 597: } ! 598: ! 599: /* ! 600: * Start (restart) transmission on the given DMF32 line. ! 601: */ ! 602: dmfstart(tp) ! 603: register struct tty *tp; ! 604: { ! 605: register struct dmfdevice *addr; ! 606: register int unit, nch; ! 607: int s; ! 608: register int dmf; ! 609: ! 610: unit = minor(tp->t_dev); ! 611: dmf = unit >> 3; ! 612: unit &= 07; ! 613: addr = (struct dmfdevice *)tp->t_addr; ! 614: ! 615: /* ! 616: * Must hold interrupts in following code to prevent ! 617: * state of the tp from changing. ! 618: */ ! 619: s = spltty(); ! 620: /* ! 621: * If it's currently active, or delaying, no need to do anything. ! 622: */ ! 623: if (tp->t_state&(TS_TIMEOUT|TS_BUSY|TS_TTSTOP)) ! 624: goto out; ! 625: /* ! 626: * If there are still characters in the silo, ! 627: * just reenable the transmitter. ! 628: */ ! 629: addr->dmfcsr = DMF_IE | DMFIR_TBUF | unit; ! 630: if (addr->dmftsc) { ! 631: addr->dmfcsr = DMF_IE | DMFIR_LCR | unit; ! 632: addr->dmflctms = addr->dmflctms | DMF_TE; ! 633: tp->t_state |= TS_BUSY; ! 634: goto out; ! 635: } ! 636: /* ! 637: * If there are sleepers, and output has drained below low ! 638: * water mark, wake up the sleepers. ! 639: */ ! 640: if (tp->t_outq.c_cc<=TTLOWAT(tp)) { ! 641: if (tp->t_state&TS_ASLEEP) { ! 642: tp->t_state &= ~TS_ASLEEP; ! 643: wakeup((caddr_t)&tp->t_outq); ! 644: } ! 645: if (tp->t_wsel) { ! 646: selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL); ! 647: tp->t_wsel = 0; ! 648: tp->t_state &= ~TS_WCOLL; ! 649: } ! 650: } ! 651: /* ! 652: * Now restart transmission unless the output queue is ! 653: * empty. ! 654: */ ! 655: if (tp->t_outq.c_cc == 0) ! 656: goto out; ! 657: if (tp->t_flags & (RAW|LITOUT)) ! 658: nch = ndqb(&tp->t_outq, 0); ! 659: else { ! 660: if ((nch = ndqb(&tp->t_outq, 0200)) == 0) { ! 661: /* ! 662: * If first thing on queue is a delay process it. ! 663: */ ! 664: nch = getc(&tp->t_outq); ! 665: timeout(ttrstrt, (caddr_t)tp, (nch&0x7f)+6); ! 666: tp->t_state |= TS_TIMEOUT; ! 667: goto out; ! 668: } ! 669: } ! 670: /* ! 671: * If characters to transmit, restart transmission. ! 672: */ ! 673: if (nch >= dmf_mindma) { ! 674: register car; ! 675: ! 676: dmf_dma[minor(tp->t_dev)] = 1; ! 677: addr->dmfcsr = DMF_IE | DMFIR_LCR | unit; ! 678: addr->dmflctms = addr->dmflctms | DMF_TE; ! 679: car = UBACVT(tp->t_outq.c_cf, dmfinfo[dmf]->ui_ubanum); ! 680: addr->dmfcsr = DMF_IE | DMFIR_TBA | unit; ! 681: addr->dmftba = car; ! 682: addr->dmftcc = ((car >> 2) & 0xc000) | nch; ! 683: tp->t_state |= TS_BUSY; ! 684: } else if (nch) { ! 685: register char *cp = tp->t_outq.c_cf; ! 686: register int i; ! 687: ! 688: dmf_dma[minor(tp->t_dev)] = 0; ! 689: nch = MIN(nch, DMF_SILOCNT); ! 690: addr->dmfcsr = DMF_IE | DMFIR_LCR | unit; ! 691: addr->dmflctms = addr->dmflctms | DMF_TE; ! 692: addr->dmfcsr = DMF_IE | DMFIR_TBUF | unit; ! 693: for (i = 0; i < nch; i++) ! 694: addr->dmftbuf = *cp++; ! 695: ndflush(&tp->t_outq, nch); ! 696: tp->t_state |= TS_BUSY; ! 697: } ! 698: out: ! 699: splx(s); ! 700: } ! 701: ! 702: /* ! 703: * Stop output on a line, e.g. for ^S/^Q or output flush. ! 704: */ ! 705: /*ARGSUSED*/ ! 706: dmfstop(tp, flag) ! 707: register struct tty *tp; ! 708: { ! 709: register struct dmfdevice *addr; ! 710: register unit = minor(tp->t_dev) & 7; ! 711: int s; ! 712: ! 713: addr = (struct dmfdevice *)tp->t_addr; ! 714: /* ! 715: * Block input/output interrupts while messing with state. ! 716: */ ! 717: s = spltty(); ! 718: if (flag) { ! 719: addr->dmfcsr = DMF_IE | DMFIR_TBUF | unit; ! 720: if (addr->dmftsc) { ! 721: /* ! 722: * Flush regardless of whether we're transmitting ! 723: * (TS_BUSY), if the silo contains untransmitted ! 724: * characters. ! 725: */ ! 726: addr->dmfcsr = DMFIR_LCR | unit | DMF_IE; ! 727: addr->dmflctms = addr->dmflctms | DMF_TE | DMF_FLUSH; ! 728: /* this will interrupt so let dmfxint handle the rest */ ! 729: tp->t_state |= TS_FLUSH|TS_BUSY; ! 730: } ! 731: } else { ! 732: if (tp->t_state & TS_BUSY) { ! 733: /* ! 734: * Stop transmission by disabling ! 735: * the transmitter. We'll pick up where we ! 736: * left off by reenabling in dmfstart. ! 737: */ ! 738: addr->dmfcsr = DMFIR_LCR | unit | DMF_IE; ! 739: addr->dmflctms = addr->dmflctms &~ DMF_TE; ! 740: /* no interrupt here */ ! 741: tp->t_state &= ~TS_BUSY; ! 742: } ! 743: } ! 744: splx(s); ! 745: } ! 746: ! 747: /* ! 748: * DMF32 modem control ! 749: */ ! 750: dmfmctl(dev, bits, how) ! 751: dev_t dev; ! 752: int bits, how; ! 753: { ! 754: register struct dmfdevice *dmfaddr; ! 755: register int unit, mbits, lcr; ! 756: int s; ! 757: ! 758: unit = minor(dev); ! 759: dmfaddr = (struct dmfdevice *)(dmf_tty[unit].t_addr); ! 760: unit &= 07; ! 761: s = spltty(); ! 762: dmfaddr->dmfcsr = DMF_IE | DMFIR_TBUF | unit; ! 763: mbits = dmfaddr->dmfrms << 8; ! 764: dmfaddr->dmfcsr = DMF_IE | DMFIR_LCR | unit; ! 765: lcr = dmfaddr->dmflctms; ! 766: mbits |= (lcr & 0xff00) >> 8; ! 767: switch (how) { ! 768: case DMSET: ! 769: mbits = (mbits &0xff00) | bits; ! 770: break; ! 771: ! 772: case DMBIS: ! 773: mbits |= bits; ! 774: break; ! 775: ! 776: case DMBIC: ! 777: mbits &= ~bits; ! 778: break; ! 779: ! 780: case DMGET: ! 781: (void) splx(s); ! 782: return(mbits); ! 783: } ! 784: if (mbits & DMF_BRK) ! 785: lcr |= DMF_RBRK; ! 786: else ! 787: lcr &= ~DMF_RBRK; ! 788: dmfaddr->dmflctms = ((mbits & 037) << 8) | (lcr & 0xff); ! 789: (void) splx(s); ! 790: return(mbits); ! 791: } ! 792: ! 793: /* ! 794: * Reset state of driver if UBA reset was necessary. ! 795: * Reset the csr, lpr, and lcr registers on open lines, and ! 796: * restart transmitters. ! 797: */ ! 798: dmfreset(uban) ! 799: int uban; ! 800: { ! 801: register int dmf, unit; ! 802: register struct tty *tp; ! 803: register struct uba_device *ui; ! 804: register struct dmfdevice *addr; ! 805: int i; ! 806: ! 807: for (dmf = 0; dmf < NDMF; dmf++) { ! 808: ui = dmfinfo[dmf]; ! 809: if (ui == 0 || ui->ui_alive == 0 || ui->ui_ubanum != uban) ! 810: continue; ! 811: printf(" dmf%d", dmf); ! 812: if (dmf_ubinfo[uban]) { ! 813: dmf_ubinfo[uban] = uballoc(uban, (caddr_t)cfree, ! 814: nclist*sizeof (struct cblock), 0); ! 815: cbase[uban] = UBAI_ADDR(dmf_ubinfo[uban]); ! 816: } ! 817: addr = (struct dmfdevice *)ui->ui_addr; ! 818: addr->dmfcsr = DMF_IE; ! 819: addr->dmfrsp = dmf_timeout; ! 820: unit = dmf * 8; ! 821: for (i = 0; i < 8; i++) { ! 822: tp = &dmf_tty[unit]; ! 823: if (tp->t_state & (TS_ISOPEN|TS_WOPEN)) { ! 824: dmfparam(unit); ! 825: (void) dmfmctl(unit, DMF_ON, DMSET); ! 826: tp->t_state &= ~TS_BUSY; ! 827: dmfstart(tp); ! 828: } ! 829: unit++; ! 830: } ! 831: } ! 832: } ! 833: ! 834: /* ! 835: * dmflopen -- open the line printer port on a dmf32 ! 836: */ ! 837: /* ARGSUSED */ ! 838: dmflopen(dev, flag) ! 839: dev_t dev; ! 840: int flag; ! 841: { ! 842: register int dmf; ! 843: register struct dmfl_softc *sc; ! 844: register struct uba_device *ui; ! 845: register struct dmfdevice *addr; ! 846: ! 847: dmf = DMFL_UNIT(dev); ! 848: if (dmf >= NDMF || (ui = dmfinfo[dmf]) == 0 || ui->ui_alive == 0) ! 849: return (ENXIO); ! 850: sc = &dmfl_softc[dmf]; ! 851: if (sc->dmfl_state & OPEN) ! 852: return (EBUSY); ! 853: addr = (struct dmfdevice *)ui->ui_addr; ! 854: if (addr->dmfl_ctrl & DMFL_OFFLINE) { ! 855: #ifdef notdef ! 856: log(LOG_WARNING, "dmf%d: line printer offline/jammed\n", ! 857: dmf); ! 858: #endif ! 859: return (EIO); ! 860: } ! 861: if ((addr->dmfl_ctrl & DMFL_CONV)) { ! 862: log(LOG_WARNING, "dmf%d: line printer disconnected\n", dmf); ! 863: return (EIO); ! 864: } ! 865: ! 866: addr->dmfl_ctrl = 0; ! 867: sc->dmfl_state |= OPEN; ! 868: return (0); ! 869: } ! 870: ! 871: /* ARGSUSED */ ! 872: dmflclose(dev, flag) ! 873: dev_t dev; ! 874: int flag; ! 875: { ! 876: register int dmf = DMFL_UNIT(dev); ! 877: register struct dmfl_softc *sc = &dmfl_softc[dmf]; ! 878: register struct uba_device *ui = dmfinfo[dmf]; ! 879: ! 880: sc->dmfl_state = 0; ! 881: if (sc->dmfl_info != 0) ! 882: ubarelse((int)ui->ui_ubanum, &sc->dmfl_info); ! 883: ! 884: ((struct dmfdevice *)ui->ui_addr)->dmfl_ctrl = 0; ! 885: } ! 886: ! 887: dmflwrite(dev, uio) ! 888: dev_t dev; ! 889: struct uio *uio; ! 890: { ! 891: register int n; ! 892: register int error; ! 893: register struct dmfl_softc *sc; ! 894: ! 895: sc = &dmfl_softc[DMFL_UNIT(dev)]; ! 896: if (sc->dmfl_state & ERROR) ! 897: return (EIO); ! 898: while (n = (unsigned)uio->uio_resid) { ! 899: if (n > DMFL_BUFSIZ) { ! 900: n = DMFL_BUFSIZ; ! 901: sc->dmfl_state |= MOREIO; ! 902: } else ! 903: sc->dmfl_state &= ~MOREIO; ! 904: if (error = uiomove(sc->dmfl_buf, (int)n, UIO_WRITE, uio)) ! 905: return (error); ! 906: if (error = dmflout(dev, sc->dmfl_buf, n)) ! 907: return (error); ! 908: } ! 909: return (0); ! 910: } ! 911: ! 912: ! 913: /* ! 914: * dmflout -- start io operation to dmf line printer ! 915: * cp is addr of buf of n chars to be sent. ! 916: * ! 917: * -- dmf will be put in formatted output mode, this will ! 918: * be selectable from an ioctl if the ! 919: * need ever arises. ! 920: */ ! 921: dmflout(dev, cp, n) ! 922: dev_t dev; ! 923: char *cp; ! 924: int n; ! 925: { ! 926: register struct dmfl_softc *sc; ! 927: register int dmf; ! 928: register struct uba_device *ui; ! 929: register struct dmfdevice *d; ! 930: int s; ! 931: ! 932: dmf = DMFL_UNIT(dev); ! 933: sc = &dmfl_softc[dmf]; ! 934: if (sc->dmfl_state & ERROR) ! 935: return (EIO); ! 936: ui = dmfinfo[dmf]; ! 937: /* ! 938: * allocate unibus resources, will be released when io ! 939: * operation is done. ! 940: */ ! 941: if (sc->dmfl_info == 0) ! 942: sc->dmfl_info = uballoc(ui->ui_ubanum, cp, n, 0); ! 943: d = (struct dmfdevice *)ui->ui_addr; ! 944: d->dmfl_ctrl = sc->dmfl_format; /* indir reg 2 */ ! 945: /* indir reg auto increments on r/w */ ! 946: /* SO DON'T CHANGE THE ORDER OF THIS CODE */ ! 947: d->dmfl_indrct = 0; /* prefix chars & num */ ! 948: d->dmfl_indrct = 0; /* suffix chars & num */ ! 949: d->dmfl_indrct = sc->dmfl_info; /* dma lo 16 bits addr */ ! 950: d->dmfl_indrct = -n; /* number of chars */ ! 951: ! 952: d->dmfl_indrct = ((sc->dmfl_info>>16)&3) | DMFL_OPTIONS; ! 953: /* dma hi 2 bits addr */ ! 954: d->dmfl_indrct = sc->dmfl_lines /* lines per page */ ! 955: | (sc->dmfl_cols<<8); /* carriage width */ ! 956: sc->dmfl_state |= ASLP; ! 957: s = spltty(); ! 958: d->dmfl_ctrl |= DMFL_PEN | DMFL_IE; ! 959: while (sc->dmfl_state & ASLP) { ! 960: sleep(sc->dmfl_buf, PZERO + 8); ! 961: while (sc->dmfl_state & ERROR) { ! 962: timeout(dmflint, (caddr_t)dmf, 10 * hz); ! 963: sleep((caddr_t)&sc->dmfl_state, PZERO + 8); ! 964: } ! 965: } ! 966: splx(s); ! 967: return (0); ! 968: } ! 969: ! 970: /* ! 971: * dmflint -- handle an interrupt from the line printer part of the dmf32 ! 972: */ ! 973: dmflint(dmf) ! 974: int dmf; ! 975: { ! 976: register struct uba_device *ui; ! 977: register struct dmfl_softc *sc; ! 978: register struct dmfdevice *d; ! 979: short dmfl_stats; ! 980: ! 981: ui = dmfinfo[dmf]; ! 982: sc = &dmfl_softc[dmf]; ! 983: d = (struct dmfdevice *)ui->ui_addr; ! 984: ! 985: d->dmfl_ctrl &= ~DMFL_IE; ! 986: dmfl_stats = d->dmfl_ctrl; ! 987: if (sc->dmfl_state & ERROR) { ! 988: if ((dmfl_stats & DMFL_OFFLINE) == 0) ! 989: sc->dmfl_state &= ~ERROR; ! 990: wakeup((caddr_t)&sc->dmfl_state); ! 991: return; ! 992: } ! 993: if (dmfl_stats & DMFL_DMAERR) ! 994: log(LOG_WARNING, "dmf%d: NXM\n", dmf); ! 995: if (dmfl_stats & DMFL_OFFLINE) { ! 996: log(LOG_WARNING, "dmf%d: printer error\n", dmf); ! 997: sc->dmfl_state |= ERROR; ! 998: } ! 999: #ifdef notdef ! 1000: if (dmfl_stats & DMFL_PDONE) { ! 1001: printf("bytes= %d\n", d->dmfl_indrct); ! 1002: printf("lines= %d\n", d->dmfl_indrct); ! 1003: } ! 1004: #endif ! 1005: sc->dmfl_state &= ~ASLP; ! 1006: wakeup((caddr_t)sc->dmfl_buf); ! 1007: if (sc->dmfl_info && (sc->dmfl_state & MOREIO) == 0) ! 1008: ubarelse(ui->ui_ubanum, &sc->dmfl_info); ! 1009: } ! 1010: ! 1011: /* stubs for interrupt routines for devices not yet supported */ ! 1012: ! 1013: dmfsrint() ! 1014: { ! 1015: printf("dmfsrint\n"); ! 1016: } ! 1017: ! 1018: dmfsxint() ! 1019: { ! 1020: printf("dmfsxint\n"); ! 1021: } ! 1022: ! 1023: dmfdaint() ! 1024: { ! 1025: printf("dmfdaint\n"); ! 1026: } ! 1027: ! 1028: dmfdbint() ! 1029: { ! 1030: printf("dmfdbint\n"); ! 1031: } ! 1032: #endif NDMF
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.