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