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