![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dca.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev|
Return to dca.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1990 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution is only permitted until one year after the first shipment ! 6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 7: * binary forms are permitted provided that: (1) source distributions retain ! 8: * this entire copyright notice and comment, and (2) distributions including ! 9: * binaries display the following acknowledgement: This product includes ! 10: * software developed by the University of California, Berkeley and its ! 11: * contributors'' in the documentation or other materials provided with the ! 12: * distribution and in all advertising materials mentioning features or use ! 13: * of this software. Neither the name of the University nor the names of ! 14: * its contributors may be used to endorse or promote products derived from ! 15: * this software without specific prior written permission. ! 16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 19: * ! 20: * @(#)dca.c 7.7 (Berkeley) 6/30/90 ! 21: */ ! 22: ! 23: #include "dca.h" ! 24: #if NDCA > 0 ! 25: /* ! 26: * 98626/98644/internal serial interface ! 27: */ ! 28: #include "param.h" ! 29: #include "systm.h" ! 30: #include "ioctl.h" ! 31: #include "tty.h" ! 32: #include "user.h" ! 33: #include "conf.h" ! 34: #include "file.h" ! 35: #include "uio.h" ! 36: #include "kernel.h" ! 37: #include "syslog.h" ! 38: ! 39: #include "device.h" ! 40: #include "dcareg.h" ! 41: #include "machine/cpu.h" ! 42: #include "machine/isr.h" ! 43: ! 44: int dcaprobe(); ! 45: struct driver dcadriver = { ! 46: dcaprobe, "dca", ! 47: }; ! 48: ! 49: int dcastart(), dcaparam(), dcaintr(); ! 50: int dcasoftCAR; ! 51: int dca_active; ! 52: int ndca = NDCA; ! 53: int dcaconsole = -1; ! 54: int dcadefaultrate = TTYDEF_SPEED; ! 55: struct dcadevice *dca_addr[NDCA]; ! 56: struct tty dca_tty[NDCA]; ! 57: struct isr dcaisr[NDCA]; ! 58: ! 59: struct speedtab dcaspeedtab[] = { ! 60: 0, 0, ! 61: 50, DCABRD(50), ! 62: 75, DCABRD(75), ! 63: 110, DCABRD(110), ! 64: 134, DCABRD(134), ! 65: 150, DCABRD(150), ! 66: 200, DCABRD(200), ! 67: 300, DCABRD(300), ! 68: 600, DCABRD(600), ! 69: 1200, DCABRD(1200), ! 70: 1800, DCABRD(1800), ! 71: 2400, DCABRD(2400), ! 72: 4800, DCABRD(4800), ! 73: 9600, DCABRD(9600), ! 74: 19200, DCABRD(19200), ! 75: 38400, DCABRD(38400), ! 76: -1, -1 ! 77: }; ! 78: ! 79: extern struct tty *constty; ! 80: #ifdef KGDB ! 81: extern int kgdb_dev; ! 82: extern int kgdb_rate; ! 83: extern int kgdb_debug_init; ! 84: #endif ! 85: ! 86: #define UNIT(x) minor(x) ! 87: ! 88: dcaprobe(hd) ! 89: register struct hp_device *hd; ! 90: { ! 91: register struct dcadevice *dca; ! 92: register int unit; ! 93: ! 94: dca = (struct dcadevice *)hd->hp_addr; ! 95: if (dca->dca_irid != DCAID0 && ! 96: dca->dca_irid != DCAREMID0 && ! 97: dca->dca_irid != DCAID1 && ! 98: dca->dca_irid != DCAREMID1) ! 99: return (0); ! 100: unit = hd->hp_unit; ! 101: if (unit == dcaconsole) ! 102: DELAY(100000); ! 103: dca->dca_irid = 0xFF; ! 104: DELAY(100); ! 105: ! 106: hd->hp_ipl = DCAIPL(dca->dca_ic); ! 107: dcaisr[unit].isr_ipl = hd->hp_ipl; ! 108: dcaisr[unit].isr_arg = unit; ! 109: dcaisr[unit].isr_intr = dcaintr; ! 110: dca_addr[unit] = dca; ! 111: dca_active |= 1 << unit; ! 112: dcasoftCAR = hd->hp_flags; ! 113: isrlink(&dcaisr[unit]); ! 114: #ifdef KGDB ! 115: if (kgdb_dev == makedev(1, unit)) { ! 116: if (dcaconsole == unit) ! 117: kgdb_dev = -1; /* can't debug over console port */ ! 118: else { ! 119: (void) dcainit(unit); ! 120: dcaconsole = -2; /* XXX */ ! 121: if (kgdb_debug_init) { ! 122: printf("dca%d: kgdb waiting...", unit); ! 123: /* trap into kgdb */ ! 124: asm("trap #15;"); ! 125: printf("connected.\n"); ! 126: } else ! 127: printf("dca%d: kgdb enabled\n", unit); ! 128: } ! 129: } ! 130: #endif ! 131: dca->dca_ic = IC_IE; ! 132: /* ! 133: * Need to reset baud rate, etc. of next print so reset dcaconsole. ! 134: * Also make sure console is always "hardwired" ! 135: */ ! 136: if (unit == dcaconsole) { ! 137: dcaconsole = -1; ! 138: dcasoftCAR |= (1 << unit); ! 139: } ! 140: return (1); ! 141: } ! 142: ! 143: dcaopen(dev, flag) ! 144: dev_t dev; ! 145: { ! 146: register struct tty *tp; ! 147: register int unit; ! 148: int error = 0; ! 149: ! 150: unit = UNIT(dev); ! 151: if (unit >= NDCA || (dca_active & (1 << unit)) == 0) ! 152: return (ENXIO); ! 153: tp = &dca_tty[unit]; ! 154: tp->t_oproc = dcastart; ! 155: tp->t_param = dcaparam; ! 156: tp->t_dev = dev; ! 157: if ((tp->t_state & TS_ISOPEN) == 0) { ! 158: tp->t_state |= TS_WOPEN; ! 159: ttychars(tp); ! 160: tp->t_iflag = TTYDEF_IFLAG; ! 161: tp->t_oflag = TTYDEF_OFLAG; ! 162: tp->t_cflag = TTYDEF_CFLAG; ! 163: tp->t_lflag = TTYDEF_LFLAG; ! 164: tp->t_ispeed = tp->t_ospeed = dcadefaultrate; ! 165: dcaparam(tp, &tp->t_termios); ! 166: ttsetwater(tp); ! 167: } else if (tp->t_state&TS_XCLUDE && u.u_uid != 0) ! 168: return (EBUSY); ! 169: (void) dcamctl(dev, MCR_DTR | MCR_RTS, DMSET); ! 170: if ((dcasoftCAR & (1 << unit)) || (dcamctl(dev, 0, DMGET) & MSR_DCD)) ! 171: tp->t_state |= TS_CARR_ON; ! 172: (void) spltty(); ! 173: while ((flag&O_NONBLOCK) == 0 && (tp->t_cflag&CLOCAL) == 0 && ! 174: (tp->t_state & TS_CARR_ON) == 0) { ! 175: tp->t_state |= TS_WOPEN; ! 176: if (error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI | PCATCH, ! 177: ttopen, 0)) ! 178: break; ! 179: } ! 180: (void) spl0(); ! 181: if (error == 0) ! 182: error = (*linesw[tp->t_line].l_open)(dev, tp); ! 183: return (error); ! 184: } ! 185: ! 186: /*ARGSUSED*/ ! 187: dcaclose(dev, flag) ! 188: dev_t dev; ! 189: { ! 190: register struct tty *tp; ! 191: register struct dcadevice *dca; ! 192: register int unit; ! 193: ! 194: unit = UNIT(dev); ! 195: dca = dca_addr[unit]; ! 196: tp = &dca_tty[unit]; ! 197: (*linesw[tp->t_line].l_close)(tp); ! 198: dca->dca_cfcr &= ~CFCR_SBREAK; ! 199: #ifdef KGDB ! 200: /* do not disable interrupts if debugging */ ! 201: if (kgdb_dev != makedev(1, unit)) ! 202: #endif ! 203: dca->dca_ier = 0; ! 204: if (tp->t_cflag&HUPCL || tp->t_state&TS_WOPEN || ! 205: (tp->t_state&TS_ISOPEN) == 0) ! 206: (void) dcamctl(dev, 0, DMSET); ! 207: ttyclose(tp); ! 208: return(0); ! 209: } ! 210: ! 211: dcaread(dev, uio, flag) ! 212: dev_t dev; ! 213: struct uio *uio; ! 214: { ! 215: register struct tty *tp = &dca_tty[UNIT(dev)]; ! 216: ! 217: return ((*linesw[tp->t_line].l_read)(tp, uio, flag)); ! 218: } ! 219: ! 220: dcawrite(dev, uio, flag) ! 221: dev_t dev; ! 222: struct uio *uio; ! 223: { ! 224: int unit = UNIT(dev); ! 225: register struct tty *tp = &dca_tty[unit]; ! 226: ! 227: /* ! 228: * (XXX) We disallow virtual consoles if the physical console is ! 229: * a serial port. This is in case there is a display attached that ! 230: * is not the console. In that situation we don't need/want the X ! 231: * server taking over the console. ! 232: */ ! 233: if (constty && unit == dcaconsole) ! 234: constty = NULL; ! 235: return ((*linesw[tp->t_line].l_write)(tp, uio, flag)); ! 236: } ! 237: ! 238: dcaintr(unit) ! 239: register int unit; ! 240: { ! 241: register struct dcadevice *dca; ! 242: register u_char code; ! 243: register struct tty *tp; ! 244: ! 245: dca = dca_addr[unit]; ! 246: if ((dca->dca_ic & IC_IR) == 0) ! 247: return(0); ! 248: while (1) { ! 249: code = dca->dca_iir; ! 250: switch (code) { ! 251: case IIR_NOPEND: ! 252: return (1); ! 253: case IIR_RXRDY: ! 254: /* do time-critical read in-line */ ! 255: tp = &dca_tty[unit]; ! 256: code = dca->dca_data; ! 257: if ((tp->t_state & TS_ISOPEN) == 0) { ! 258: #ifdef KGDB ! 259: if (kgdb_dev == makedev(1, unit) && ! 260: code == '!') { ! 261: printf("kgdb trap from dca%d\n", unit); ! 262: /* trap into kgdb */ ! 263: asm("trap #15;"); ! 264: } ! 265: #endif ! 266: } else ! 267: (*linesw[tp->t_line].l_rint)(code, tp); ! 268: break; ! 269: case IIR_TXRDY: ! 270: tp = &dca_tty[unit]; ! 271: tp->t_state &=~ (TS_BUSY|TS_FLUSH); ! 272: if (tp->t_line) ! 273: (*linesw[tp->t_line].l_start)(tp); ! 274: else ! 275: dcastart(tp); ! 276: break; ! 277: case IIR_RLS: ! 278: dcaeint(unit, dca); ! 279: break; ! 280: default: ! 281: if (code & IIR_NOPEND) ! 282: return (1); ! 283: log(LOG_WARNING, "dca%d: weird interrupt: 0x%x\n", ! 284: unit, code); ! 285: /* fall through */ ! 286: case IIR_MLSC: ! 287: dcamint(unit, dca); ! 288: break; ! 289: } ! 290: } ! 291: } ! 292: ! 293: dcaeint(unit, dca) ! 294: register int unit; ! 295: register struct dcadevice *dca; ! 296: { ! 297: register struct tty *tp; ! 298: register int stat, c; ! 299: ! 300: tp = &dca_tty[unit]; ! 301: stat = dca->dca_lsr; ! 302: c = dca->dca_data; ! 303: if ((tp->t_state & TS_ISOPEN) == 0) { ! 304: #ifdef KGDB ! 305: /* we don't care about parity errors */ ! 306: if (((stat & (LSR_BI|LSR_FE|LSR_PE)) == LSR_PE) && ! 307: kgdb_dev == makedev(1, unit) && c == '!') { ! 308: printf("kgdb trap from dca%d\n", unit); ! 309: /* trap into kgdb */ ! 310: asm("trap #15;"); ! 311: } ! 312: #endif ! 313: return; ! 314: } ! 315: if (stat & (LSR_BI | LSR_FE)) ! 316: c |= TTY_FE; ! 317: else if (stat & LSR_PE) ! 318: c |= TTY_PE; ! 319: else if (stat & LSR_OE) ! 320: log(LOG_WARNING, "dca%d: silo overflow\n", unit); ! 321: (*linesw[tp->t_line].l_rint)(c, tp); ! 322: } ! 323: ! 324: dcamint(unit, dca) ! 325: register int unit; ! 326: register struct dcadevice *dca; ! 327: { ! 328: register struct tty *tp; ! 329: register int stat; ! 330: ! 331: tp = &dca_tty[unit]; ! 332: stat = dca->dca_msr; ! 333: if ((stat & MSR_DDCD) && (dcasoftCAR & (1 << unit)) == 0) { ! 334: if (stat & MSR_DCD) ! 335: (void)(*linesw[tp->t_line].l_modem)(tp, 1); ! 336: else if ((*linesw[tp->t_line].l_modem)(tp, 0) == 0) ! 337: dca->dca_mcr &= ~(MCR_DTR | MCR_RTS); ! 338: } else if ((stat & MSR_DCTS) && (tp->t_state & TS_ISOPEN) && ! 339: (tp->t_flags & CRTSCTS)) { ! 340: /* the line is up and we want to do rts/cts flow control */ ! 341: if (stat & MSR_CTS) { ! 342: tp->t_state &=~ TS_TTSTOP; ! 343: ttstart(tp); ! 344: } else ! 345: tp->t_state |= TS_TTSTOP; ! 346: } ! 347: } ! 348: ! 349: dcaioctl(dev, cmd, data, flag) ! 350: dev_t dev; ! 351: caddr_t data; ! 352: { ! 353: register struct tty *tp; ! 354: register int unit = UNIT(dev); ! 355: register struct dcadevice *dca; ! 356: register int error; ! 357: ! 358: tp = &dca_tty[unit]; ! 359: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag); ! 360: if (error >= 0) ! 361: return (error); ! 362: error = ttioctl(tp, cmd, data, flag); ! 363: if (error >= 0) ! 364: return (error); ! 365: ! 366: dca = dca_addr[unit]; ! 367: switch (cmd) { ! 368: ! 369: case TIOCSBRK: ! 370: dca->dca_cfcr |= CFCR_SBREAK; ! 371: break; ! 372: ! 373: case TIOCCBRK: ! 374: dca->dca_cfcr &= ~CFCR_SBREAK; ! 375: break; ! 376: ! 377: case TIOCSDTR: ! 378: (void) dcamctl(dev, MCR_DTR | MCR_RTS, DMBIS); ! 379: break; ! 380: ! 381: case TIOCCDTR: ! 382: (void) dcamctl(dev, MCR_DTR | MCR_RTS, DMBIC); ! 383: break; ! 384: ! 385: case TIOCMSET: ! 386: (void) dcamctl(dev, *(int *)data, DMSET); ! 387: break; ! 388: ! 389: case TIOCMBIS: ! 390: (void) dcamctl(dev, *(int *)data, DMBIS); ! 391: break; ! 392: ! 393: case TIOCMBIC: ! 394: (void) dcamctl(dev, *(int *)data, DMBIC); ! 395: break; ! 396: ! 397: case TIOCMGET: ! 398: *(int *)data = dcamctl(dev, 0, DMGET); ! 399: break; ! 400: ! 401: default: ! 402: return (ENOTTY); ! 403: } ! 404: return (0); ! 405: } ! 406: ! 407: dcaparam(tp, t) ! 408: register struct tty *tp; ! 409: register struct termios *t; ! 410: { ! 411: register struct dcadevice *dca; ! 412: register int cfcr, cflag = t->c_cflag; ! 413: int unit = UNIT(tp->t_dev); ! 414: int ospeed = ttspeedtab(t->c_ospeed, dcaspeedtab); ! 415: ! 416: /* check requested parameters */ ! 417: if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed)) ! 418: return(EINVAL); ! 419: /* and copy to tty */ ! 420: tp->t_ispeed = t->c_ispeed; ! 421: tp->t_ospeed = t->c_ospeed; ! 422: tp->t_cflag = cflag; ! 423: ! 424: dca = dca_addr[unit]; ! 425: dca->dca_ier = IER_ERXRDY | IER_ETXRDY | IER_ERLS | IER_EMSC; ! 426: if (ospeed == 0) { ! 427: (void) dcamctl(unit, 0, DMSET); /* hang up line */ ! 428: return(0); ! 429: } ! 430: dca->dca_cfcr |= CFCR_DLAB; ! 431: dca->dca_data = ospeed & 0xFF; ! 432: dca->dca_ier = ospeed >> 8; ! 433: switch (cflag&CSIZE) { ! 434: case CS5: ! 435: cfcr = CFCR_5BITS; break; ! 436: case CS6: ! 437: cfcr = CFCR_6BITS; break; ! 438: case CS7: ! 439: cfcr = CFCR_7BITS; break; ! 440: case CS8: ! 441: cfcr = CFCR_8BITS; break; ! 442: } ! 443: if (cflag&PARENB) { ! 444: cfcr |= CFCR_PENAB; ! 445: if ((cflag&PARODD) == 0) ! 446: cfcr |= CFCR_PEVEN; ! 447: } ! 448: if (cflag&CSTOPB) ! 449: cfcr |= CFCR_STOPB; ! 450: dca->dca_cfcr = cfcr; ! 451: return(0); ! 452: } ! 453: ! 454: dcastart(tp) ! 455: register struct tty *tp; ! 456: { ! 457: register struct dcadevice *dca; ! 458: int s, unit, c; ! 459: ! 460: unit = UNIT(tp->t_dev); ! 461: dca = dca_addr[unit]; ! 462: s = spltty(); ! 463: if (tp->t_state & (TS_TIMEOUT|TS_TTSTOP)) ! 464: goto out; ! 465: if (tp->t_outq.c_cc <= tp->t_lowat) { ! 466: if (tp->t_state&TS_ASLEEP) { ! 467: tp->t_state &= ~TS_ASLEEP; ! 468: wakeup((caddr_t)&tp->t_outq); ! 469: } ! 470: if (tp->t_wsel) { ! 471: selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL); ! 472: tp->t_wsel = 0; ! 473: tp->t_state &= ~TS_WCOLL; ! 474: } ! 475: } ! 476: if (tp->t_outq.c_cc == 0) ! 477: goto out; ! 478: if (dca->dca_lsr & LSR_TXRDY) { ! 479: c = getc(&tp->t_outq); ! 480: tp->t_state |= TS_BUSY; ! 481: dca->dca_data = c; ! 482: } ! 483: out: ! 484: splx(s); ! 485: } ! 486: ! 487: /* ! 488: * Stop output on a line. ! 489: */ ! 490: /*ARGSUSED*/ ! 491: dcastop(tp, flag) ! 492: register struct tty *tp; ! 493: { ! 494: register int s; ! 495: ! 496: s = spltty(); ! 497: if (tp->t_state & TS_BUSY) { ! 498: if ((tp->t_state&TS_TTSTOP)==0) ! 499: tp->t_state |= TS_FLUSH; ! 500: } ! 501: splx(s); ! 502: } ! 503: ! 504: dcamctl(dev, bits, how) ! 505: dev_t dev; ! 506: int bits, how; ! 507: { ! 508: register struct dcadevice *dca; ! 509: register int unit; ! 510: int s; ! 511: ! 512: unit = UNIT(dev); ! 513: dca = dca_addr[unit]; ! 514: s = spltty(); ! 515: switch (how) { ! 516: ! 517: case DMSET: ! 518: dca->dca_mcr = bits; ! 519: break; ! 520: ! 521: case DMBIS: ! 522: dca->dca_mcr |= bits; ! 523: break; ! 524: ! 525: case DMBIC: ! 526: dca->dca_mcr &= ~bits; ! 527: break; ! 528: ! 529: case DMGET: ! 530: bits = dca->dca_msr; ! 531: break; ! 532: } ! 533: (void) splx(s); ! 534: return(bits); ! 535: } ! 536: ! 537: /* ! 538: * Following are all routines needed for DCA to act as console ! 539: */ ! 540: #include "machine/cons.h" ! 541: ! 542: dcacnprobe(cp) ! 543: struct consdev *cp; ! 544: { ! 545: int unit, i; ! 546: extern int dcaopen(); ! 547: ! 548: /* XXX: ick */ ! 549: unit = CONUNIT; ! 550: dca_addr[CONUNIT] = CONADDR; ! 551: ! 552: /* make sure hardware exists */ ! 553: if (badaddr((short *)dca_addr[unit])) { ! 554: cp->cn_pri = CN_DEAD; ! 555: return; ! 556: } ! 557: ! 558: /* locate the major number */ ! 559: for (i = 0; i < nchrdev; i++) ! 560: if (cdevsw[i].d_open == dcaopen) ! 561: break; ! 562: ! 563: /* initialize required fields */ ! 564: cp->cn_dev = makedev(i, unit); ! 565: cp->cn_tp = &dca_tty[unit]; ! 566: switch (dca_addr[unit]->dca_irid) { ! 567: case DCAID0: ! 568: case DCAID1: ! 569: cp->cn_pri = CN_NORMAL; ! 570: break; ! 571: case DCAREMID0: ! 572: case DCAREMID1: ! 573: cp->cn_pri = CN_REMOTE; ! 574: break; ! 575: default: ! 576: cp->cn_pri = CN_DEAD; ! 577: break; ! 578: } ! 579: } ! 580: ! 581: dcacninit(cp) ! 582: struct consdev *cp; ! 583: { ! 584: int unit = UNIT(cp->cn_dev); ! 585: ! 586: dcainit(unit); ! 587: dcaconsole = unit; ! 588: } ! 589: ! 590: dcainit(unit) ! 591: int unit; ! 592: { ! 593: register struct dcadevice *dca; ! 594: int s, rate; ! 595: short stat; ! 596: ! 597: #ifdef lint ! 598: stat = unit; if (stat) return; ! 599: #endif ! 600: dca = dca_addr[unit]; ! 601: s = splhigh(); ! 602: dca->dca_irid = 0xFF; ! 603: DELAY(100); ! 604: dca->dca_ic = IC_IE; ! 605: dca->dca_cfcr = CFCR_DLAB; ! 606: rate = ttspeedtab(dcadefaultrate, dcaspeedtab); ! 607: dca->dca_data = rate & 0xFF; ! 608: dca->dca_ier = rate >> 8; ! 609: dca->dca_cfcr = CFCR_8BITS; ! 610: dca->dca_ier = IER_ERXRDY | IER_ETXRDY; ! 611: stat = dca->dca_iir; ! 612: splx(s); ! 613: } ! 614: ! 615: dcacngetc(dev) ! 616: { ! 617: register struct dcadevice *dca = dca_addr[UNIT(dev)]; ! 618: short stat; ! 619: int c, s; ! 620: ! 621: #ifdef lint ! 622: stat = dev; if (stat) return(0); ! 623: #endif ! 624: s = splhigh(); ! 625: while (((stat = dca->dca_lsr) & LSR_RXRDY) == 0) ! 626: ; ! 627: c = dca->dca_data; ! 628: stat = dca->dca_iir; ! 629: splx(s); ! 630: return(c); ! 631: } ! 632: ! 633: /* ! 634: * Console kernel output character routine. ! 635: */ ! 636: dcacnputc(dev, c) ! 637: dev_t dev; ! 638: register int c; ! 639: { ! 640: register struct dcadevice *dca = dca_addr[UNIT(dev)]; ! 641: register int timo; ! 642: short stat; ! 643: int s = splhigh(); ! 644: ! 645: #ifdef lint ! 646: stat = dev; if (stat) return; ! 647: #endif ! 648: if (dcaconsole == -1) { ! 649: (void) dcainit(UNIT(dev)); ! 650: dcaconsole = UNIT(dev); ! 651: } ! 652: /* wait for any pending transmission to finish */ ! 653: timo = 50000; ! 654: while (((stat = dca->dca_lsr) & LSR_TXRDY) == 0 && --timo) ! 655: ; ! 656: dca->dca_data = c; ! 657: /* wait for this transmission to complete */ ! 658: timo = 1500000; ! 659: while (((stat = dca->dca_lsr) & LSR_TXRDY) == 0 && --timo) ! 660: ; ! 661: /* clear any interrupts generated by this transmission */ ! 662: stat = dca->dca_iir; ! 663: splx(s); ! 664: } ! 665: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.