![[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 / kernel / USRSRC / i8086 / drv|
Return to alx.c CVS log | Up to [MW Coherent from dump] / coherent / d / kernel / USRSRC / i8086 / drv |
1.1 ! root 1: /* (-lgl ! 2: * COHERENT Driver Kit Version 1.1.0 ! 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.12 91/08/06 10:32:23 bin ! 8: * 2nd rts/cts version form hal ! 9: * ! 10: * Revision 1.7 91/08/02 07:59:27 hal ! 11: * Raw input silo uses last slot for byte count. ! 12: * Modem control now gives RTS/CTS flow control: ! 13: * CTS is checked 10x/sec (probably not often enough). ! 14: * On Rx_INT, check T_ISTOP and rawin silo levels; drop RTS if need to. ! 15: * ! 16: * Revision 1.6 91/04/03 18:55:07 root ! 17: * alxclose(): do closing state machine BEFORE dropping control lines. ! 18: * alxioctl(): save and restore interrupt enable register. ! 19: * alxopen(): wait for pending last close (fixes SLOW port bug). ! 20: * This version needs al.h 1.3 or later. ! 21: * ! 22: * Revision 1.5 91/04/02 17:53:37 root ! 23: * save MSR delta status; add MS_INTR handling; use al.h 1.2 ! 24: * ! 25: * Revision 1.4 91/02/22 09:21:17 root ! 26: * alxintr(): replace repeated use of ALPORT macro by local variable ! 27: * ! 28: * Revision 1.3 91/02/21 14:58:16 root ! 29: * Fix unconditional "hupcl" bug in 3.1.0 version. ! 30: * ! 31: * Revision 1.2 91/02/21 11:21:40 hal ! 32: * Used in COH Release 3.1.0 - add COM3/COM4 and polling ! 33: * ! 34: * Revision 1.1 91/02/21 11:08:31 hal ! 35: * Used in COH Release 3.0.0 - no COM3/COM4 ! 36: * ! 37: -lgl) */ ! 38: /* ! 39: * Shared parts of IBM async port drivers. ! 40: */ ! 41: #include <sys/coherent.h> ! 42: #include <sys/i8086.h> ! 43: #include <sys/al.h> ! 44: #include <sys/con.h> ! 45: #include <errno.h> ! 46: #include <sys/stat.h> ! 47: #include <sys/tty.h> ! 48: #include <sys/uproc.h> ! 49: #include <sys/timeout.h> ! 50: #include <sys/clist.h> ! 51: #include <sys/ins8250.h> ! 52: #include <sys/sched.h> ! 53: ! 54: #define ALPORT (((COM_DDP *)(tp->t_ddp))->port) ! 55: #define AL_TIM (((COM_DDP *)(tp->t_ddp))->tim) ! 56: #define AL_NUM (((COM_DDP *)(tp->t_ddp))->com_num) ! 57: #define AL_MSR_DELTAS (((COM_DDP *)(tp->t_ddp))->msr_deltas) ! 58: #define AL_H_CLOSE (((COM_DDP *)(tp->t_ddp))->h_close) ! 59: ! 60: #define DTRTMOUT 3 /* DTR timeout interval in seconds for close */ ! 61: #define IENABLE (IE_RxI+IE_TxI+IE_LSI+IE_MSI) ! 62: ! 63: /* ! 64: * For rawin silo (see ktty.h), use last element of si_buf to count the number ! 65: * of characters in the silo. ! 66: */ ! 67: #define SILO_CHAR_COUNT si_buf[SI_BUFSIZ-1] ! 68: #define SILO_HIGH_MARK (SI_BUFSIZ-SI_BUFSIZ/4) ! 69: #define MAX_SILO_INDEX (SI_BUFSIZ-2) ! 70: #define MAX_SILO_CHARS (SI_BUFSIZ-1) ! 71: ! 72: int al_sg_set = 0; ! 73: int al_sg_clr = 0; ! 74: static int poll_divisor; /* set by set_poll_rate(), read by alxclk() */ ! 75: ! 76: /* ! 77: * functions herein ! 78: */ ! 79: int alxopen(); ! 80: int alxclose(); ! 81: int alxtimer(); ! 82: int alxioctl(); ! 83: int alxparam(); ! 84: int alxcycle(); ! 85: int alxstart(); ! 86: int alxbreak(); ! 87: int alxintr(); ! 88: static int alxclk(); ! 89: static set_poll_rate(); ! 90: ! 91: /* ! 92: * Baud rate table and polling rate table. ! 93: * Indexed by ioctl bit rates. ! 94: */ ! 95: int albaud[] ={ ! 96: 0, /* 0 */ ! 97: 2304, /* 50 */ ! 98: 1536, /* 75 */ ! 99: 1047, /* 110 */ ! 100: 857, /* 134.5 */ ! 101: 768, /* 150 */ ! 102: 576, /* 200 */ ! 103: 384, /* 300 */ ! 104: 192, /* 600 */ ! 105: 96, /* 1200 */ ! 106: 64, /* 1800 */ ! 107: 58, /* 2000 */ ! 108: 48, /* 2400 */ ! 109: 32, /* 3600 */ ! 110: 24, /* 4800 */ ! 111: 16, /* 7200 */ ! 112: 12, /* 9600 */ ! 113: 6, /* 19200 */ ! 114: 0, /* EXTA */ ! 115: 0 /* EXTB */ ! 116: }; ! 117: ! 118: /* ! 119: * alp_rate[] is tied to albaud[] - it gives the minimum polling ! 120: * rate for the corresponding port speed; it must be a multiple ! 121: * of 100 (system clock Hz) and >= baud/6 ! 122: */ ! 123: int alp_rate[] ={ /* baud/6 or zero */ ! 124: 0, /* 0 */ ! 125: 1*HZ, /* 50 */ ! 126: 1*HZ, /* 75 */ ! 127: 1*HZ, /* 110 */ ! 128: 1*HZ, /* 134.5 */ ! 129: 1*HZ, /* 150 */ ! 130: 1*HZ, /* 200 */ ! 131: 1*HZ, /* 300 */ ! 132: 1*HZ, /* 600 */ ! 133: 2*HZ, /* 1200 */ ! 134: 3*HZ, /* 1800 */ ! 135: 4*HZ, /* 2000 */ ! 136: 4*HZ, /* 2400 */ ! 137: 6*HZ, /* 3600 */ ! 138: 8*HZ, /* 4800 */ ! 139: 12*HZ, /* 7200 */ ! 140: 16*HZ, /* 9600 */ ! 141: 0, /* 19200 */ ! 142: 0, /* EXTA */ ! 143: 0 /* EXTB */ ! 144: }; ! 145: ! 146: /* ! 147: * the following is for debug only ! 148: */ ! 149: #if 0 ! 150: #define CDUMP(text) cdump(text); ! 151: ! 152: cdump(message) ! 153: char *message; ! 154: { ! 155: int i, b; ! 156: ! 157: for (i = 0; i < NUM_AL_PORTS; i++) { ! 158: b = ((COM_DDP *)(tp_table[i]->t_ddp))->port; ! 159: printf("%x:%x:%x:%x ", i+1, b, inb(b+MCR), inb(b+IER)); ! 160: } ! 161: printf("poll=%d ", poll_rate); ! 162: printf("%s\n", message); ! 163: } ! 164: #else ! 165: #define CDUMP(text) ! 166: #endif ! 167: ! 168: /* ! 169: * alxopen() ! 170: */ ! 171: alxopen(dev, mode, tp, irqtty) ! 172: dev_t dev; ! 173: int mode; ! 174: register TTY *tp, **irqtty; ! 175: { ! 176: register int s; ! 177: register int b; ! 178: register int minor_h; /* minor device number including high bit */ ! 179: unsigned char msr; ! 180: ! 181: minor_h = minor(dev); /* complete minor number */ ! 182: ! 183: b = ALPORT; ! 184: ! 185: if (inb(b+IER) & ~IENABLE) { /* chip not found */ ! 186: u.u_error = ENXIO; ! 187: return; ! 188: } ! 189: ! 190: if ((tp->t_flags & T_EXCL) && !super()) { ! 191: u.u_error = ENODEV; ! 192: return; ! 193: } ! 194: ! 195: if (drvl[major(dev)].d_time != 0) { /* Modem settling */ ! 196: u.u_error = EDBUSY; ! 197: return; ! 198: } ! 199: ! 200: /* ! 201: * Can't open a polled port if another driver is using polling. ! 202: */ ! 203: if (dev & CPOLL && poll_owner & ~ POLL_AL) { ! 204: u.u_error = EDBUSY; ! 205: return; ! 206: } ! 207: ! 208: /* ! 209: * exclusion conditions: ! 210: * can't have same port polled and IRQ at once ! 211: * can't have both com[13] or both com[24] IRQ at once ! 212: */ ! 213: if (dev & CPOLL) { ! 214: if (com_usage[AL_NUM] == COM_IRQ) { ! 215: u.u_error = EDBUSY; ! 216: return; ! 217: } ! 218: } else { ! 219: if (com_usage[AL_NUM] == COM_POLLED ! 220: || com_usage[AL_NUM ^ 2] == COM_IRQ) { ! 221: u.u_error = EDBUSY; ! 222: return; ! 223: } ! 224: } ! 225: ! 226: if (tp->t_open == 0) { /* not already open */ ! 227: /* ! 228: * Wait for pending last close (if any) to finish. ! 229: */ ! 230: while (AL_H_CLOSE) { ! 231: sleep((char *)(&AL_H_CLOSE), CVTTOUT, IVTTOUT, ! 232: SVTTOUT); ! 233: } ! 234: s = sphi(); ! 235: /* ! 236: * Raise basic modem control lines even if modem ! 237: * control hasn't been specified. ! 238: * MC_OUT2 turns on NON-open-collector IRQ line from the UART. ! 239: * since we can't have two UART's on same IRQ with MC_OUT2 on ! 240: */ ! 241: if (dev & CPOLL) { ! 242: outb(b+MCR, MC_RTS|MC_DTR); ! 243: } else { ! 244: *irqtty = tp_table[AL_NUM]; ! 245: outb(b+MCR, MC_RTS|MC_DTR|MC_OUT2); ! 246: } ! 247: ! 248: outb(b+IER, IENABLE); /* enable interrupts */ ! 249: ! 250: if ((minor_h & NMODC) == 0) { /* want modem control? */ ! 251: tp->t_flags |= T_MODC | T_HOPEN | T_STOP; ! 252: while (1) { /* wait for carrier */ ! 253: msr = inb(b+MSR); ! 254: AL_MSR_DELTAS |= msr; ! 255: if (msr & MS_RLSD) ! 256: break; ! 257: sleep((char *)(&tp->t_open), CVTTOUT, IVTTOUT, ! 258: SVTTOUT); /* wait for carrier */ ! 259: if (SELF->p_ssig && nondsig()) { /* signal? */ ! 260: outb(b+MCR, inb(b+MCR)&MC_OUT2); ! 261: /* ! 262: * make sure port is hungup ! 263: * disable all ints except for TxI ! 264: */ ! 265: outb(b+IER, IE_TxI); ! 266: u.u_error = EINTR; ! 267: spl(s); ! 268: return; ! 269: } ! 270: } ! 271: tp->t_flags &= ~T_HOPEN; /* no longer hanging in open */ ! 272: if (msr & MS_CTS) ! 273: tp->t_flags &= ~T_STOP; ! 274: } else { ! 275: tp->t_flags &= ~T_MODC; /* no modem control */ ! 276: } ! 277: tp->t_flags |= T_CARR; /* carrier on */ ! 278: ttopen(tp); /* stty inits */ ! 279: ! 280: /* ! 281: * Allow custom modification of defaults. ! 282: */ ! 283: tp->t_sgttyb.sg_flags |= al_sg_set; ! 284: tp->t_sgttyb.sg_flags &= ~al_sg_clr; ! 285: alxparam(tp); ! 286: spl(s); ! 287: } else { /* already open */ ! 288: if ((minor_h & NMODC) == 0) { /* want modem control? */ ! 289: if ((tp->t_flags & T_MODC)==0) { /* already not modem control? */ ! 290: u.u_error = ENODEV; /* yes, don't allow open */ ! 291: return; ! 292: } ! 293: } else { /* don't want modem control */ ! 294: if (tp->t_flags & T_MODC) { /* already modem control? */ ! 295: u.u_error = ENODEV; /* yes, don't allow open */ ! 296: return; ! 297: } ! 298: } ! 299: } ! 300: tp->t_open++; ! 301: ttsetgrp(tp, dev); ! 302: ! 303: /* ! 304: * now that we've successfully opened, designate port as ! 305: * polled or interrupt driven to avoid future conflicts ! 306: */ ! 307: if (dev & CPOLL) { ! 308: com_usage[AL_NUM] = COM_POLLED; ! 309: set_poll_rate(); ! 310: } else { /* irq-driven port */ ! 311: com_usage[AL_NUM] = COM_IRQ; ! 312: } ! 313: ! 314: CDUMP((dev&CPOLL)?"open polled":"open irq") ! 315: } ! 316: ! 317: /* ! 318: * alxclose() ! 319: * ! 320: * Called at high priority on last close for the device. ! 321: */ ! 322: alxclose(dev, mode, tp) ! 323: dev_t dev; ! 324: int mode; ! 325: TTY *tp; ! 326: { ! 327: register unsigned holdflags; ! 328: register int b; ! 329: int state, maj; ! 330: int s; ! 331: ! 332: /* ! 333: * Called at high priority by alclose after al_buff is drained ! 334: */ ! 335: holdflags = tp->t_flags; /* save flags */ ! 336: AL_H_CLOSE = 1; /* disallow reopen til done closing */ ! 337: ttclose(tp); /* clear flags */ ! 338: b = ALPORT; ! 339: /* ! 340: * ttclose() only emptied the output queue tp->t_oq; ! 341: * now wait for the silo tp->rawout to empty ! 342: * and allow a delay for the UART on-chip xmit buffer to empty ! 343: * state 2: waiting for silo to empty ! 344: * state 1: stalling so UART can empty xmit buffer ! 345: * state 0: done! ok to shut off IRQ for this chip by clearing MC_OUT2 ! 346: */ ! 347: state = 2; ! 348: while (state) { ! 349: timeout(&AL_TIM, 10, wakeup, (int)&AL_TIM); ! 350: sleep((char *)&AL_TIM, CVTTOUT, IVTTOUT, SVTTOUT); ! 351: if (tp->t_rawout.si_ix == tp->t_rawout.si_ox && state) ! 352: state--; ! 353: } ! 354: ! 355: /* ! 356: * If not hanging in open ! 357: */ ! 358: if ((holdflags & T_HOPEN) == 0) { ! 359: /* ! 360: * Disable all ints except TxI ! 361: */ ! 362: outb(b+IER, IE_TxI); ! 363: } else { ! 364: /* ! 365: * Flags for first open ! 366: */ ! 367: tp->t_flags = T_MODC | T_HOPEN; ! 368: } ! 369: ! 370: /* ! 371: * If hupcls ! 372: */ ! 373: if (holdflags & T_HPCL) { ! 374: /* ! 375: * Hangup port ! 376: */ ! 377: s = sphi(); ! 378: outb(b+MCR, inb(b+MCR)&MC_OUT2); ! 379: spl(s); ! 380: ! 381: /* ! 382: * Hold dtr low for timeout ! 383: */ ! 384: maj = major(dev); ! 385: drvl[maj].d_time = 1; ! 386: sleep((char *)&drvl[maj].d_time, CVTTOUT, IVTTOUT, SVTTOUT); ! 387: drvl[maj].d_time = 0; ! 388: } ! 389: s = sphi(); ! 390: outb(b+MCR, inb(b+MCR)&(~MC_OUT2)); ! 391: spl(s); ! 392: com_usage[AL_NUM] = COM_UNUSED; ! 393: set_poll_rate(); ! 394: AL_H_CLOSE = 0; /* allow reopen - done closing */ ! 395: wakeup((char *)&AL_H_CLOSE); ! 396: CDUMP("closed") ! 397: } ! 398: ! 399: /* ! 400: * Common c_timer routine for async ports. ! 401: */ ! 402: alxtimer(dev) ! 403: dev_t dev; ! 404: { ! 405: if (++drvl[major(dev)].d_time > DTRTMOUT) ! 406: wakeup((char *)&drvl[major(dev)].d_time); ! 407: } ! 408: ! 409: ! 410: /* ! 411: * Common c_ioctl routine for async ports. ! 412: */ ! 413: alxioctl(dev, com, vec, tp) ! 414: dev_t dev; ! 415: struct sgttyb *vec; ! 416: register TTY *tp; ! 417: { ! 418: register int s, b; ! 419: int stat1, stat2; ! 420: unsigned char msr; ! 421: unsigned char ier_save; ! 422: ! 423: s = sphi(); ! 424: b = ALPORT; ! 425: ier_save=inb(b+IER); ! 426: stat1 = inb(b+MCR); /* get current MCR register status */ ! 427: stat2 = inb(b+LCR); /* get current LCR register status */ ! 428: ! 429: switch(com) { ! 430: case TIOCSBRK: /* set BREAK */ ! 431: outb(b+LCR, stat2|LC_SBRK); ! 432: break; ! 433: case TIOCCBRK: /* clear BREAK */ ! 434: outb(b+LCR, stat2 & ~LC_SBRK); ! 435: break; ! 436: case TIOCSDTR: /* set DTR */ ! 437: outb(b+MCR, stat1|MC_DTR); ! 438: break; ! 439: case TIOCCDTR: /* clear DTR */ ! 440: outb(b+MCR, stat1 & ~MC_DTR); ! 441: break; ! 442: case TIOCSRTS: /* set RTS */ ! 443: outb(b+MCR, stat1|MC_RTS); ! 444: break; ! 445: case TIOCCRTS: /* clear RTS */ ! 446: outb(b+MCR, stat1 & ~MC_RTS); ! 447: break; ! 448: case TIOCRSPEED: /* set "raw" I/O speed divisor */ ! 449: outb(b+LCR, stat2|LC_DLAB); /* set speed latch bit */ ! 450: outb(b+DLL, (unsigned) vec); ! 451: outb(b+DLH, (unsigned) vec >> 8); ! 452: outb(b+LCR, stat2); /* reset latch bit */ ! 453: break; ! 454: case TIOCWORDL: /* set word length and stop bits */ ! 455: outb(b+LCR, ((stat2&~0x7) | ((unsigned) vec & 0x7))); ! 456: break; ! 457: case TIOCRMSR: /* get CTS/DSR/RI/RLSD (MSR) */ ! 458: msr = inb(b+MSR); ! 459: AL_MSR_DELTAS |= msr; ! 460: stat1 = msr >> 4; ! 461: kucopy(&stat1, (unsigned *) vec, sizeof(unsigned)); ! 462: break; ! 463: default: ! 464: ttioctl(tp, com, vec); ! 465: } ! 466: outb(b+IER, ier_save); ! 467: spl(s); ! 468: } ! 469: ! 470: alxparam(tp) ! 471: TTY *tp; ! 472: { ! 473: register int b; ! 474: register int baud; ! 475: int s; ! 476: ! 477: b = ALPORT; ! 478: ! 479: /* ! 480: * error if input speed not the same as output speed ! 481: */ ! 482: if (tp->t_sgttyb.sg_ispeed!=tp->t_sgttyb.sg_ospeed) { ! 483: u.u_error = ENODEV; ! 484: return; ! 485: } ! 486: ! 487: if ((baud = albaud[tp->t_sgttyb.sg_ispeed]) == 0) { ! 488: if (tp->t_flags & T_MODC) { /* modem control? */ ! 489: tp->t_flags &= ~T_CARR; /* indicate no carrier */ ! 490: s = sphi(); ! 491: outb(b+MCR, inb(b+MCR) & MC_OUT2); /* hangup */ ! 492: spl(s); ! 493: } ! 494: } ! 495: ! 496: if (baud) { ! 497: unsigned char ier_save; ! 498: ! 499: s=sphi(); ! 500: ier_save=inb(b+IER); /* some chips need this */ ! 501: outb(b+LCR, LC_DLAB); ! 502: outb(b+DLL, baud); ! 503: outb(b+DLH, baud >> 8); ! 504: switch (tp->t_sgttyb.sg_flags & (EVENP|ODDP|RAW)) { ! 505: case EVENP: ! 506: outb(b+LCR, LC_CS7 + LC_PARENB + LC_PAREVEN); ! 507: break; ! 508: ! 509: case ODDP: ! 510: outb(b+LCR, LC_CS7 + LC_PARENB); ! 511: break; ! 512: ! 513: default: ! 514: outb(b+LCR, LC_CS8); ! 515: break; ! 516: } ! 517: outb(b+IER, ier_save); ! 518: spl(s); ! 519: } ! 520: set_poll_rate(); ! 521: } ! 522: ! 523: /* ! 524: * Middle level processor. ! 525: * ! 526: * Invoked 10 times per second. ! 527: * Checks modem status for loss of carrier. ! 528: * Tranfers rawin buffer [from intr level] to canonical input queue. ! 529: * Transfers output queue to rawout buffer [for intr level]. ! 530: */ ! 531: alxcycle(tp) ! 532: register TTY * tp; ! 533: { ! 534: register int b; ! 535: register int n; ! 536: unsigned char msr, mcr; ! 537: int s; ! 538: ! 539: /* ! 540: * Check modem status every ten clock ticks. ! 541: * ! 542: * Modem status interrupts were not enabled due to 8250 hardware bug. ! 543: * Enabling modem status and receive interrupts may cause lockup ! 544: * on older parts. ! 545: * ! 546: * Also check if input silo is nearly full in case we need RTS ! 547: * flow control. ! 548: */ ! 549: if (tp->t_flags & T_MODC) { ! 550: ! 551: /* ! 552: * Get status ! 553: */ ! 554: msr = inb(ALPORT+MSR); ! 555: AL_MSR_DELTAS |= msr; ! 556: ! 557: /* ! 558: * Carrier changed. ! 559: */ ! 560: if (AL_MSR_DELTAS & MS_DRLSD) { ! 561: AL_MSR_DELTAS &= ~MS_DRLSD; ! 562: /* ! 563: * wakeup open ! 564: */ ! 565: if (tp->t_open == 0) { ! 566: wakeup((char *)(&tp->t_open)); ! 567: } ! 568: ! 569: /* ! 570: * carrier off? ! 571: */ ! 572: else if ((msr & MS_RLSD) == 0) { ! 573: /* ! 574: * clear carrier flag; send hangup signal ! 575: */ ! 576: s = sphi(); ! 577: tp->t_rawin.si_ox = tp->t_rawin.si_ix; ! 578: tp->t_rawin.SILO_CHAR_COUNT = 0; ! 579: spl(s); ! 580: tthup(tp); ! 581: } ! 582: } ! 583: ! 584: /* ! 585: * CTS changed. ! 586: */ ! 587: if (AL_MSR_DELTAS & MS_DCTS) { ! 588: AL_MSR_DELTAS &= ~MS_DCTS; ! 589: if (msr & MS_CTS) ! 590: tp->t_flags &= ~T_STOP; ! 591: else ! 592: tp->t_flags |= T_STOP; ! 593: } ! 594: ! 595: /* ! 596: * If input silo not nearly full, assert RTS. ! 597: */ ! 598: if (tp->t_rawin.SILO_CHAR_COUNT <= SILO_HIGH_MARK) { ! 599: mcr = inb(ALPORT+MCR); ! 600: if ((mcr & MC_RTS) == 0) { ! 601: printf("%x RTS ON\n", ALPORT); ! 602: outb(ALPORT+MCR, mcr | MC_RTS); ! 603: } ! 604: } ! 605: } ! 606: ! 607: /* ! 608: * Empty raw input buffer. ! 609: * If modem control enabled and tt input queue is at high limit ! 610: * (e.g., tp->t_iq.cq_cc >= IHILIM), don't copy from rawin silo ! 611: * to tt input queue. ! 612: */ ! 613: if (!(tp->t_flags & T_MODC) || !(tp->t_flags & T_ISTOP)) ! 614: while (tp->t_rawin.SILO_CHAR_COUNT > 0) { ! 615: ttin(tp, tp->t_rawin.si_buf[tp->t_rawin.si_ox]); ! 616: if (tp->t_rawin.si_ox < MAX_SILO_INDEX) ! 617: tp->t_rawin.si_ox++; ! 618: else ! 619: tp->t_rawin.si_ox = 0; ! 620: tp->t_rawin.SILO_CHAR_COUNT--; ! 621: } ! 622: ! 623: /* ! 624: * Calculate free output slot count. ! 625: */ ! 626: n = sizeof(tp->t_rawout.si_buf) - 1; ! 627: n += tp->t_rawout.si_ox - tp->t_rawout.si_ix; ! 628: n %= sizeof(tp->t_rawout.si_buf); ! 629: ! 630: /* ! 631: * Fill raw output buffer. ! 632: */ ! 633: while ((--n >= 0) && ((b = ttout(tp)) >= 0)) { ! 634: tp->t_rawout.si_buf[ tp->t_rawout.si_ix ] = b; ! 635: if (tp->t_rawout.si_ix >= sizeof(tp->t_rawout.si_buf) - 1) ! 636: tp->t_rawout.si_ix = 0; ! 637: else ! 638: tp->t_rawout.si_ix++; ! 639: } ! 640: ! 641: /* ! 642: * (Re)start output, wake sleeping processes, etc. ! 643: */ ! 644: ttstart(tp); ! 645: ! 646: /* ! 647: * Schedule next cycle. ! 648: */ ! 649: timeout(&tp->t_rawtim, HZ/10, alxcycle, tp); ! 650: } ! 651: ! 652: /* ! 653: * Serial Transmit Start Routine. ! 654: */ ! 655: alxstart(tp) ! 656: register TTY * tp; ! 657: { ! 658: register int b; ! 659: register int s; ! 660: extern alxbreak(); ! 661: ! 662: /* ! 663: * Read line status register AFTER disabling interrupts. ! 664: */ ! 665: s = sphi(); ! 666: b = inb(ALPORT+LSR); ! 667: ! 668: /* ! 669: * Process break indication. ! 670: * NOTE: Break indication cleared when line status register was read. ! 671: */ ! 672: if (b & LS_BREAK) ! 673: defer(alxbreak, tp); ! 674: ! 675: /* ! 676: * Transmitter is empty, output data is pending. ! 677: */ ! 678: if ((b & LS_TxRDY) && (tp->t_rawout.si_ix != tp->t_rawout.si_ox)) { ! 679: outb( ALPORT+DREG, ! 680: tp->t_rawout.si_buf[ tp->t_rawout.si_ox ]); ! 681: if (++tp->t_rawout.si_ox >= sizeof(tp->t_rawout.si_buf)) ! 682: tp->t_rawout.si_ox = 0; ! 683: } ! 684: spl(s); ! 685: } ! 686: ! 687: /* ! 688: * Serial Received Break Handler. ! 689: */ ! 690: alxbreak(tp) ! 691: TTY * tp; ! 692: { ! 693: ttsignal(tp, SIGINT); ! 694: } ! 695: ! 696: /* ! 697: * Serial Interrupt Handler. ! 698: */ ! 699: alxintr(tp) ! 700: register TTY * tp; ! 701: { ! 702: register int b; ! 703: int port = ALPORT; ! 704: unsigned char mcr; ! 705: ! 706: rescan: ! 707: switch (inb(port+IIR)) { ! 708: ! 709: case LS_INTR: ! 710: if (inb(port+LSR) & LS_BREAK) ! 711: defer(alxbreak, tp); ! 712: goto rescan; ! 713: ! 714: case Rx_INTR: ! 715: b = inb(port+DREG); ! 716: if (tp->t_open == 0) ! 717: goto rescan; ! 718: /* ! 719: * Must recognize XOFF quickly to avoid transmit overrun. ! 720: * Recognize XON here as well to avoid race conditions. ! 721: */ ! 722: if ((tp->t_sgttyb.sg_flags & RAWIN) == 0) { ! 723: /* ! 724: * XOFF. ! 725: */ ! 726: if (tp->t_tchars.t_stopc == (b & 0177)) { ! 727: tp->t_flags |= T_STOP; ! 728: goto rescan; ! 729: } ! 730: ! 731: /* ! 732: * XON. ! 733: */ ! 734: if (tp->t_tchars.t_startc == (b & 0177)) { ! 735: tp->t_flags &= ~T_STOP; ! 736: goto rescan; ! 737: } ! 738: } ! 739: ! 740: /* ! 741: * Save char in raw input buffer. ! 742: */ ! 743: if (tp->t_rawin.SILO_CHAR_COUNT < MAX_SILO_CHARS) { ! 744: tp->t_rawin.si_buf[tp->t_rawin.si_ix] = b; ! 745: if (tp->t_rawin.si_ix < MAX_SILO_INDEX) ! 746: tp->t_rawin.si_ix++; ! 747: else ! 748: tp->t_rawin.si_ix = 0; ! 749: tp->t_rawin.SILO_CHAR_COUNT++; ! 750: } ! 751: if (tp->t_flags & T_MODC) ! 752: if ((tp->t_flags & T_ISTOP) ! 753: || (tp->t_rawin.SILO_CHAR_COUNT > SILO_HIGH_MARK)) { ! 754: mcr = inb(port+MCR); ! 755: if (mcr & MC_RTS) { ! 756: outb(port+MCR, mcr & ~MC_RTS); ! 757: printf("%x RTS OFF\n", port); ! 758: } ! 759: } ! 760: goto rescan; ! 761: ! 762: case Tx_INTR: ! 763: /* ! 764: * Do nothing if no raw output data or output is stopped. ! 765: */ ! 766: if (tp->t_rawout.si_ix == tp->t_rawout.si_ox) { ! 767: goto rescan; ! 768: } ! 769: if (tp->t_flags & T_STOP) ! 770: goto rescan; ! 771: ! 772: /* ! 773: * Transmit next char in raw output buffer. ! 774: */ ! 775: outb(port+DREG, ! 776: tp->t_rawout.si_buf[ tp->t_rawout.si_ox ]); ! 777: ! 778: /* ! 779: * Adjust raw output buffer output index. ! 780: */ ! 781: if (++tp->t_rawout.si_ox >= sizeof(tp->t_rawout.si_buf)) ! 782: tp->t_rawout.si_ox = 0; ! 783: ! 784: /* ! 785: * Try to fill buffer if now empty. ! 786: */ ! 787: if (tp->t_rawout.si_ox == tp->t_rawout.si_ix) { ! 788: defer(alxcycle, tp); ! 789: } ! 790: goto rescan; ! 791: ! 792: case MS_INTR: ! 793: AL_MSR_DELTAS |= inb(port+MSR); ! 794: defer(alxcycle, tp); ! 795: goto rescan; ! 796: } ! 797: } ! 798: ! 799: /* ! 800: * alxclk will be called every time T0 interrupts - if it returns 0, ! 801: * the usual system timer interrupt stuff is done ! 802: */ ! 803: static int alxclk() ! 804: { ! 805: static int count; ! 806: int i; ! 807: ! 808: for (i = 0; i < NUM_AL_PORTS; i++) ! 809: if (com_usage[i] == COM_POLLED) ! 810: alxintr(tp_table[i]); ! 811: count++; ! 812: if (count >= poll_divisor) ! 813: count = 0; ! 814: return count; ! 815: } ! 816: ! 817: /* ! 818: * set_poll_rate is called when a port is opened or closed or changes speed ! 819: * it sets the polling rate only as fast as needed, and shuts off polling ! 820: * whenever possible ! 821: */ ! 822: static set_poll_rate() ! 823: { ! 824: int port_num, max_rate, port_rate; ! 825: ! 826: /* ! 827: * If another driver has the polling clock, do nothing. ! 828: */ ! 829: if (poll_owner & ~ POLL_AL) ! 830: return; ! 831: ! 832: /* ! 833: * find highest valid polling rate in units of HZ/10 ! 834: */ ! 835: max_rate = 0; ! 836: for (port_num = 0; port_num < NUM_AL_PORTS; port_num++) { ! 837: if (com_usage[port_num] == COM_POLLED) { ! 838: port_rate = alp_rate[(tp_table[port_num])->t_sgttyb.sg_ispeed]; ! 839: if (max_rate < port_rate) ! 840: max_rate = port_rate; ! 841: } ! 842: } ! 843: /* ! 844: * if max_rate is not current rate, adjust the system clock ! 845: */ ! 846: if (max_rate != poll_rate) { ! 847: poll_rate = max_rate; ! 848: poll_divisor = poll_rate/HZ; /* used in alxclk() */ ! 849: altclk_out(); /* stop previous polling */ ! 850: poll_owner &= ~ POLL_AL; ! 851: if (max_rate) { /* resume polling at new rate if needed */ ! 852: poll_owner |= POLL_AL; ! 853: altclk_in(poll_rate, alxclk); ! 854: } ! 855: CDUMP("new rate") ! 856: } ! 857: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.