This source file includes following definitions.
- serial_in
- serial_inp
- serial_out
- serial_outp
- rs_stop
- rs_start
- rs_probe
- rs_sched_event
- receive_chars
- transmit_chars
- check_modem_status
- figure_RS_timer
- rs_interrupt
- handle_rs_break
- do_softint
- rs_timer
- grab_all_interrupts
- free_all_interrupts
- figure_IRQ_timeout
- startup
- shutdown
- change_speed
- restart_port
- rs_write
- rs_throttle
- get_serial_info
- set_serial_info
- get_modem_info
- set_modem_info
- do_autoconfig
- send_break
- check_wild_interrupts
- rs_ioctl
- rs_set_termios
- rs_close
- rs_hangup
- block_til_ready
- rs_open
- show_serial_version
- get_auto_irq
- do_auto_irq
- autoconfig
- rs_init
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 #include <linux/errno.h>
21 #include <linux/signal.h>
22 #include <linux/sched.h>
23 #include <linux/timer.h>
24 #include <linux/tty.h>
25 #include <linux/serial.h>
26 #include <linux/interrupt.h>
27 #include <linux/config.h>
28 #include <linux/major.h>
29 #include <linux/string.h>
30 #include <linux/fcntl.h>
31 #include <linux/ptrace.h>
32
33 #include <asm/system.h>
34 #include <asm/io.h>
35 #include <asm/segment.h>
36 #include <asm/bitops.h>
37
38 #undef ISR_HACK
39
40
41
42
43
44
45
46
47
48
49
50
51 static int rs_event[2];
52
53 static struct async_struct *IRQ_ports[16];
54 static int IRQ_active;
55 static unsigned long IRQ_timer[16];
56 static int IRQ_timeout[16];
57 static volatile int rs_irq_triggered;
58 static volatile int rs_triggered;
59 static int rs_wild_int_mask;
60
61 static void autoconfig(struct async_struct * info);
62 static void change_speed(unsigned int line);
63
64
65
66
67
68
69
70
71 #define BASE_BAUD ( 1843200 / 16 )
72
73 #ifdef CONFIG_AUTO_IRQ
74 #define AUTO_IRQ_FLAG ASYNC_AUTO_IRQ
75 #else
76 #define AUTO_IRQ_FLAG 0
77 #endif
78
79
80 #define STD_COM_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST | AUTO_IRQ_FLAG)
81 #define STD_COM4_FLAGS (ASYNC_BOOT_AUTOCONF | AUTO_IRQ_FLAG)
82
83 #ifdef CONFIG_AST_FOURPORT
84 #define FOURPORT_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_FOURPORT | AUTO_IRQ_FLAG)
85 #else
86 #define FOURPORT_FLAGS (ASYNC_FOURPORT | AUTO_IRQ_FLAG)
87 #endif
88
89 #ifdef CONFIG_ACCENT_ASYNC
90 #define ACCENT_FLAGS (ASYNC_BOOT_AUTOCONF | AUTO_IRQ_FLAG)
91 #else
92 #define ACCENT_FLAGS AUTO_IRQ_FLAG
93 #endif
94
95 #ifdef CONFIG_BOCA
96 #define BOCA_FLAGS (ASYNC_BOOT_AUTOCONF | AUTO_IRQ_FLAG)
97 #else
98 #define BOCA_FLAGS AUTO_IRQ_FLAG
99 #endif
100
101 #ifdef CONFIG_HUB6
102 #define HUB6_FLAGS (ASYNC_BOOT_AUTOCONF)
103 #else
104 #define HUB6_FLAGS 0
105 #endif
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121 #define C_P(card,port) (((card)<<6|(port)<<3) + 1)
122
123 struct async_struct rs_table[] = {
124
125 { BASE_BAUD, 0x3F8, 4, STD_COM_FLAGS },
126 { BASE_BAUD, 0x2F8, 3, STD_COM_FLAGS },
127 { BASE_BAUD, 0x3E8, 4, STD_COM_FLAGS },
128 { BASE_BAUD, 0x2E8, 3, STD_COM4_FLAGS },
129
130 { BASE_BAUD, 0x1A0, 9, FOURPORT_FLAGS },
131 { BASE_BAUD, 0x1A8, 9, FOURPORT_FLAGS },
132 { BASE_BAUD, 0x1B0, 9, FOURPORT_FLAGS },
133 { BASE_BAUD, 0x1B8, 9, FOURPORT_FLAGS },
134
135 { BASE_BAUD, 0x2A0, 5, FOURPORT_FLAGS },
136 { BASE_BAUD, 0x2A8, 5, FOURPORT_FLAGS },
137 { BASE_BAUD, 0x2B0, 5, FOURPORT_FLAGS },
138 { BASE_BAUD, 0x2B8, 5, FOURPORT_FLAGS },
139
140 { BASE_BAUD, 0x330, 4, ACCENT_FLAGS },
141 { BASE_BAUD, 0x338, 4, ACCENT_FLAGS },
142 { BASE_BAUD, 0x000, 0, 0 },
143 { BASE_BAUD, 0x000, 0, 0 },
144
145 { BASE_BAUD, 0x100, 12, BOCA_FLAGS },
146 { BASE_BAUD, 0x108, 12, BOCA_FLAGS },
147 { BASE_BAUD, 0x110, 12, BOCA_FLAGS },
148 { BASE_BAUD, 0x118, 12, BOCA_FLAGS },
149 { BASE_BAUD, 0x120, 12, BOCA_FLAGS },
150 { BASE_BAUD, 0x128, 12, BOCA_FLAGS },
151 { BASE_BAUD, 0x130, 12, BOCA_FLAGS },
152 { BASE_BAUD, 0x138, 12, BOCA_FLAGS },
153 { BASE_BAUD, 0x140, 12, BOCA_FLAGS },
154 { BASE_BAUD, 0x148, 12, BOCA_FLAGS },
155 { BASE_BAUD, 0x150, 12, BOCA_FLAGS },
156 { BASE_BAUD, 0x158, 12, BOCA_FLAGS },
157 { BASE_BAUD, 0x160, 12, BOCA_FLAGS },
158 { BASE_BAUD, 0x168, 12, BOCA_FLAGS },
159 { BASE_BAUD, 0x170, 12, BOCA_FLAGS },
160 { BASE_BAUD, 0x178, 12, BOCA_FLAGS },
161
162
163
164
165 { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,0) },
166 { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,1) },
167 { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,2) },
168 { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,3) },
169 { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,4) },
170 { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(0,5) },
171 { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,0) },
172 { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,1) },
173 { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,2) },
174 { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,3) },
175 { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,4) },
176 { BASE_BAUD, 0x302, 3, HUB6_FLAGS, C_P(1,5) },
177 };
178
179 #define NR_PORTS (sizeof(rs_table)/sizeof(struct async_struct))
180
181
182
183
184 static int baud_table[] = {
185 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
186 9600, 19200, 38400, 57600, 115200, 0 };
187
188 static void rs_throttle(struct tty_struct * tty, int status);
189
190 static inline unsigned int serial_in(struct async_struct *info, int offset)
191 {
192 if (info->hub6) {
193 outb(info->hub6 - 1 + offset, info->port);
194 return inb(info->port+1);
195 } else
196 return inb(info->port + offset);
197 }
198
199 static inline unsigned int serial_inp(struct async_struct *info, int offset)
200 {
201 if (info->hub6) {
202 outb(info->hub6 - 1 + offset, info->port);
203 return inb_p(info->port+1);
204 } else
205 return inb_p(info->port + offset);
206 }
207
208 static inline void serial_out(struct async_struct *info, int offset, int value)
209 {
210 if (info->hub6) {
211 outb(info->hub6 - 1 + offset, info->port);
212 outb(value, info->port+1);
213 } else
214 outb(value, info->port+offset);
215 }
216
217 static inline void serial_outp(struct async_struct *info, int offset,
218 int value)
219 {
220 if (info->hub6) {
221 outb(info->hub6 - 1 + offset, info->port);
222 outb_p(value, info->port+1);
223 } else
224 outb_p(value, info->port+offset);
225 }
226
227
228
229
230
231
232
233
234
235 static void rs_stop(struct tty_struct *tty)
236 {
237 struct async_struct *info;
238
239 info = rs_table + DEV_TO_SL(tty->line);
240
241 if (info->flags & ASYNC_CLOSING) {
242 tty->stopped = 0;
243 tty->hw_stopped = 0;
244 return;
245 }
246
247 info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
248 #ifdef ISR_HACK
249 serial_out(info, UART_IER, info->IER);
250 #endif
251 }
252
253 static void rs_start(struct tty_struct *tty)
254 {
255 struct async_struct *info;
256
257 info = rs_table + DEV_TO_SL(tty->line);
258
259 info->IER = (UART_IER_MSI | UART_IER_RLSI |
260 UART_IER_THRI | UART_IER_RDI);
261 #ifdef ISR_HACK
262 serial_out(info, UART_IER, info->IER);
263 #endif
264 }
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291 static void rs_probe(int irq)
292 {
293 rs_irq_triggered = irq;
294 rs_triggered |= 1 << irq;
295 return;
296 }
297
298
299
300
301
302 static inline void rs_sched_event(struct async_struct *info,
303 int event)
304 {
305 info->event |= 1 << event;
306 set_bit(info->line, rs_event);
307 mark_bh(SERIAL_BH);
308 }
309
310 static inline void receive_chars(struct async_struct *info,
311 int *status)
312 {
313 struct tty_queue * queue;
314 int head, tail, ch;
315
316
317
318
319
320 #define VLEFT ((tail-head-1)&(TTY_BUF_SIZE-1))
321
322 queue = &info->tty->read_q;
323 head = queue->head;
324 tail = queue->tail;
325 do {
326 ch = serial_inp(info, UART_RX);
327
328
329
330
331 if (VLEFT < 2)
332 break;
333 if (*status & info->read_status_mask) {
334 set_bit(head, &info->tty->readq_flags);
335 if (*status & (UART_LSR_BI)) {
336 queue->buf[head++]= TTY_BREAK;
337 rs_sched_event(info, RS_EVENT_BREAK);
338 } else if (*status & UART_LSR_PE)
339 queue->buf[head++]= TTY_PARITY;
340 else if (*status & UART_LSR_FE)
341 queue->buf[head++]= TTY_FRAME;
342 else if (*status & UART_LSR_OE)
343 queue->buf[head++]= TTY_OVERRUN;
344 head &= TTY_BUF_SIZE-1;
345 }
346 queue->buf[head++] = ch;
347 head &= TTY_BUF_SIZE-1;
348 } while ((*status = serial_inp(info, UART_LSR)) & UART_LSR_DR);
349 queue->head = head;
350 if ((VLEFT < RQ_THRESHOLD_LW) && !set_bit(TTY_RQ_THROTTLED,
351 &info->tty->flags))
352 rs_throttle(info->tty, TTY_THROTTLE_RQ_FULL);
353 rs_sched_event(info, RS_EVENT_READ_PROCESS);
354 #ifdef SERIAL_DEBUG_INTR
355 printk("DR...");
356 #endif
357 }
358
359 static inline void transmit_chars(struct async_struct *info, int *done_work)
360 {
361 struct tty_queue * queue;
362 int head, tail, count;
363
364 queue = &info->tty->write_q;
365 head = queue->head;
366 tail = queue->tail;
367 if (head==tail && !info->x_char) {
368 info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
369 #ifdef ISR_HACK
370 serial_out(info, UART_IER, info->IER);
371 #endif
372 return;
373 }
374 count = info->xmit_fifo_size;
375 if (info->x_char) {
376 serial_outp(info, UART_TX, info->x_char);
377 info->x_char = 0;
378 count--;
379 }
380 while (count-- && (tail != head)) {
381 serial_outp(info, UART_TX, queue->buf[tail++]);
382 tail &= TTY_BUF_SIZE-1;
383 }
384 queue->tail = tail;
385 if (VLEFT > WAKEUP_CHARS) {
386 rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
387 if (info->tty->write_data_cnt) {
388 set_bit(info->tty->line, &tty_check_write);
389 mark_bh(TTY_BH);
390 }
391 }
392 #ifdef SERIAL_DEBUG_INTR
393 printk("THRE...");
394 #endif
395 (*done_work)++;
396 }
397
398 static inline int check_modem_status(struct async_struct *info)
399 {
400 int status;
401
402 status = serial_in(info, UART_MSR);
403
404 if ((status & UART_MSR_DDCD) && !C_CLOCAL(info->tty)) {
405 #if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
406 printk("ttys%d CD now %s...", info->line,
407 (status & UART_MSR_DCD) ? "on" : "off");
408 #endif
409 if (status & UART_MSR_DCD)
410 rs_sched_event(info, RS_EVENT_OPEN_WAKEUP);
411 else if (!((info->flags & ASYNC_CALLOUT_ACTIVE) &&
412 (info->flags & ASYNC_CALLOUT_NOHUP))) {
413 #ifdef SERIAL_DEBUG_OPEN
414 printk("scheduling hangup...");
415 #endif
416 rs_sched_event(info, RS_EVENT_HANGUP);
417 }
418 }
419 if (C_CRTSCTS(info->tty) && !(info->flags & ASYNC_CLOSING)) {
420 if (info->tty->hw_stopped) {
421 if (status & UART_MSR_CTS) {
422 #ifdef SERIAL_DEBUG_INTR
423 printk("CTS tx start...");
424 #endif
425 info->tty->hw_stopped = 0;
426 rs_start(info->tty);
427 return 1;
428 }
429 } else {
430 if (!(status & UART_MSR_CTS)) {
431 #ifdef SERIAL_DEBUG_INTR
432 printk("CTS tx stop...");
433 #endif
434 info->tty->hw_stopped = 1;
435 rs_stop(info->tty);
436 }
437 }
438 }
439 return 0;
440 }
441
442 static inline void figure_RS_timer(void)
443 {
444 int timeout = jiffies + 60*HZ;
445 int i, mask;
446
447 if (!IRQ_active)
448 return;
449 for (i=0, mask = 1; mask <= IRQ_active; i++, mask <<= 1) {
450 if (!(mask & IRQ_active))
451 continue;
452 if (IRQ_timer[i] < timeout)
453 timeout = IRQ_timer[i];
454 }
455 timer_table[RS_TIMER].expires = timeout;
456 timer_active |= 1 << RS_TIMER;
457 }
458
459
460
461
462
463 static void rs_interrupt(int irq)
464 {
465 int status;
466 struct async_struct * info;
467 int done, done_work, pass_number, recheck_count;
468
469 rs_irq_triggered = irq;
470 rs_triggered |= 1 << irq;
471
472 info = IRQ_ports[irq];
473 done = 1;
474 done_work = 0;
475 pass_number = 0;
476 while (info) {
477 if (info->tty &&
478 info->tty->termios &&
479 (!pass_number ||
480 !(serial_inp(info, UART_IIR) & UART_IIR_NO_INT))) {
481 done = 0;
482 status = serial_inp(info, UART_LSR);
483 if (status & UART_LSR_DR) {
484 receive_chars(info, &status);
485 done_work++;
486 }
487 recheck_count = 0;
488 recheck_write:
489 if (status & UART_LSR_THRE) {
490 wake_up_interruptible(&info->xmit_wait);
491 if (!info->tty->stopped &&
492 !info->tty->hw_stopped)
493 transmit_chars(info, &done_work);
494 }
495 if (check_modem_status(info) &&
496 (recheck_count++ <= 64))
497 goto recheck_write;
498 #ifdef SERIAL_DEBUG_INTR
499 if (recheck_count > 16)
500 printk("recheck_count = %d\n", recheck_count);
501 #endif
502 }
503 #ifdef ISR_HACK
504 serial_outp(info, UART_IER, 0);
505 serial_out(info, UART_IER, info->IER);
506 #endif
507
508 info = info->next_port;
509 if (!info && !done) {
510 info = IRQ_ports[irq];
511 done = 1;
512 if (pass_number++ > 64)
513 break;
514 }
515 }
516 if ((info = IRQ_ports[irq]) != NULL) {
517 #ifdef 0
518 do {
519 serial_outp(info, UART_IER, 0);
520 serial_out(info, UART_IER, info->IER);
521 info = info->next_port;
522 } while (info);
523 #endif
524 if (irq && !done_work)
525 IRQ_timer[irq] = jiffies + 1500;
526 else
527 IRQ_timer[irq] = jiffies + IRQ_timeout[irq];
528 IRQ_active |= 1 << irq;
529 }
530 figure_RS_timer();
531 }
532
533
534
535
536
537
538
539
540
541
542
543 static inline void handle_rs_break(struct async_struct *info)
544 {
545 if (info->flags & ASYNC_SAK)
546 do_SAK(info->tty);
547
548 if (!I_IGNBRK(info->tty) && I_BRKINT(info->tty)) {
549 flush_input(info->tty);
550 flush_output(info->tty);
551 if (info->tty->pgrp > 0)
552 kill_pg(info->tty->pgrp, SIGINT,1);
553 }
554 }
555
556
557
558
559
560
561
562
563
564
565 static void do_softint(void *unused)
566 {
567 int i;
568 struct async_struct *info;
569
570 for (i = 0, info = rs_table; i < NR_PORTS; i++,info++) {
571 if (clear_bit(i, rs_event)) {
572 if (!info->tty)
573 continue;
574 if (clear_bit(RS_EVENT_READ_PROCESS, &info->event)) {
575 TTY_READ_FLUSH(info->tty);
576 }
577 if (clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
578 wake_up_interruptible(&info->tty->write_q.proc_list);
579 }
580 if (clear_bit(RS_EVENT_HANGUP, &info->event)) {
581 tty_hangup(info->tty);
582 wake_up_interruptible(&info->open_wait);
583 info->flags &= ~(ASYNC_NORMAL_ACTIVE|
584 ASYNC_CALLOUT_ACTIVE);
585 }
586 if (clear_bit(RS_EVENT_BREAK, &info->event))
587 handle_rs_break(info);
588 if (clear_bit(RS_EVENT_OPEN_WAKEUP, &info->event)) {
589 wake_up_interruptible(&info->open_wait);
590 }
591 }
592 }
593 }
594
595
596
597
598
599
600
601
602 static void rs_timer(void)
603 {
604 int i, mask;
605 int timeout = 0;
606
607 for (i = 0, mask = 1; mask <= IRQ_active; i++, mask <<= 1) {
608 if ((mask & IRQ_active) && (IRQ_timer[i] <= jiffies)) {
609 IRQ_active &= ~mask;
610 cli();
611 #ifdef SERIAL_DEBUG_TIMER
612 printk("rs_timer: rs_interrupt(%d)...", i);
613 #endif
614 rs_interrupt(i);
615 sti();
616 }
617 if (mask & IRQ_active) {
618 if (!timeout || (IRQ_timer[i] < timeout))
619 timeout = IRQ_timer[i];
620 }
621 }
622 if (timeout) {
623 timer_table[RS_TIMER].expires = timeout;
624 timer_active |= 1 << RS_TIMER;
625 }
626 }
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643 static int grab_all_interrupts(int dontgrab)
644 {
645 int irq_lines = 0;
646 int i, mask;
647 struct sigaction sa;
648
649 sa.sa_handler = rs_probe;
650 sa.sa_flags = (SA_INTERRUPT);
651 sa.sa_mask = 0;
652 sa.sa_restorer = NULL;
653
654 for (i = 0, mask = 1; i < 16; i++, mask <<= 1) {
655 if (!(mask & dontgrab) && !irqaction(i, &sa)) {
656 irq_lines |= mask;
657 }
658 }
659 return irq_lines;
660 }
661
662
663
664
665 static void free_all_interrupts(int irq_lines)
666 {
667 int i;
668
669 for (i = 0; i < 16; i++) {
670 if (irq_lines & (1 << i))
671 free_irq(i);
672 }
673 }
674
675
676
677
678
679
680 static void figure_IRQ_timeout(int irq)
681 {
682 struct async_struct *info;
683 int timeout = 6000;
684
685 info = IRQ_ports[irq];
686 if (!info) {
687 IRQ_timeout[irq] = 6000;
688 return;
689 }
690 while (info) {
691 if (info->timeout < timeout)
692 timeout = info->timeout;
693 info = info->next_port;
694 }
695 if (!irq)
696 timeout = timeout / 2;
697 IRQ_timeout[irq] = timeout ? timeout : 1;
698 }
699
700 static int startup(struct async_struct * info, int get_irq)
701 {
702 unsigned short ICP;
703 unsigned long flags;
704 struct sigaction sa;
705 int retval;
706
707 if (info->flags & ASYNC_INITIALIZED)
708 return 0;
709
710 if (!info->port || !info->type) {
711 if (info->tty)
712 set_bit(TTY_IO_ERROR, &info->tty->flags);
713 return 0;
714 }
715
716 save_flags(flags); cli();
717
718 #ifdef SERIAL_DEBUG_OPEN
719 printk("starting up ttys%d (irq %d)...", info->line, info->irq);
720 #endif
721
722
723
724
725 if (get_irq && info->irq && !IRQ_ports[info->irq]) {
726 sa.sa_handler = rs_interrupt;
727 sa.sa_flags = (SA_INTERRUPT);
728 sa.sa_mask = 0;
729 sa.sa_restorer = NULL;
730 retval = irqaction(info->irq,&sa);
731 if (retval) {
732 restore_flags(flags);
733 return retval;
734 }
735 }
736
737
738
739
740
741 if (info->type == PORT_16550A) {
742 serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
743 UART_FCR_CLEAR_XMIT));
744 info->xmit_fifo_size = 16;
745 } else
746 info->xmit_fifo_size = 1;
747
748
749
750
751 (void)serial_inp(info, UART_LSR);
752 (void)serial_inp(info, UART_RX);
753 (void)serial_inp(info, UART_IIR);
754 (void)serial_inp(info, UART_MSR);
755
756
757
758
759 serial_outp(info, UART_LCR, UART_LCR_WLEN8);
760 if (info->flags & ASYNC_FOURPORT)
761 serial_outp(info, UART_MCR, UART_MCR_DTR | UART_MCR_RTS);
762 else
763 serial_outp(info, UART_MCR,
764 UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
765
766
767
768
769 #ifdef ISR_HACK
770 info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
771 serial_outp(info, UART_IER, info->IER);
772 #else
773 info->IER = (UART_IER_MSI | UART_IER_RLSI |
774 UART_IER_THRI | UART_IER_RDI);
775 serial_outp(info, UART_IER, info->IER);
776 #endif
777 if (info->flags & ASYNC_FOURPORT) {
778
779 ICP = (info->port & 0xFE0) | 0x01F;
780 outb_p(0x80, ICP);
781 (void) inb_p(ICP);
782 }
783
784
785
786
787 (void)serial_inp(info, UART_LSR);
788 (void)serial_inp(info, UART_RX);
789 (void)serial_inp(info, UART_IIR);
790 (void)serial_inp(info, UART_MSR);
791
792 if (info->tty)
793 clear_bit(TTY_IO_ERROR, &info->tty->flags);
794
795
796
797 if (info->tty && info->tty->termios && I_INPCK(info->tty))
798 info->read_status_mask = (UART_LSR_OE | UART_LSR_BI |
799 UART_LSR_FE | UART_LSR_PE);
800 else
801 info->read_status_mask = (UART_LSR_OE | UART_LSR_BI |
802 UART_LSR_FE);
803
804
805
806
807 info->prev_port = 0;
808 info->next_port = IRQ_ports[info->irq];
809 if (info->next_port)
810 info->next_port->prev_port = info;
811 IRQ_ports[info->irq] = info;
812 figure_IRQ_timeout(info->irq);
813
814
815
816
817 IRQ_active |= 1 << info->irq;
818 figure_RS_timer();
819
820
821
822
823 change_speed(info->line);
824
825 info->flags |= ASYNC_INITIALIZED;
826 restore_flags(flags);
827 return 0;
828 }
829
830
831
832
833
834 static void shutdown(struct async_struct * info, int do_free_irq)
835 {
836 unsigned long flags;
837
838 if (!(info->flags & ASYNC_INITIALIZED))
839 return;
840
841 #ifdef SERIAL_DEBUG_OPEN
842 printk("Shutting down serial port %d (irq %d)....", info->line,
843 info->irq);
844 #endif
845
846 save_flags(flags); cli();
847
848
849
850
851 if (info->next_port)
852 info->next_port->prev_port = info->prev_port;
853 if (info->prev_port)
854 info->prev_port->next_port = info->next_port;
855 else
856 IRQ_ports[info->irq] = info->next_port;
857 figure_IRQ_timeout(info->irq);
858
859
860
861
862 if (do_free_irq && info->irq && !IRQ_ports[info->irq])
863 free_irq(info->irq);
864
865 info->IER = 0;
866 serial_outp(info, UART_IER, 0x00);
867 if (info->flags & ASYNC_FOURPORT) {
868
869 (void) inb((info->port & 0xFE0) | 0x01F);
870 }
871 if (info->tty && !(info->tty->termios->c_cflag & HUPCL))
872 serial_outp(info, UART_MCR, UART_MCR_DTR);
873 else
874
875 serial_outp(info, UART_MCR, 0x00);
876
877
878 serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
879 UART_FCR_CLEAR_XMIT));
880 (void)serial_in(info, UART_RX);
881
882 if (info->tty)
883 set_bit(TTY_IO_ERROR, &info->tty->flags);
884
885 info->flags &= ~ASYNC_INITIALIZED;
886 restore_flags(flags);
887 }
888
889
890
891
892
893 static void change_speed(unsigned int line)
894 {
895 struct async_struct * info;
896 unsigned short port;
897 int quot = 0;
898 unsigned cflag,cval,mcr,fcr;
899 int i;
900
901 if (line >= NR_PORTS)
902 return;
903 info = rs_table + line;
904 if (!info->tty || !info->tty->termios)
905 return;
906 cflag = info->tty->termios->c_cflag;
907 if (!(port = info->port))
908 return;
909 i = cflag & CBAUD;
910 if (i == 15) {
911 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
912 i += 1;
913 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
914 i += 2;
915 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
916 quot = info->custom_divisor;
917 }
918 if (quot) {
919 info->timeout = ((info->xmit_fifo_size*HZ*15*quot) /
920 info->baud_base) + 2;
921 } else if (baud_table[i] == 134) {
922 quot = (2*info->baud_base / 269);
923 info->timeout = (info->xmit_fifo_size*HZ*30/269) + 2;
924 } else if (baud_table[i]) {
925 quot = info->baud_base / baud_table[i];
926 info->timeout = (info->xmit_fifo_size*HZ*15/baud_table[i]) + 2;
927 } else {
928 quot = 0;
929 info->timeout = 0;
930 }
931 cli();
932 mcr = serial_in(info, UART_MCR);
933 if (quot) {
934 serial_out(info, UART_MCR, mcr | UART_MCR_DTR);
935 } else {
936 serial_out(info, UART_MCR, mcr & ~UART_MCR_DTR);
937 sti();
938 return;
939 }
940 sti();
941
942 cval = cflag & (CSIZE | CSTOPB);
943 cval >>= 4;
944 if (cflag & PARENB)
945 cval |= UART_LCR_PARITY;
946 if (!(cflag & PARODD))
947 cval |= UART_LCR_EPAR;
948 if (info->type == PORT_16550A) {
949 if ((info->baud_base / quot) < 2400)
950 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
951 else
952 fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_8;
953 } else
954 fcr = 0;
955
956 cli();
957 serial_outp(info, UART_LCR, cval | UART_LCR_DLAB);
958 serial_outp(info, UART_DLL, quot & 0xff);
959 serial_outp(info, UART_DLM, quot >> 8);
960 serial_outp(info, UART_LCR, cval);
961 serial_outp(info, UART_FCR, fcr);
962 sti();
963 }
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978 static inline void restart_port(struct async_struct *info)
979 {
980 struct tty_queue * queue;
981 int head, tail, count;
982
983 if (!info)
984 return;
985
986 if (serial_inp(info, UART_LSR) & UART_LSR_THRE) {
987 if (info->x_char) {
988 serial_outp(info, UART_TX, info->x_char);
989 info->x_char = 0;
990 } else {
991 queue = &info->tty->write_q;
992 head = queue->head;
993 tail = queue->tail;
994 count = info->xmit_fifo_size;
995 while (count--) {
996 if (tail == head)
997 break;
998 serial_outp(info, UART_TX, queue->buf[tail++]);
999 tail &= TTY_BUF_SIZE-1;
1000 }
1001 queue->tail = tail;
1002 }
1003 }
1004 }
1005
1006
1007
1008
1009
1010 void rs_write(struct tty_struct * tty)
1011 {
1012 struct async_struct *info;
1013
1014 if (!tty || tty->stopped || tty->hw_stopped)
1015 return;
1016 info = rs_table + DEV_TO_SL(tty->line);
1017 cli();
1018 if (!info || !info->tty || !(info->flags & ASYNC_INITIALIZED)) {
1019 sti();
1020 return;
1021 }
1022 restart_port(info);
1023 info->IER = (UART_IER_MSI | UART_IER_RLSI |
1024 UART_IER_THRI | UART_IER_RDI);
1025 #ifdef ISR_HACK
1026 serial_out(info, UART_IER, info->IER);
1027 #endif
1028 sti();
1029 }
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040 static void rs_throttle(struct tty_struct * tty, int status)
1041 {
1042 struct async_struct *info;
1043 unsigned char mcr;
1044 unsigned long flags;
1045
1046 save_flags(flags); cli();
1047 #if SERIAL_DEBUG_THROTTLE
1048 printk("throttle tty%d: %d (%d, %d)....\n", DEV_TO_SL(tty->line),
1049 status, LEFT(&tty->read_q), LEFT(&tty->secondary));
1050 #endif
1051 switch (status) {
1052 case TTY_THROTTLE_RQ_FULL:
1053 info = rs_table + DEV_TO_SL(tty->line);
1054 if (I_IXOFF(tty)) {
1055 info->x_char = STOP_CHAR(tty);
1056 } else {
1057 mcr = serial_inp(info, UART_MCR);
1058 mcr &= ~UART_MCR_RTS;
1059 serial_out(info, UART_MCR, mcr);
1060 }
1061 break;
1062 case TTY_THROTTLE_RQ_AVAIL:
1063 info = rs_table + DEV_TO_SL(tty->line);
1064 if (I_IXOFF(tty)) {
1065 if (info->x_char)
1066 info->x_char = 0;
1067 else
1068 info->x_char = START_CHAR(tty);
1069 } else {
1070 mcr = serial_in(info, UART_MCR);
1071 mcr |= UART_MCR_RTS;
1072 serial_out(info, UART_MCR, mcr);
1073 }
1074 break;
1075 }
1076 restore_flags(flags);
1077 }
1078
1079
1080
1081
1082
1083
1084
1085 static int get_serial_info(struct async_struct * info,
1086 struct serial_struct * retinfo)
1087 {
1088 struct serial_struct tmp;
1089
1090 if (!retinfo)
1091 return -EFAULT;
1092 memset(&tmp, 0, sizeof(tmp));
1093 tmp.type = info->type;
1094 tmp.line = info->line;
1095 tmp.port = info->port;
1096 tmp.irq = info->irq;
1097 tmp.flags = info->flags;
1098 tmp.baud_base = info->baud_base;
1099 tmp.close_delay = info->close_delay;
1100 tmp.custom_divisor = info->custom_divisor;
1101 tmp.hub6 = info->hub6;
1102 memcpy_tofs(retinfo,&tmp,sizeof(*retinfo));
1103 return 0;
1104 }
1105
1106 static int set_serial_info(struct async_struct * info,
1107 struct serial_struct * new_info)
1108 {
1109 struct serial_struct new_serial;
1110 struct async_struct old_info;
1111 unsigned int i,change_irq,change_port;
1112 int retval;
1113 struct sigaction sa;
1114
1115 if (!new_info)
1116 return -EFAULT;
1117 memcpy_fromfs(&new_serial,new_info,sizeof(new_serial));
1118 old_info = *info;
1119
1120 change_irq = new_serial.irq != info->irq;
1121 change_port = (new_serial.port != info->port) || (new_serial.hub6 != info->hub6);
1122
1123 if (!suser()) {
1124 if (change_irq || change_port ||
1125 (new_serial.baud_base != info->baud_base) ||
1126 (new_serial.type != info->type) ||
1127 (new_serial.close_delay != info->close_delay) ||
1128 ((new_serial.flags & ~ASYNC_USR_MASK) !=
1129 (info->flags & ~ASYNC_USR_MASK)))
1130 return -EPERM;
1131 info->flags = ((info->flags & ~ASYNC_USR_MASK) |
1132 (new_serial.flags & ASYNC_USR_MASK));
1133 info->custom_divisor = new_serial.custom_divisor;
1134 goto check_and_exit;
1135 }
1136
1137 if (new_serial.irq == 2)
1138 new_serial.irq = 9;
1139
1140 if ((new_serial.irq > 15) || (new_serial.port > 0xffff) ||
1141 (new_serial.type < PORT_UNKNOWN) || (new_serial.type > PORT_MAX)) {
1142 return -EINVAL;
1143 }
1144
1145
1146 for (i = 0 ; i < NR_PORTS; i++)
1147 if ((info != &rs_table[i]) &&
1148 (rs_table[i].port == new_serial.port) && rs_table[i].type)
1149 return -EADDRINUSE;
1150
1151
1152
1153
1154
1155
1156 if (new_serial.port && new_serial.type && new_serial.irq &&
1157 (change_irq || !(info->flags & ASYNC_INITIALIZED))) {
1158 if (!IRQ_ports[new_serial.irq]) {
1159 sa.sa_handler = rs_interrupt;
1160 sa.sa_flags = (SA_INTERRUPT);
1161 sa.sa_mask = 0;
1162 sa.sa_restorer = NULL;
1163 retval = irqaction(new_serial.irq,&sa);
1164 if (retval)
1165 return retval;
1166 }
1167 }
1168
1169 if ((change_port || change_irq) && (info->count > 1))
1170 return -EBUSY;
1171
1172
1173
1174
1175
1176
1177 info->baud_base = new_serial.baud_base;
1178 info->flags = ((info->flags & ~ASYNC_FLAGS) |
1179 (new_serial.flags & ASYNC_FLAGS));
1180 info->custom_divisor = new_serial.custom_divisor;
1181 info->type = new_serial.type;
1182 info->close_delay = new_serial.close_delay;
1183
1184 if (change_port || change_irq) {
1185
1186
1187
1188
1189 shutdown(info, change_irq);
1190 info->irq = new_serial.irq;
1191 info->port = new_serial.port;
1192 info->hub6 = new_serial.hub6;
1193 }
1194
1195 check_and_exit:
1196 if (!info->port || !info->type)
1197 return 0;
1198 if (info->flags & ASYNC_INITIALIZED) {
1199 if (((old_info.flags & ASYNC_SPD_MASK) !=
1200 (info->flags & ASYNC_SPD_MASK)) ||
1201 (old_info.custom_divisor != info->custom_divisor))
1202 change_speed(info->line);
1203 } else
1204 (void) startup(info, 0);
1205 return 0;
1206 }
1207
1208 static int get_modem_info(struct async_struct * info, unsigned int *value)
1209 {
1210 unsigned char control, status;
1211 unsigned int result;
1212
1213 cli();
1214 control = serial_in(info, UART_MCR);
1215 status = serial_in(info, UART_MSR);
1216 sti();
1217 result = ((control & UART_MCR_RTS) ? TIOCM_RTS : 0)
1218 | ((control & UART_MCR_DTR) ? TIOCM_DTR : 0)
1219 | ((status & UART_MSR_DCD) ? TIOCM_CAR : 0)
1220 | ((status & UART_MSR_RI) ? TIOCM_RNG : 0)
1221 | ((status & UART_MSR_DSR) ? TIOCM_DSR : 0)
1222 | ((status & UART_MSR_CTS) ? TIOCM_CTS : 0);
1223 put_fs_long(result,(unsigned long *) value);
1224 return 0;
1225 }
1226
1227 static int set_modem_info(struct async_struct * info, unsigned int cmd,
1228 unsigned int *value)
1229 {
1230 unsigned char control;
1231 unsigned int arg = get_fs_long((unsigned long *) value);
1232
1233 cli();
1234 control = serial_in(info, UART_MCR);
1235 sti();
1236
1237 switch (cmd) {
1238 case TIOCMBIS:
1239 if (arg & TIOCM_RTS)
1240 control |= UART_MCR_RTS;
1241 if (arg & TIOCM_DTR)
1242 control |= UART_MCR_DTR;
1243 break;
1244 case TIOCMBIC:
1245 if (arg & TIOCM_RTS)
1246 control &= ~UART_MCR_RTS;
1247 if (arg & TIOCM_DTR)
1248 control &= ~UART_MCR_DTR;
1249 break;
1250 case TIOCMSET:
1251 control = (control & ~(UART_MCR_RTS | UART_MCR_DTR))
1252 | ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0)
1253 | ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0);
1254 break;
1255 default:
1256 return -EINVAL;
1257 }
1258 cli();
1259 serial_out(info, UART_MCR, control);
1260 sti();
1261 return 0;
1262 }
1263
1264 static int do_autoconfig(struct async_struct * info)
1265 {
1266 int retval;
1267
1268 if (!suser())
1269 return -EPERM;
1270
1271 if (info->count > 1)
1272 return -EBUSY;
1273
1274 shutdown(info, 1);
1275
1276 cli();
1277 autoconfig(info);
1278 sti();
1279
1280 retval = startup(info, 1);
1281 if (retval)
1282 return retval;
1283 return 0;
1284 }
1285
1286
1287
1288
1289
1290 static void send_break( struct async_struct * info, int duration)
1291 {
1292 if (!info->port)
1293 return;
1294 current->state = TASK_INTERRUPTIBLE;
1295 current->timeout = jiffies + duration;
1296 cli();
1297 serial_out(info, UART_LCR, serial_inp(info, UART_LCR) | UART_LCR_SBC);
1298 schedule();
1299 serial_out(info, UART_LCR, serial_inp(info, UART_LCR) & ~UART_LCR_SBC);
1300 sti();
1301 }
1302
1303
1304
1305
1306
1307 static int check_wild_interrupts(int doprint)
1308 {
1309 int i, mask;
1310 int wild_interrupts = 0;
1311 int irq_lines;
1312 unsigned long timeout;
1313 unsigned long flags;
1314
1315
1316 save_flags(flags); sti();
1317
1318 irq_lines = grab_all_interrupts(0);
1319
1320
1321
1322
1323
1324 timeout = jiffies+10;
1325 while (timeout >= jiffies)
1326 ;
1327
1328 rs_triggered = 0;
1329
1330 timeout = jiffies+10;
1331 while (timeout >= jiffies)
1332 ;
1333
1334 for (i = 0, mask = 1; i < 16; i++, mask <<= 1) {
1335 if ((rs_triggered & (1 << i)) &&
1336 (irq_lines & (1 << i))) {
1337 wild_interrupts |= mask;
1338 if (doprint)
1339 printk("Wild interrupt? (IRQ %d)\n", i);
1340 }
1341 }
1342 free_all_interrupts(irq_lines);
1343 restore_flags(flags);
1344 return wild_interrupts;
1345 }
1346
1347 static int rs_ioctl(struct tty_struct *tty, struct file * file,
1348 unsigned int cmd, unsigned long arg)
1349 {
1350 int error, line;
1351 struct async_struct * info;
1352
1353 line = DEV_TO_SL(tty->line);
1354 if (line < 0 || line >= NR_PORTS)
1355 return -ENODEV;
1356 info = rs_table + line;
1357
1358 switch (cmd) {
1359 case TCSBRK:
1360 if (!arg)
1361 send_break(info, HZ/4);
1362 return 0;
1363 case TCSBRKP:
1364 send_break(info, arg ? arg*(HZ/10) : HZ/4);
1365 return 0;
1366 case TIOCGSOFTCAR:
1367 error = verify_area(VERIFY_WRITE, (void *) arg,sizeof(long));
1368 if (error)
1369 return error;
1370 put_fs_long(C_CLOCAL(tty) ? 1 : 0,
1371 (unsigned long *) arg);
1372 return 0;
1373 case TIOCSSOFTCAR:
1374 arg = get_fs_long((unsigned long *) arg);
1375 tty->termios->c_cflag =
1376 ((tty->termios->c_cflag & ~CLOCAL) |
1377 (arg ? CLOCAL : 0));
1378 return 0;
1379 case TIOCMGET:
1380 error = verify_area(VERIFY_WRITE, (void *) arg,
1381 sizeof(unsigned int));
1382 if (error)
1383 return error;
1384 return get_modem_info(info, (unsigned int *) arg);
1385 case TIOCMBIS:
1386 case TIOCMBIC:
1387 case TIOCMSET:
1388 return set_modem_info(info, cmd, (unsigned int *) arg);
1389 case TIOCGSERIAL:
1390 error = verify_area(VERIFY_WRITE, (void *) arg,
1391 sizeof(struct serial_struct));
1392 if (error)
1393 return error;
1394 return get_serial_info(info,
1395 (struct serial_struct *) arg);
1396 case TIOCSSERIAL:
1397 return set_serial_info(info,
1398 (struct serial_struct *) arg);
1399 case TIOCSERCONFIG:
1400 return do_autoconfig(info);
1401
1402 case TIOCSERGWILD:
1403 error = verify_area(VERIFY_WRITE, (void *) arg,
1404 sizeof(int));
1405 if (error)
1406 return error;
1407 put_fs_long(rs_wild_int_mask, (unsigned long *) arg);
1408 return 0;
1409
1410 case TIOCSERSWILD:
1411 if (!suser())
1412 return -EPERM;
1413 rs_wild_int_mask = get_fs_long((unsigned long *) arg);
1414 if (rs_wild_int_mask < 0)
1415 rs_wild_int_mask = check_wild_interrupts(0);
1416 return 0;
1417
1418 default:
1419 return -EINVAL;
1420 }
1421 return 0;
1422 }
1423
1424 static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios)
1425 {
1426 struct async_struct *info;
1427
1428 if (tty->termios->c_cflag == old_termios->c_cflag)
1429 return;
1430
1431 info = &rs_table[DEV_TO_SL(tty->line)];
1432
1433 change_speed(DEV_TO_SL(tty->line));
1434
1435 if ((old_termios->c_cflag & CRTSCTS) &&
1436 !(tty->termios->c_cflag & CRTSCTS)) {
1437 tty->hw_stopped = 0;
1438 rs_write(tty);
1439 }
1440
1441 if (!(old_termios->c_cflag & CLOCAL) &&
1442 (tty->termios->c_cflag & CLOCAL))
1443 wake_up_interruptible(&info->open_wait);
1444
1445 if (I_INPCK(tty))
1446 info->read_status_mask = (UART_LSR_OE | UART_LSR_BI |
1447 UART_LSR_FE | UART_LSR_PE);
1448 else
1449 info->read_status_mask = (UART_LSR_OE | UART_LSR_BI |
1450 UART_LSR_FE);
1451 }
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463 static void rs_close(struct tty_struct *tty, struct file * filp)
1464 {
1465 struct async_struct * info;
1466 int line;
1467
1468 if (tty_hung_up_p(filp))
1469 return;
1470
1471 line = DEV_TO_SL(tty->line);
1472 if ((line < 0) || (line >= NR_PORTS))
1473 return;
1474 info = rs_table + line;
1475 #ifdef SERIAL_DEBUG_OPEN
1476 printk("rs_close ttys%d, count = %d\n", info->line, info->count);
1477 #endif
1478 if ((tty->count == 1) && (info->count != 1)) {
1479
1480
1481
1482
1483
1484
1485
1486 printk("rs_close: bad serial port count; tty->count is 1, "
1487 "info->count is %d\n", info->count);
1488 info->count = 1;
1489 }
1490 if (--info->count < 0) {
1491 printk("rs_close: bad serial port count for ttys%d: %d\n",
1492 info->line, info->count);
1493 info->count = 0;
1494 }
1495 if (info->count)
1496 return;
1497 info->flags |= ASYNC_CLOSING;
1498
1499
1500
1501
1502 if (info->flags & ASYNC_NORMAL_ACTIVE)
1503 info->normal_termios = *tty->termios;
1504 if (info->flags & ASYNC_CALLOUT_ACTIVE)
1505 info->callout_termios = *tty->termios;
1506 tty->stopped = 0;
1507 tty->hw_stopped = 0;
1508 if (info->flags & ASYNC_INITIALIZED) {
1509 rs_start(tty);
1510 wait_until_sent(tty, 6000);
1511 } else
1512 flush_output(tty);
1513 flush_input(tty);
1514 cli();
1515
1516
1517
1518
1519 if (!(serial_inp(info, UART_LSR) & UART_LSR_THRE)) {
1520 rs_start(tty);
1521 interruptible_sleep_on(&info->xmit_wait);
1522 }
1523 sti();
1524 shutdown(info, 1);
1525 clear_bit(line, rs_event);
1526 info->event = 0;
1527 info->tty = 0;
1528 if (info->blocked_open) {
1529 if (info->close_delay) {
1530 tty->count++;
1531 current->state = TASK_INTERRUPTIBLE;
1532 current->timeout = jiffies + info->close_delay;
1533 schedule();
1534 tty->count--;
1535 }
1536 wake_up_interruptible(&info->open_wait);
1537 }
1538 info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
1539 ASYNC_CLOSING);
1540 wake_up_interruptible(&info->close_wait);
1541 }
1542
1543
1544
1545
1546 void rs_hangup(struct tty_struct *tty)
1547 {
1548 struct async_struct * info;
1549 int line;
1550
1551 line = DEV_TO_SL(tty->line);
1552 if ((line < 0) || (line >= NR_PORTS))
1553 return;
1554 info = rs_table + line;
1555
1556 shutdown(info, 1);
1557 clear_bit(line, rs_event);
1558 info->event = 0;
1559 info->count = 0;
1560 info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
1561 info->tty = 0;
1562 wake_up_interruptible(&info->open_wait);
1563 }
1564
1565
1566
1567
1568
1569
1570 static int block_til_ready(struct tty_struct *tty, struct file * filp,
1571 struct async_struct *info)
1572 {
1573 struct wait_queue wait = { current, NULL };
1574 int retval;
1575 int do_clocal = C_CLOCAL(tty);
1576
1577
1578
1579
1580
1581 if (info->flags & ASYNC_CLOSING) {
1582 interruptible_sleep_on(&info->close_wait);
1583 #ifdef SERIAL_DO_RESTART
1584 if (info->flags & ASYNC_HUP_NOTIFY)
1585 return -EAGAIN;
1586 else
1587 return -ERESTARTSYS;
1588 #else
1589 return -EAGAIN;
1590 #endif
1591 }
1592
1593
1594
1595
1596
1597 if (MAJOR(filp->f_rdev) == TTYAUX_MAJOR) {
1598 if (info->flags & ASYNC_NORMAL_ACTIVE)
1599 return -EBUSY;
1600 if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
1601 (info->flags & ASYNC_SESSION_LOCKOUT) &&
1602 (info->session != current->session))
1603 return -EBUSY;
1604 if ((info->flags & ASYNC_CALLOUT_ACTIVE) &&
1605 (info->flags & ASYNC_PGRP_LOCKOUT) &&
1606 (info->pgrp != current->pgrp))
1607 return -EBUSY;
1608 info->flags |= ASYNC_CALLOUT_ACTIVE;
1609 return 0;
1610 }
1611
1612
1613
1614
1615
1616 if (filp->f_flags & O_NONBLOCK) {
1617 if (info->flags & ASYNC_CALLOUT_ACTIVE)
1618 return -EBUSY;
1619 info->flags |= ASYNC_NORMAL_ACTIVE;
1620 return 0;
1621 }
1622
1623
1624
1625
1626
1627
1628
1629
1630 retval = 0;
1631 add_wait_queue(&info->open_wait, &wait);
1632 #ifdef SERIAL_DEBUG_OPEN
1633 printk("block_til_ready before block: ttys%d, count = %d\n",
1634 info->line, info->count);
1635 #endif
1636 info->count--;
1637 info->blocked_open++;
1638 while (1) {
1639 cli();
1640 if (!(info->flags & ASYNC_CALLOUT_ACTIVE))
1641 serial_out(info, UART_MCR,
1642 serial_inp(info, UART_MCR) |
1643 (UART_MCR_DTR | UART_MCR_RTS));
1644 sti();
1645 current->state = TASK_INTERRUPTIBLE;
1646 if (tty_hung_up_p(filp) ||
1647 !(info->flags & ASYNC_INITIALIZED)) {
1648 #ifdef SERIAL_DO_RESTART
1649 if (info->flags & ASYNC_HUP_NOTIFY)
1650 retval = -EAGAIN;
1651 else
1652 retval = -ERESTARTSYS;
1653 #else
1654 retval = -EAGAIN;
1655 #endif
1656 break;
1657 }
1658 if (!(info->flags & ASYNC_CALLOUT_ACTIVE) &&
1659 !(info->flags & ASYNC_CLOSING) &&
1660 (do_clocal || (serial_in(info, UART_MSR) &
1661 UART_MSR_DCD)))
1662 break;
1663 if (current->signal & ~current->blocked) {
1664 retval = -ERESTARTSYS;
1665 break;
1666 }
1667 #ifdef SERIAL_DEBUG_OPEN
1668 printk("block_til_ready blocking: ttys%d, count = %d\n",
1669 info->line, info->count);
1670 #endif
1671 schedule();
1672 }
1673 current->state = TASK_RUNNING;
1674 remove_wait_queue(&info->open_wait, &wait);
1675 if (!tty_hung_up_p(filp))
1676 info->count++;
1677 info->blocked_open--;
1678 #ifdef SERIAL_DEBUG_OPEN
1679 printk("block_til_ready after blocking: ttys%d, count = %d\n",
1680 info->line, info->count);
1681 #endif
1682 if (retval)
1683 return retval;
1684 info->flags |= ASYNC_NORMAL_ACTIVE;
1685 return 0;
1686 }
1687
1688
1689
1690
1691
1692
1693
1694 int rs_open(struct tty_struct *tty, struct file * filp)
1695 {
1696 struct async_struct *info;
1697 int retval, line;
1698
1699 line = DEV_TO_SL(tty->line);
1700 if ((line < 0) || (line >= NR_PORTS))
1701 return -ENODEV;
1702 info = rs_table + line;
1703 #ifdef SERIAL_DEBUG_OPEN
1704 printk("rs_open ttys%d, count = %d\n", info->line, info->count);
1705 #endif
1706 info->count++;
1707 info->tty = tty;
1708
1709 tty->write = rs_write;
1710 tty->close = rs_close;
1711 tty->ioctl = rs_ioctl;
1712 tty->throttle = rs_throttle;
1713 tty->set_termios = rs_set_termios;
1714 tty->stop = rs_stop;
1715 tty->start = rs_start;
1716 tty->hangup = rs_hangup;
1717 if ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
1718 if (MAJOR(filp->f_rdev) == TTY_MAJOR)
1719 *tty->termios = info->normal_termios;
1720 else
1721 *tty->termios = info->callout_termios;
1722 }
1723
1724
1725
1726 retval = startup(info, 1);
1727 if (retval)
1728 return retval;
1729
1730 retval = block_til_ready(tty, filp, info);
1731 if (retval) {
1732 #ifdef SERIAL_DEBUG_OPEN
1733 printk("rs_open returning after block_til_ready with %d\n",
1734 retval);
1735 #endif
1736 return retval;
1737 }
1738
1739 info->session = current->session;
1740 info->pgrp = current->pgrp;
1741
1742 #ifdef SERIAL_DEBUG_OPEN
1743 printk("rs_open ttys%d successful...", info->line);
1744 #endif
1745 return 0;
1746 }
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761 static void show_serial_version(void)
1762 {
1763 printk("Serial driver version 3.99a with");
1764 #ifdef CONFIG_AST_FOURPORT
1765 printk(" AST_FOURPORT");
1766 #define SERIAL_OPT
1767 #endif
1768 #ifdef CONFIG_ACCENT_ASYNC
1769 printk(" ACCENT_ASYNC");
1770 #define SERIAL_OPT
1771 #endif
1772 #ifdef CONFIG_HUB6
1773 printk(" HUB-6");
1774 #define SERIAL_OPT
1775 #endif
1776 #ifdef CONFIG_AUTO_IRQ
1777 printk (" AUTO_IRQ");
1778 #define SERIAL_OPT
1779 #endif
1780 #ifdef SERIAL_OPT
1781 printk(" enabled\n");
1782 #else
1783 printk(" no serial options enabled\n");
1784 #endif
1785 #undef SERIAL_OPT
1786 }
1787
1788
1789
1790
1791
1792
1793 static int get_auto_irq(struct async_struct *info)
1794 {
1795 unsigned char save_MCR, save_IER, save_ICP=0;
1796 unsigned short ICP=0, port = info->port;
1797 unsigned long timeout;
1798
1799
1800
1801
1802 rs_irq_triggered = 0;
1803 cli();
1804 save_IER = serial_inp(info, UART_IER);
1805 save_MCR = serial_inp(info, UART_MCR);
1806 if (info->flags & ASYNC_FOURPORT) {
1807 serial_outp(info, UART_MCR, UART_MCR_DTR | UART_MCR_RTS);
1808 serial_outp(info, UART_IER, 0x0f);
1809 ICP = (port & 0xFE0) | 0x01F;
1810 save_ICP = inb_p(ICP);
1811 outb_p(0x80, ICP);
1812 (void) inb_p(ICP);
1813 } else {
1814 serial_outp(info, UART_MCR,
1815 UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
1816 serial_outp(info, UART_IER, 0x0f);
1817 }
1818 sti();
1819
1820
1821
1822 (void)serial_inp(info, UART_LSR);
1823 (void)serial_inp(info, UART_RX);
1824 (void)serial_inp(info, UART_IIR);
1825 (void)serial_inp(info, UART_MSR);
1826
1827 timeout = jiffies+2;
1828 while (timeout >= jiffies) {
1829 if (rs_irq_triggered)
1830 break;
1831 }
1832
1833
1834
1835 cli();
1836 serial_outp(info, UART_IER, save_IER);
1837 serial_outp(info, UART_MCR, save_MCR);
1838 if (info->flags & ASYNC_FOURPORT)
1839 outb_p(save_ICP, ICP);
1840 sti();
1841 return(rs_irq_triggered);
1842 }
1843
1844
1845
1846
1847
1848 static int do_auto_irq(struct async_struct * info)
1849 {
1850 unsigned port = info->port;
1851 int irq_lines = 0;
1852 int irq_try_1 = 0, irq_try_2 = 0;
1853 int retries;
1854 unsigned long flags;
1855
1856 if (!port)
1857 return 0;
1858
1859
1860 save_flags(flags); sti();
1861
1862 irq_lines = grab_all_interrupts(rs_wild_int_mask);
1863
1864 for (retries = 0; retries < 5; retries++) {
1865 if (!irq_try_1)
1866 irq_try_1 = get_auto_irq(info);
1867 if (!irq_try_2)
1868 irq_try_2 = get_auto_irq(info);
1869 if (irq_try_1 && irq_try_2) {
1870 if (irq_try_1 == irq_try_2)
1871 break;
1872 irq_try_1 = irq_try_2 = 0;
1873 }
1874 }
1875 restore_flags(flags);
1876 free_all_interrupts(irq_lines);
1877 return (irq_try_1 == irq_try_2) ? irq_try_1 : 0;
1878 }
1879
1880
1881
1882
1883
1884
1885
1886
1887 static void autoconfig(struct async_struct * info)
1888 {
1889 unsigned char status1, status2, scratch, scratch2;
1890 unsigned port = info->port;
1891 unsigned long flags;
1892
1893 info->type = PORT_UNKNOWN;
1894
1895 if (!port)
1896 return;
1897
1898 save_flags(flags); cli();
1899
1900
1901
1902
1903
1904 scratch = serial_inp(info, UART_IER);
1905 serial_outp(info, UART_IER, 0);
1906 scratch2 = serial_inp(info, UART_IER);
1907 serial_outp(info, UART_IER, scratch);
1908 if (scratch2) {
1909 restore_flags(flags);
1910 return;
1911 }
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922 if (!(info->flags & ASYNC_SKIP_TEST)) {
1923 scratch = serial_inp(info, UART_MCR);
1924 serial_outp(info, UART_MCR, UART_MCR_LOOP | scratch);
1925 scratch2 = serial_inp(info, UART_MSR);
1926 serial_outp(info, UART_MCR, UART_MCR_LOOP | 0x0A);
1927 status1 = serial_inp(info, UART_MSR) & 0xF0;
1928 serial_outp(info, UART_MCR, scratch);
1929 serial_outp(info, UART_MSR, scratch2);
1930 if (status1 != 0x90) {
1931 restore_flags(flags);
1932 return;
1933 }
1934 }
1935
1936
1937
1938
1939
1940 if (info->flags & ASYNC_AUTO_IRQ)
1941 info->irq = do_auto_irq(info);
1942
1943 serial_outp(info, UART_FCR, UART_FCR_ENABLE_FIFO);
1944 scratch = serial_in(info, UART_IIR) >> 6;
1945 info->xmit_fifo_size = 1;
1946 switch (scratch) {
1947 case 0:
1948 info->type = PORT_16450;
1949 break;
1950 case 1:
1951 info->type = PORT_UNKNOWN;
1952 break;
1953 case 2:
1954 info->type = PORT_16550;
1955 break;
1956 case 3:
1957 info->type = PORT_16550A;
1958 info->xmit_fifo_size = 16;
1959 break;
1960 }
1961 if (info->type == PORT_16450) {
1962 scratch = serial_in(info, UART_SCR);
1963 serial_outp(info, UART_SCR, 0xa5);
1964 status1 = serial_in(info, UART_SCR);
1965 serial_outp(info, UART_SCR, 0x5a);
1966 status2 = serial_in(info, UART_SCR);
1967 serial_outp(info, UART_SCR, scratch);
1968
1969 if ((status1 != 0xa5) || (status2 != 0x5a))
1970 info->type = PORT_8250;
1971 }
1972
1973
1974
1975
1976 serial_outp(info, UART_MCR, 0x00);
1977 serial_outp(info, UART_FCR, (UART_FCR_CLEAR_RCVR |
1978 UART_FCR_CLEAR_XMIT));
1979 (void)serial_in(info, UART_RX);
1980
1981 restore_flags(flags);
1982 }
1983
1984
1985
1986
1987 long rs_init(long kmem_start)
1988 {
1989 int i;
1990 struct async_struct * info;
1991
1992 memset(&rs_event, 0, sizeof(rs_event));
1993 bh_base[SERIAL_BH].routine = do_softint;
1994 timer_table[RS_TIMER].fn = rs_timer;
1995 timer_table[RS_TIMER].expires = 0;
1996 IRQ_active = 0;
1997 #ifdef CONFIG_AUTO_IRQ
1998 rs_wild_int_mask = check_wild_interrupts(1);
1999 #endif
2000
2001 for (i = 0; i < 16; i++) {
2002 IRQ_ports[i] = 0;
2003 IRQ_timeout[i] = 0;
2004 }
2005
2006 show_serial_version();
2007 for (i = 0, info = rs_table; i < NR_PORTS; i++,info++) {
2008 info->line = i;
2009 info->tty = 0;
2010 info->type = PORT_UNKNOWN;
2011 info->custom_divisor = 0;
2012 info->close_delay = 50;
2013 info->x_char = 0;
2014 info->event = 0;
2015 info->count = 0;
2016 info->blocked_open = 0;
2017 memset(&info->callout_termios, 0, sizeof(struct termios));
2018 memset(&info->normal_termios, 0, sizeof(struct termios));
2019 info->open_wait = 0;
2020 info->xmit_wait = 0;
2021 info->close_wait = 0;
2022 info->next_port = 0;
2023 info->prev_port = 0;
2024 if (info->irq == 2)
2025 info->irq = 9;
2026 if (!(info->flags & ASYNC_BOOT_AUTOCONF))
2027 continue;
2028 autoconfig(info);
2029 if (info->type == PORT_UNKNOWN)
2030 continue;
2031 printk("tty%02d%s at 0x%04x (irq = %d)", info->line,
2032 (info->flags & ASYNC_FOURPORT) ? " FourPort" : "",
2033 info->port, info->irq);
2034 switch (info->type) {
2035 case PORT_8250:
2036 printk(" is a 8250\n");
2037 break;
2038 case PORT_16450:
2039 printk(" is a 16450\n");
2040 break;
2041 case PORT_16550:
2042 printk(" is a 16550\n");
2043 break;
2044 case PORT_16550A:
2045 printk(" is a 16550A\n");
2046 break;
2047 default:
2048 printk("\n");
2049 break;
2050 }
2051 }
2052 return kmem_start;
2053 }
2054