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