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