1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/module.h>
24#include <linux/tty.h>
25#include <linux/tty_flip.h>
26#include <linux/slab.h>
27#include <linux/init.h>
28#include <linux/console.h>
29#include <linux/proc_fs.h>
30#include <linux/seq_file.h>
31#include <linux/device.h>
32#include <linux/serial.h>
33#include <linux/serial_core.h>
34#include <linux/delay.h>
35#include <linux/mutex.h>
36
37#include <asm/irq.h>
38#include <asm/uaccess.h>
39
40
41
42
43static DEFINE_MUTEX(port_mutex);
44
45
46
47
48
49static struct lock_class_key port_lock_key;
50
51#define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8)
52
53#ifdef CONFIG_SERIAL_CORE_CONSOLE
54#define uart_console(port) ((port)->cons && (port)->cons->index == (port)->line)
55#else
56#define uart_console(port) (0)
57#endif
58
59static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
60 struct ktermios *old_termios);
61static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
62static void uart_change_pm(struct uart_state *state,
63 enum uart_pm_state pm_state);
64
65static void uart_port_shutdown(struct tty_port *port);
66
67
68
69
70
71void uart_write_wakeup(struct uart_port *port)
72{
73 struct uart_state *state = port->state;
74
75
76
77
78 BUG_ON(!state);
79 tty_wakeup(state->port.tty);
80}
81
82static void uart_stop(struct tty_struct *tty)
83{
84 struct uart_state *state = tty->driver_data;
85 struct uart_port *port = state->uart_port;
86 unsigned long flags;
87
88 spin_lock_irqsave(&port->lock, flags);
89 port->ops->stop_tx(port);
90 spin_unlock_irqrestore(&port->lock, flags);
91}
92
93static void __uart_start(struct tty_struct *tty)
94{
95 struct uart_state *state = tty->driver_data;
96 struct uart_port *port = state->uart_port;
97
98 if (!uart_circ_empty(&state->xmit) && state->xmit.buf &&
99 !tty->stopped && !tty->hw_stopped)
100 port->ops->start_tx(port);
101}
102
103static void uart_start(struct tty_struct *tty)
104{
105 struct uart_state *state = tty->driver_data;
106 struct uart_port *port = state->uart_port;
107 unsigned long flags;
108
109 spin_lock_irqsave(&port->lock, flags);
110 __uart_start(tty);
111 spin_unlock_irqrestore(&port->lock, flags);
112}
113
114static inline void
115uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
116{
117 unsigned long flags;
118 unsigned int old;
119
120 spin_lock_irqsave(&port->lock, flags);
121 old = port->mctrl;
122 port->mctrl = (old & ~clear) | set;
123 if (old != port->mctrl)
124 port->ops->set_mctrl(port, port->mctrl);
125 spin_unlock_irqrestore(&port->lock, flags);
126}
127
128#define uart_set_mctrl(port, set) uart_update_mctrl(port, set, 0)
129#define uart_clear_mctrl(port, clear) uart_update_mctrl(port, 0, clear)
130
131
132
133
134
135static int uart_port_startup(struct tty_struct *tty, struct uart_state *state,
136 int init_hw)
137{
138 struct uart_port *uport = state->uart_port;
139 struct tty_port *port = &state->port;
140 unsigned long page;
141 int retval = 0;
142
143 if (uport->type == PORT_UNKNOWN)
144 return 1;
145
146
147
148
149
150 if (!state->xmit.buf) {
151
152 page = get_zeroed_page(GFP_KERNEL);
153 if (!page)
154 return -ENOMEM;
155
156 state->xmit.buf = (unsigned char *) page;
157 uart_circ_clear(&state->xmit);
158 }
159
160 retval = uport->ops->startup(uport);
161 if (retval == 0) {
162 if (uart_console(uport) && uport->cons->cflag) {
163 tty->termios.c_cflag = uport->cons->cflag;
164 uport->cons->cflag = 0;
165 }
166
167
168
169 uart_change_speed(tty, state, NULL);
170
171 if (init_hw) {
172
173
174
175
176 if (tty->termios.c_cflag & CBAUD)
177 uart_set_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
178 }
179
180 if (tty_port_cts_enabled(port)) {
181 spin_lock_irq(&uport->lock);
182 if (!(uport->ops->get_mctrl(uport) & TIOCM_CTS))
183 tty->hw_stopped = 1;
184 spin_unlock_irq(&uport->lock);
185 }
186 }
187
188
189
190
191
192
193 if (retval && capable(CAP_SYS_ADMIN))
194 return 1;
195
196 return retval;
197}
198
199static int uart_startup(struct tty_struct *tty, struct uart_state *state,
200 int init_hw)
201{
202 struct tty_port *port = &state->port;
203 int retval;
204
205 if (port->flags & ASYNC_INITIALIZED)
206 return 0;
207
208
209
210
211
212 set_bit(TTY_IO_ERROR, &tty->flags);
213
214 retval = uart_port_startup(tty, state, init_hw);
215 if (!retval) {
216 set_bit(ASYNCB_INITIALIZED, &port->flags);
217 clear_bit(TTY_IO_ERROR, &tty->flags);
218 } else if (retval > 0)
219 retval = 0;
220
221 return retval;
222}
223
224
225
226
227
228
229static void uart_shutdown(struct tty_struct *tty, struct uart_state *state)
230{
231 struct uart_port *uport = state->uart_port;
232 struct tty_port *port = &state->port;
233
234
235
236
237 if (tty)
238 set_bit(TTY_IO_ERROR, &tty->flags);
239
240 if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
241
242
243
244 if (!tty || (tty->termios.c_cflag & HUPCL))
245 uart_clear_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
246
247 uart_port_shutdown(port);
248 }
249
250
251
252
253
254
255 clear_bit(ASYNCB_SUSPENDED, &port->flags);
256
257
258
259
260 if (state->xmit.buf) {
261 free_page((unsigned long)state->xmit.buf);
262 state->xmit.buf = NULL;
263 }
264}
265
266
267
268
269
270
271
272
273
274
275void
276uart_update_timeout(struct uart_port *port, unsigned int cflag,
277 unsigned int baud)
278{
279 unsigned int bits;
280
281
282 switch (cflag & CSIZE) {
283 case CS5:
284 bits = 7;
285 break;
286 case CS6:
287 bits = 8;
288 break;
289 case CS7:
290 bits = 9;
291 break;
292 default:
293 bits = 10;
294 break;
295 }
296
297 if (cflag & CSTOPB)
298 bits++;
299 if (cflag & PARENB)
300 bits++;
301
302
303
304
305 bits = bits * port->fifosize;
306
307
308
309
310
311 port->timeout = (HZ * bits) / baud + HZ/50;
312}
313
314EXPORT_SYMBOL(uart_update_timeout);
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335unsigned int
336uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
337 struct ktermios *old, unsigned int min, unsigned int max)
338{
339 unsigned int try, baud, altbaud = 38400;
340 int hung_up = 0;
341 upf_t flags = port->flags & UPF_SPD_MASK;
342
343 if (flags == UPF_SPD_HI)
344 altbaud = 57600;
345 else if (flags == UPF_SPD_VHI)
346 altbaud = 115200;
347 else if (flags == UPF_SPD_SHI)
348 altbaud = 230400;
349 else if (flags == UPF_SPD_WARP)
350 altbaud = 460800;
351
352 for (try = 0; try < 2; try++) {
353 baud = tty_termios_baud_rate(termios);
354
355
356
357
358
359 if (baud == 38400)
360 baud = altbaud;
361
362
363
364
365 if (baud == 0) {
366 hung_up = 1;
367 baud = 9600;
368 }
369
370 if (baud >= min && baud <= max)
371 return baud;
372
373
374
375
376
377 termios->c_cflag &= ~CBAUD;
378 if (old) {
379 baud = tty_termios_baud_rate(old);
380 if (!hung_up)
381 tty_termios_encode_baud_rate(termios,
382 baud, baud);
383 old = NULL;
384 continue;
385 }
386
387
388
389
390
391 if (!hung_up) {
392 if (baud <= min)
393 tty_termios_encode_baud_rate(termios,
394 min + 1, min + 1);
395 else
396 tty_termios_encode_baud_rate(termios,
397 max - 1, max - 1);
398 }
399 }
400
401 WARN_ON(1);
402 return 0;
403}
404
405EXPORT_SYMBOL(uart_get_baud_rate);
406
407
408
409
410
411
412
413
414unsigned int
415uart_get_divisor(struct uart_port *port, unsigned int baud)
416{
417 unsigned int quot;
418
419
420
421
422 if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)
423 quot = port->custom_divisor;
424 else
425 quot = DIV_ROUND_CLOSEST(port->uartclk, 16 * baud);
426
427 return quot;
428}
429
430EXPORT_SYMBOL(uart_get_divisor);
431
432
433static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
434 struct ktermios *old_termios)
435{
436 struct tty_port *port = &state->port;
437 struct uart_port *uport = state->uart_port;
438 struct ktermios *termios;
439
440
441
442
443
444 if (!tty || uport->type == PORT_UNKNOWN)
445 return;
446
447 termios = &tty->termios;
448
449
450
451
452 if (termios->c_cflag & CRTSCTS)
453 set_bit(ASYNCB_CTS_FLOW, &port->flags);
454 else
455 clear_bit(ASYNCB_CTS_FLOW, &port->flags);
456
457 if (termios->c_cflag & CLOCAL)
458 clear_bit(ASYNCB_CHECK_CD, &port->flags);
459 else
460 set_bit(ASYNCB_CHECK_CD, &port->flags);
461
462 uport->ops->set_termios(uport, termios, old_termios);
463}
464
465static inline int __uart_put_char(struct uart_port *port,
466 struct circ_buf *circ, unsigned char c)
467{
468 unsigned long flags;
469 int ret = 0;
470
471 if (!circ->buf)
472 return 0;
473
474 spin_lock_irqsave(&port->lock, flags);
475 if (uart_circ_chars_free(circ) != 0) {
476 circ->buf[circ->head] = c;
477 circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1);
478 ret = 1;
479 }
480 spin_unlock_irqrestore(&port->lock, flags);
481 return ret;
482}
483
484static int uart_put_char(struct tty_struct *tty, unsigned char ch)
485{
486 struct uart_state *state = tty->driver_data;
487
488 return __uart_put_char(state->uart_port, &state->xmit, ch);
489}
490
491static void uart_flush_chars(struct tty_struct *tty)
492{
493 uart_start(tty);
494}
495
496static int uart_write(struct tty_struct *tty,
497 const unsigned char *buf, int count)
498{
499 struct uart_state *state = tty->driver_data;
500 struct uart_port *port;
501 struct circ_buf *circ;
502 unsigned long flags;
503 int c, ret = 0;
504
505
506
507
508
509 if (!state) {
510 WARN_ON(1);
511 return -EL3HLT;
512 }
513
514 port = state->uart_port;
515 circ = &state->xmit;
516
517 if (!circ->buf)
518 return 0;
519
520 spin_lock_irqsave(&port->lock, flags);
521 while (1) {
522 c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
523 if (count < c)
524 c = count;
525 if (c <= 0)
526 break;
527 memcpy(circ->buf + circ->head, buf, c);
528 circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
529 buf += c;
530 count -= c;
531 ret += c;
532 }
533 spin_unlock_irqrestore(&port->lock, flags);
534
535 uart_start(tty);
536 return ret;
537}
538
539static int uart_write_room(struct tty_struct *tty)
540{
541 struct uart_state *state = tty->driver_data;
542 unsigned long flags;
543 int ret;
544
545 spin_lock_irqsave(&state->uart_port->lock, flags);
546 ret = uart_circ_chars_free(&state->xmit);
547 spin_unlock_irqrestore(&state->uart_port->lock, flags);
548 return ret;
549}
550
551static int uart_chars_in_buffer(struct tty_struct *tty)
552{
553 struct uart_state *state = tty->driver_data;
554 unsigned long flags;
555 int ret;
556
557 spin_lock_irqsave(&state->uart_port->lock, flags);
558 ret = uart_circ_chars_pending(&state->xmit);
559 spin_unlock_irqrestore(&state->uart_port->lock, flags);
560 return ret;
561}
562
563static void uart_flush_buffer(struct tty_struct *tty)
564{
565 struct uart_state *state = tty->driver_data;
566 struct uart_port *port;
567 unsigned long flags;
568
569
570
571
572
573 if (!state) {
574 WARN_ON(1);
575 return;
576 }
577
578 port = state->uart_port;
579 pr_debug("uart_flush_buffer(%d) called\n", tty->index);
580
581 spin_lock_irqsave(&port->lock, flags);
582 uart_circ_clear(&state->xmit);
583 if (port->ops->flush_buffer)
584 port->ops->flush_buffer(port);
585 spin_unlock_irqrestore(&port->lock, flags);
586 tty_wakeup(tty);
587}
588
589
590
591
592
593static void uart_send_xchar(struct tty_struct *tty, char ch)
594{
595 struct uart_state *state = tty->driver_data;
596 struct uart_port *port = state->uart_port;
597 unsigned long flags;
598
599 if (port->ops->send_xchar)
600 port->ops->send_xchar(port, ch);
601 else {
602 port->x_char = ch;
603 if (ch) {
604 spin_lock_irqsave(&port->lock, flags);
605 port->ops->start_tx(port);
606 spin_unlock_irqrestore(&port->lock, flags);
607 }
608 }
609}
610
611static void uart_throttle(struct tty_struct *tty)
612{
613 struct uart_state *state = tty->driver_data;
614 struct uart_port *port = state->uart_port;
615 uint32_t mask = 0;
616
617 if (I_IXOFF(tty))
618 mask |= UPF_SOFT_FLOW;
619 if (tty->termios.c_cflag & CRTSCTS)
620 mask |= UPF_HARD_FLOW;
621
622 if (port->flags & mask) {
623 port->ops->throttle(port);
624 mask &= ~port->flags;
625 }
626
627 if (mask & UPF_SOFT_FLOW)
628 uart_send_xchar(tty, STOP_CHAR(tty));
629
630 if (mask & UPF_HARD_FLOW)
631 uart_clear_mctrl(port, TIOCM_RTS);
632}
633
634static void uart_unthrottle(struct tty_struct *tty)
635{
636 struct uart_state *state = tty->driver_data;
637 struct uart_port *port = state->uart_port;
638 uint32_t mask = 0;
639
640 if (I_IXOFF(tty))
641 mask |= UPF_SOFT_FLOW;
642 if (tty->termios.c_cflag & CRTSCTS)
643 mask |= UPF_HARD_FLOW;
644
645 if (port->flags & mask) {
646 port->ops->unthrottle(port);
647 mask &= ~port->flags;
648 }
649
650 if (mask & UPF_SOFT_FLOW) {
651 if (port->x_char)
652 port->x_char = 0;
653 else
654 uart_send_xchar(tty, START_CHAR(tty));
655 }
656
657 if (mask & UPF_HARD_FLOW)
658 uart_set_mctrl(port, TIOCM_RTS);
659}
660
661static void do_uart_get_info(struct tty_port *port,
662 struct serial_struct *retinfo)
663{
664 struct uart_state *state = container_of(port, struct uart_state, port);
665 struct uart_port *uport = state->uart_port;
666
667 memset(retinfo, 0, sizeof(*retinfo));
668
669 retinfo->type = uport->type;
670 retinfo->line = uport->line;
671 retinfo->port = uport->iobase;
672 if (HIGH_BITS_OFFSET)
673 retinfo->port_high = (long) uport->iobase >> HIGH_BITS_OFFSET;
674 retinfo->irq = uport->irq;
675 retinfo->flags = uport->flags;
676 retinfo->xmit_fifo_size = uport->fifosize;
677 retinfo->baud_base = uport->uartclk / 16;
678 retinfo->close_delay = jiffies_to_msecs(port->close_delay) / 10;
679 retinfo->closing_wait = port->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
680 ASYNC_CLOSING_WAIT_NONE :
681 jiffies_to_msecs(port->closing_wait) / 10;
682 retinfo->custom_divisor = uport->custom_divisor;
683 retinfo->hub6 = uport->hub6;
684 retinfo->io_type = uport->iotype;
685 retinfo->iomem_reg_shift = uport->regshift;
686 retinfo->iomem_base = (void *)(unsigned long)uport->mapbase;
687}
688
689static void uart_get_info(struct tty_port *port,
690 struct serial_struct *retinfo)
691{
692
693
694 mutex_lock(&port->mutex);
695 do_uart_get_info(port, retinfo);
696 mutex_unlock(&port->mutex);
697}
698
699static int uart_get_info_user(struct tty_port *port,
700 struct serial_struct __user *retinfo)
701{
702 struct serial_struct tmp;
703 uart_get_info(port, &tmp);
704
705 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
706 return -EFAULT;
707 return 0;
708}
709
710static int uart_set_info(struct tty_struct *tty, struct tty_port *port,
711 struct uart_state *state,
712 struct serial_struct *new_info)
713{
714 struct uart_port *uport = state->uart_port;
715 unsigned long new_port;
716 unsigned int change_irq, change_port, closing_wait;
717 unsigned int old_custom_divisor, close_delay;
718 upf_t old_flags, new_flags;
719 int retval = 0;
720
721 new_port = new_info->port;
722 if (HIGH_BITS_OFFSET)
723 new_port += (unsigned long) new_info->port_high << HIGH_BITS_OFFSET;
724
725 new_info->irq = irq_canonicalize(new_info->irq);
726 close_delay = msecs_to_jiffies(new_info->close_delay * 10);
727 closing_wait = new_info->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
728 ASYNC_CLOSING_WAIT_NONE :
729 msecs_to_jiffies(new_info->closing_wait * 10);
730
731
732 change_irq = !(uport->flags & UPF_FIXED_PORT)
733 && new_info->irq != uport->irq;
734
735
736
737
738
739
740 change_port = !(uport->flags & UPF_FIXED_PORT)
741 && (new_port != uport->iobase ||
742 (unsigned long)new_info->iomem_base != uport->mapbase ||
743 new_info->hub6 != uport->hub6 ||
744 new_info->io_type != uport->iotype ||
745 new_info->iomem_reg_shift != uport->regshift ||
746 new_info->type != uport->type);
747
748 old_flags = uport->flags;
749 new_flags = new_info->flags;
750 old_custom_divisor = uport->custom_divisor;
751
752 if (!capable(CAP_SYS_ADMIN)) {
753 retval = -EPERM;
754 if (change_irq || change_port ||
755 (new_info->baud_base != uport->uartclk / 16) ||
756 (close_delay != port->close_delay) ||
757 (closing_wait != port->closing_wait) ||
758 (new_info->xmit_fifo_size &&
759 new_info->xmit_fifo_size != uport->fifosize) ||
760 (((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0))
761 goto exit;
762 uport->flags = ((uport->flags & ~UPF_USR_MASK) |
763 (new_flags & UPF_USR_MASK));
764 uport->custom_divisor = new_info->custom_divisor;
765 goto check_and_exit;
766 }
767
768
769
770
771 if (uport->ops->verify_port)
772 retval = uport->ops->verify_port(uport, new_info);
773
774 if ((new_info->irq >= nr_irqs) || (new_info->irq < 0) ||
775 (new_info->baud_base < 9600))
776 retval = -EINVAL;
777
778 if (retval)
779 goto exit;
780
781 if (change_port || change_irq) {
782 retval = -EBUSY;
783
784
785
786
787 if (tty_port_users(port) > 1)
788 goto exit;
789
790
791
792
793
794 uart_shutdown(tty, state);
795 }
796
797 if (change_port) {
798 unsigned long old_iobase, old_mapbase;
799 unsigned int old_type, old_iotype, old_hub6, old_shift;
800
801 old_iobase = uport->iobase;
802 old_mapbase = uport->mapbase;
803 old_type = uport->type;
804 old_hub6 = uport->hub6;
805 old_iotype = uport->iotype;
806 old_shift = uport->regshift;
807
808
809
810
811 if (old_type != PORT_UNKNOWN)
812 uport->ops->release_port(uport);
813
814 uport->iobase = new_port;
815 uport->type = new_info->type;
816 uport->hub6 = new_info->hub6;
817 uport->iotype = new_info->io_type;
818 uport->regshift = new_info->iomem_reg_shift;
819 uport->mapbase = (unsigned long)new_info->iomem_base;
820
821
822
823
824 if (uport->type != PORT_UNKNOWN) {
825 retval = uport->ops->request_port(uport);
826 } else {
827
828 retval = 0;
829 }
830
831
832
833
834
835 if (retval && old_type != PORT_UNKNOWN) {
836 uport->iobase = old_iobase;
837 uport->type = old_type;
838 uport->hub6 = old_hub6;
839 uport->iotype = old_iotype;
840 uport->regshift = old_shift;
841 uport->mapbase = old_mapbase;
842 retval = uport->ops->request_port(uport);
843
844
845
846
847 if (retval)
848 uport->type = PORT_UNKNOWN;
849
850
851
852
853 retval = -EBUSY;
854
855 goto exit;
856 }
857 }
858
859 if (change_irq)
860 uport->irq = new_info->irq;
861 if (!(uport->flags & UPF_FIXED_PORT))
862 uport->uartclk = new_info->baud_base * 16;
863 uport->flags = (uport->flags & ~UPF_CHANGE_MASK) |
864 (new_flags & UPF_CHANGE_MASK);
865 uport->custom_divisor = new_info->custom_divisor;
866 port->close_delay = close_delay;
867 port->closing_wait = closing_wait;
868 if (new_info->xmit_fifo_size)
869 uport->fifosize = new_info->xmit_fifo_size;
870 port->low_latency = (uport->flags & UPF_LOW_LATENCY) ? 1 : 0;
871
872 check_and_exit:
873 retval = 0;
874 if (uport->type == PORT_UNKNOWN)
875 goto exit;
876 if (port->flags & ASYNC_INITIALIZED) {
877 if (((old_flags ^ uport->flags) & UPF_SPD_MASK) ||
878 old_custom_divisor != uport->custom_divisor) {
879
880
881
882
883
884 if (uport->flags & UPF_SPD_MASK) {
885 char buf[64];
886 printk(KERN_NOTICE
887 "%s sets custom speed on %s. This "
888 "is deprecated.\n", current->comm,
889 tty_name(port->tty, buf));
890 }
891 uart_change_speed(tty, state, NULL);
892 }
893 } else
894 retval = uart_startup(tty, state, 1);
895 exit:
896 return retval;
897}
898
899static int uart_set_info_user(struct tty_struct *tty, struct uart_state *state,
900 struct serial_struct __user *newinfo)
901{
902 struct serial_struct new_serial;
903 struct tty_port *port = &state->port;
904 int retval;
905
906 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
907 return -EFAULT;
908
909
910
911
912
913
914
915
916 mutex_lock(&port->mutex);
917 retval = uart_set_info(tty, port, state, &new_serial);
918 mutex_unlock(&port->mutex);
919 return retval;
920}
921
922
923
924
925
926
927
928
929
930static int uart_get_lsr_info(struct tty_struct *tty,
931 struct uart_state *state, unsigned int __user *value)
932{
933 struct uart_port *uport = state->uart_port;
934 unsigned int result;
935
936 result = uport->ops->tx_empty(uport);
937
938
939
940
941
942
943
944 if (uport->x_char ||
945 ((uart_circ_chars_pending(&state->xmit) > 0) &&
946 !tty->stopped && !tty->hw_stopped))
947 result &= ~TIOCSER_TEMT;
948
949 return put_user(result, value);
950}
951
952static int uart_tiocmget(struct tty_struct *tty)
953{
954 struct uart_state *state = tty->driver_data;
955 struct tty_port *port = &state->port;
956 struct uart_port *uport = state->uart_port;
957 int result = -EIO;
958
959 mutex_lock(&port->mutex);
960 if (!(tty->flags & (1 << TTY_IO_ERROR))) {
961 result = uport->mctrl;
962 spin_lock_irq(&uport->lock);
963 result |= uport->ops->get_mctrl(uport);
964 spin_unlock_irq(&uport->lock);
965 }
966 mutex_unlock(&port->mutex);
967
968 return result;
969}
970
971static int
972uart_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)
973{
974 struct uart_state *state = tty->driver_data;
975 struct uart_port *uport = state->uart_port;
976 struct tty_port *port = &state->port;
977 int ret = -EIO;
978
979 mutex_lock(&port->mutex);
980 if (!(tty->flags & (1 << TTY_IO_ERROR))) {
981 uart_update_mctrl(uport, set, clear);
982 ret = 0;
983 }
984 mutex_unlock(&port->mutex);
985 return ret;
986}
987
988static int uart_break_ctl(struct tty_struct *tty, int break_state)
989{
990 struct uart_state *state = tty->driver_data;
991 struct tty_port *port = &state->port;
992 struct uart_port *uport = state->uart_port;
993
994 mutex_lock(&port->mutex);
995
996 if (uport->type != PORT_UNKNOWN)
997 uport->ops->break_ctl(uport, break_state);
998
999 mutex_unlock(&port->mutex);
1000 return 0;
1001}
1002
1003static int uart_do_autoconfig(struct tty_struct *tty,struct uart_state *state)
1004{
1005 struct uart_port *uport = state->uart_port;
1006 struct tty_port *port = &state->port;
1007 int flags, ret;
1008
1009 if (!capable(CAP_SYS_ADMIN))
1010 return -EPERM;
1011
1012
1013
1014
1015
1016
1017 if (mutex_lock_interruptible(&port->mutex))
1018 return -ERESTARTSYS;
1019
1020 ret = -EBUSY;
1021 if (tty_port_users(port) == 1) {
1022 uart_shutdown(tty, state);
1023
1024
1025
1026
1027
1028 if (uport->type != PORT_UNKNOWN)
1029 uport->ops->release_port(uport);
1030
1031 flags = UART_CONFIG_TYPE;
1032 if (uport->flags & UPF_AUTO_IRQ)
1033 flags |= UART_CONFIG_IRQ;
1034
1035
1036
1037
1038
1039 uport->ops->config_port(uport, flags);
1040
1041 ret = uart_startup(tty, state, 1);
1042 }
1043 mutex_unlock(&port->mutex);
1044 return ret;
1045}
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056static int
1057uart_wait_modem_status(struct uart_state *state, unsigned long arg)
1058{
1059 struct uart_port *uport = state->uart_port;
1060 struct tty_port *port = &state->port;
1061 DECLARE_WAITQUEUE(wait, current);
1062 struct uart_icount cprev, cnow;
1063 int ret;
1064
1065
1066
1067
1068 spin_lock_irq(&uport->lock);
1069 memcpy(&cprev, &uport->icount, sizeof(struct uart_icount));
1070
1071
1072
1073
1074 uport->ops->enable_ms(uport);
1075 spin_unlock_irq(&uport->lock);
1076
1077 add_wait_queue(&port->delta_msr_wait, &wait);
1078 for (;;) {
1079 spin_lock_irq(&uport->lock);
1080 memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
1081 spin_unlock_irq(&uport->lock);
1082
1083 set_current_state(TASK_INTERRUPTIBLE);
1084
1085 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
1086 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
1087 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
1088 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
1089 ret = 0;
1090 break;
1091 }
1092
1093 schedule();
1094
1095
1096 if (signal_pending(current)) {
1097 ret = -ERESTARTSYS;
1098 break;
1099 }
1100
1101 cprev = cnow;
1102 }
1103
1104 current->state = TASK_RUNNING;
1105 remove_wait_queue(&port->delta_msr_wait, &wait);
1106
1107 return ret;
1108}
1109
1110
1111
1112
1113
1114
1115
1116static int uart_get_icount(struct tty_struct *tty,
1117 struct serial_icounter_struct *icount)
1118{
1119 struct uart_state *state = tty->driver_data;
1120 struct uart_icount cnow;
1121 struct uart_port *uport = state->uart_port;
1122
1123 spin_lock_irq(&uport->lock);
1124 memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
1125 spin_unlock_irq(&uport->lock);
1126
1127 icount->cts = cnow.cts;
1128 icount->dsr = cnow.dsr;
1129 icount->rng = cnow.rng;
1130 icount->dcd = cnow.dcd;
1131 icount->rx = cnow.rx;
1132 icount->tx = cnow.tx;
1133 icount->frame = cnow.frame;
1134 icount->overrun = cnow.overrun;
1135 icount->parity = cnow.parity;
1136 icount->brk = cnow.brk;
1137 icount->buf_overrun = cnow.buf_overrun;
1138
1139 return 0;
1140}
1141
1142
1143
1144
1145static int
1146uart_ioctl(struct tty_struct *tty, unsigned int cmd,
1147 unsigned long arg)
1148{
1149 struct uart_state *state = tty->driver_data;
1150 struct tty_port *port = &state->port;
1151 void __user *uarg = (void __user *)arg;
1152 int ret = -ENOIOCTLCMD;
1153
1154
1155
1156
1157
1158 switch (cmd) {
1159 case TIOCGSERIAL:
1160 ret = uart_get_info_user(port, uarg);
1161 break;
1162
1163 case TIOCSSERIAL:
1164 ret = uart_set_info_user(tty, state, uarg);
1165 break;
1166
1167 case TIOCSERCONFIG:
1168 ret = uart_do_autoconfig(tty, state);
1169 break;
1170
1171 case TIOCSERGWILD:
1172 case TIOCSERSWILD:
1173 ret = 0;
1174 break;
1175 }
1176
1177 if (ret != -ENOIOCTLCMD)
1178 goto out;
1179
1180 if (tty->flags & (1 << TTY_IO_ERROR)) {
1181 ret = -EIO;
1182 goto out;
1183 }
1184
1185
1186
1187
1188 switch (cmd) {
1189 case TIOCMIWAIT:
1190 ret = uart_wait_modem_status(state, arg);
1191 break;
1192 }
1193
1194 if (ret != -ENOIOCTLCMD)
1195 goto out;
1196
1197 mutex_lock(&port->mutex);
1198
1199 if (tty->flags & (1 << TTY_IO_ERROR)) {
1200 ret = -EIO;
1201 goto out_up;
1202 }
1203
1204
1205
1206
1207
1208 switch (cmd) {
1209 case TIOCSERGETLSR:
1210 ret = uart_get_lsr_info(tty, state, uarg);
1211 break;
1212
1213 default: {
1214 struct uart_port *uport = state->uart_port;
1215 if (uport->ops->ioctl)
1216 ret = uport->ops->ioctl(uport, cmd, arg);
1217 break;
1218 }
1219 }
1220out_up:
1221 mutex_unlock(&port->mutex);
1222out:
1223 return ret;
1224}
1225
1226static void uart_set_ldisc(struct tty_struct *tty)
1227{
1228 struct uart_state *state = tty->driver_data;
1229 struct uart_port *uport = state->uart_port;
1230
1231 if (uport->ops->set_ldisc)
1232 uport->ops->set_ldisc(uport, tty->termios.c_line);
1233}
1234
1235static void uart_set_termios(struct tty_struct *tty,
1236 struct ktermios *old_termios)
1237{
1238 struct uart_state *state = tty->driver_data;
1239 struct uart_port *uport = state->uart_port;
1240 unsigned long flags;
1241 unsigned int cflag = tty->termios.c_cflag;
1242 unsigned int iflag_mask = IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK;
1243 bool sw_changed = false;
1244
1245
1246
1247
1248
1249 if (uport->flags & UPF_SOFT_FLOW) {
1250 iflag_mask |= IXANY|IXON|IXOFF;
1251 sw_changed =
1252 tty->termios.c_cc[VSTART] != old_termios->c_cc[VSTART] ||
1253 tty->termios.c_cc[VSTOP] != old_termios->c_cc[VSTOP];
1254 }
1255
1256
1257
1258
1259
1260
1261
1262 if ((cflag ^ old_termios->c_cflag) == 0 &&
1263 tty->termios.c_ospeed == old_termios->c_ospeed &&
1264 tty->termios.c_ispeed == old_termios->c_ispeed &&
1265 ((tty->termios.c_iflag ^ old_termios->c_iflag) & iflag_mask) == 0 &&
1266 !sw_changed) {
1267 return;
1268 }
1269
1270 uart_change_speed(tty, state, old_termios);
1271
1272
1273 if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
1274 uart_clear_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
1275
1276 else if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
1277 unsigned int mask = TIOCM_DTR;
1278 if (!(cflag & CRTSCTS) ||
1279 !test_bit(TTY_THROTTLED, &tty->flags))
1280 mask |= TIOCM_RTS;
1281 uart_set_mctrl(uport, mask);
1282 }
1283
1284
1285
1286
1287
1288 if (uport->flags & UPF_HARD_FLOW)
1289 return;
1290
1291
1292 if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
1293 spin_lock_irqsave(&uport->lock, flags);
1294 tty->hw_stopped = 0;
1295 __uart_start(tty);
1296 spin_unlock_irqrestore(&uport->lock, flags);
1297 }
1298
1299 else if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
1300 spin_lock_irqsave(&uport->lock, flags);
1301 if (!(uport->ops->get_mctrl(uport) & TIOCM_CTS)) {
1302 tty->hw_stopped = 1;
1303 uport->ops->stop_tx(uport);
1304 }
1305 spin_unlock_irqrestore(&uport->lock, flags);
1306 }
1307}
1308
1309
1310
1311
1312
1313
1314
1315static void uart_close(struct tty_struct *tty, struct file *filp)
1316{
1317 struct uart_state *state = tty->driver_data;
1318 struct tty_port *port;
1319 struct uart_port *uport;
1320 unsigned long flags;
1321
1322 if (!state)
1323 return;
1324
1325 uport = state->uart_port;
1326 port = &state->port;
1327
1328 pr_debug("uart_close(%d) called\n", uport->line);
1329
1330 if (tty_port_close_start(port, tty, filp) == 0)
1331 return;
1332
1333
1334
1335
1336
1337 if (port->flags & ASYNC_INITIALIZED) {
1338 unsigned long flags;
1339 spin_lock_irqsave(&uport->lock, flags);
1340 uport->ops->stop_rx(uport);
1341 spin_unlock_irqrestore(&uport->lock, flags);
1342
1343
1344
1345
1346
1347 uart_wait_until_sent(tty, uport->timeout);
1348 }
1349
1350 mutex_lock(&port->mutex);
1351 uart_shutdown(tty, state);
1352 uart_flush_buffer(tty);
1353
1354 tty_ldisc_flush(tty);
1355
1356 tty_port_tty_set(port, NULL);
1357 spin_lock_irqsave(&port->lock, flags);
1358 tty->closing = 0;
1359
1360 if (port->blocked_open) {
1361 spin_unlock_irqrestore(&port->lock, flags);
1362 if (port->close_delay)
1363 msleep_interruptible(
1364 jiffies_to_msecs(port->close_delay));
1365 spin_lock_irqsave(&port->lock, flags);
1366 } else if (!uart_console(uport)) {
1367 spin_unlock_irqrestore(&port->lock, flags);
1368 uart_change_pm(state, UART_PM_STATE_OFF);
1369 spin_lock_irqsave(&port->lock, flags);
1370 }
1371
1372
1373
1374
1375 clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
1376 clear_bit(ASYNCB_CLOSING, &port->flags);
1377 spin_unlock_irqrestore(&port->lock, flags);
1378 wake_up_interruptible(&port->open_wait);
1379 wake_up_interruptible(&port->close_wait);
1380
1381 mutex_unlock(&port->mutex);
1382}
1383
1384static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
1385{
1386 struct uart_state *state = tty->driver_data;
1387 struct uart_port *port = state->uart_port;
1388 unsigned long char_time, expire;
1389
1390 if (port->type == PORT_UNKNOWN || port->fifosize == 0)
1391 return;
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401 char_time = (port->timeout - HZ/50) / port->fifosize;
1402 char_time = char_time / 5;
1403 if (char_time == 0)
1404 char_time = 1;
1405 if (timeout && timeout < char_time)
1406 char_time = timeout;
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417 if (timeout == 0 || timeout > 2 * port->timeout)
1418 timeout = 2 * port->timeout;
1419
1420 expire = jiffies + timeout;
1421
1422 pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n",
1423 port->line, jiffies, expire);
1424
1425
1426
1427
1428
1429
1430 while (!port->ops->tx_empty(port)) {
1431 msleep_interruptible(jiffies_to_msecs(char_time));
1432 if (signal_pending(current))
1433 break;
1434 if (time_after(jiffies, expire))
1435 break;
1436 }
1437}
1438
1439
1440
1441
1442
1443
1444static void uart_hangup(struct tty_struct *tty)
1445{
1446 struct uart_state *state = tty->driver_data;
1447 struct tty_port *port = &state->port;
1448 unsigned long flags;
1449
1450 pr_debug("uart_hangup(%d)\n", state->uart_port->line);
1451
1452 mutex_lock(&port->mutex);
1453 if (port->flags & ASYNC_NORMAL_ACTIVE) {
1454 uart_flush_buffer(tty);
1455 uart_shutdown(tty, state);
1456 spin_lock_irqsave(&port->lock, flags);
1457 port->count = 0;
1458 clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
1459 spin_unlock_irqrestore(&port->lock, flags);
1460 tty_port_tty_set(port, NULL);
1461 wake_up_interruptible(&port->open_wait);
1462 wake_up_interruptible(&port->delta_msr_wait);
1463 }
1464 mutex_unlock(&port->mutex);
1465}
1466
1467static int uart_port_activate(struct tty_port *port, struct tty_struct *tty)
1468{
1469 return 0;
1470}
1471
1472static void uart_port_shutdown(struct tty_port *port)
1473{
1474 struct uart_state *state = container_of(port, struct uart_state, port);
1475 struct uart_port *uport = state->uart_port;
1476
1477
1478
1479
1480
1481
1482
1483
1484 wake_up_interruptible(&port->delta_msr_wait);
1485
1486
1487
1488
1489 uport->ops->shutdown(uport);
1490
1491
1492
1493
1494 synchronize_irq(uport->irq);
1495}
1496
1497static int uart_carrier_raised(struct tty_port *port)
1498{
1499 struct uart_state *state = container_of(port, struct uart_state, port);
1500 struct uart_port *uport = state->uart_port;
1501 int mctrl;
1502 spin_lock_irq(&uport->lock);
1503 uport->ops->enable_ms(uport);
1504 mctrl = uport->ops->get_mctrl(uport);
1505 spin_unlock_irq(&uport->lock);
1506 if (mctrl & TIOCM_CAR)
1507 return 1;
1508 return 0;
1509}
1510
1511static void uart_dtr_rts(struct tty_port *port, int onoff)
1512{
1513 struct uart_state *state = container_of(port, struct uart_state, port);
1514 struct uart_port *uport = state->uart_port;
1515
1516 if (onoff)
1517 uart_set_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
1518 else
1519 uart_clear_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
1520}
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532static int uart_open(struct tty_struct *tty, struct file *filp)
1533{
1534 struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;
1535 int retval, line = tty->index;
1536 struct uart_state *state = drv->state + line;
1537 struct tty_port *port = &state->port;
1538
1539 pr_debug("uart_open(%d) called\n", line);
1540
1541
1542
1543
1544
1545
1546
1547
1548 if (mutex_lock_interruptible(&port->mutex)) {
1549 retval = -ERESTARTSYS;
1550 goto end;
1551 }
1552
1553 port->count++;
1554 if (!state->uart_port || state->uart_port->flags & UPF_DEAD) {
1555 retval = -ENXIO;
1556 goto err_dec_count;
1557 }
1558
1559
1560
1561
1562
1563
1564 tty->driver_data = state;
1565 state->uart_port->state = state;
1566 state->port.low_latency =
1567 (state->uart_port->flags & UPF_LOW_LATENCY) ? 1 : 0;
1568 tty_port_tty_set(port, tty);
1569
1570
1571
1572
1573 if (tty_hung_up_p(filp)) {
1574 retval = -EAGAIN;
1575 goto err_dec_count;
1576 }
1577
1578
1579
1580
1581 if (port->count == 1)
1582 uart_change_pm(state, UART_PM_STATE_ON);
1583
1584
1585
1586
1587 retval = uart_startup(tty, state, 0);
1588
1589
1590
1591
1592 mutex_unlock(&port->mutex);
1593 if (retval == 0)
1594 retval = tty_port_block_til_ready(port, tty, filp);
1595
1596end:
1597 return retval;
1598err_dec_count:
1599 port->count--;
1600 mutex_unlock(&port->mutex);
1601 goto end;
1602}
1603
1604static const char *uart_type(struct uart_port *port)
1605{
1606 const char *str = NULL;
1607
1608 if (port->ops->type)
1609 str = port->ops->type(port);
1610
1611 if (!str)
1612 str = "unknown";
1613
1614 return str;
1615}
1616
1617#ifdef CONFIG_PROC_FS
1618
1619static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i)
1620{
1621 struct uart_state *state = drv->state + i;
1622 struct tty_port *port = &state->port;
1623 enum uart_pm_state pm_state;
1624 struct uart_port *uport = state->uart_port;
1625 char stat_buf[32];
1626 unsigned int status;
1627 int mmio;
1628
1629 if (!uport)
1630 return;
1631
1632 mmio = uport->iotype >= UPIO_MEM;
1633 seq_printf(m, "%d: uart:%s %s%08llX irq:%d",
1634 uport->line, uart_type(uport),
1635 mmio ? "mmio:0x" : "port:",
1636 mmio ? (unsigned long long)uport->mapbase
1637 : (unsigned long long)uport->iobase,
1638 uport->irq);
1639
1640 if (uport->type == PORT_UNKNOWN) {
1641 seq_putc(m, '\n');
1642 return;
1643 }
1644
1645 if (capable(CAP_SYS_ADMIN)) {
1646 mutex_lock(&port->mutex);
1647 pm_state = state->pm_state;
1648 if (pm_state != UART_PM_STATE_ON)
1649 uart_change_pm(state, UART_PM_STATE_ON);
1650 spin_lock_irq(&uport->lock);
1651 status = uport->ops->get_mctrl(uport);
1652 spin_unlock_irq(&uport->lock);
1653 if (pm_state != UART_PM_STATE_ON)
1654 uart_change_pm(state, pm_state);
1655 mutex_unlock(&port->mutex);
1656
1657 seq_printf(m, " tx:%d rx:%d",
1658 uport->icount.tx, uport->icount.rx);
1659 if (uport->icount.frame)
1660 seq_printf(m, " fe:%d",
1661 uport->icount.frame);
1662 if (uport->icount.parity)
1663 seq_printf(m, " pe:%d",
1664 uport->icount.parity);
1665 if (uport->icount.brk)
1666 seq_printf(m, " brk:%d",
1667 uport->icount.brk);
1668 if (uport->icount.overrun)
1669 seq_printf(m, " oe:%d",
1670 uport->icount.overrun);
1671
1672#define INFOBIT(bit, str) \
1673 if (uport->mctrl & (bit)) \
1674 strncat(stat_buf, (str), sizeof(stat_buf) - \
1675 strlen(stat_buf) - 2)
1676#define STATBIT(bit, str) \
1677 if (status & (bit)) \
1678 strncat(stat_buf, (str), sizeof(stat_buf) - \
1679 strlen(stat_buf) - 2)
1680
1681 stat_buf[0] = '\0';
1682 stat_buf[1] = '\0';
1683 INFOBIT(TIOCM_RTS, "|RTS");
1684 STATBIT(TIOCM_CTS, "|CTS");
1685 INFOBIT(TIOCM_DTR, "|DTR");
1686 STATBIT(TIOCM_DSR, "|DSR");
1687 STATBIT(TIOCM_CAR, "|CD");
1688 STATBIT(TIOCM_RNG, "|RI");
1689 if (stat_buf[0])
1690 stat_buf[0] = ' ';
1691
1692 seq_puts(m, stat_buf);
1693 }
1694 seq_putc(m, '\n');
1695#undef STATBIT
1696#undef INFOBIT
1697}
1698
1699static int uart_proc_show(struct seq_file *m, void *v)
1700{
1701 struct tty_driver *ttydrv = m->private;
1702 struct uart_driver *drv = ttydrv->driver_state;
1703 int i;
1704
1705 seq_printf(m, "serinfo:1.0 driver%s%s revision:%s\n",
1706 "", "", "");
1707 for (i = 0; i < drv->nr; i++)
1708 uart_line_info(m, drv, i);
1709 return 0;
1710}
1711
1712static int uart_proc_open(struct inode *inode, struct file *file)
1713{
1714 return single_open(file, uart_proc_show, PDE_DATA(inode));
1715}
1716
1717static const struct file_operations uart_proc_fops = {
1718 .owner = THIS_MODULE,
1719 .open = uart_proc_open,
1720 .read = seq_read,
1721 .llseek = seq_lseek,
1722 .release = single_release,
1723};
1724#endif
1725
1726#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(CONFIG_CONSOLE_POLL)
1727
1728
1729
1730
1731
1732
1733
1734void uart_console_write(struct uart_port *port, const char *s,
1735 unsigned int count,
1736 void (*putchar)(struct uart_port *, int))
1737{
1738 unsigned int i;
1739
1740 for (i = 0; i < count; i++, s++) {
1741 if (*s == '\n')
1742 putchar(port, '\r');
1743 putchar(port, *s);
1744 }
1745}
1746EXPORT_SYMBOL_GPL(uart_console_write);
1747
1748
1749
1750
1751
1752
1753struct uart_port * __init
1754uart_get_console(struct uart_port *ports, int nr, struct console *co)
1755{
1756 int idx = co->index;
1757
1758 if (idx < 0 || idx >= nr || (ports[idx].iobase == 0 &&
1759 ports[idx].membase == NULL))
1760 for (idx = 0; idx < nr; idx++)
1761 if (ports[idx].iobase != 0 ||
1762 ports[idx].membase != NULL)
1763 break;
1764
1765 co->index = idx;
1766
1767 return ports + idx;
1768}
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782void
1783uart_parse_options(char *options, int *baud, int *parity, int *bits, int *flow)
1784{
1785 char *s = options;
1786
1787 *baud = simple_strtoul(s, NULL, 10);
1788 while (*s >= '0' && *s <= '9')
1789 s++;
1790 if (*s)
1791 *parity = *s++;
1792 if (*s)
1793 *bits = *s++ - '0';
1794 if (*s)
1795 *flow = *s;
1796}
1797EXPORT_SYMBOL_GPL(uart_parse_options);
1798
1799struct baud_rates {
1800 unsigned int rate;
1801 unsigned int cflag;
1802};
1803
1804static const struct baud_rates baud_rates[] = {
1805 { 921600, B921600 },
1806 { 460800, B460800 },
1807 { 230400, B230400 },
1808 { 115200, B115200 },
1809 { 57600, B57600 },
1810 { 38400, B38400 },
1811 { 19200, B19200 },
1812 { 9600, B9600 },
1813 { 4800, B4800 },
1814 { 2400, B2400 },
1815 { 1200, B1200 },
1816 { 0, B38400 }
1817};
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828int
1829uart_set_options(struct uart_port *port, struct console *co,
1830 int baud, int parity, int bits, int flow)
1831{
1832 struct ktermios termios;
1833 static struct ktermios dummy;
1834 int i;
1835
1836
1837
1838
1839
1840 spin_lock_init(&port->lock);
1841 lockdep_set_class(&port->lock, &port_lock_key);
1842
1843 memset(&termios, 0, sizeof(struct ktermios));
1844
1845 termios.c_cflag = CREAD | HUPCL | CLOCAL;
1846
1847
1848
1849
1850 for (i = 0; baud_rates[i].rate; i++)
1851 if (baud_rates[i].rate <= baud)
1852 break;
1853
1854 termios.c_cflag |= baud_rates[i].cflag;
1855
1856 if (bits == 7)
1857 termios.c_cflag |= CS7;
1858 else
1859 termios.c_cflag |= CS8;
1860
1861 switch (parity) {
1862 case 'o': case 'O':
1863 termios.c_cflag |= PARODD;
1864
1865 case 'e': case 'E':
1866 termios.c_cflag |= PARENB;
1867 break;
1868 }
1869
1870 if (flow == 'r')
1871 termios.c_cflag |= CRTSCTS;
1872
1873
1874
1875
1876
1877 port->mctrl |= TIOCM_DTR;
1878
1879 port->ops->set_termios(port, &termios, &dummy);
1880
1881
1882
1883
1884 if (co)
1885 co->cflag = termios.c_cflag;
1886
1887 return 0;
1888}
1889EXPORT_SYMBOL_GPL(uart_set_options);
1890#endif
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900static void uart_change_pm(struct uart_state *state,
1901 enum uart_pm_state pm_state)
1902{
1903 struct uart_port *port = state->uart_port;
1904
1905 if (state->pm_state != pm_state) {
1906 if (port->ops->pm)
1907 port->ops->pm(port, pm_state, state->pm_state);
1908 state->pm_state = pm_state;
1909 }
1910}
1911
1912struct uart_match {
1913 struct uart_port *port;
1914 struct uart_driver *driver;
1915};
1916
1917static int serial_match_port(struct device *dev, void *data)
1918{
1919 struct uart_match *match = data;
1920 struct tty_driver *tty_drv = match->driver->tty_driver;
1921 dev_t devt = MKDEV(tty_drv->major, tty_drv->minor_start) +
1922 match->port->line;
1923
1924 return dev->devt == devt;
1925}
1926
1927int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
1928{
1929 struct uart_state *state = drv->state + uport->line;
1930 struct tty_port *port = &state->port;
1931 struct device *tty_dev;
1932 struct uart_match match = {uport, drv};
1933
1934 mutex_lock(&port->mutex);
1935
1936 tty_dev = device_find_child(uport->dev, &match, serial_match_port);
1937 if (device_may_wakeup(tty_dev)) {
1938 if (!enable_irq_wake(uport->irq))
1939 uport->irq_wake = 1;
1940 put_device(tty_dev);
1941 mutex_unlock(&port->mutex);
1942 return 0;
1943 }
1944 put_device(tty_dev);
1945
1946 if (console_suspend_enabled || !uart_console(uport))
1947 uport->suspended = 1;
1948
1949 if (port->flags & ASYNC_INITIALIZED) {
1950 const struct uart_ops *ops = uport->ops;
1951 int tries;
1952
1953 if (console_suspend_enabled || !uart_console(uport)) {
1954 set_bit(ASYNCB_SUSPENDED, &port->flags);
1955 clear_bit(ASYNCB_INITIALIZED, &port->flags);
1956
1957 spin_lock_irq(&uport->lock);
1958 ops->stop_tx(uport);
1959 ops->set_mctrl(uport, 0);
1960 ops->stop_rx(uport);
1961 spin_unlock_irq(&uport->lock);
1962 }
1963
1964
1965
1966
1967 for (tries = 3; !ops->tx_empty(uport) && tries; tries--)
1968 msleep(10);
1969 if (!tries)
1970 printk(KERN_ERR "%s%s%s%d: Unable to drain "
1971 "transmitter\n",
1972 uport->dev ? dev_name(uport->dev) : "",
1973 uport->dev ? ": " : "",
1974 drv->dev_name,
1975 drv->tty_driver->name_base + uport->line);
1976
1977 if (console_suspend_enabled || !uart_console(uport))
1978 ops->shutdown(uport);
1979 }
1980
1981
1982
1983
1984 if (console_suspend_enabled && uart_console(uport))
1985 console_stop(uport->cons);
1986
1987 if (console_suspend_enabled || !uart_console(uport))
1988 uart_change_pm(state, UART_PM_STATE_OFF);
1989
1990 mutex_unlock(&port->mutex);
1991
1992 return 0;
1993}
1994
1995int uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
1996{
1997 struct uart_state *state = drv->state + uport->line;
1998 struct tty_port *port = &state->port;
1999 struct device *tty_dev;
2000 struct uart_match match = {uport, drv};
2001 struct ktermios termios;
2002
2003 mutex_lock(&port->mutex);
2004
2005 tty_dev = device_find_child(uport->dev, &match, serial_match_port);
2006 if (!uport->suspended && device_may_wakeup(tty_dev)) {
2007 if (uport->irq_wake) {
2008 disable_irq_wake(uport->irq);
2009 uport->irq_wake = 0;
2010 }
2011 put_device(tty_dev);
2012 mutex_unlock(&port->mutex);
2013 return 0;
2014 }
2015 put_device(tty_dev);
2016 uport->suspended = 0;
2017
2018
2019
2020
2021 if (uart_console(uport)) {
2022
2023
2024
2025 memset(&termios, 0, sizeof(struct ktermios));
2026 termios.c_cflag = uport->cons->cflag;
2027
2028
2029
2030
2031 if (port->tty && termios.c_cflag == 0)
2032 termios = port->tty->termios;
2033
2034 if (console_suspend_enabled)
2035 uart_change_pm(state, UART_PM_STATE_ON);
2036 uport->ops->set_termios(uport, &termios, NULL);
2037 if (console_suspend_enabled)
2038 console_start(uport->cons);
2039 }
2040
2041 if (port->flags & ASYNC_SUSPENDED) {
2042 const struct uart_ops *ops = uport->ops;
2043 int ret;
2044
2045 uart_change_pm(state, UART_PM_STATE_ON);
2046 spin_lock_irq(&uport->lock);
2047 ops->set_mctrl(uport, 0);
2048 spin_unlock_irq(&uport->lock);
2049 if (console_suspend_enabled || !uart_console(uport)) {
2050
2051 struct tty_struct *tty = port->tty;
2052 ret = ops->startup(uport);
2053 if (ret == 0) {
2054 if (tty)
2055 uart_change_speed(tty, state, NULL);
2056 spin_lock_irq(&uport->lock);
2057 ops->set_mctrl(uport, uport->mctrl);
2058 ops->start_tx(uport);
2059 spin_unlock_irq(&uport->lock);
2060 set_bit(ASYNCB_INITIALIZED, &port->flags);
2061 } else {
2062
2063
2064
2065
2066
2067 uart_shutdown(tty, state);
2068 }
2069 }
2070
2071 clear_bit(ASYNCB_SUSPENDED, &port->flags);
2072 }
2073
2074 mutex_unlock(&port->mutex);
2075
2076 return 0;
2077}
2078
2079static inline void
2080uart_report_port(struct uart_driver *drv, struct uart_port *port)
2081{
2082 char address[64];
2083
2084 switch (port->iotype) {
2085 case UPIO_PORT:
2086 snprintf(address, sizeof(address), "I/O 0x%lx", port->iobase);
2087 break;
2088 case UPIO_HUB6:
2089 snprintf(address, sizeof(address),
2090 "I/O 0x%lx offset 0x%x", port->iobase, port->hub6);
2091 break;
2092 case UPIO_MEM:
2093 case UPIO_MEM32:
2094 case UPIO_AU:
2095 case UPIO_TSI:
2096 snprintf(address, sizeof(address),
2097 "MMIO 0x%llx", (unsigned long long)port->mapbase);
2098 break;
2099 default:
2100 strlcpy(address, "*unknown*", sizeof(address));
2101 break;
2102 }
2103
2104 printk(KERN_INFO "%s%s%s%d at %s (irq = %d) is a %s\n",
2105 port->dev ? dev_name(port->dev) : "",
2106 port->dev ? ": " : "",
2107 drv->dev_name,
2108 drv->tty_driver->name_base + port->line,
2109 address, port->irq, uart_type(port));
2110}
2111
2112static void
2113uart_configure_port(struct uart_driver *drv, struct uart_state *state,
2114 struct uart_port *port)
2115{
2116 unsigned int flags;
2117
2118
2119
2120
2121 if (!port->iobase && !port->mapbase && !port->membase)
2122 return;
2123
2124
2125
2126
2127
2128 flags = 0;
2129 if (port->flags & UPF_AUTO_IRQ)
2130 flags |= UART_CONFIG_IRQ;
2131 if (port->flags & UPF_BOOT_AUTOCONF) {
2132 if (!(port->flags & UPF_FIXED_TYPE)) {
2133 port->type = PORT_UNKNOWN;
2134 flags |= UART_CONFIG_TYPE;
2135 }
2136 port->ops->config_port(port, flags);
2137 }
2138
2139 if (port->type != PORT_UNKNOWN) {
2140 unsigned long flags;
2141
2142 uart_report_port(drv, port);
2143
2144
2145 uart_change_pm(state, UART_PM_STATE_ON);
2146
2147
2148
2149
2150
2151
2152 spin_lock_irqsave(&port->lock, flags);
2153 port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR);
2154 spin_unlock_irqrestore(&port->lock, flags);
2155
2156
2157
2158
2159
2160
2161 if (port->cons && !(port->cons->flags & CON_ENABLED))
2162 register_console(port->cons);
2163
2164
2165
2166
2167
2168 if (!uart_console(port))
2169 uart_change_pm(state, UART_PM_STATE_OFF);
2170 }
2171}
2172
2173#ifdef CONFIG_CONSOLE_POLL
2174
2175static int uart_poll_init(struct tty_driver *driver, int line, char *options)
2176{
2177 struct uart_driver *drv = driver->driver_state;
2178 struct uart_state *state = drv->state + line;
2179 struct uart_port *port;
2180 int baud = 9600;
2181 int bits = 8;
2182 int parity = 'n';
2183 int flow = 'n';
2184 int ret;
2185
2186 if (!state || !state->uart_port)
2187 return -1;
2188
2189 port = state->uart_port;
2190 if (!(port->ops->poll_get_char && port->ops->poll_put_char))
2191 return -1;
2192
2193 if (port->ops->poll_init) {
2194 struct tty_port *tport = &state->port;
2195
2196 ret = 0;
2197 mutex_lock(&tport->mutex);
2198
2199
2200
2201
2202 if (!test_bit(ASYNCB_INITIALIZED, &tport->flags))
2203 ret = port->ops->poll_init(port);
2204 mutex_unlock(&tport->mutex);
2205 if (ret)
2206 return ret;
2207 }
2208
2209 if (options) {
2210 uart_parse_options(options, &baud, &parity, &bits, &flow);
2211 return uart_set_options(port, NULL, baud, parity, bits, flow);
2212 }
2213
2214 return 0;
2215}
2216
2217static int uart_poll_get_char(struct tty_driver *driver, int line)
2218{
2219 struct uart_driver *drv = driver->driver_state;
2220 struct uart_state *state = drv->state + line;
2221 struct uart_port *port;
2222
2223 if (!state || !state->uart_port)
2224 return -1;
2225
2226 port = state->uart_port;
2227 return port->ops->poll_get_char(port);
2228}
2229
2230static void uart_poll_put_char(struct tty_driver *driver, int line, char ch)
2231{
2232 struct uart_driver *drv = driver->driver_state;
2233 struct uart_state *state = drv->state + line;
2234 struct uart_port *port;
2235
2236 if (!state || !state->uart_port)
2237 return;
2238
2239 port = state->uart_port;
2240 port->ops->poll_put_char(port, ch);
2241}
2242#endif
2243
2244static const struct tty_operations uart_ops = {
2245 .open = uart_open,
2246 .close = uart_close,
2247 .write = uart_write,
2248 .put_char = uart_put_char,
2249 .flush_chars = uart_flush_chars,
2250 .write_room = uart_write_room,
2251 .chars_in_buffer= uart_chars_in_buffer,
2252 .flush_buffer = uart_flush_buffer,
2253 .ioctl = uart_ioctl,
2254 .throttle = uart_throttle,
2255 .unthrottle = uart_unthrottle,
2256 .send_xchar = uart_send_xchar,
2257 .set_termios = uart_set_termios,
2258 .set_ldisc = uart_set_ldisc,
2259 .stop = uart_stop,
2260 .start = uart_start,
2261 .hangup = uart_hangup,
2262 .break_ctl = uart_break_ctl,
2263 .wait_until_sent= uart_wait_until_sent,
2264#ifdef CONFIG_PROC_FS
2265 .proc_fops = &uart_proc_fops,
2266#endif
2267 .tiocmget = uart_tiocmget,
2268 .tiocmset = uart_tiocmset,
2269 .get_icount = uart_get_icount,
2270#ifdef CONFIG_CONSOLE_POLL
2271 .poll_init = uart_poll_init,
2272 .poll_get_char = uart_poll_get_char,
2273 .poll_put_char = uart_poll_put_char,
2274#endif
2275};
2276
2277static const struct tty_port_operations uart_port_ops = {
2278 .activate = uart_port_activate,
2279 .shutdown = uart_port_shutdown,
2280 .carrier_raised = uart_carrier_raised,
2281 .dtr_rts = uart_dtr_rts,
2282};
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297int uart_register_driver(struct uart_driver *drv)
2298{
2299 struct tty_driver *normal;
2300 int i, retval;
2301
2302 BUG_ON(drv->state);
2303
2304
2305
2306
2307
2308 drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
2309 if (!drv->state)
2310 goto out;
2311
2312 normal = alloc_tty_driver(drv->nr);
2313 if (!normal)
2314 goto out_kfree;
2315
2316 drv->tty_driver = normal;
2317
2318 normal->driver_name = drv->driver_name;
2319 normal->name = drv->dev_name;
2320 normal->major = drv->major;
2321 normal->minor_start = drv->minor;
2322 normal->type = TTY_DRIVER_TYPE_SERIAL;
2323 normal->subtype = SERIAL_TYPE_NORMAL;
2324 normal->init_termios = tty_std_termios;
2325 normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2326 normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
2327 normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
2328 normal->driver_state = drv;
2329 tty_set_operations(normal, &uart_ops);
2330
2331
2332
2333
2334 for (i = 0; i < drv->nr; i++) {
2335 struct uart_state *state = drv->state + i;
2336 struct tty_port *port = &state->port;
2337
2338 tty_port_init(port);
2339 port->ops = &uart_port_ops;
2340 port->close_delay = HZ / 2;
2341 port->closing_wait = 30 * HZ;
2342 }
2343
2344 retval = tty_register_driver(normal);
2345 if (retval >= 0)
2346 return retval;
2347
2348 for (i = 0; i < drv->nr; i++)
2349 tty_port_destroy(&drv->state[i].port);
2350 put_tty_driver(normal);
2351out_kfree:
2352 kfree(drv->state);
2353out:
2354 return -ENOMEM;
2355}
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366void uart_unregister_driver(struct uart_driver *drv)
2367{
2368 struct tty_driver *p = drv->tty_driver;
2369 unsigned int i;
2370
2371 tty_unregister_driver(p);
2372 put_tty_driver(p);
2373 for (i = 0; i < drv->nr; i++)
2374 tty_port_destroy(&drv->state[i].port);
2375 kfree(drv->state);
2376 drv->state = NULL;
2377 drv->tty_driver = NULL;
2378}
2379
2380struct tty_driver *uart_console_device(struct console *co, int *index)
2381{
2382 struct uart_driver *p = co->data;
2383 *index = co->index;
2384 return p->tty_driver;
2385}
2386
2387static ssize_t uart_get_attr_uartclk(struct device *dev,
2388 struct device_attribute *attr, char *buf)
2389{
2390 struct serial_struct tmp;
2391 struct tty_port *port = dev_get_drvdata(dev);
2392
2393 uart_get_info(port, &tmp);
2394 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.baud_base * 16);
2395}
2396
2397static ssize_t uart_get_attr_type(struct device *dev,
2398 struct device_attribute *attr, char *buf)
2399{
2400 struct serial_struct tmp;
2401 struct tty_port *port = dev_get_drvdata(dev);
2402
2403 uart_get_info(port, &tmp);
2404 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.type);
2405}
2406static ssize_t uart_get_attr_line(struct device *dev,
2407 struct device_attribute *attr, char *buf)
2408{
2409 struct serial_struct tmp;
2410 struct tty_port *port = dev_get_drvdata(dev);
2411
2412 uart_get_info(port, &tmp);
2413 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.line);
2414}
2415
2416static ssize_t uart_get_attr_port(struct device *dev,
2417 struct device_attribute *attr, char *buf)
2418{
2419 struct serial_struct tmp;
2420 struct tty_port *port = dev_get_drvdata(dev);
2421 unsigned long ioaddr;
2422
2423 uart_get_info(port, &tmp);
2424 ioaddr = tmp.port;
2425 if (HIGH_BITS_OFFSET)
2426 ioaddr |= (unsigned long)tmp.port_high << HIGH_BITS_OFFSET;
2427 return snprintf(buf, PAGE_SIZE, "0x%lX\n", ioaddr);
2428}
2429
2430static ssize_t uart_get_attr_irq(struct device *dev,
2431 struct device_attribute *attr, char *buf)
2432{
2433 struct serial_struct tmp;
2434 struct tty_port *port = dev_get_drvdata(dev);
2435
2436 uart_get_info(port, &tmp);
2437 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.irq);
2438}
2439
2440static ssize_t uart_get_attr_flags(struct device *dev,
2441 struct device_attribute *attr, char *buf)
2442{
2443 struct serial_struct tmp;
2444 struct tty_port *port = dev_get_drvdata(dev);
2445
2446 uart_get_info(port, &tmp);
2447 return snprintf(buf, PAGE_SIZE, "0x%X\n", tmp.flags);
2448}
2449
2450static ssize_t uart_get_attr_xmit_fifo_size(struct device *dev,
2451 struct device_attribute *attr, char *buf)
2452{
2453 struct serial_struct tmp;
2454 struct tty_port *port = dev_get_drvdata(dev);
2455
2456 uart_get_info(port, &tmp);
2457 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.xmit_fifo_size);
2458}
2459
2460
2461static ssize_t uart_get_attr_close_delay(struct device *dev,
2462 struct device_attribute *attr, char *buf)
2463{
2464 struct serial_struct tmp;
2465 struct tty_port *port = dev_get_drvdata(dev);
2466
2467 uart_get_info(port, &tmp);
2468 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.close_delay);
2469}
2470
2471
2472static ssize_t uart_get_attr_closing_wait(struct device *dev,
2473 struct device_attribute *attr, char *buf)
2474{
2475 struct serial_struct tmp;
2476 struct tty_port *port = dev_get_drvdata(dev);
2477
2478 uart_get_info(port, &tmp);
2479 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.closing_wait);
2480}
2481
2482static ssize_t uart_get_attr_custom_divisor(struct device *dev,
2483 struct device_attribute *attr, char *buf)
2484{
2485 struct serial_struct tmp;
2486 struct tty_port *port = dev_get_drvdata(dev);
2487
2488 uart_get_info(port, &tmp);
2489 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.custom_divisor);
2490}
2491
2492static ssize_t uart_get_attr_io_type(struct device *dev,
2493 struct device_attribute *attr, char *buf)
2494{
2495 struct serial_struct tmp;
2496 struct tty_port *port = dev_get_drvdata(dev);
2497
2498 uart_get_info(port, &tmp);
2499 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.io_type);
2500}
2501
2502static ssize_t uart_get_attr_iomem_base(struct device *dev,
2503 struct device_attribute *attr, char *buf)
2504{
2505 struct serial_struct tmp;
2506 struct tty_port *port = dev_get_drvdata(dev);
2507
2508 uart_get_info(port, &tmp);
2509 return snprintf(buf, PAGE_SIZE, "0x%lX\n", (unsigned long)tmp.iomem_base);
2510}
2511
2512static ssize_t uart_get_attr_iomem_reg_shift(struct device *dev,
2513 struct device_attribute *attr, char *buf)
2514{
2515 struct serial_struct tmp;
2516 struct tty_port *port = dev_get_drvdata(dev);
2517
2518 uart_get_info(port, &tmp);
2519 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.iomem_reg_shift);
2520}
2521
2522static DEVICE_ATTR(type, S_IRUSR | S_IRGRP, uart_get_attr_type, NULL);
2523static DEVICE_ATTR(line, S_IRUSR | S_IRGRP, uart_get_attr_line, NULL);
2524static DEVICE_ATTR(port, S_IRUSR | S_IRGRP, uart_get_attr_port, NULL);
2525static DEVICE_ATTR(irq, S_IRUSR | S_IRGRP, uart_get_attr_irq, NULL);
2526static DEVICE_ATTR(flags, S_IRUSR | S_IRGRP, uart_get_attr_flags, NULL);
2527static DEVICE_ATTR(xmit_fifo_size, S_IRUSR | S_IRGRP, uart_get_attr_xmit_fifo_size, NULL);
2528static DEVICE_ATTR(uartclk, S_IRUSR | S_IRGRP, uart_get_attr_uartclk, NULL);
2529static DEVICE_ATTR(close_delay, S_IRUSR | S_IRGRP, uart_get_attr_close_delay, NULL);
2530static DEVICE_ATTR(closing_wait, S_IRUSR | S_IRGRP, uart_get_attr_closing_wait, NULL);
2531static DEVICE_ATTR(custom_divisor, S_IRUSR | S_IRGRP, uart_get_attr_custom_divisor, NULL);
2532static DEVICE_ATTR(io_type, S_IRUSR | S_IRGRP, uart_get_attr_io_type, NULL);
2533static DEVICE_ATTR(iomem_base, S_IRUSR | S_IRGRP, uart_get_attr_iomem_base, NULL);
2534static DEVICE_ATTR(iomem_reg_shift, S_IRUSR | S_IRGRP, uart_get_attr_iomem_reg_shift, NULL);
2535
2536static struct attribute *tty_dev_attrs[] = {
2537 &dev_attr_type.attr,
2538 &dev_attr_line.attr,
2539 &dev_attr_port.attr,
2540 &dev_attr_irq.attr,
2541 &dev_attr_flags.attr,
2542 &dev_attr_xmit_fifo_size.attr,
2543 &dev_attr_uartclk.attr,
2544 &dev_attr_close_delay.attr,
2545 &dev_attr_closing_wait.attr,
2546 &dev_attr_custom_divisor.attr,
2547 &dev_attr_io_type.attr,
2548 &dev_attr_iomem_base.attr,
2549 &dev_attr_iomem_reg_shift.attr,
2550 NULL,
2551 };
2552
2553static const struct attribute_group tty_dev_attr_group = {
2554 .attrs = tty_dev_attrs,
2555 };
2556
2557static const struct attribute_group *tty_dev_attr_groups[] = {
2558 &tty_dev_attr_group,
2559 NULL
2560 };
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
2574{
2575 struct uart_state *state;
2576 struct tty_port *port;
2577 int ret = 0;
2578 struct device *tty_dev;
2579
2580 BUG_ON(in_interrupt());
2581
2582 if (uport->line >= drv->nr)
2583 return -EINVAL;
2584
2585 state = drv->state + uport->line;
2586 port = &state->port;
2587
2588 mutex_lock(&port_mutex);
2589 mutex_lock(&port->mutex);
2590 if (state->uart_port) {
2591 ret = -EINVAL;
2592 goto out;
2593 }
2594
2595 state->uart_port = uport;
2596 state->pm_state = UART_PM_STATE_UNDEFINED;
2597
2598 uport->cons = drv->cons;
2599 uport->state = state;
2600
2601
2602
2603
2604
2605 if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) {
2606 spin_lock_init(&uport->lock);
2607 lockdep_set_class(&uport->lock, &port_lock_key);
2608 }
2609
2610 uart_configure_port(drv, state, uport);
2611
2612
2613
2614
2615
2616 tty_dev = tty_port_register_device_attr(port, drv->tty_driver,
2617 uport->line, uport->dev, port, tty_dev_attr_groups);
2618 if (likely(!IS_ERR(tty_dev))) {
2619 device_set_wakeup_capable(tty_dev, 1);
2620 } else {
2621 printk(KERN_ERR "Cannot register tty device on line %d\n",
2622 uport->line);
2623 }
2624
2625
2626
2627
2628 uport->flags &= ~UPF_DEAD;
2629
2630 out:
2631 mutex_unlock(&port->mutex);
2632 mutex_unlock(&port_mutex);
2633
2634 return ret;
2635}
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
2647{
2648 struct uart_state *state = drv->state + uport->line;
2649 struct tty_port *port = &state->port;
2650 int ret = 0;
2651
2652 BUG_ON(in_interrupt());
2653
2654 if (state->uart_port != uport)
2655 printk(KERN_ALERT "Removing wrong port: %p != %p\n",
2656 state->uart_port, uport);
2657
2658 mutex_lock(&port_mutex);
2659
2660
2661
2662
2663
2664 mutex_lock(&port->mutex);
2665 if (!state->uart_port) {
2666 mutex_unlock(&port->mutex);
2667 ret = -EINVAL;
2668 goto out;
2669 }
2670 uport->flags |= UPF_DEAD;
2671 mutex_unlock(&port->mutex);
2672
2673
2674
2675
2676 tty_unregister_device(drv->tty_driver, uport->line);
2677
2678 if (port->tty)
2679 tty_vhangup(port->tty);
2680
2681
2682
2683
2684 if (uport->type != PORT_UNKNOWN)
2685 uport->ops->release_port(uport);
2686
2687
2688
2689
2690 uport->type = PORT_UNKNOWN;
2691
2692 state->uart_port = NULL;
2693out:
2694 mutex_unlock(&port_mutex);
2695
2696 return ret;
2697}
2698
2699
2700
2701
2702int uart_match_port(struct uart_port *port1, struct uart_port *port2)
2703{
2704 if (port1->iotype != port2->iotype)
2705 return 0;
2706
2707 switch (port1->iotype) {
2708 case UPIO_PORT:
2709 return (port1->iobase == port2->iobase);
2710 case UPIO_HUB6:
2711 return (port1->iobase == port2->iobase) &&
2712 (port1->hub6 == port2->hub6);
2713 case UPIO_MEM:
2714 case UPIO_MEM32:
2715 case UPIO_AU:
2716 case UPIO_TSI:
2717 return (port1->mapbase == port2->mapbase);
2718 }
2719 return 0;
2720}
2721EXPORT_SYMBOL(uart_match_port);
2722
2723
2724
2725
2726
2727
2728void uart_handle_dcd_change(struct uart_port *uport, unsigned int status)
2729{
2730 struct tty_port *port = &uport->state->port;
2731 struct tty_struct *tty = port->tty;
2732 struct tty_ldisc *ld = tty ? tty_ldisc_ref(tty) : NULL;
2733
2734 if (ld) {
2735 if (ld->ops->dcd_change)
2736 ld->ops->dcd_change(tty, status);
2737 tty_ldisc_deref(ld);
2738 }
2739
2740 uport->icount.dcd++;
2741
2742 if (port->flags & ASYNC_CHECK_CD) {
2743 if (status)
2744 wake_up_interruptible(&port->open_wait);
2745 else if (tty)
2746 tty_hangup(tty);
2747 }
2748}
2749EXPORT_SYMBOL_GPL(uart_handle_dcd_change);
2750
2751
2752
2753
2754
2755
2756void uart_handle_cts_change(struct uart_port *uport, unsigned int status)
2757{
2758 struct tty_port *port = &uport->state->port;
2759 struct tty_struct *tty = port->tty;
2760
2761 uport->icount.cts++;
2762
2763 if (tty_port_cts_enabled(port)) {
2764 if (tty->hw_stopped) {
2765 if (status) {
2766 tty->hw_stopped = 0;
2767 uport->ops->start_tx(uport);
2768 uart_write_wakeup(uport);
2769 }
2770 } else {
2771 if (!status) {
2772 tty->hw_stopped = 1;
2773 uport->ops->stop_tx(uport);
2774 }
2775 }
2776 }
2777}
2778EXPORT_SYMBOL_GPL(uart_handle_cts_change);
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792void uart_insert_char(struct uart_port *port, unsigned int status,
2793 unsigned int overrun, unsigned int ch, unsigned int flag)
2794{
2795 struct tty_port *tport = &port->state->port;
2796
2797 if ((status & port->ignore_status_mask & ~overrun) == 0)
2798 if (tty_insert_flip_char(tport, ch, flag) == 0)
2799 ++port->icount.buf_overrun;
2800
2801
2802
2803
2804
2805 if (status & ~port->ignore_status_mask & overrun)
2806 if (tty_insert_flip_char(tport, 0, TTY_OVERRUN) == 0)
2807 ++port->icount.buf_overrun;
2808}
2809EXPORT_SYMBOL_GPL(uart_insert_char);
2810
2811EXPORT_SYMBOL(uart_write_wakeup);
2812EXPORT_SYMBOL(uart_register_driver);
2813EXPORT_SYMBOL(uart_unregister_driver);
2814EXPORT_SYMBOL(uart_suspend_port);
2815EXPORT_SYMBOL(uart_resume_port);
2816EXPORT_SYMBOL(uart_add_one_port);
2817EXPORT_SYMBOL(uart_remove_one_port);
2818
2819MODULE_DESCRIPTION("Serial driver core");
2820MODULE_LICENSE("GPL");
2821