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