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