![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to alx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / io.386|
Return to alx.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / io.386 |
1.1 ! root 1: /* (-lgl ! 2: * COHERENT Driver Kit Version x.x.x ! 3: * Copyright (c) 1982, 1990 by Mark Williams Company. ! 4: * All rights reserved. May not be copied without permission. ! 5: * ! 6: * $Log: alx.c,v $ ! 7: * Revision 1.2 92/08/04 12:51:47 bin ! 8: * update for ker59 ! 9: * ! 10: * Revision 1.11 92/04/30 08:59:18 hal ! 11: * Add asy. Remove silos from tty struct. ! 12: * ! 13: * Revision 1.10 92/04/13 14:53:15 hal ! 14: * Silos moved out of TTY struct. ! 15: * ! 16: * Revision 1.9 92/04/13 10:12:27 hal ! 17: * Add NO_ISILO test code. ! 18: * ! 19: * Revision 1.8 92/03/19 18:33:17 hal ! 20: * LSR_READ debug macro. ! 21: * ! 22: * Revision 1.7 92/03/16 16:51:39 hal ! 23: * t_hal diagnostics. ! 24: * ! 25: * Revision 1.6 92/02/20 19:43:13 piggy ! 26: * Add "mode" arg to ttsetgrp() for NOCTTY support. ! 27: * ! 28: * Revision 1.5 92/02/16 18:27:47 hal ! 29: * Binary compatibility with Sys V sgtty ! 30: * ! 31: * Revision 1.4 92/02/07 09:41:21 hal ! 32: * Fix Wallenberg bug. ! 33: * ! 34: * Revision 2.10 92/02/04 18:50:00 hal ! 35: * Use EBUSY, not EDBUSY - merge for 386 code. ! 36: * ! 37: * Revision 2.9 92/01/13 08:38:24 hal ! 38: * Rearrange alxopen() to deal with ill-behaved daemons. ! 39: * ! 40: * Revision 2.8 92/01/12 19:23:50 hal ! 41: * Tracking nasty Kelly bug. ! 42: * ! 43: * Revision 2.6 91/12/26 16:52:05 hal ! 44: * Flags left in bad state if open r-device got killed. ! 45: * ! 46: * Revision 2.5 91/12/20 14:08:27 hal ! 47: * Add static alx_send(). ! 48: * From alxstart(), don't toggle Tx interrupts - call alx_send(). ! 49: * ! 50: * Revision 2.4 91/12/10 08:04:13 hal ! 51: * Make interrupt routine clear all UART irq conditions if it gets an ! 52: * interrupt without an argument telling which port interrupted. ! 53: * ! 54: * Revision 2.3 91/12/05 09:35:06 hal ! 55: * Working 16550A code. Nfg on GeeSee. ! 56: * ! 57: * Revision 2.2 91/12/02 19:21:45 hal ! 58: * Last version before FIFO testing. ! 59: * ! 60: * Revision 2.1 91/11/21 18:17:44 hal ! 61: * Same as V1.13 - used in 3.2.05k ! 62: * ! 63: -lgl) */ ! 64: /* ! 65: * Shared parts of IBM async port drivers. ! 66: */ ! 67: #include <sys/coherent.h> ! 68: #ifndef _I386 ! 69: #include <sys/i8086.h> ! 70: #endif ! 71: #include <sys/al.h> ! 72: #include <sys/con.h> ! 73: #include <errno.h> ! 74: #include <sys/stat.h> ! 75: #include <sys/tty.h> ! 76: #include <sys/timeout.h> ! 77: #include <sys/clist.h> ! 78: #include <sys/ins8250.h> ! 79: #include <sys/sched.h> ! 80: #include <sys/silo.h> ! 81: ! 82: #ifdef _I386 ! 83: #define EEBUSY EBUSY ! 84: #else ! 85: #define EEBUSY EDBUSY ! 86: #endif ! 87: ! 88: #define ALPORT (((COM_DDP *)(tp->t_ddp))->port) ! 89: #define AL_NUM (((COM_DDP *)(tp->t_ddp))->com_num) ! 90: ! 91: #define DTRTMOUT 3 /* DTR timeout interval in seconds for close */ ! 92: ! 93: /* ! 94: * For rawin silo (see poll_clk.h), use last element of si_buf to count ! 95: * the number of characters in the silo. ! 96: */ ! 97: #define SILO_CHAR_COUNT si_buf[SI_BUFSIZ-1] ! 98: #define SILO_HIGH_MARK (SI_BUFSIZ-SI_BUFSIZ/4) ! 99: #define SILO_LOW_MARK (SI_BUFSIZ/4) ! 100: #define MAX_SILO_INDEX (SI_BUFSIZ-2) ! 101: #define MAX_SILO_CHARS (SI_BUFSIZ-1) ! 102: ! 103: /* ! 104: * The following silo FLUSH macros are always called at high priority! ! 105: */ ! 106: #ifdef NO_ISILO ! 107: #define RAWIN_FLUSH(in_silo) ! 108: #else ! 109: #define RAWIN_FLUSH(in_silo) { in_silo->si_ox = in_silo->si_ix; \ ! 110: in_silo->SILO_CHAR_COUNT = 0; } ! 111: #endif ! 112: #define RAWOUT_FLUSH(out_silo) { out_silo->si_ox = out_silo->si_ix; } ! 113: ! 114: int al_sg_set = 0; ! 115: int al_sg_clr = 0; ! 116: static int poll_divisor; /* set by set_poll_rate(), read by alxclk() */ ! 117: ! 118: /* ! 119: * functions herein ! 120: */ ! 121: int alxopen(); ! 122: int alxclose(); ! 123: int alxtimer(); ! 124: int alxioctl(); ! 125: int alxparam(); ! 126: int alxcycle(); ! 127: int alxstart(); ! 128: int alxbreak(); ! 129: int alxintr(); ! 130: static int alxclk(); ! 131: static set_poll_rate(); ! 132: static void alxpoll(); ! 133: static void alx_send(); ! 134: static int iocbaud[4]; ! 135: static char ioclcr[4]; ! 136: ! 137: /* ! 138: * Port addresses are now patchable. ! 139: */ ! 140: int AL_ADDR[] = { ! 141: #if BOB_H ! 142: 0x280, 0x288, 0x290, 0x298 ! 143: #else ! 144: 0x3F8, 0x2F8, 0x3E8, 0x2E8 ! 145: #endif ! 146: }; ! 147: ! 148: /* ! 149: * Baud rate table and polling rate table. ! 150: * Indexed by ioctl bit rates. ! 151: */ ! 152: extern int albaud[], alp_rate[]; ! 153: ! 154: /* ! 155: * the following is for debug only ! 156: */ ! 157: #if TRACER ! 158: int ASY_OR = 0; ! 159: #define LSR_READ(lval, port) \ ! 160: { lval = inb((port)+LSR); if (lval & LS_OVER) ASY_OR++; } ! 161: #define CDUMP(text, tp) cdump(text, tp); ! 162: #define tprintf(str) { T_HAL(4, printf(str)); } ! 163: #define REPORT_OE {if(ASY_OR&&(t_hal&0x20)){printf("oe=%d ",ASY_OR);ASY_OR=0;}} ! 164: cdump(message, tp) ! 165: char *message; ! 166: TTY *tp; ! 167: { ! 168: int i, b; ! 169: char cmd[11]; ! 170: ! 171: if ((t_hal & 4) == 0) ! 172: return; ! 173: for (i = 0; i < NUM_AL_PORTS; i++) { ! 174: if (tp_table[i]) { ! 175: b = ((COM_DDP *)(tp_table[i]->t_ddp))->port; ! 176: printf("%x:%x:%x:%x ", i+1, b, inb(b+MCR), inb(b+IER)); ! 177: } ! 178: } ! 179: for (i = 0; i < 10; i++) { ! 180: cmd[i] = u.u_comm[i]; ! 181: } ! 182: cmd[10] = '\0'; ! 183: printf("poll=%d cmd=%s pid=%d ", poll_rate, cmd, SELF->p_pid); ! 184: printf("%s\n", message); ! 185: if (tp) { ! 186: printf("#%d f=%x op=%d ", AL_NUM, tp->t_flags, tp->t_open); ! 187: printf("in_use=%d irq=%d has_irq=%d ", ! 188: com_usage[AL_NUM].in_use, ! 189: com_usage[AL_NUM].irq, ! 190: com_usage[AL_NUM].has_irq); ! 191: printf("poll=%d hcls=%d ohlt=%d\n", ! 192: com_usage[AL_NUM].poll, ! 193: com_usage[AL_NUM].hcls, ! 194: com_usage[AL_NUM].ohlt); ! 195: } ! 196: } ! 197: #else ! 198: #define CDUMP(text, tp) ! 199: #define REPORT_OE ! 200: #define LSR_READ(lval, port) { lval = inb((port)+LSR); } ! 201: #endif ! 202: ! 203: /* ! 204: * alxopen() ! 205: */ ! 206: alxopen(dev, mode, tp, irqtty) ! 207: dev_t dev; ! 208: int mode; ! 209: register TTY *tp, **irqtty; ! 210: { ! 211: int s; ! 212: int b; ! 213: int minor_h; /* minor device number including high bit */ ! 214: unsigned char msr; ! 215: ! 216: minor_h = minor(dev); /* complete minor number */ ! 217: b = ALPORT; ! 218: ! 219: if (com_usage[AL_NUM].uart_type == US_NONE) { /* chip not found */ ! 220: u.u_error = ENXIO; ! 221: goto bad_open; ! 222: } ! 223: ! 224: if ((tp->t_flags & T_EXCL) && !super()) { ! 225: u.u_error = ENODEV; ! 226: goto bad_open; ! 227: } ! 228: ! 229: if (drvl[major(dev)].d_time != 0) { /* Modem settling */ ! 230: u.u_error = EEBUSY; ! 231: goto bad_open; ! 232: } ! 233: ! 234: /* ! 235: * Can't open a polled port if another driver is using polling. ! 236: */ ! 237: if (dev & CPOLL && poll_owner & ~ POLL_AL) { ! 238: u.u_error = EEBUSY; ! 239: goto bad_open; ! 240: } ! 241: ! 242: /* ! 243: * Can't have both com[13] or both com[24] IRQ at once. ! 244: */ ! 245: if ( !(dev & CPOLL) ! 246: && com_usage[AL_NUM^2].irq ! 247: && com_usage[AL_NUM^2].in_use) { ! 248: u.u_error = EEBUSY; ! 249: goto bad_open; ! 250: } ! 251: ! 252: /* ! 253: * If port already in use, are new and old open modes compatible? ! 254: */ ! 255: if (com_usage[AL_NUM].in_use) { ! 256: int oldmode = 0, newmode = 0; /* mctl:1 poll:2 flow:4 */ ! 257: ! 258: if (tp->t_flags & T_MODC) ! 259: oldmode += 1; ! 260: if (com_usage[AL_NUM].irq == 0) ! 261: oldmode += 2; ! 262: if (tp->t_flags & T_CFLOW) ! 263: oldmode += 4; ! 264: if ((minor_h & NMODC) == 0) ! 265: newmode += 1; ! 266: if (dev & CPOLL) ! 267: newmode += 2; ! 268: if (minor_h & CFLOW) ! 269: newmode += 4; ! 270: if (oldmode != newmode) { ! 271: u.u_error = EEBUSY; ! 272: goto bad_open; ! 273: } ! 274: } ! 275: ! 276: /* ! 277: * Sleep here if another process is opening or closing the port. ! 278: * This can happen if: ! 279: * another process is trying a first open and awaiting CD; ! 280: * another process is closing the port after losing CD; ! 281: * a remote process opened the port, spawned a daemon, ! 282: * and disconnected, and the daemon ignored SIGHUP and is ! 283: * improperly keeping the port open. ! 284: * Don't try to set tp->t_flags before this sleep! During ! 285: * the sleep, ttclose() may be called and clear the flags. ! 286: */ ! 287: while (com_usage[AL_NUM].in_use && ! 288: (com_usage[AL_NUM].hcls || ! 289: ((minor_h & NMODC) == 0 && (inb(b+MSR) & MS_RLSD) == 0))) { ! 290: sleep((char *)(&tp->t_open), CVTTOUT, IVTTOUT, SVTTOUT); ! 291: if (SELF->p_ssig && nondsig()) { /* signal? */ ! 292: u.u_error = EINTR; ! 293: goto bad_open; ! 294: } ! 295: } ! 296: ! 297: /* ! 298: * If port already in use, are new and old open modes compatible? ! 299: * If not in use, mark it as such. ! 300: */ ! 301: if (com_usage[AL_NUM].in_use) { ! 302: int oldmode = 0, newmode = 0; /* mctl:1 poll:2 flow:4 */ ! 303: ! 304: if (tp->t_flags & T_MODC) ! 305: oldmode += 1; ! 306: if (com_usage[AL_NUM].irq == 0) ! 307: oldmode += 2; ! 308: if (tp->t_flags & T_CFLOW) ! 309: oldmode += 4; ! 310: if ((minor_h & NMODC) == 0) ! 311: newmode += 1; ! 312: if (dev & CPOLL) ! 313: newmode += 2; ! 314: if (minor_h & CFLOW) ! 315: newmode += 4; ! 316: if (oldmode != newmode) { ! 317: u.u_error = EEBUSY; ! 318: goto bad_open; ! 319: } ! 320: } else { ! 321: /* ! 322: * Save modes for this open attempt to avoid future conflicts. ! 323: * Then start alxcycle() for this port. ! 324: */ ! 325: if (dev & CPOLL) ! 326: com_usage[AL_NUM].irq = 0; ! 327: else ! 328: com_usage[AL_NUM].irq = 1; ! 329: if (minor_h & CFLOW) ! 330: tp->t_flags |= T_CFLOW; ! 331: else ! 332: tp->t_flags &= ~T_CFLOW; ! 333: if (minor_h & NMODC) ! 334: tp->t_flags &= ~T_MODC; ! 335: else ! 336: tp->t_flags |= T_MODC; ! 337: } ! 338: com_usage[AL_NUM].in_use++; ! 339: /* ! 340: * From here, error exit is bad_open_u. ! 341: */ ! 342: ! 343: if (tp->t_open == 0) { /* not already open */ ! 344: if (!(dev & CPOLL)) { ! 345: *irqtty = tp_table[AL_NUM]; ! 346: com_usage[AL_NUM].has_irq = 1; ! 347: } ! 348: ! 349: /* ! 350: * Need to start cycling to scan for CD. ! 351: */ ! 352: alxcycle(tp); ! 353: ! 354: s = sphi(); ! 355: /* ! 356: * Raise basic modem control lines even if modem ! 357: * control hasn't been specified. ! 358: * MC_OUT2 turns on NON-open-collector IRQ line from the UART. ! 359: * since we can't have two UART's on same IRQ with MC_OUT2 on ! 360: */ ! 361: if (dev & CPOLL) { ! 362: outb(b+MCR, MC_RTS|MC_DTR); ! 363: } else { ! 364: outb(b+MCR, MC_RTS|MC_DTR|MC_OUT2); ! 365: outb(b+IER, IENABLE); ! 366: } ! 367: ! 368: if ((minor_h & NMODC) == 0) { /* want modem control? */ ! 369: tp->t_flags |= T_HOPEN | T_STOP; ! 370: for (;;) { /* wait for carrier */ ! 371: msr = inb(b+MSR); ! 372: /* ! 373: * If carrier detect present ! 374: * if port not already open ! 375: * break out of loop and finish first open ! 376: * else ! 377: * do second (or third, etc.) open ! 378: */ ! 379: if (msr & MS_RLSD) ! 380: break; ! 381: sleep((char *)(&tp->t_open), CVTTOUT, IVTTOUT, ! 382: SVTTOUT); /* wait for carrier */ ! 383: if (SELF->p_ssig && nondsig()) { /* signal? */ ! 384: outb(b+MCR, 0); ! 385: outb(b+IER, 0); ! 386: u.u_error = EINTR; ! 387: tp->t_flags &= ~(T_HOPEN | T_STOP); ! 388: spl(s); ! 389: goto bad_open_u; ! 390: } ! 391: } ! 392: ! 393: /* ! 394: * Mark that we are no longer hanging in open. ! 395: * Allow output over the port unless hardware flow ! 396: * control says not to. ! 397: */ ! 398: tp->t_flags &= ~T_HOPEN; ! 399: tp->t_flags &= ~T_STOP; ! 400: if (!(tp->t_flags & T_CFLOW) || (msr & MS_CTS)) ! 401: com_usage[AL_NUM].ohlt = 0; ! 402: else ! 403: com_usage[AL_NUM].ohlt = 1; ! 404: ! 405: /* ! 406: * Awaken any other opens on same device. ! 407: */ ! 408: wakeup((char *)(&tp->t_open)); ! 409: } ! 410: tp->t_flags |= T_CARR; ! 411: ttopen(tp); /* stty inits */ ! 412: ! 413: /* ! 414: * Allow custom modification of defaults. ! 415: */ ! 416: tp->t_sgttyb.sg_flags |= al_sg_set; ! 417: tp->t_sgttyb.sg_flags &= ~al_sg_clr; ! 418: ! 419: alxparam(tp); ! 420: spl(s); ! 421: } /* end of first-open case */ ! 422: ! 423: tp->t_open++; ! 424: ttsetgrp(tp, dev, mode); ! 425: ! 426: /* ! 427: * Turn on polling for the port. ! 428: */ ! 429: if (dev & CPOLL) { ! 430: com_usage[AL_NUM].poll = 1; ! 431: set_poll_rate(); ! 432: } ! 433: ! 434: CDUMP((dev&CPOLL)?"open polled":"open irq", tp) ! 435: return; ! 436: ! 437: bad_open_u: ! 438: --com_usage[AL_NUM].in_use; ! 439: wakeup((char *)(&tp->t_open)); ! 440: bad_open: ! 441: return; ! 442: } ! 443: ! 444: /* ! 445: * alxclose() ! 446: * ! 447: * Called whenever kernel closes a com port. ! 448: */ ! 449: alxclose(dev, mode, tp) ! 450: dev_t dev; ! 451: int mode; ! 452: TTY *tp; ! 453: { ! 454: register int b; ! 455: int maj; ! 456: int flags; ! 457: int s; ! 458: unsigned char lsr; ! 459: silo_t * out_silo = &com_usage[AL_NUM].raw_out; ! 460: silo_t * in_silo = &com_usage[AL_NUM].raw_in; ! 461: ! 462: if (--tp->t_open) ! 463: goto closed; ! 464: s = sphi(); ! 465: ! 466: /* ! 467: * Called at high priority by alclose after al_buff is drained ! 468: */ ! 469: com_usage[AL_NUM].hcls = 1; /* disallow reopen til done closing */ ! 470: flags = tp->t_flags; /* save flags - ttclose zeroes them */ ! 471: ttclose(tp); ! 472: b = ALPORT; ! 473: ! 474: /* ! 475: * Wait for output silo and uart xmit buffer to empty. ! 476: * Allow signal to break the sleep. ! 477: */ ! 478: for (;;) { ! 479: LSR_READ(lsr, b); ! 480: if ((lsr & LS_TxIDLE) ! 481: && (out_silo->si_ix == out_silo->si_ox)) ! 482: break; ! 483: CDUMP("slp cls", tp) ! 484: sleep((char *)out_silo, CVTTOUT, IVTTOUT, SVTTOUT); ! 485: if (SELF->p_ssig && nondsig()) { /* signal? */ ! 486: RAWOUT_FLUSH(out_silo); ! 487: break; ! 488: } ! 489: } ! 490: ! 491: /* ! 492: * If not hanging in open ! 493: */ ! 494: if ((flags & T_HOPEN) == 0) { ! 495: /* ! 496: * Disable interrupts. ! 497: */ ! 498: outb(b+IER, 0); ! 499: outb(b+MCR, inb(b+MCR)&(~MC_OUT2)); ! 500: } ! 501: ! 502: /* ! 503: * If hupcls ! 504: */ ! 505: if (flags & T_HPCL) { ! 506: /* ! 507: * Hangup port - drop DTR and RTS. ! 508: */ ! 509: outb(b+MCR, inb(b+MCR)&MC_OUT2); ! 510: ! 511: /* ! 512: * Hold dtr low for timeout ! 513: */ ! 514: maj = major(dev); ! 515: drvl[maj].d_time = 1; ! 516: CDUMP("slp DTR", tp) ! 517: sleep((char *)&drvl[maj].d_time, CVTTOUT, IVTTOUT, SVTTOUT); ! 518: drvl[maj].d_time = 0; ! 519: } ! 520: com_usage[AL_NUM].poll = 0; ! 521: set_poll_rate(); ! 522: RAWIN_FLUSH(in_silo); ! 523: com_usage[AL_NUM].hcls = 0; /* allow reopen - done closing */ ! 524: wakeup((char *)(&tp->t_open)); ! 525: spl(s); ! 526: closed:; ! 527: --com_usage[AL_NUM].in_use; ! 528: wakeup((char *)(&tp->t_open)); ! 529: CDUMP("closed", tp) ! 530: } ! 531: ! 532: /* ! 533: * Common c_timer routine for async ports. ! 534: */ ! 535: alxtimer(dev) ! 536: dev_t dev; ! 537: { ! 538: if (++drvl[major(dev)].d_time > DTRTMOUT) ! 539: wakeup((char *)&drvl[major(dev)].d_time); ! 540: } ! 541: ! 542: ! 543: /* ! 544: * Common c_ioctl routine for async ports. ! 545: */ ! 546: alxioctl(dev, com, vec, tp) ! 547: dev_t dev; ! 548: struct sgttyb *vec; ! 549: register TTY *tp; ! 550: { ! 551: register int s, b; ! 552: int stat1, stat2; ! 553: unsigned char msr; ! 554: unsigned char ier_save; ! 555: silo_t * out_silo = &com_usage[AL_NUM].raw_out; ! 556: silo_t * in_silo = &com_usage[AL_NUM].raw_in; ! 557: ! 558: s = sphi(); ! 559: b = ALPORT; ! 560: ier_save=inb(b+IER); ! 561: stat1 = inb(b+MCR); /* get current MCR register status */ ! 562: stat2 = inb(b+LCR); /* get current LCR register status */ ! 563: ! 564: switch(com) { ! 565: case TIOCSBRK: /* set BREAK */ ! 566: outb(b+LCR, stat2|LC_SBRK); ! 567: break; ! 568: case TIOCCBRK: /* clear BREAK */ ! 569: outb(b+LCR, stat2 & ~LC_SBRK); ! 570: break; ! 571: case TIOCSDTR: /* set DTR */ ! 572: outb(b+MCR, stat1|MC_DTR); ! 573: break; ! 574: case TIOCCDTR: /* clear DTR */ ! 575: outb(b+MCR, stat1 & ~MC_DTR); ! 576: break; ! 577: case TIOCSRTS: /* set RTS */ ! 578: outb(b+MCR, stat1|MC_RTS); ! 579: break; ! 580: case TIOCCRTS: /* clear RTS */ ! 581: outb(b+MCR, stat1 & ~MC_RTS); ! 582: break; ! 583: case TIOCRSPEED: /* set "raw" I/O speed divisor */ ! 584: outb(b+LCR, stat2|LC_DLAB); /* set speed latch bit */ ! 585: outb(b+DLL, (unsigned) vec); ! 586: outb(b+DLH, (unsigned) vec >> 8); ! 587: outb(b+LCR, stat2); /* reset latch bit */ ! 588: break; ! 589: case TIOCWORDL: /* set word length and stop bits */ ! 590: outb(b+LCR, ((stat2&~0x7) | ((unsigned) vec & 0x7))); ! 591: break; ! 592: case TIOCRMSR: /* get CTS/DSR/RI/RLSD (MSR) */ ! 593: msr = inb(b+MSR); ! 594: stat1 = msr >> 4; ! 595: kucopy(&stat1, (unsigned *) vec, sizeof(unsigned)); ! 596: break; ! 597: case TIOCFLUSH: /* Flush silos here, queues in tty.c */ ! 598: RAWIN_FLUSH(in_silo); ! 599: RAWOUT_FLUSH(out_silo); ! 600: /* fall through to default... */ ! 601: default: ! 602: ttioctl(tp, com, vec); ! 603: } ! 604: outb(b+IER, ier_save); ! 605: spl(s); ! 606: } ! 607: ! 608: alxparam(tp) ! 609: TTY *tp; ! 610: { ! 611: register int b; ! 612: register int baud; ! 613: int s; ! 614: char newlcr; ! 615: int write_baud=1, write_lcr=1; ! 616: int alnum; ! 617: ! 618: b = ALPORT; ! 619: ! 620: /* ! 621: * error if input speed not the same as output speed ! 622: */ ! 623: if (tp->t_sgttyb.sg_ispeed!=tp->t_sgttyb.sg_ospeed) { ! 624: u.u_error = ENODEV; ! 625: return; ! 626: } ! 627: ! 628: if ((baud = albaud[tp->t_sgttyb.sg_ispeed]) == 0) { ! 629: if (tp->t_flags & T_MODC) { /* modem control? */ ! 630: s = sphi(); ! 631: tp->t_flags &= ~T_CARR; /* indicate no carrier */ ! 632: outb(b+MCR, inb(b+MCR) & MC_OUT2); /* hangup */ ! 633: spl(s); ! 634: } ! 635: write_baud = 0; ! 636: } ! 637: ! 638: switch (tp->t_sgttyb.sg_flags & (EVENP|ODDP|RAW)) { ! 639: case ODDP: ! 640: newlcr = LC_CS7|LC_PARENB; ! 641: break; ! 642: case EVENP: ! 643: newlcr = LC_CS7|LC_PARENB|LC_PAREVEN; ! 644: break; ! 645: default: ! 646: newlcr = LC_CS8; ! 647: break; ! 648: } ! 649: ! 650: alnum = AL_NUM; ! 651: if (alnum >= 0 && alnum < 4) { ! 652: if (baud == iocbaud[alnum]) { ! 653: write_baud = 0; ! 654: if (newlcr == ioclcr[alnum]) { ! 655: write_lcr = 0; ! 656: } ! 657: } ! 658: iocbaud[alnum] = baud; ! 659: ioclcr[alnum] = newlcr; ! 660: } ! 661: ! 662: if (write_lcr) { ! 663: unsigned char ier_save; ! 664: s=sphi(); ! 665: ier_save=inb(b+IER); ! 666: if (write_baud) { ! 667: outb(b+LCR, LC_DLAB); ! 668: outb(b+DLL, baud); ! 669: outb(b+DLH, baud >> 8); ! 670: } ! 671: outb(b+LCR, newlcr); ! 672: if (com_usage[AL_NUM].uart_type == US_16550A) ! 673: outb(b+FCR, FC_ENABLE | FC_Rx_RST | FC_Rx_08); ! 674: outb(b+IER, ier_save); ! 675: spl(s); ! 676: } ! 677: ! 678: set_poll_rate(); ! 679: } ! 680: ! 681: /* ! 682: * Middle level processor. ! 683: * ! 684: * Invoked 10 times per second. (Once every ten clock ticks.) ! 685: * Tranfers rawin buffer [from intr level] to canonical input queue. ! 686: * Checks modem status for loss of carrier. ! 687: * Transfers output queue to rawout buffer [for intr level]. ! 688: */ ! 689: alxcycle(tp) ! 690: register TTY * tp; ! 691: { ! 692: register int b; ! 693: register int n; ! 694: unsigned char msr, mcr; ! 695: int s; ! 696: silo_t * out_silo = &com_usage[AL_NUM].raw_out; ! 697: silo_t * in_silo = &com_usage[AL_NUM].raw_in; ! 698: ! 699: REPORT_OE; ! 700: /* ! 701: * Check Carrier Detect (RLSD). ! 702: * ! 703: * Modem status interrupts were not enabled due to 8250 hardware bug. ! 704: * Enabling modem status and receive interrupts may cause lockup ! 705: * on older parts. ! 706: */ ! 707: if (tp->t_flags & T_MODC) { ! 708: ! 709: /* ! 710: * Get status ! 711: */ ! 712: msr = inb(ALPORT+MSR); ! 713: ! 714: /* ! 715: * Carrier changed. ! 716: */ ! 717: if ((msr & MS_RLSD) && !(tp->t_flags & T_CARR)) { ! 718: /* ! 719: * Carrier is on - wakeup open. ! 720: */ ! 721: s = sphi(); ! 722: tp->t_flags |= T_CARR; ! 723: spl(s); ! 724: wakeup((char *)(&tp->t_open)); ! 725: } ! 726: ! 727: if (!(msr & MS_RLSD) && (tp->t_flags & T_CARR)) { ! 728: s = sphi(); ! 729: RAWIN_FLUSH(in_silo); ! 730: RAWOUT_FLUSH(out_silo); ! 731: tp->t_flags &= ~T_CARR; ! 732: spl(s); ! 733: tthup(tp); ! 734: } ! 735: } ! 736: ! 737: /* ! 738: * Empty raw input buffer. ! 739: * ! 740: * The line discipline module (tty.c) will set T_ISTOP true when the ! 741: * tt input queue is nearly full (tp->t_iq.cq_cc >= IHILIM), and make ! 742: * T_ISTOP false when it's ready for more input. ! 743: * ! 744: * When T_ISTOP is true, ttin() simply discards the character passed. ! 745: */ ! 746: #ifndef NOISILO ! 747: if (!(tp->t_flags & T_ISTOP)) { ! 748: while (in_silo->SILO_CHAR_COUNT > 0) { ! 749: s = sphi(); ! 750: ttin(tp, in_silo->si_buf[in_silo->si_ox]); ! 751: if (in_silo->si_ox < MAX_SILO_INDEX) ! 752: in_silo->si_ox++; ! 753: else ! 754: in_silo->si_ox = 0; ! 755: in_silo->SILO_CHAR_COUNT--; ! 756: spl(s); ! 757: } ! 758: } ! 759: #endif ! 760: ! 761: /* ! 762: * Hardware flow control. ! 763: * Check CTS to see if we need to halt output. ! 764: * (MS_INTR should have done this - repeat code here to be sure) ! 765: * Check input silo to see if we need to raise RTS. ! 766: */ ! 767: if (tp->t_flags & T_CFLOW) { ! 768: ! 769: /* ! 770: * Get status ! 771: */ ! 772: msr = inb(ALPORT+MSR); ! 773: ! 774: s = sphi(); ! 775: if (msr & MS_CTS) ! 776: com_usage[AL_NUM].ohlt = 0; ! 777: else ! 778: com_usage[AL_NUM].ohlt = 1; ! 779: spl(s); ! 780: #if TRACER ! 781: if(t_hal & 4) {static cts = 0; ! 782: if (!cts && (msr & MS_CTS)) { ! 783: cts = 1; ! 784: printf("["); ! 785: } else if (cts && !(msr & MS_CTS)) { ! 786: cts = 0; ! 787: printf("]"); ! 788: }} ! 789: #endif ! 790: ! 791: /* ! 792: * If using hardware flow control, see if we need to drop RTS. ! 793: */ ! 794: if ( (tp->t_flags & T_CFLOW) ! 795: #ifdef NO_ISILO ! 796: && (tp->t_flags & T_ISTOP)) { ! 797: #else ! 798: && (in_silo->SILO_CHAR_COUNT > SILO_HIGH_MARK)) { ! 799: #endif ! 800: s = sphi(); ! 801: mcr = inb(ALPORT+MCR); ! 802: if (mcr & MC_RTS) { ! 803: outb(ALPORT+MCR, mcr & ~MC_RTS); ! 804: #if TRACER ! 805: tprintf("-"); ! 806: #endif ! 807: } ! 808: spl(s); ! 809: } ! 810: ! 811: /* ! 812: * If input silo below low mark, assert RTS. ! 813: */ ! 814: #ifdef NO_ISILO ! 815: if ((tp->t_flags & T_ISTOP) == 0) { ! 816: #else ! 817: if (in_silo->SILO_CHAR_COUNT <= SILO_LOW_MARK) { ! 818: #endif ! 819: s = sphi(); ! 820: mcr = inb(ALPORT+MCR); ! 821: if ((mcr & MC_RTS) == 0) { ! 822: outb(ALPORT+MCR, mcr | MC_RTS); ! 823: #if TRACER ! 824: tprintf("+"); ! 825: #endif ! 826: } ! 827: spl(s); ! 828: } ! 829: } ! 830: ! 831: /* ! 832: * Calculate free output slot count. ! 833: */ ! 834: n = sizeof(out_silo->si_buf) - 1; ! 835: n += out_silo->si_ox - out_silo->si_ix; ! 836: n %= sizeof(out_silo->si_buf); ! 837: ! 838: /* ! 839: * Fill raw output buffer. ! 840: */ ! 841: for (;;) { ! 842: if (--n < 0) ! 843: break; ! 844: s = sphi(); ! 845: b = ttout(tp); ! 846: spl(s); ! 847: if (b < 0) ! 848: break; ! 849: ! 850: s = sphi(); ! 851: out_silo->si_buf[out_silo->si_ix] = b; ! 852: if (out_silo->si_ix >= sizeof(out_silo->si_buf) - 1) ! 853: out_silo->si_ix = 0; ! 854: else ! 855: out_silo->si_ix++; ! 856: spl(s); ! 857: } ! 858: ! 859: /* ! 860: * (Re)start output, wake sleeping processes, etc. ! 861: */ ! 862: ttstart(tp); ! 863: ! 864: /* ! 865: * Schedule next cycle. ! 866: */ ! 867: if (com_usage[AL_NUM].in_use) ! 868: timeout(&tp->t_rawtim, HZ/10, alxcycle, tp); ! 869: } ! 870: ! 871: /* ! 872: * Serial Transmit Start Routine. ! 873: */ ! 874: alxstart(tp) ! 875: register TTY * tp; ! 876: { ! 877: int b; ! 878: int s; ! 879: extern alxbreak(); ! 880: int need_xmit = 1; /* True if should start sending data now. */ ! 881: silo_t * out_silo = &com_usage[AL_NUM].raw_out; ! 882: ! 883: /* ! 884: * Read line status register AFTER disabling interrupts. ! 885: */ ! 886: s = sphi(); ! 887: LSR_READ(b, ALPORT); ! 888: ! 889: /* ! 890: * Process break indication. ! 891: * NOTE: Break indication cleared when line status register was read. ! 892: */ ! 893: if (b & LS_BREAK) ! 894: defer(alxbreak, tp); ! 895: ! 896: /* ! 897: * If no output data, it may be time to finish closing the port; ! 898: * but won't need another xmit interrupt. ! 899: */ ! 900: if (out_silo->si_ix == out_silo->si_ox) { ! 901: wakeup((char *)out_silo); ! 902: need_xmit = 0; ! 903: } ! 904: ! 905: /* ! 906: * Do nothing if output is stopped. ! 907: */ ! 908: if (tp->t_flags & T_STOP) ! 909: need_xmit = 0; ! 910: if (com_usage[AL_NUM].ohlt) ! 911: need_xmit = 0; ! 912: ! 913: /* ! 914: * Start data transmission by writing to UART xmit reg. ! 915: */ ! 916: if ((b & LS_TxRDY) && need_xmit) { ! 917: int xmit_count; ! 918: ! 919: xmit_count = (com_usage[AL_NUM].uart_type == US_16550A)?16:1; ! 920: alx_send(out_silo, ALPORT+DREG, xmit_count); ! 921: } ! 922: ! 923: spl(s); ! 924: } ! 925: ! 926: /* ! 927: * Serial Received Break Handler. ! 928: */ ! 929: alxbreak(tp) ! 930: TTY * tp; ! 931: { ! 932: int s; ! 933: silo_t * out_silo = &com_usage[AL_NUM].raw_out; ! 934: silo_t * in_silo = &com_usage[AL_NUM].raw_in; ! 935: ! 936: s = sphi(); ! 937: RAWIN_FLUSH(in_silo); ! 938: RAWOUT_FLUSH(out_silo); ! 939: spl(s); ! 940: ttsignal(tp, SIGINT); ! 941: } ! 942: ! 943: /* ! 944: * Serial Interrupt Handler. ! 945: */ ! 946: alxintr(tp) ! 947: register TTY * tp; ! 948: { ! 949: int c; ! 950: register int port = ALPORT; ! 951: unsigned char msr, lsr; ! 952: int xmit_count; ! 953: silo_t * in_silo = &com_usage[AL_NUM].raw_in; ! 954: silo_t * out_silo = &com_usage[AL_NUM].raw_out; ! 955: ! 956: if (tp) { ! 957: rescan: ! 958: switch (inb(port+IIR) & 0x07) { ! 959: ! 960: case LS_INTR: ! 961: LSR_READ(lsr, port); ! 962: if (lsr & LS_BREAK) ! 963: defer(alxbreak, tp); ! 964: goto rescan; ! 965: ! 966: case Rx_INTR: ! 967: c = inb(port+DREG); ! 968: if (tp->t_open == 0) ! 969: goto rescan; ! 970: /* ! 971: * Must recognize XOFF quickly to avoid transmit overrun. ! 972: * Recognize XON here as well to avoid race conditions. ! 973: */ ! 974: if (!ISRIN) { ! 975: /* ! 976: * XOFF. ! 977: */ ! 978: if (ISSTOP) { ! 979: tp->t_flags |= T_STOP; ! 980: goto rescan; ! 981: } ! 982: ! 983: /* ! 984: * XON. ! 985: */ ! 986: if (ISSTART) { ! 987: tp->t_flags &= ~T_STOP; ! 988: goto rescan; ! 989: } ! 990: } ! 991: ! 992: /* ! 993: * Save char in raw input buffer. ! 994: */ ! 995: #ifdef NO_ISILO ! 996: if (tp->t_flags & T_ISTOP) { ! 997: /* ! 998: * If using hardware flow control, we need to drop RTS. ! 999: */ ! 1000: if (tp->t_flags & T_CFLOW) { ! 1001: unsigned char mcr = inb(port+MCR); ! 1002: if (mcr & MC_RTS) ! 1003: outb(port+MCR, mcr & ~MC_RTS); ! 1004: } ! 1005: } else { ! 1006: ttin(tp, c); ! 1007: } ! 1008: #else ! 1009: if (in_silo->SILO_CHAR_COUNT < MAX_SILO_CHARS) { ! 1010: in_silo->si_buf[in_silo->si_ix] = c; ! 1011: if (in_silo->si_ix < MAX_SILO_INDEX) ! 1012: in_silo->si_ix++; ! 1013: else ! 1014: in_silo->si_ix = 0; ! 1015: in_silo->SILO_CHAR_COUNT++; ! 1016: } ! 1017: ! 1018: /* ! 1019: * If using hardware flow control, see if we need to drop RTS. ! 1020: */ ! 1021: if ( (tp->t_flags & T_CFLOW) ! 1022: && (in_silo->SILO_CHAR_COUNT > SILO_HIGH_MARK)) { ! 1023: unsigned char mcr = inb(port+MCR); ! 1024: if (mcr & MC_RTS) { ! 1025: outb(port+MCR, mcr & ~MC_RTS); ! 1026: } ! 1027: } ! 1028: #endif ! 1029: goto rescan; ! 1030: ! 1031: case Tx_INTR: ! 1032: /* ! 1033: * Do nothing if output is stopped. ! 1034: */ ! 1035: if (tp->t_flags & T_STOP) ! 1036: goto rescan; ! 1037: if (com_usage[AL_NUM].ohlt) ! 1038: goto rescan; ! 1039: ! 1040: /* ! 1041: * Transmit next char in raw output buffer. ! 1042: */ ! 1043: xmit_count = ! 1044: (com_usage[AL_NUM].uart_type == US_16550A)?16:1; ! 1045: alx_send(out_silo, port+DREG, xmit_count); ! 1046: goto rescan; ! 1047: ! 1048: case MS_INTR: ! 1049: /* ! 1050: * Get status (and clear interrupt). ! 1051: */ ! 1052: msr = inb(port+MSR); ! 1053: ! 1054: /* ! 1055: * Hardware flow control. ! 1056: * Check CTS to see if we need to halt output. ! 1057: */ ! 1058: if (tp->t_flags & T_CFLOW) { ! 1059: if (msr & MS_CTS) ! 1060: com_usage[AL_NUM].ohlt = 0; ! 1061: else ! 1062: com_usage[AL_NUM].ohlt = 1; ! 1063: } ! 1064: ! 1065: goto rescan; ! 1066: } /* endswitch */ ! 1067: } else { ! 1068: /* ! 1069: * If tp is zero, an interrupt occurred before things ! 1070: * are fully set up. Just try to clear all pending ! 1071: * interrupts from ANY serial ports. ! 1072: */ ! 1073: int com_num; ! 1074: for (com_num = 0; com_num < 4; com_num++) { ! 1075: port = AL_ADDR[com_num]; ! 1076: inb(port+IIR); ! 1077: inb(port+LSR); ! 1078: inb(port+MSR); ! 1079: inb(port+DREG); ! 1080: } ! 1081: } ! 1082: } ! 1083: ! 1084: /* ! 1085: * alxclk will be called every time T0 interrupts - if it returns 0, ! 1086: * the usual system timer interrupt stuff is done ! 1087: */ ! 1088: static int alxclk() ! 1089: { ! 1090: static int count; ! 1091: int i; ! 1092: ! 1093: for (i = 0; i < NUM_AL_PORTS; i++) ! 1094: if (com_usage[i].poll) ! 1095: alxpoll(tp_table[i]); ! 1096: count++; ! 1097: if (count >= poll_divisor) ! 1098: count = 0; ! 1099: return count; ! 1100: } ! 1101: ! 1102: /* ! 1103: * set_poll_rate is called when a port is opened or closed or changes speed ! 1104: * it sets the polling rate only as fast as needed, and shuts off polling ! 1105: * whenever possible ! 1106: */ ! 1107: static set_poll_rate() ! 1108: { ! 1109: int port_num, max_rate, port_rate; ! 1110: ! 1111: /* ! 1112: * If another driver has the polling clock, do nothing. ! 1113: */ ! 1114: if (poll_owner & ~ POLL_AL) ! 1115: return; ! 1116: ! 1117: /* ! 1118: * Find highest valid polling rate in units of HZ/10. ! 1119: * If using FIFO chip, can poll at 1/16 the usual rate. ! 1120: */ ! 1121: max_rate = 0; ! 1122: for (port_num = 0; port_num < NUM_AL_PORTS; port_num++) { ! 1123: if (com_usage[port_num].poll) { ! 1124: port_rate = alp_rate[(tp_table[port_num])->t_sgttyb.sg_ispeed]; ! 1125: if (com_usage[port_num].uart_type == US_16550A) { ! 1126: port_rate /= 16; ! 1127: if (port_rate % HZ) ! 1128: port_rate += HZ - (port_rate % HZ); ! 1129: } ! 1130: if (max_rate < port_rate) ! 1131: max_rate = port_rate; ! 1132: } ! 1133: } ! 1134: /* ! 1135: * if max_rate is not current rate, adjust the system clock ! 1136: */ ! 1137: if (max_rate != poll_rate) { ! 1138: poll_rate = max_rate; ! 1139: poll_divisor = poll_rate/HZ; /* used in alxclk() */ ! 1140: altclk_out(); /* stop previous polling */ ! 1141: poll_owner &= ~ POLL_AL; ! 1142: if (max_rate) { /* resume polling at new rate if needed */ ! 1143: poll_owner |= POLL_AL; ! 1144: altclk_in(poll_rate, alxclk); ! 1145: } ! 1146: CDUMP("new rate", 0) ! 1147: } ! 1148: } ! 1149: ! 1150: /* ! 1151: * alxpoll() ! 1152: * ! 1153: * Serial polling handler. Compare to alxintr(). ! 1154: */ ! 1155: static void alxpoll(tp) ! 1156: register TTY * tp; ! 1157: { ! 1158: int c; ! 1159: int port = ALPORT; ! 1160: int xmit_count; ! 1161: unsigned char lsr; ! 1162: silo_t * in_silo = &com_usage[AL_NUM].raw_in; ! 1163: silo_t * out_silo = &com_usage[AL_NUM].raw_out; ! 1164: ! 1165: /* ! 1166: * Check for received break first. ! 1167: * This status is wiped out on reading the LSR. ! 1168: */ ! 1169: LSR_READ(lsr, port); ! 1170: if (lsr & LS_BREAK) ! 1171: defer(alxbreak, tp); ! 1172: ! 1173: /* ! 1174: * Handle all incoming characters. ! 1175: */ ! 1176: for (;;) { ! 1177: LSR_READ(lsr, port); ! 1178: if ((lsr & LS_RxRDY) == 0) ! 1179: break; ! 1180: c = inb(port+DREG); ! 1181: if (tp->t_open == 0) ! 1182: continue; ! 1183: /* ! 1184: * Must recognize XOFF quickly to avoid transmit overrun. ! 1185: * Recognize XON here as well to avoid race conditions. ! 1186: */ ! 1187: if (!ISRIN) { ! 1188: /* ! 1189: * XOFF. ! 1190: */ ! 1191: if (ISSTOP) { ! 1192: tp->t_flags |= T_STOP; ! 1193: continue; ! 1194: } ! 1195: ! 1196: /* ! 1197: * XON. ! 1198: */ ! 1199: if (ISSTART) { ! 1200: tp->t_flags &= ~T_STOP; ! 1201: continue; ! 1202: } ! 1203: } ! 1204: ! 1205: /* ! 1206: * Save char in raw input buffer. ! 1207: */ ! 1208: #ifdef NO_ISILO ! 1209: if (tp->t_flags & T_ISTOP) { ! 1210: /* ! 1211: * If using hardware flow control, we need to drop RTS. ! 1212: */ ! 1213: if (tp->t_flags & T_CFLOW) { ! 1214: unsigned char mcr = inb(port+MCR); ! 1215: if (mcr & MC_RTS) ! 1216: outb(port+MCR, mcr & ~MC_RTS); ! 1217: } ! 1218: } else { ! 1219: ttin(tp, c); ! 1220: } ! 1221: #else ! 1222: if (in_silo->SILO_CHAR_COUNT < MAX_SILO_CHARS) { ! 1223: in_silo->si_buf[in_silo->si_ix] = c; ! 1224: if (in_silo->si_ix < MAX_SILO_INDEX) ! 1225: in_silo->si_ix++; ! 1226: else ! 1227: in_silo->si_ix = 0; ! 1228: in_silo->SILO_CHAR_COUNT++; ! 1229: } ! 1230: ! 1231: /* ! 1232: * If using hardware flow control, see if we need to drop RTS. ! 1233: */ ! 1234: if ( (tp->t_flags & T_CFLOW) ! 1235: && (in_silo->SILO_CHAR_COUNT > SILO_HIGH_MARK)) { ! 1236: unsigned char mcr = inb(port+MCR); ! 1237: if (mcr & MC_RTS) { ! 1238: outb(port+MCR, mcr & ~MC_RTS); ! 1239: } ! 1240: } ! 1241: #endif ! 1242: } ! 1243: ! 1244: /* ! 1245: * Handle outgoing characters. ! 1246: * Do nothing if output is stopped. ! 1247: */ ! 1248: LSR_READ(lsr, port); ! 1249: if ((lsr & LS_TxRDY) ! 1250: && !(tp->t_flags & T_STOP) ! 1251: && !(com_usage[AL_NUM].ohlt)) { ! 1252: /* ! 1253: * Transmit next char in raw output buffer. ! 1254: */ ! 1255: xmit_count = (com_usage[AL_NUM].uart_type == US_16550A)?16:1; ! 1256: alx_send(out_silo, port+DREG, xmit_count); ! 1257: } ! 1258: ! 1259: /* ! 1260: * Hardware flow control. ! 1261: * Check CTS to see if we need to halt output. ! 1262: */ ! 1263: if (tp->t_flags & T_CFLOW) { ! 1264: if (inb(port+MSR) & MS_CTS) ! 1265: com_usage[AL_NUM].ohlt = 0; ! 1266: else ! 1267: com_usage[AL_NUM].ohlt = 1; ! 1268: } ! 1269: } ! 1270: ! 1271: /* ! 1272: * alx_send() ! 1273: * ! 1274: * Write to xmit data register of the UART. ! 1275: * Assume all checking about whether it's time to send has been done already. ! 1276: * Called by time-critical IRQ and polling routines! ! 1277: * ! 1278: * "rawout" is the output silo for the TTY struct supplying data to the port. ! 1279: * "dreg" is the i/o address of the UART xmit data register. ! 1280: * "xmit_count" is the max number of chars we can write (16 for FIFO parts). ! 1281: */ ! 1282: static void alx_send(rawout, dreg, xmit_count) ! 1283: register silo_t * rawout; ! 1284: int dreg, xmit_count; ! 1285: { ! 1286: /* ! 1287: * Transmit next chars in raw output buffer. ! 1288: */ ! 1289: for (;(rawout->si_ix != rawout->si_ox) && xmit_count; xmit_count--) { ! 1290: outb(dreg, rawout->si_buf[rawout->si_ox]); ! 1291: /* ! 1292: * Adjust raw output buffer output index. ! 1293: */ ! 1294: if (++rawout->si_ox >= sizeof(rawout->si_buf)) ! 1295: rawout->si_ox = 0; ! 1296: } ! 1297: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.