Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0+
2 : /*
3 : * Driver core for serial ports
4 : *
5 : * Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
6 : *
7 : * Copyright 1999 ARM Limited
8 : * Copyright (C) 2000-2001 Deep Blue Solutions Ltd.
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> /* for serial_state and serial_icounter_struct */
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 : * This is used to lock changes in serial line configuration.
34 : */
35 : static DEFINE_MUTEX(port_mutex);
36 :
37 : /*
38 : * lockdep: port->lock is initialized in two places, but we
39 : * want only one lock-class:
40 : */
41 : static struct lock_class_key port_lock_key;
42 :
43 : #define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8)
44 :
45 : static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
46 : struct ktermios *old_termios);
47 : static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
48 : static void uart_change_pm(struct uart_state *state,
49 : enum uart_pm_state pm_state);
50 :
51 : static void uart_port_shutdown(struct tty_port *port);
52 :
53 0 : static int uart_dcd_enabled(struct uart_port *uport)
54 : {
55 0 : return !!(uport->status & UPSTAT_DCD_ENABLE);
56 : }
57 :
58 1363 : static inline struct uart_port *uart_port_ref(struct uart_state *state)
59 : {
60 2726 : if (atomic_add_unless(&state->refcount, 1, 0))
61 1363 : return state->uart_port;
62 : return NULL;
63 : }
64 :
65 1363 : static inline void uart_port_deref(struct uart_port *uport)
66 : {
67 2726 : if (atomic_dec_and_test(&uport->state->refcount))
68 0 : wake_up(&uport->state->remove_wait);
69 1363 : }
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 :
88 145 : static inline struct uart_port *uart_port_check(struct uart_state *state)
89 : {
90 290 : lockdep_assert_held(&state->port.mutex);
91 145 : return state->uart_port;
92 : }
93 :
94 : /*
95 : * This routine is used by the interrupt handler to schedule processing in
96 : * the software interrupt portion of the driver.
97 : */
98 712 : void uart_write_wakeup(struct uart_port *port)
99 : {
100 712 : struct uart_state *state = port->state;
101 : /*
102 : * This means you called this function _after_ the port was
103 : * closed. No cookie for you.
104 : */
105 712 : BUG_ON(!state);
106 712 : tty_port_tty_wakeup(&state->port);
107 712 : }
108 :
109 0 : static void uart_stop(struct tty_struct *tty)
110 : {
111 0 : struct uart_state *state = tty->driver_data;
112 0 : struct uart_port *port;
113 0 : unsigned long flags;
114 :
115 0 : port = uart_port_lock(state, flags);
116 0 : if (port)
117 0 : port->ops->stop_tx(port);
118 0 : uart_port_unlock(port, flags);
119 0 : }
120 :
121 397 : static void __uart_start(struct tty_struct *tty)
122 : {
123 397 : struct uart_state *state = tty->driver_data;
124 397 : struct uart_port *port = state->uart_port;
125 :
126 397 : if (port && !uart_tx_stopped(port))
127 397 : port->ops->start_tx(port);
128 397 : }
129 :
130 131 : static void uart_start(struct tty_struct *tty)
131 : {
132 131 : struct uart_state *state = tty->driver_data;
133 131 : struct uart_port *port;
134 131 : unsigned long flags;
135 :
136 131 : port = uart_port_lock(state, flags);
137 131 : __uart_start(tty);
138 131 : uart_port_unlock(port, flags);
139 131 : }
140 :
141 : static void
142 135 : uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
143 : {
144 135 : unsigned long flags;
145 135 : unsigned int old;
146 :
147 135 : spin_lock_irqsave(&port->lock, flags);
148 135 : old = port->mctrl;
149 135 : port->mctrl = (old & ~clear) | set;
150 135 : if (old != port->mctrl)
151 1 : port->ops->set_mctrl(port, port->mctrl);
152 135 : spin_unlock_irqrestore(&port->lock, flags);
153 135 : }
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 :
158 135 : static void uart_port_dtr_rts(struct uart_port *uport, int raise)
159 : {
160 135 : int rs485_on = uport->rs485_config &&
161 0 : (uport->rs485.flags & SER_RS485_ENABLED);
162 135 : int RTS_after_send = !!(uport->rs485.flags & SER_RS485_RTS_AFTER_SEND);
163 :
164 135 : if (raise) {
165 135 : if (rs485_on && !RTS_after_send) {
166 0 : uart_set_mctrl(uport, TIOCM_DTR);
167 0 : uart_clear_mctrl(uport, TIOCM_RTS);
168 : } else {
169 135 : uart_set_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
170 : }
171 : } else {
172 0 : unsigned int clear = TIOCM_DTR;
173 :
174 0 : clear |= (!rs485_on || !RTS_after_send) ? TIOCM_RTS : 0;
175 0 : uart_clear_mctrl(uport, clear);
176 : }
177 135 : }
178 :
179 : /*
180 : * Startup the port. This will be called once per open. All calls
181 : * will be serialised by the per-port mutex.
182 : */
183 1 : static int uart_port_startup(struct tty_struct *tty, struct uart_state *state,
184 : int init_hw)
185 : {
186 1 : struct uart_port *uport = uart_port_check(state);
187 1 : unsigned long page;
188 1 : unsigned long flags = 0;
189 1 : int retval = 0;
190 :
191 1 : if (uport->type == PORT_UNKNOWN)
192 : return 1;
193 :
194 : /*
195 : * Make sure the device is in D0 state.
196 : */
197 1 : uart_change_pm(state, UART_PM_STATE_ON);
198 :
199 : /*
200 : * Initialise and allocate the transmit and temporary
201 : * buffer.
202 : */
203 1 : page = get_zeroed_page(GFP_KERNEL);
204 1 : if (!page)
205 : return -ENOMEM;
206 :
207 1 : uart_port_lock(state, flags);
208 1 : if (!state->xmit.buf) {
209 1 : state->xmit.buf = (unsigned char *) page;
210 1 : uart_circ_clear(&state->xmit);
211 1 : uart_port_unlock(uport, flags);
212 : } else {
213 0 : uart_port_unlock(uport, flags);
214 : /*
215 : * Do not free() the page under the port lock, see
216 : * uart_shutdown().
217 : */
218 0 : free_page(page);
219 : }
220 :
221 1 : retval = uport->ops->startup(uport);
222 1 : if (retval == 0) {
223 1 : if (uart_console(uport) && uport->cons->cflag) {
224 1 : tty->termios.c_cflag = uport->cons->cflag;
225 1 : uport->cons->cflag = 0;
226 : }
227 : /*
228 : * Initialise the hardware port settings.
229 : */
230 1 : uart_change_speed(tty, state, NULL);
231 :
232 : /*
233 : * Setup the RTS and DTR signals once the
234 : * port is open and ready to respond.
235 : */
236 1 : if (init_hw && C_BAUD(tty))
237 0 : uart_port_dtr_rts(uport, 1);
238 : }
239 :
240 : /*
241 : * This is to allow setserial on this port. People may want to set
242 : * port/irq/type and then reconfigure the port properly if it failed
243 : * now.
244 : */
245 1 : if (retval && capable(CAP_SYS_ADMIN))
246 0 : return 1;
247 :
248 : return retval;
249 : }
250 :
251 1 : static int uart_startup(struct tty_struct *tty, struct uart_state *state,
252 : int init_hw)
253 : {
254 1 : struct tty_port *port = &state->port;
255 1 : int retval;
256 :
257 1 : if (tty_port_initialized(port))
258 : return 0;
259 :
260 1 : retval = uart_port_startup(tty, state, init_hw);
261 1 : if (retval)
262 0 : set_bit(TTY_IO_ERROR, &tty->flags);
263 :
264 : return retval;
265 : }
266 :
267 : /*
268 : * This routine will shutdown a serial port; interrupts are disabled, and
269 : * DTR is dropped if the hangup on close termio flag is on. Calls to
270 : * uart_shutdown are serialised by the per-port semaphore.
271 : *
272 : * uport == NULL if uart_port has already been removed
273 : */
274 0 : static void uart_shutdown(struct tty_struct *tty, struct uart_state *state)
275 : {
276 0 : struct uart_port *uport = uart_port_check(state);
277 0 : struct tty_port *port = &state->port;
278 0 : unsigned long flags = 0;
279 0 : char *xmit_buf = NULL;
280 :
281 : /*
282 : * Set the TTY IO error marker
283 : */
284 0 : if (tty)
285 0 : set_bit(TTY_IO_ERROR, &tty->flags);
286 :
287 0 : if (tty_port_initialized(port)) {
288 0 : tty_port_set_initialized(port, 0);
289 :
290 : /*
291 : * Turn off DTR and RTS early.
292 : */
293 0 : if (uport && uart_console(uport) && tty)
294 0 : uport->cons->cflag = tty->termios.c_cflag;
295 :
296 0 : if (!tty || C_HUPCL(tty))
297 0 : uart_port_dtr_rts(uport, 0);
298 :
299 0 : uart_port_shutdown(port);
300 : }
301 :
302 : /*
303 : * It's possible for shutdown to be called after suspend if we get
304 : * a DCD drop (hangup) at just the right time. Clear suspended bit so
305 : * we don't try to resume a port that has been shutdown.
306 : */
307 0 : tty_port_set_suspended(port, 0);
308 :
309 : /*
310 : * Do not free() the transmit buffer page under the port lock since
311 : * this can create various circular locking scenarios. For instance,
312 : * console driver may need to allocate/free a debug object, which
313 : * can endup in printk() recursion.
314 : */
315 0 : uart_port_lock(state, flags);
316 0 : xmit_buf = state->xmit.buf;
317 0 : state->xmit.buf = NULL;
318 0 : uart_port_unlock(uport, flags);
319 :
320 0 : if (xmit_buf)
321 0 : free_page((unsigned long)xmit_buf);
322 0 : }
323 :
324 : /**
325 : * uart_update_timeout - update per-port FIFO timeout.
326 : * @port: uart_port structure describing the port
327 : * @cflag: termios cflag value
328 : * @baud: speed of the port
329 : *
330 : * Set the port FIFO timeout value. The @cflag value should
331 : * reflect the actual hardware settings.
332 : */
333 : void
334 2 : uart_update_timeout(struct uart_port *port, unsigned int cflag,
335 : unsigned int baud)
336 : {
337 2 : unsigned int bits;
338 :
339 : /* byte size and parity */
340 2 : switch (cflag & CSIZE) {
341 : case CS5:
342 : bits = 7;
343 : break;
344 0 : case CS6:
345 0 : bits = 8;
346 0 : break;
347 0 : case CS7:
348 0 : bits = 9;
349 0 : break;
350 2 : default:
351 2 : bits = 10;
352 2 : break; /* CS8 */
353 : }
354 :
355 2 : if (cflag & CSTOPB)
356 0 : bits++;
357 2 : if (cflag & PARENB)
358 0 : bits++;
359 :
360 : /*
361 : * The total number of bits to be transmitted in the fifo.
362 : */
363 2 : bits = bits * port->fifosize;
364 :
365 : /*
366 : * Figure the timeout to send the above number of bits.
367 : * Add .02 seconds of slop
368 : */
369 2 : port->timeout = (HZ * bits) / baud + HZ/50;
370 2 : }
371 :
372 : EXPORT_SYMBOL(uart_update_timeout);
373 :
374 : /**
375 : * uart_get_baud_rate - return baud rate for a particular port
376 : * @port: uart_port structure describing the port in question.
377 : * @termios: desired termios settings.
378 : * @old: old termios (or NULL)
379 : * @min: minimum acceptable baud rate
380 : * @max: maximum acceptable baud rate
381 : *
382 : * Decode the termios structure into a numeric baud rate,
383 : * taking account of the magic 38400 baud rate (with spd_*
384 : * flags), and mapping the %B0 rate to 9600 baud.
385 : *
386 : * If the new baud rate is invalid, try the old termios setting.
387 : * If it's still invalid, we try 9600 baud.
388 : *
389 : * Update the @termios structure to reflect the baud rate
390 : * we're actually going to be using. Don't do this for the case
391 : * where B0 is requested ("hang up").
392 : */
393 : unsigned int
394 2 : uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
395 : struct ktermios *old, unsigned int min, unsigned int max)
396 : {
397 2 : unsigned int try;
398 2 : unsigned int baud;
399 2 : unsigned int altbaud;
400 2 : int hung_up = 0;
401 2 : upf_t flags = port->flags & UPF_SPD_MASK;
402 :
403 2 : switch (flags) {
404 : case UPF_SPD_HI:
405 : altbaud = 57600;
406 : break;
407 0 : case UPF_SPD_VHI:
408 0 : altbaud = 115200;
409 0 : break;
410 0 : case UPF_SPD_SHI:
411 0 : altbaud = 230400;
412 0 : break;
413 0 : case UPF_SPD_WARP:
414 0 : altbaud = 460800;
415 0 : break;
416 2 : default:
417 2 : altbaud = 38400;
418 2 : break;
419 : }
420 :
421 2 : for (try = 0; try < 2; try++) {
422 2 : baud = tty_termios_baud_rate(termios);
423 :
424 : /*
425 : * The spd_hi, spd_vhi, spd_shi, spd_warp kludge...
426 : * Die! Die! Die!
427 : */
428 2 : if (try == 0 && baud == 38400)
429 0 : baud = altbaud;
430 :
431 : /*
432 : * Special case: B0 rate.
433 : */
434 2 : if (baud == 0) {
435 0 : hung_up = 1;
436 0 : baud = 9600;
437 : }
438 :
439 2 : if (baud >= min && baud <= max)
440 2 : return baud;
441 :
442 : /*
443 : * Oops, the quotient was zero. Try again with
444 : * the old baud rate if possible.
445 : */
446 0 : termios->c_cflag &= ~CBAUD;
447 0 : if (old) {
448 0 : baud = tty_termios_baud_rate(old);
449 0 : if (!hung_up)
450 0 : tty_termios_encode_baud_rate(termios,
451 : baud, baud);
452 0 : old = NULL;
453 0 : continue;
454 : }
455 :
456 : /*
457 : * As a last resort, if the range cannot be met then clip to
458 : * the nearest chip supported rate.
459 : */
460 0 : if (!hung_up) {
461 0 : if (baud <= min)
462 0 : tty_termios_encode_baud_rate(termios,
463 : min + 1, min + 1);
464 : else
465 0 : tty_termios_encode_baud_rate(termios,
466 : max - 1, max - 1);
467 : }
468 : }
469 : /* Should never happen */
470 0 : WARN_ON(1);
471 0 : return 0;
472 : }
473 :
474 : EXPORT_SYMBOL(uart_get_baud_rate);
475 :
476 : /**
477 : * uart_get_divisor - return uart clock divisor
478 : * @port: uart_port structure describing the port.
479 : * @baud: desired baud rate
480 : *
481 : * Calculate the uart clock divisor for the port.
482 : */
483 : unsigned int
484 2 : uart_get_divisor(struct uart_port *port, unsigned int baud)
485 : {
486 2 : unsigned int quot;
487 :
488 : /*
489 : * Old custom speed handling.
490 : */
491 2 : if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)
492 0 : quot = port->custom_divisor;
493 : else
494 2 : quot = DIV_ROUND_CLOSEST(port->uartclk, 16 * baud);
495 :
496 2 : return quot;
497 : }
498 :
499 : EXPORT_SYMBOL(uart_get_divisor);
500 :
501 : /* Caller holds port mutex */
502 1 : static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
503 : struct ktermios *old_termios)
504 : {
505 1 : struct uart_port *uport = uart_port_check(state);
506 1 : struct ktermios *termios;
507 1 : int hw_stopped;
508 :
509 : /*
510 : * If we have no tty, termios, or the port does not exist,
511 : * then we can't set the parameters for this port.
512 : */
513 1 : if (!tty || uport->type == PORT_UNKNOWN)
514 : return;
515 :
516 1 : termios = &tty->termios;
517 1 : uport->ops->set_termios(uport, termios, old_termios);
518 :
519 : /*
520 : * Set modem status enables based on termios cflag
521 : */
522 1 : spin_lock_irq(&uport->lock);
523 1 : if (termios->c_cflag & CRTSCTS)
524 0 : uport->status |= UPSTAT_CTS_ENABLE;
525 : else
526 1 : uport->status &= ~UPSTAT_CTS_ENABLE;
527 :
528 1 : if (termios->c_cflag & CLOCAL)
529 1 : uport->status &= ~UPSTAT_DCD_ENABLE;
530 : else
531 0 : uport->status |= UPSTAT_DCD_ENABLE;
532 :
533 : /* reset sw-assisted CTS flow control based on (possibly) new mode */
534 1 : hw_stopped = uport->hw_stopped;
535 1 : uport->hw_stopped = uart_softcts_mode(uport) &&
536 0 : !(uport->ops->get_mctrl(uport) & TIOCM_CTS);
537 1 : if (uport->hw_stopped) {
538 0 : if (!hw_stopped)
539 0 : uport->ops->stop_tx(uport);
540 : } else {
541 1 : if (hw_stopped)
542 0 : __uart_start(tty);
543 : }
544 1 : spin_unlock_irq(&uport->lock);
545 : }
546 :
547 0 : static int uart_put_char(struct tty_struct *tty, unsigned char c)
548 : {
549 0 : struct uart_state *state = tty->driver_data;
550 0 : struct uart_port *port;
551 0 : struct circ_buf *circ;
552 0 : unsigned long flags;
553 0 : int ret = 0;
554 :
555 0 : circ = &state->xmit;
556 0 : port = uart_port_lock(state, flags);
557 0 : if (!circ->buf) {
558 0 : uart_port_unlock(port, flags);
559 0 : return 0;
560 : }
561 :
562 0 : if (port && uart_circ_chars_free(circ) != 0) {
563 0 : circ->buf[circ->head] = c;
564 0 : circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1);
565 0 : ret = 1;
566 : }
567 0 : uart_port_unlock(port, flags);
568 : return ret;
569 : }
570 :
571 131 : static void uart_flush_chars(struct tty_struct *tty)
572 : {
573 131 : uart_start(tty);
574 131 : }
575 :
576 266 : static int uart_write(struct tty_struct *tty,
577 : const unsigned char *buf, int count)
578 : {
579 266 : struct uart_state *state = tty->driver_data;
580 266 : struct uart_port *port;
581 266 : struct circ_buf *circ;
582 266 : unsigned long flags;
583 266 : int c, ret = 0;
584 :
585 : /*
586 : * This means you called this function _after_ the port was
587 : * closed. No cookie for you.
588 : */
589 266 : if (!state) {
590 0 : WARN_ON(1);
591 0 : return -EL3HLT;
592 : }
593 :
594 266 : port = uart_port_lock(state, flags);
595 266 : circ = &state->xmit;
596 266 : if (!circ->buf) {
597 0 : uart_port_unlock(port, flags);
598 0 : return 0;
599 : }
600 :
601 532 : while (port) {
602 532 : c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
603 532 : if (count < c)
604 : c = count;
605 532 : if (c <= 0)
606 : break;
607 266 : memcpy(circ->buf + circ->head, buf, c);
608 266 : circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
609 266 : buf += c;
610 266 : count -= c;
611 266 : ret += c;
612 : }
613 :
614 266 : __uart_start(tty);
615 266 : uart_port_unlock(port, flags);
616 : return ret;
617 : }
618 :
619 266 : static int uart_write_room(struct tty_struct *tty)
620 : {
621 266 : struct uart_state *state = tty->driver_data;
622 266 : struct uart_port *port;
623 266 : unsigned long flags;
624 266 : int ret;
625 :
626 266 : port = uart_port_lock(state, flags);
627 266 : ret = uart_circ_chars_free(&state->xmit);
628 266 : uart_port_unlock(port, flags);
629 266 : return ret;
630 : }
631 :
632 428 : static int uart_chars_in_buffer(struct tty_struct *tty)
633 : {
634 428 : struct uart_state *state = tty->driver_data;
635 428 : struct uart_port *port;
636 428 : unsigned long flags;
637 428 : int ret;
638 :
639 428 : port = uart_port_lock(state, flags);
640 428 : ret = uart_circ_chars_pending(&state->xmit);
641 428 : uart_port_unlock(port, flags);
642 428 : return ret;
643 : }
644 :
645 1 : static void uart_flush_buffer(struct tty_struct *tty)
646 : {
647 1 : struct uart_state *state = tty->driver_data;
648 1 : struct uart_port *port;
649 1 : unsigned long flags;
650 :
651 : /*
652 : * This means you called this function _after_ the port was
653 : * closed. No cookie for you.
654 : */
655 1 : if (!state) {
656 0 : WARN_ON(1);
657 0 : return;
658 : }
659 :
660 1 : pr_debug("uart_flush_buffer(%d) called\n", tty->index);
661 :
662 1 : port = uart_port_lock(state, flags);
663 1 : if (!port)
664 : return;
665 1 : uart_circ_clear(&state->xmit);
666 1 : if (port->ops->flush_buffer)
667 0 : port->ops->flush_buffer(port);
668 1 : uart_port_unlock(port, flags);
669 1 : tty_port_tty_wakeup(&state->port);
670 : }
671 :
672 : /*
673 : * This function is used to send a high-priority XON/XOFF character to
674 : * the device
675 : */
676 0 : static void uart_send_xchar(struct tty_struct *tty, char ch)
677 : {
678 0 : struct uart_state *state = tty->driver_data;
679 0 : struct uart_port *port;
680 0 : unsigned long flags;
681 :
682 0 : port = uart_port_ref(state);
683 0 : if (!port)
684 : return;
685 :
686 0 : if (port->ops->send_xchar)
687 0 : port->ops->send_xchar(port, ch);
688 : else {
689 0 : spin_lock_irqsave(&port->lock, flags);
690 0 : port->x_char = ch;
691 0 : if (ch)
692 0 : port->ops->start_tx(port);
693 0 : spin_unlock_irqrestore(&port->lock, flags);
694 : }
695 0 : uart_port_deref(port);
696 : }
697 :
698 0 : static void uart_throttle(struct tty_struct *tty)
699 : {
700 0 : struct uart_state *state = tty->driver_data;
701 0 : upstat_t mask = UPSTAT_SYNC_FIFO;
702 0 : struct uart_port *port;
703 :
704 0 : port = uart_port_ref(state);
705 0 : if (!port)
706 : return;
707 :
708 0 : if (I_IXOFF(tty))
709 0 : mask |= UPSTAT_AUTOXOFF;
710 0 : if (C_CRTSCTS(tty))
711 0 : mask |= UPSTAT_AUTORTS;
712 :
713 0 : if (port->status & mask) {
714 0 : port->ops->throttle(port);
715 0 : mask &= ~port->status;
716 : }
717 :
718 0 : if (mask & UPSTAT_AUTORTS)
719 0 : uart_clear_mctrl(port, TIOCM_RTS);
720 :
721 0 : if (mask & UPSTAT_AUTOXOFF)
722 0 : uart_send_xchar(tty, STOP_CHAR(tty));
723 :
724 0 : uart_port_deref(port);
725 : }
726 :
727 0 : static void uart_unthrottle(struct tty_struct *tty)
728 : {
729 0 : struct uart_state *state = tty->driver_data;
730 0 : upstat_t mask = UPSTAT_SYNC_FIFO;
731 0 : struct uart_port *port;
732 :
733 0 : port = uart_port_ref(state);
734 0 : if (!port)
735 : return;
736 :
737 0 : if (I_IXOFF(tty))
738 0 : mask |= UPSTAT_AUTOXOFF;
739 0 : if (C_CRTSCTS(tty))
740 0 : mask |= UPSTAT_AUTORTS;
741 :
742 0 : if (port->status & mask) {
743 0 : port->ops->unthrottle(port);
744 0 : mask &= ~port->status;
745 : }
746 :
747 0 : if (mask & UPSTAT_AUTORTS)
748 0 : uart_set_mctrl(port, TIOCM_RTS);
749 :
750 0 : if (mask & UPSTAT_AUTOXOFF)
751 0 : uart_send_xchar(tty, START_CHAR(tty));
752 :
753 0 : uart_port_deref(port);
754 : }
755 :
756 0 : static int uart_get_info(struct tty_port *port, struct serial_struct *retinfo)
757 : {
758 0 : struct uart_state *state = container_of(port, struct uart_state, port);
759 0 : struct uart_port *uport;
760 0 : int ret = -ENODEV;
761 :
762 0 : memset(retinfo, 0, sizeof(*retinfo));
763 :
764 : /*
765 : * Ensure the state we copy is consistent and no hardware changes
766 : * occur as we go
767 : */
768 0 : mutex_lock(&port->mutex);
769 0 : uport = uart_port_check(state);
770 0 : if (!uport)
771 0 : goto out;
772 :
773 0 : retinfo->type = uport->type;
774 0 : retinfo->line = uport->line;
775 0 : retinfo->port = uport->iobase;
776 0 : if (HIGH_BITS_OFFSET)
777 0 : retinfo->port_high = (long) uport->iobase >> HIGH_BITS_OFFSET;
778 0 : retinfo->irq = uport->irq;
779 0 : retinfo->flags = (__force int)uport->flags;
780 0 : retinfo->xmit_fifo_size = uport->fifosize;
781 0 : retinfo->baud_base = uport->uartclk / 16;
782 0 : retinfo->close_delay = jiffies_to_msecs(port->close_delay) / 10;
783 0 : retinfo->closing_wait = port->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
784 : ASYNC_CLOSING_WAIT_NONE :
785 0 : jiffies_to_msecs(port->closing_wait) / 10;
786 0 : retinfo->custom_divisor = uport->custom_divisor;
787 0 : retinfo->hub6 = uport->hub6;
788 0 : retinfo->io_type = uport->iotype;
789 0 : retinfo->iomem_reg_shift = uport->regshift;
790 0 : retinfo->iomem_base = (void *)(unsigned long)uport->mapbase;
791 :
792 0 : ret = 0;
793 0 : out:
794 0 : mutex_unlock(&port->mutex);
795 0 : return ret;
796 : }
797 :
798 0 : static int uart_get_info_user(struct tty_struct *tty,
799 : struct serial_struct *ss)
800 : {
801 0 : struct uart_state *state = tty->driver_data;
802 0 : struct tty_port *port = &state->port;
803 :
804 0 : return uart_get_info(port, ss) < 0 ? -EIO : 0;
805 : }
806 :
807 0 : static 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 0 : struct uart_port *uport = uart_port_check(state);
812 0 : unsigned long new_port;
813 0 : unsigned int change_irq, change_port, closing_wait;
814 0 : unsigned int old_custom_divisor, close_delay;
815 0 : upf_t old_flags, new_flags;
816 0 : int retval = 0;
817 :
818 0 : if (!uport)
819 : return -EIO;
820 :
821 0 : new_port = new_info->port;
822 0 : if (HIGH_BITS_OFFSET)
823 0 : new_port += (unsigned long) new_info->port_high << HIGH_BITS_OFFSET;
824 :
825 0 : new_info->irq = irq_canonicalize(new_info->irq);
826 0 : close_delay = msecs_to_jiffies(new_info->close_delay * 10);
827 0 : closing_wait = new_info->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
828 : ASYNC_CLOSING_WAIT_NONE :
829 0 : msecs_to_jiffies(new_info->closing_wait * 10);
830 :
831 :
832 0 : change_irq = !(uport->flags & UPF_FIXED_PORT)
833 0 : && new_info->irq != uport->irq;
834 :
835 : /*
836 : * Since changing the 'type' of the port changes its resource
837 : * allocations, we should treat type changes the same as
838 : * IO port changes.
839 : */
840 0 : change_port = !(uport->flags & UPF_FIXED_PORT)
841 0 : && (new_port != uport->iobase ||
842 0 : (unsigned long)new_info->iomem_base != uport->mapbase ||
843 0 : new_info->hub6 != uport->hub6 ||
844 0 : new_info->io_type != uport->iotype ||
845 0 : new_info->iomem_reg_shift != uport->regshift ||
846 0 : new_info->type != uport->type);
847 :
848 0 : old_flags = uport->flags;
849 0 : new_flags = (__force upf_t)new_info->flags;
850 0 : old_custom_divisor = uport->custom_divisor;
851 :
852 0 : if (!capable(CAP_SYS_ADMIN)) {
853 0 : retval = -EPERM;
854 0 : if (change_irq || change_port ||
855 0 : (new_info->baud_base != uport->uartclk / 16) ||
856 0 : (close_delay != port->close_delay) ||
857 0 : (closing_wait != port->closing_wait) ||
858 0 : (new_info->xmit_fifo_size &&
859 0 : new_info->xmit_fifo_size != uport->fifosize) ||
860 0 : (((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0))
861 0 : goto exit;
862 0 : uport->flags = ((uport->flags & ~UPF_USR_MASK) |
863 0 : (new_flags & UPF_USR_MASK));
864 0 : uport->custom_divisor = new_info->custom_divisor;
865 0 : goto check_and_exit;
866 : }
867 :
868 0 : retval = security_locked_down(LOCKDOWN_TIOCSSERIAL);
869 0 : if (retval && (change_irq || change_port))
870 0 : goto exit;
871 :
872 : /*
873 : * Ask the low level driver to verify the settings.
874 : */
875 0 : if (uport->ops->verify_port)
876 0 : retval = uport->ops->verify_port(uport, new_info);
877 :
878 0 : if ((new_info->irq >= nr_irqs) || (new_info->irq < 0) ||
879 0 : (new_info->baud_base < 9600))
880 : retval = -EINVAL;
881 :
882 0 : if (retval)
883 0 : goto exit;
884 :
885 0 : if (change_port || change_irq) {
886 0 : retval = -EBUSY;
887 :
888 : /*
889 : * Make sure that we are the sole user of this port.
890 : */
891 0 : if (tty_port_users(port) > 1)
892 0 : goto exit;
893 :
894 : /*
895 : * We need to shutdown the serial port at the old
896 : * port/type/irq combination.
897 : */
898 0 : uart_shutdown(tty, state);
899 : }
900 :
901 0 : if (change_port) {
902 0 : unsigned long old_iobase, old_mapbase;
903 0 : unsigned int old_type, old_iotype, old_hub6, old_shift;
904 :
905 0 : old_iobase = uport->iobase;
906 0 : old_mapbase = uport->mapbase;
907 0 : old_type = uport->type;
908 0 : old_hub6 = uport->hub6;
909 0 : old_iotype = uport->iotype;
910 0 : old_shift = uport->regshift;
911 :
912 : /*
913 : * Free and release old regions
914 : */
915 0 : if (old_type != PORT_UNKNOWN && uport->ops->release_port)
916 0 : uport->ops->release_port(uport);
917 :
918 0 : uport->iobase = new_port;
919 0 : uport->type = new_info->type;
920 0 : uport->hub6 = new_info->hub6;
921 0 : uport->iotype = new_info->io_type;
922 0 : uport->regshift = new_info->iomem_reg_shift;
923 0 : uport->mapbase = (unsigned long)new_info->iomem_base;
924 :
925 : /*
926 : * Claim and map the new regions
927 : */
928 0 : if (uport->type != PORT_UNKNOWN && uport->ops->request_port) {
929 0 : retval = uport->ops->request_port(uport);
930 : } else {
931 : /* Always success - Jean II */
932 : retval = 0;
933 : }
934 :
935 : /*
936 : * If we fail to request resources for the
937 : * new port, try to restore the old settings.
938 : */
939 0 : if (retval) {
940 0 : uport->iobase = old_iobase;
941 0 : uport->type = old_type;
942 0 : uport->hub6 = old_hub6;
943 0 : uport->iotype = old_iotype;
944 0 : uport->regshift = old_shift;
945 0 : uport->mapbase = old_mapbase;
946 :
947 0 : if (old_type != PORT_UNKNOWN) {
948 0 : retval = uport->ops->request_port(uport);
949 : /*
950 : * If we failed to restore the old settings,
951 : * we fail like this.
952 : */
953 0 : if (retval)
954 0 : uport->type = PORT_UNKNOWN;
955 :
956 : /*
957 : * We failed anyway.
958 : */
959 : retval = -EBUSY;
960 : }
961 :
962 : /* Added to return the correct error -Ram Gupta */
963 0 : goto exit;
964 : }
965 : }
966 :
967 0 : if (change_irq)
968 0 : uport->irq = new_info->irq;
969 0 : if (!(uport->flags & UPF_FIXED_PORT))
970 0 : uport->uartclk = new_info->baud_base * 16;
971 0 : uport->flags = (uport->flags & ~UPF_CHANGE_MASK) |
972 0 : (new_flags & UPF_CHANGE_MASK);
973 0 : uport->custom_divisor = new_info->custom_divisor;
974 0 : port->close_delay = close_delay;
975 0 : port->closing_wait = closing_wait;
976 0 : if (new_info->xmit_fifo_size)
977 0 : uport->fifosize = new_info->xmit_fifo_size;
978 :
979 0 : check_and_exit:
980 0 : retval = 0;
981 0 : if (uport->type == PORT_UNKNOWN)
982 0 : goto exit;
983 0 : if (tty_port_initialized(port)) {
984 0 : if (((old_flags ^ uport->flags) & UPF_SPD_MASK) ||
985 0 : old_custom_divisor != uport->custom_divisor) {
986 : /*
987 : * If they're setting up a custom divisor or speed,
988 : * instead of clearing it, then bitch about it.
989 : */
990 0 : if (uport->flags & UPF_SPD_MASK) {
991 0 : 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 0 : uart_change_speed(tty, state, NULL);
997 : }
998 : } else {
999 0 : retval = uart_startup(tty, state, 1);
1000 0 : if (retval == 0)
1001 0 : tty_port_set_initialized(port, true);
1002 0 : if (retval > 0)
1003 : retval = 0;
1004 : }
1005 0 : exit:
1006 : return retval;
1007 : }
1008 :
1009 0 : static int uart_set_info_user(struct tty_struct *tty, struct serial_struct *ss)
1010 : {
1011 0 : struct uart_state *state = tty->driver_data;
1012 0 : struct tty_port *port = &state->port;
1013 0 : int retval;
1014 :
1015 0 : down_write(&tty->termios_rwsem);
1016 : /*
1017 : * This semaphore protects port->count. It is also
1018 : * very useful to prevent opens. Also, take the
1019 : * port configuration semaphore to make sure that a
1020 : * module insertion/removal doesn't change anything
1021 : * under us.
1022 : */
1023 0 : mutex_lock(&port->mutex);
1024 0 : retval = uart_set_info(tty, port, state, ss);
1025 0 : mutex_unlock(&port->mutex);
1026 0 : up_write(&tty->termios_rwsem);
1027 0 : return retval;
1028 : }
1029 :
1030 : /**
1031 : * uart_get_lsr_info - get line status register info
1032 : * @tty: tty associated with the UART
1033 : * @state: UART being queried
1034 : * @value: returned modem value
1035 : */
1036 0 : static int uart_get_lsr_info(struct tty_struct *tty,
1037 : struct uart_state *state, unsigned int __user *value)
1038 : {
1039 0 : struct uart_port *uport = uart_port_check(state);
1040 0 : unsigned int result;
1041 :
1042 0 : result = uport->ops->tx_empty(uport);
1043 :
1044 : /*
1045 : * If we're about to load something into the transmit
1046 : * register, we'll pretend the transmitter isn't empty to
1047 : * avoid a race condition (depending on when the transmit
1048 : * interrupt happens).
1049 : */
1050 0 : if (uport->x_char ||
1051 0 : ((uart_circ_chars_pending(&state->xmit) > 0) &&
1052 0 : !uart_tx_stopped(uport)))
1053 0 : result &= ~TIOCSER_TEMT;
1054 :
1055 0 : return put_user(result, value);
1056 : }
1057 :
1058 0 : static int uart_tiocmget(struct tty_struct *tty)
1059 : {
1060 0 : struct uart_state *state = tty->driver_data;
1061 0 : struct tty_port *port = &state->port;
1062 0 : struct uart_port *uport;
1063 0 : int result = -EIO;
1064 :
1065 0 : mutex_lock(&port->mutex);
1066 0 : uport = uart_port_check(state);
1067 0 : if (!uport)
1068 0 : goto out;
1069 :
1070 0 : if (!tty_io_error(tty)) {
1071 0 : result = uport->mctrl;
1072 0 : spin_lock_irq(&uport->lock);
1073 0 : result |= uport->ops->get_mctrl(uport);
1074 0 : spin_unlock_irq(&uport->lock);
1075 : }
1076 0 : out:
1077 0 : mutex_unlock(&port->mutex);
1078 0 : return result;
1079 : }
1080 :
1081 : static int
1082 0 : uart_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)
1083 : {
1084 0 : struct uart_state *state = tty->driver_data;
1085 0 : struct tty_port *port = &state->port;
1086 0 : struct uart_port *uport;
1087 0 : int ret = -EIO;
1088 :
1089 0 : mutex_lock(&port->mutex);
1090 0 : uport = uart_port_check(state);
1091 0 : if (!uport)
1092 0 : goto out;
1093 :
1094 0 : if (!tty_io_error(tty)) {
1095 0 : uart_update_mctrl(uport, set, clear);
1096 0 : ret = 0;
1097 : }
1098 0 : out:
1099 0 : mutex_unlock(&port->mutex);
1100 0 : return ret;
1101 : }
1102 :
1103 0 : static int uart_break_ctl(struct tty_struct *tty, int break_state)
1104 : {
1105 0 : struct uart_state *state = tty->driver_data;
1106 0 : struct tty_port *port = &state->port;
1107 0 : struct uart_port *uport;
1108 0 : int ret = -EIO;
1109 :
1110 0 : mutex_lock(&port->mutex);
1111 0 : uport = uart_port_check(state);
1112 0 : if (!uport)
1113 0 : goto out;
1114 :
1115 0 : if (uport->type != PORT_UNKNOWN && uport->ops->break_ctl)
1116 0 : uport->ops->break_ctl(uport, break_state);
1117 : ret = 0;
1118 0 : out:
1119 0 : mutex_unlock(&port->mutex);
1120 0 : return ret;
1121 : }
1122 :
1123 0 : static int uart_do_autoconfig(struct tty_struct *tty, struct uart_state *state)
1124 : {
1125 0 : struct tty_port *port = &state->port;
1126 0 : struct uart_port *uport;
1127 0 : int flags, ret;
1128 :
1129 0 : if (!capable(CAP_SYS_ADMIN))
1130 : return -EPERM;
1131 :
1132 : /*
1133 : * Take the per-port semaphore. This prevents count from
1134 : * changing, and hence any extra opens of the port while
1135 : * we're auto-configuring.
1136 : */
1137 0 : if (mutex_lock_interruptible(&port->mutex))
1138 : return -ERESTARTSYS;
1139 :
1140 0 : uport = uart_port_check(state);
1141 0 : if (!uport) {
1142 0 : ret = -EIO;
1143 0 : goto out;
1144 : }
1145 :
1146 0 : ret = -EBUSY;
1147 0 : if (tty_port_users(port) == 1) {
1148 0 : uart_shutdown(tty, state);
1149 :
1150 : /*
1151 : * If we already have a port type configured,
1152 : * we must release its resources.
1153 : */
1154 0 : if (uport->type != PORT_UNKNOWN && uport->ops->release_port)
1155 0 : uport->ops->release_port(uport);
1156 :
1157 0 : flags = UART_CONFIG_TYPE;
1158 0 : if (uport->flags & UPF_AUTO_IRQ)
1159 0 : flags |= UART_CONFIG_IRQ;
1160 :
1161 : /*
1162 : * This will claim the ports resources if
1163 : * a port is found.
1164 : */
1165 0 : uport->ops->config_port(uport, flags);
1166 :
1167 0 : ret = uart_startup(tty, state, 1);
1168 0 : if (ret == 0)
1169 0 : tty_port_set_initialized(port, true);
1170 0 : if (ret > 0)
1171 : ret = 0;
1172 : }
1173 0 : out:
1174 0 : mutex_unlock(&port->mutex);
1175 0 : return ret;
1176 : }
1177 :
1178 0 : static void uart_enable_ms(struct uart_port *uport)
1179 : {
1180 : /*
1181 : * Force modem status interrupts on
1182 : */
1183 0 : if (uport->ops->enable_ms)
1184 0 : uport->ops->enable_ms(uport);
1185 : }
1186 :
1187 : /*
1188 : * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
1189 : * - mask passed in arg for lines of interest
1190 : * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
1191 : * Caller should use TIOCGICOUNT to see which one it was
1192 : *
1193 : * FIXME: This wants extracting into a common all driver implementation
1194 : * of TIOCMWAIT using tty_port.
1195 : */
1196 0 : static int uart_wait_modem_status(struct uart_state *state, unsigned long arg)
1197 : {
1198 0 : struct uart_port *uport;
1199 0 : struct tty_port *port = &state->port;
1200 0 : DECLARE_WAITQUEUE(wait, current);
1201 0 : struct uart_icount cprev, cnow;
1202 0 : int ret;
1203 :
1204 : /*
1205 : * note the counters on entry
1206 : */
1207 0 : uport = uart_port_ref(state);
1208 0 : if (!uport)
1209 : return -EIO;
1210 0 : spin_lock_irq(&uport->lock);
1211 0 : memcpy(&cprev, &uport->icount, sizeof(struct uart_icount));
1212 0 : uart_enable_ms(uport);
1213 0 : spin_unlock_irq(&uport->lock);
1214 :
1215 0 : add_wait_queue(&port->delta_msr_wait, &wait);
1216 0 : for (;;) {
1217 0 : spin_lock_irq(&uport->lock);
1218 0 : memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
1219 0 : spin_unlock_irq(&uport->lock);
1220 :
1221 0 : set_current_state(TASK_INTERRUPTIBLE);
1222 :
1223 0 : if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
1224 0 : ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
1225 0 : ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
1226 0 : ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
1227 : ret = 0;
1228 : break;
1229 : }
1230 :
1231 0 : schedule();
1232 :
1233 : /* see if a signal did it */
1234 0 : if (signal_pending(current)) {
1235 : ret = -ERESTARTSYS;
1236 : break;
1237 : }
1238 :
1239 0 : cprev = cnow;
1240 : }
1241 0 : __set_current_state(TASK_RUNNING);
1242 0 : remove_wait_queue(&port->delta_msr_wait, &wait);
1243 0 : uart_port_deref(uport);
1244 :
1245 0 : return ret;
1246 : }
1247 :
1248 : /*
1249 : * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1250 : * Return: write counters to the user passed counter struct
1251 : * NB: both 1->0 and 0->1 transitions are counted except for
1252 : * RI where only 0->1 is counted.
1253 : */
1254 0 : static int uart_get_icount(struct tty_struct *tty,
1255 : struct serial_icounter_struct *icount)
1256 : {
1257 0 : struct uart_state *state = tty->driver_data;
1258 0 : struct uart_icount cnow;
1259 0 : struct uart_port *uport;
1260 :
1261 0 : uport = uart_port_ref(state);
1262 0 : if (!uport)
1263 : return -EIO;
1264 0 : spin_lock_irq(&uport->lock);
1265 0 : memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
1266 0 : spin_unlock_irq(&uport->lock);
1267 0 : uart_port_deref(uport);
1268 :
1269 0 : icount->cts = cnow.cts;
1270 0 : icount->dsr = cnow.dsr;
1271 0 : icount->rng = cnow.rng;
1272 0 : icount->dcd = cnow.dcd;
1273 0 : icount->rx = cnow.rx;
1274 0 : icount->tx = cnow.tx;
1275 0 : icount->frame = cnow.frame;
1276 0 : icount->overrun = cnow.overrun;
1277 0 : icount->parity = cnow.parity;
1278 0 : icount->brk = cnow.brk;
1279 0 : icount->buf_overrun = cnow.buf_overrun;
1280 :
1281 0 : return 0;
1282 : }
1283 :
1284 0 : static int uart_get_rs485_config(struct uart_port *port,
1285 : struct serial_rs485 __user *rs485)
1286 : {
1287 0 : unsigned long flags;
1288 0 : struct serial_rs485 aux;
1289 :
1290 0 : spin_lock_irqsave(&port->lock, flags);
1291 0 : aux = port->rs485;
1292 0 : spin_unlock_irqrestore(&port->lock, flags);
1293 :
1294 0 : if (copy_to_user(rs485, &aux, sizeof(aux)))
1295 0 : return -EFAULT;
1296 :
1297 : return 0;
1298 : }
1299 :
1300 0 : static int uart_set_rs485_config(struct uart_port *port,
1301 : struct serial_rs485 __user *rs485_user)
1302 : {
1303 0 : struct serial_rs485 rs485;
1304 0 : int ret;
1305 0 : unsigned long flags;
1306 :
1307 0 : if (!port->rs485_config)
1308 : return -ENOIOCTLCMD;
1309 :
1310 0 : if (copy_from_user(&rs485, rs485_user, sizeof(*rs485_user)))
1311 : return -EFAULT;
1312 :
1313 0 : spin_lock_irqsave(&port->lock, flags);
1314 0 : ret = port->rs485_config(port, &rs485);
1315 0 : spin_unlock_irqrestore(&port->lock, flags);
1316 0 : if (ret)
1317 : return ret;
1318 :
1319 0 : if (copy_to_user(rs485_user, &port->rs485, sizeof(port->rs485)))
1320 0 : return -EFAULT;
1321 :
1322 : return 0;
1323 : }
1324 :
1325 0 : static int uart_get_iso7816_config(struct uart_port *port,
1326 : struct serial_iso7816 __user *iso7816)
1327 : {
1328 0 : unsigned long flags;
1329 0 : struct serial_iso7816 aux;
1330 :
1331 0 : if (!port->iso7816_config)
1332 : return -ENOIOCTLCMD;
1333 :
1334 0 : spin_lock_irqsave(&port->lock, flags);
1335 0 : aux = port->iso7816;
1336 0 : spin_unlock_irqrestore(&port->lock, flags);
1337 :
1338 0 : if (copy_to_user(iso7816, &aux, sizeof(aux)))
1339 0 : return -EFAULT;
1340 :
1341 : return 0;
1342 : }
1343 :
1344 0 : static int uart_set_iso7816_config(struct uart_port *port,
1345 : struct serial_iso7816 __user *iso7816_user)
1346 : {
1347 0 : struct serial_iso7816 iso7816;
1348 0 : int i, ret;
1349 0 : unsigned long flags;
1350 :
1351 0 : if (!port->iso7816_config)
1352 : return -ENOIOCTLCMD;
1353 :
1354 0 : if (copy_from_user(&iso7816, iso7816_user, sizeof(*iso7816_user)))
1355 : return -EFAULT;
1356 :
1357 : /*
1358 : * There are 5 words reserved for future use. Check that userspace
1359 : * doesn't put stuff in there to prevent breakages in the future.
1360 : */
1361 0 : for (i = 0; i < 5; i++)
1362 0 : if (iso7816.reserved[i])
1363 : return -EINVAL;
1364 :
1365 0 : spin_lock_irqsave(&port->lock, flags);
1366 0 : ret = port->iso7816_config(port, &iso7816);
1367 0 : spin_unlock_irqrestore(&port->lock, flags);
1368 0 : if (ret)
1369 : return ret;
1370 :
1371 0 : if (copy_to_user(iso7816_user, &port->iso7816, sizeof(port->iso7816)))
1372 0 : return -EFAULT;
1373 :
1374 : return 0;
1375 : }
1376 :
1377 : /*
1378 : * Called via sys_ioctl. We can use spin_lock_irq() here.
1379 : */
1380 : static int
1381 139 : uart_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)
1382 : {
1383 139 : struct uart_state *state = tty->driver_data;
1384 139 : struct tty_port *port = &state->port;
1385 139 : struct uart_port *uport;
1386 139 : void __user *uarg = (void __user *)arg;
1387 139 : int ret = -ENOIOCTLCMD;
1388 :
1389 :
1390 : /*
1391 : * These ioctls don't rely on the hardware to be present.
1392 : */
1393 139 : switch (cmd) {
1394 0 : case TIOCSERCONFIG:
1395 0 : down_write(&tty->termios_rwsem);
1396 0 : ret = uart_do_autoconfig(tty, state);
1397 0 : up_write(&tty->termios_rwsem);
1398 0 : break;
1399 : }
1400 :
1401 0 : if (ret != -ENOIOCTLCMD)
1402 0 : goto out;
1403 :
1404 139 : if (tty_io_error(tty)) {
1405 0 : ret = -EIO;
1406 0 : goto out;
1407 : }
1408 :
1409 : /*
1410 : * The following should only be used when hardware is present.
1411 : */
1412 139 : switch (cmd) {
1413 0 : case TIOCMIWAIT:
1414 0 : ret = uart_wait_modem_status(state, arg);
1415 0 : break;
1416 : }
1417 :
1418 139 : if (ret != -ENOIOCTLCMD)
1419 0 : goto out;
1420 :
1421 139 : mutex_lock(&port->mutex);
1422 139 : uport = uart_port_check(state);
1423 :
1424 278 : if (!uport || tty_io_error(tty)) {
1425 0 : ret = -EIO;
1426 0 : goto out_up;
1427 : }
1428 :
1429 : /*
1430 : * All these rely on hardware being present and need to be
1431 : * protected against the tty being hung up.
1432 : */
1433 :
1434 139 : switch (cmd) {
1435 0 : case TIOCSERGETLSR: /* Get line status register */
1436 0 : ret = uart_get_lsr_info(tty, state, uarg);
1437 0 : break;
1438 :
1439 0 : case TIOCGRS485:
1440 0 : ret = uart_get_rs485_config(uport, uarg);
1441 0 : break;
1442 :
1443 0 : case TIOCSRS485:
1444 0 : ret = uart_set_rs485_config(uport, uarg);
1445 0 : break;
1446 :
1447 0 : case TIOCSISO7816:
1448 0 : ret = uart_set_iso7816_config(state->uart_port, uarg);
1449 0 : break;
1450 :
1451 0 : case TIOCGISO7816:
1452 0 : ret = uart_get_iso7816_config(state->uart_port, uarg);
1453 0 : break;
1454 139 : default:
1455 139 : if (uport->ops->ioctl)
1456 0 : ret = uport->ops->ioctl(uport, cmd, arg);
1457 : break;
1458 : }
1459 139 : out_up:
1460 139 : mutex_unlock(&port->mutex);
1461 139 : out:
1462 139 : return ret;
1463 : }
1464 :
1465 0 : static void uart_set_ldisc(struct tty_struct *tty)
1466 : {
1467 0 : struct uart_state *state = tty->driver_data;
1468 0 : struct uart_port *uport;
1469 0 : struct tty_port *port = &state->port;
1470 :
1471 0 : if (!tty_port_initialized(port))
1472 : return;
1473 :
1474 0 : mutex_lock(&state->port.mutex);
1475 0 : uport = uart_port_check(state);
1476 0 : if (uport && uport->ops->set_ldisc)
1477 0 : uport->ops->set_ldisc(uport, &tty->termios);
1478 0 : mutex_unlock(&state->port.mutex);
1479 : }
1480 :
1481 1 : static void uart_set_termios(struct tty_struct *tty,
1482 : struct ktermios *old_termios)
1483 : {
1484 1 : struct uart_state *state = tty->driver_data;
1485 1 : struct uart_port *uport;
1486 1 : unsigned int cflag = tty->termios.c_cflag;
1487 1 : unsigned int iflag_mask = IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK;
1488 1 : bool sw_changed = false;
1489 :
1490 1 : mutex_lock(&state->port.mutex);
1491 1 : uport = uart_port_check(state);
1492 1 : if (!uport)
1493 0 : goto out;
1494 :
1495 : /*
1496 : * Drivers doing software flow control also need to know
1497 : * about changes to these input settings.
1498 : */
1499 1 : if (uport->flags & UPF_SOFT_FLOW) {
1500 0 : iflag_mask |= IXANY|IXON|IXOFF;
1501 0 : sw_changed =
1502 0 : 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 : * These are the bits that are used to setup various
1508 : * flags in the low level driver. We can ignore the Bfoo
1509 : * bits in c_cflag; c_[io]speed will always be set
1510 : * appropriately by set_termios() in tty_ioctl.c
1511 : */
1512 1 : if ((cflag ^ old_termios->c_cflag) == 0 &&
1513 1 : tty->termios.c_ospeed == old_termios->c_ospeed &&
1514 1 : tty->termios.c_ispeed == old_termios->c_ispeed &&
1515 1 : ((tty->termios.c_iflag ^ old_termios->c_iflag) & iflag_mask) == 0 &&
1516 : !sw_changed) {
1517 1 : goto out;
1518 : }
1519 :
1520 0 : uart_change_speed(tty, state, old_termios);
1521 : /* reload cflag from termios; port driver may have overridden flags */
1522 0 : cflag = tty->termios.c_cflag;
1523 :
1524 : /* Handle transition to B0 status */
1525 0 : if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
1526 0 : uart_clear_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
1527 : /* Handle transition away from B0 status */
1528 0 : else if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
1529 0 : unsigned int mask = TIOCM_DTR;
1530 :
1531 0 : if (!(cflag & CRTSCTS) || !tty_throttled(tty))
1532 : mask |= TIOCM_RTS;
1533 0 : uart_set_mctrl(uport, mask);
1534 : }
1535 0 : out:
1536 1 : mutex_unlock(&state->port.mutex);
1537 1 : }
1538 :
1539 : /*
1540 : * Calls to uart_close() are serialised via the tty_lock in
1541 : * drivers/tty/tty_io.c:tty_release()
1542 : * drivers/tty/tty_io.c:do_tty_hangup()
1543 : */
1544 135 : static void uart_close(struct tty_struct *tty, struct file *filp)
1545 : {
1546 135 : struct uart_state *state = tty->driver_data;
1547 :
1548 135 : if (!state) {
1549 0 : struct uart_driver *drv = tty->driver->driver_state;
1550 0 : struct tty_port *port;
1551 :
1552 0 : state = drv->state + tty->index;
1553 0 : port = &state->port;
1554 0 : spin_lock_irq(&port->lock);
1555 0 : --port->count;
1556 0 : spin_unlock_irq(&port->lock);
1557 0 : return;
1558 : }
1559 :
1560 135 : pr_debug("uart_close(%d) called\n", tty->index);
1561 :
1562 135 : tty_port_close(tty->port, tty, filp);
1563 : }
1564 :
1565 0 : static void uart_tty_port_shutdown(struct tty_port *port)
1566 : {
1567 0 : struct uart_state *state = container_of(port, struct uart_state, port);
1568 0 : struct uart_port *uport = uart_port_check(state);
1569 :
1570 : /*
1571 : * At this point, we stop accepting input. To do this, we
1572 : * disable the receive line status interrupts.
1573 : */
1574 0 : if (WARN(!uport, "detached port still initialized!\n"))
1575 : return;
1576 :
1577 0 : spin_lock_irq(&uport->lock);
1578 0 : uport->ops->stop_rx(uport);
1579 0 : spin_unlock_irq(&uport->lock);
1580 :
1581 0 : uart_port_shutdown(port);
1582 :
1583 : /*
1584 : * It's possible for shutdown to be called after suspend if we get
1585 : * a DCD drop (hangup) at just the right time. Clear suspended bit so
1586 : * we don't try to resume a port that has been shutdown.
1587 : */
1588 0 : tty_port_set_suspended(port, 0);
1589 :
1590 0 : uart_change_pm(state, UART_PM_STATE_OFF);
1591 :
1592 : }
1593 :
1594 135 : static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
1595 : {
1596 135 : struct uart_state *state = tty->driver_data;
1597 135 : struct uart_port *port;
1598 135 : unsigned long char_time, expire;
1599 :
1600 135 : port = uart_port_ref(state);
1601 135 : if (!port)
1602 : return;
1603 :
1604 135 : if (port->type == PORT_UNKNOWN || port->fifosize == 0) {
1605 0 : uart_port_deref(port);
1606 0 : return;
1607 : }
1608 :
1609 : /*
1610 : * Set the check interval to be 1/5 of the estimated time to
1611 : * send a single character, and make it at least 1. The check
1612 : * interval should also be less than the timeout.
1613 : *
1614 : * Note: we have to use pretty tight timings here to satisfy
1615 : * the NIST-PCTS.
1616 : */
1617 135 : char_time = (port->timeout - HZ/50) / port->fifosize;
1618 135 : char_time = char_time / 5;
1619 135 : if (char_time == 0)
1620 135 : char_time = 1;
1621 135 : if (timeout && timeout < char_time)
1622 : char_time = timeout;
1623 :
1624 : /*
1625 : * If the transmitter hasn't cleared in twice the approximate
1626 : * amount of time to send the entire FIFO, it probably won't
1627 : * ever clear. This assumes the UART isn't doing flow
1628 : * control, which is currently the case. Hence, if it ever
1629 : * takes longer than port->timeout, this is probably due to a
1630 : * UART bug of some kind. So, we clamp the timeout parameter at
1631 : * 2*port->timeout.
1632 : */
1633 135 : if (timeout == 0 || timeout > 2 * port->timeout)
1634 135 : timeout = 2 * port->timeout;
1635 :
1636 135 : expire = jiffies + timeout;
1637 :
1638 135 : pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n",
1639 : port->line, jiffies, expire);
1640 :
1641 : /*
1642 : * Check whether the transmitter is empty every 'char_time'.
1643 : * 'timeout' / 'expire' give us the maximum amount of time
1644 : * we wait.
1645 : */
1646 135 : while (!port->ops->tx_empty(port)) {
1647 0 : msleep_interruptible(jiffies_to_msecs(char_time));
1648 0 : if (signal_pending(current))
1649 : break;
1650 0 : if (time_after(jiffies, expire))
1651 : break;
1652 : }
1653 135 : uart_port_deref(port);
1654 : }
1655 :
1656 : /*
1657 : * Calls to uart_hangup() are serialised by the tty_lock in
1658 : * drivers/tty/tty_io.c:do_tty_hangup()
1659 : * This runs from a workqueue and can sleep for a _short_ time only.
1660 : */
1661 0 : static void uart_hangup(struct tty_struct *tty)
1662 : {
1663 0 : struct uart_state *state = tty->driver_data;
1664 0 : struct tty_port *port = &state->port;
1665 0 : struct uart_port *uport;
1666 0 : unsigned long flags;
1667 :
1668 0 : pr_debug("uart_hangup(%d)\n", tty->index);
1669 :
1670 0 : mutex_lock(&port->mutex);
1671 0 : uport = uart_port_check(state);
1672 0 : WARN(!uport, "hangup of detached port!\n");
1673 :
1674 0 : if (tty_port_active(port)) {
1675 0 : uart_flush_buffer(tty);
1676 0 : uart_shutdown(tty, state);
1677 0 : spin_lock_irqsave(&port->lock, flags);
1678 0 : port->count = 0;
1679 0 : spin_unlock_irqrestore(&port->lock, flags);
1680 0 : tty_port_set_active(port, 0);
1681 0 : tty_port_tty_set(port, NULL);
1682 0 : if (uport && !uart_console(uport))
1683 0 : uart_change_pm(state, UART_PM_STATE_OFF);
1684 0 : wake_up_interruptible(&port->open_wait);
1685 0 : wake_up_interruptible(&port->delta_msr_wait);
1686 : }
1687 0 : mutex_unlock(&port->mutex);
1688 0 : }
1689 :
1690 : /* uport == NULL if uart_port has already been removed */
1691 0 : static void uart_port_shutdown(struct tty_port *port)
1692 : {
1693 0 : struct uart_state *state = container_of(port, struct uart_state, port);
1694 0 : struct uart_port *uport = uart_port_check(state);
1695 :
1696 : /*
1697 : * clear delta_msr_wait queue to avoid mem leaks: we may free
1698 : * the irq here so the queue might never be woken up. Note
1699 : * that we won't end up waiting on delta_msr_wait again since
1700 : * any outstanding file descriptors should be pointing at
1701 : * hung_up_tty_fops now.
1702 : */
1703 0 : wake_up_interruptible(&port->delta_msr_wait);
1704 :
1705 : /*
1706 : * Free the IRQ and disable the port.
1707 : */
1708 0 : if (uport)
1709 0 : uport->ops->shutdown(uport);
1710 :
1711 : /*
1712 : * Ensure that the IRQ handler isn't running on another CPU.
1713 : */
1714 0 : if (uport)
1715 0 : synchronize_irq(uport->irq);
1716 0 : }
1717 :
1718 0 : static int uart_carrier_raised(struct tty_port *port)
1719 : {
1720 0 : struct uart_state *state = container_of(port, struct uart_state, port);
1721 0 : struct uart_port *uport;
1722 0 : int mctrl;
1723 :
1724 0 : uport = uart_port_ref(state);
1725 : /*
1726 : * Should never observe uport == NULL since checks for hangup should
1727 : * abort the tty_port_block_til_ready() loop before checking for carrier
1728 : * raised -- but report carrier raised if it does anyway so open will
1729 : * continue and not sleep
1730 : */
1731 0 : if (WARN_ON(!uport))
1732 : return 1;
1733 0 : spin_lock_irq(&uport->lock);
1734 0 : uart_enable_ms(uport);
1735 0 : mctrl = uport->ops->get_mctrl(uport);
1736 0 : spin_unlock_irq(&uport->lock);
1737 0 : uart_port_deref(uport);
1738 0 : if (mctrl & TIOCM_CAR)
1739 0 : return 1;
1740 : return 0;
1741 : }
1742 :
1743 135 : static void uart_dtr_rts(struct tty_port *port, int raise)
1744 : {
1745 135 : struct uart_state *state = container_of(port, struct uart_state, port);
1746 135 : struct uart_port *uport;
1747 :
1748 135 : uport = uart_port_ref(state);
1749 135 : if (!uport)
1750 : return;
1751 135 : uart_port_dtr_rts(uport, raise);
1752 135 : uart_port_deref(uport);
1753 : }
1754 :
1755 135 : static int uart_install(struct tty_driver *driver, struct tty_struct *tty)
1756 : {
1757 135 : struct uart_driver *drv = driver->driver_state;
1758 135 : struct uart_state *state = drv->state + tty->index;
1759 :
1760 135 : tty->driver_data = state;
1761 :
1762 135 : return tty_standard_install(driver, tty);
1763 : }
1764 :
1765 : /*
1766 : * Calls to uart_open are serialised by the tty_lock in
1767 : * drivers/tty/tty_io.c:tty_open()
1768 : * Note that if this fails, then uart_close() _will_ be called.
1769 : *
1770 : * In time, we want to scrap the "opening nonpresent ports"
1771 : * behaviour and implement an alternative way for setserial
1772 : * to set base addresses/ports/types. This will allow us to
1773 : * get rid of a certain amount of extra tests.
1774 : */
1775 135 : static int uart_open(struct tty_struct *tty, struct file *filp)
1776 : {
1777 135 : struct uart_state *state = tty->driver_data;
1778 135 : int retval;
1779 :
1780 135 : retval = tty_port_open(&state->port, tty, filp);
1781 135 : if (retval > 0)
1782 : retval = 0;
1783 :
1784 135 : return retval;
1785 : }
1786 :
1787 1 : static int uart_port_activate(struct tty_port *port, struct tty_struct *tty)
1788 : {
1789 1 : struct uart_state *state = container_of(port, struct uart_state, port);
1790 1 : struct uart_port *uport;
1791 1 : int ret;
1792 :
1793 1 : uport = uart_port_check(state);
1794 1 : if (!uport || uport->flags & UPF_DEAD)
1795 : return -ENXIO;
1796 :
1797 : /*
1798 : * Start up the serial port.
1799 : */
1800 1 : ret = uart_startup(tty, state, 0);
1801 1 : if (ret > 0)
1802 0 : tty_port_set_active(port, 1);
1803 :
1804 : return ret;
1805 : }
1806 :
1807 1 : static const char *uart_type(struct uart_port *port)
1808 : {
1809 1 : const char *str = NULL;
1810 :
1811 1 : if (port->ops->type)
1812 1 : str = port->ops->type(port);
1813 :
1814 1 : if (!str)
1815 : str = "unknown";
1816 :
1817 1 : return str;
1818 : }
1819 :
1820 : #ifdef CONFIG_PROC_FS
1821 :
1822 0 : static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i)
1823 : {
1824 0 : struct uart_state *state = drv->state + i;
1825 0 : struct tty_port *port = &state->port;
1826 0 : enum uart_pm_state pm_state;
1827 0 : struct uart_port *uport;
1828 0 : char stat_buf[32];
1829 0 : unsigned int status;
1830 0 : int mmio;
1831 :
1832 0 : mutex_lock(&port->mutex);
1833 0 : uport = uart_port_check(state);
1834 0 : if (!uport)
1835 0 : goto out;
1836 :
1837 0 : mmio = uport->iotype >= UPIO_MEM;
1838 0 : 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 0 : if (uport->type == PORT_UNKNOWN) {
1846 0 : seq_putc(m, '\n');
1847 0 : goto out;
1848 : }
1849 :
1850 0 : if (capable(CAP_SYS_ADMIN)) {
1851 0 : pm_state = state->pm_state;
1852 0 : if (pm_state != UART_PM_STATE_ON)
1853 0 : uart_change_pm(state, UART_PM_STATE_ON);
1854 0 : spin_lock_irq(&uport->lock);
1855 0 : status = uport->ops->get_mctrl(uport);
1856 0 : spin_unlock_irq(&uport->lock);
1857 0 : if (pm_state != UART_PM_STATE_ON)
1858 0 : uart_change_pm(state, pm_state);
1859 :
1860 0 : seq_printf(m, " tx:%d rx:%d",
1861 : uport->icount.tx, uport->icount.rx);
1862 0 : if (uport->icount.frame)
1863 0 : seq_printf(m, " fe:%d", uport->icount.frame);
1864 0 : if (uport->icount.parity)
1865 0 : seq_printf(m, " pe:%d", uport->icount.parity);
1866 0 : if (uport->icount.brk)
1867 0 : seq_printf(m, " brk:%d", uport->icount.brk);
1868 0 : if (uport->icount.overrun)
1869 0 : seq_printf(m, " oe:%d", uport->icount.overrun);
1870 0 : if (uport->icount.buf_overrun)
1871 0 : 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 0 : stat_buf[0] = '\0';
1883 0 : stat_buf[1] = '\0';
1884 0 : INFOBIT(TIOCM_RTS, "|RTS");
1885 0 : STATBIT(TIOCM_CTS, "|CTS");
1886 0 : INFOBIT(TIOCM_DTR, "|DTR");
1887 0 : STATBIT(TIOCM_DSR, "|DSR");
1888 0 : STATBIT(TIOCM_CAR, "|CD");
1889 0 : STATBIT(TIOCM_RNG, "|RI");
1890 0 : if (stat_buf[0])
1891 0 : stat_buf[0] = ' ';
1892 :
1893 0 : seq_puts(m, stat_buf);
1894 : }
1895 0 : seq_putc(m, '\n');
1896 : #undef STATBIT
1897 : #undef INFOBIT
1898 0 : out:
1899 0 : mutex_unlock(&port->mutex);
1900 0 : }
1901 :
1902 0 : static int uart_proc_show(struct seq_file *m, void *v)
1903 : {
1904 0 : struct tty_driver *ttydrv = m->private;
1905 0 : struct uart_driver *drv = ttydrv->driver_state;
1906 0 : int i;
1907 :
1908 0 : seq_printf(m, "serinfo:1.0 driver%s%s revision:%s\n", "", "", "");
1909 0 : for (i = 0; i < drv->nr; i++)
1910 0 : uart_line_info(m, drv, i);
1911 0 : return 0;
1912 : }
1913 : #endif
1914 :
1915 5 : static inline bool uart_console_enabled(struct uart_port *port)
1916 : {
1917 5 : return uart_console(port) && (port->cons->flags & CON_ENABLED);
1918 : }
1919 :
1920 4 : static void uart_port_spin_lock_init(struct uart_port *port)
1921 : {
1922 4 : spin_lock_init(&port->lock);
1923 4 : lockdep_set_class(&port->lock, &port_lock_key);
1924 4 : }
1925 :
1926 : #if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(CONFIG_CONSOLE_POLL)
1927 : /**
1928 : * uart_console_write - write a console message to a serial port
1929 : * @port: the port to write the message
1930 : * @s: array of characters
1931 : * @count: number of characters in string to write
1932 : * @putchar: function to write character to port
1933 : */
1934 256 : void uart_console_write(struct uart_port *port, const char *s,
1935 : unsigned int count,
1936 : void (*putchar)(struct uart_port *, int))
1937 : {
1938 256 : unsigned int i;
1939 :
1940 13683 : for (i = 0; i < count; i++, s++) {
1941 13427 : if (*s == '\n')
1942 256 : putchar(port, '\r');
1943 13427 : putchar(port, *s);
1944 : }
1945 256 : }
1946 : EXPORT_SYMBOL_GPL(uart_console_write);
1947 :
1948 : /*
1949 : * Check whether an invalid uart number has been specified, and
1950 : * if so, search for the first available port that does have
1951 : * console support.
1952 : */
1953 : struct uart_port * __init
1954 0 : uart_get_console(struct uart_port *ports, int nr, struct console *co)
1955 : {
1956 0 : int idx = co->index;
1957 :
1958 0 : if (idx < 0 || idx >= nr || (ports[idx].iobase == 0 &&
1959 0 : ports[idx].membase == NULL))
1960 0 : for (idx = 0; idx < nr; idx++)
1961 0 : if (ports[idx].iobase != 0 ||
1962 0 : ports[idx].membase != NULL)
1963 : break;
1964 :
1965 0 : co->index = idx;
1966 :
1967 0 : return ports + idx;
1968 : }
1969 :
1970 : /**
1971 : * uart_parse_earlycon - Parse earlycon options
1972 : * @p: ptr to 2nd field (ie., just beyond '<name>,')
1973 : * @iotype: ptr for decoded iotype (out)
1974 : * @addr: ptr for decoded mapbase/iobase (out)
1975 : * @options: ptr for <options> field; NULL if not present (out)
1976 : *
1977 : * Decodes earlycon kernel command line parameters of the form
1978 : * earlycon=<name>,io|mmio|mmio16|mmio32|mmio32be|mmio32native,<addr>,<options>
1979 : * console=<name>,io|mmio|mmio16|mmio32|mmio32be|mmio32native,<addr>,<options>
1980 : *
1981 : * The optional form
1982 : *
1983 : * earlycon=<name>,0x<addr>,<options>
1984 : * console=<name>,0x<addr>,<options>
1985 : *
1986 : * is also accepted; the returned @iotype will be UPIO_MEM.
1987 : *
1988 : * Returns 0 on success or -EINVAL on failure
1989 : */
1990 0 : int uart_parse_earlycon(char *p, unsigned char *iotype, resource_size_t *addr,
1991 : char **options)
1992 : {
1993 0 : if (strncmp(p, "mmio,", 5) == 0) {
1994 0 : *iotype = UPIO_MEM;
1995 0 : p += 5;
1996 0 : } else if (strncmp(p, "mmio16,", 7) == 0) {
1997 0 : *iotype = UPIO_MEM16;
1998 0 : p += 7;
1999 0 : } else if (strncmp(p, "mmio32,", 7) == 0) {
2000 0 : *iotype = UPIO_MEM32;
2001 0 : p += 7;
2002 0 : } else if (strncmp(p, "mmio32be,", 9) == 0) {
2003 0 : *iotype = UPIO_MEM32BE;
2004 0 : p += 9;
2005 0 : } else if (strncmp(p, "mmio32native,", 13) == 0) {
2006 0 : *iotype = IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) ?
2007 : UPIO_MEM32BE : UPIO_MEM32;
2008 0 : p += 13;
2009 0 : } else if (strncmp(p, "io,", 3) == 0) {
2010 0 : *iotype = UPIO_PORT;
2011 0 : p += 3;
2012 0 : } else if (strncmp(p, "0x", 2) == 0) {
2013 0 : *iotype = UPIO_MEM;
2014 : } else {
2015 : return -EINVAL;
2016 : }
2017 :
2018 : /*
2019 : * Before you replace it with kstrtoull(), think about options separator
2020 : * (',') it will not tolerate
2021 : */
2022 0 : *addr = simple_strtoull(p, NULL, 0);
2023 0 : p = strchr(p, ',');
2024 0 : if (p)
2025 0 : p++;
2026 :
2027 0 : *options = p;
2028 0 : return 0;
2029 : }
2030 : EXPORT_SYMBOL_GPL(uart_parse_earlycon);
2031 :
2032 : /**
2033 : * uart_parse_options - Parse serial port baud/parity/bits/flow control.
2034 : * @options: pointer to option string
2035 : * @baud: pointer to an 'int' variable for the baud rate.
2036 : * @parity: pointer to an 'int' variable for the parity.
2037 : * @bits: pointer to an 'int' variable for the number of data bits.
2038 : * @flow: pointer to an 'int' variable for the flow control character.
2039 : *
2040 : * uart_parse_options decodes a string containing the serial console
2041 : * options. The format of the string is <baud><parity><bits><flow>,
2042 : * eg: 115200n8r
2043 : */
2044 : void
2045 0 : uart_parse_options(const char *options, int *baud, int *parity,
2046 : int *bits, int *flow)
2047 : {
2048 0 : const char *s = options;
2049 :
2050 0 : *baud = simple_strtoul(s, NULL, 10);
2051 0 : while (*s >= '0' && *s <= '9')
2052 0 : s++;
2053 0 : if (*s)
2054 0 : *parity = *s++;
2055 0 : if (*s)
2056 0 : *bits = *s++ - '0';
2057 0 : if (*s)
2058 0 : *flow = *s;
2059 0 : }
2060 : EXPORT_SYMBOL_GPL(uart_parse_options);
2061 :
2062 : /**
2063 : * uart_set_options - setup the serial console parameters
2064 : * @port: pointer to the serial ports uart_port structure
2065 : * @co: console pointer
2066 : * @baud: baud rate
2067 : * @parity: parity character - 'n' (none), 'o' (odd), 'e' (even)
2068 : * @bits: number of data bits
2069 : * @flow: flow control character - 'r' (rts)
2070 : */
2071 : int
2072 1 : uart_set_options(struct uart_port *port, struct console *co,
2073 : int baud, int parity, int bits, int flow)
2074 : {
2075 1 : struct ktermios termios;
2076 1 : static struct ktermios dummy;
2077 :
2078 : /*
2079 : * Ensure that the serial-console lock is initialised early.
2080 : *
2081 : * Note that the console-enabled check is needed because of kgdboc,
2082 : * which can end up calling uart_set_options() for an already enabled
2083 : * console via tty_find_polling_driver() and uart_poll_init().
2084 : */
2085 1 : if (!uart_console_enabled(port) && !port->console_reinit)
2086 1 : uart_port_spin_lock_init(port);
2087 :
2088 1 : memset(&termios, 0, sizeof(struct ktermios));
2089 :
2090 1 : termios.c_cflag |= CREAD | HUPCL | CLOCAL;
2091 1 : tty_termios_encode_baud_rate(&termios, baud, baud);
2092 :
2093 1 : if (bits == 7)
2094 0 : termios.c_cflag |= CS7;
2095 : else
2096 1 : termios.c_cflag |= CS8;
2097 :
2098 1 : switch (parity) {
2099 0 : case 'o': case 'O':
2100 0 : termios.c_cflag |= PARODD;
2101 0 : fallthrough;
2102 0 : case 'e': case 'E':
2103 0 : termios.c_cflag |= PARENB;
2104 0 : break;
2105 : }
2106 :
2107 1 : if (flow == 'r')
2108 0 : termios.c_cflag |= CRTSCTS;
2109 :
2110 : /*
2111 : * some uarts on other side don't support no flow control.
2112 : * So we set * DTR in host uart to make them happy
2113 : */
2114 1 : port->mctrl |= TIOCM_DTR;
2115 :
2116 1 : port->ops->set_termios(port, &termios, &dummy);
2117 : /*
2118 : * Allow the setting of the UART parameters with a NULL console
2119 : * too:
2120 : */
2121 1 : if (co)
2122 1 : co->cflag = termios.c_cflag;
2123 :
2124 1 : return 0;
2125 : }
2126 : EXPORT_SYMBOL_GPL(uart_set_options);
2127 : #endif /* CONFIG_SERIAL_CORE_CONSOLE */
2128 :
2129 : /**
2130 : * uart_change_pm - set power state of the port
2131 : *
2132 : * @state: port descriptor
2133 : * @pm_state: new state
2134 : *
2135 : * Locking: port->mutex has to be held
2136 : */
2137 2 : static void uart_change_pm(struct uart_state *state,
2138 : enum uart_pm_state pm_state)
2139 : {
2140 2 : struct uart_port *port = uart_port_check(state);
2141 :
2142 2 : if (state->pm_state != pm_state) {
2143 1 : if (port && port->ops->pm)
2144 1 : port->ops->pm(port, pm_state, state->pm_state);
2145 1 : state->pm_state = pm_state;
2146 : }
2147 2 : }
2148 :
2149 : struct uart_match {
2150 : struct uart_port *port;
2151 : struct uart_driver *driver;
2152 : };
2153 :
2154 0 : static int serial_match_port(struct device *dev, void *data)
2155 : {
2156 0 : struct uart_match *match = data;
2157 0 : struct tty_driver *tty_drv = match->driver->tty_driver;
2158 0 : dev_t devt = MKDEV(tty_drv->major, tty_drv->minor_start) +
2159 0 : match->port->line;
2160 :
2161 0 : return dev->devt == devt; /* Actually, only one tty per port */
2162 : }
2163 :
2164 0 : int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
2165 : {
2166 0 : struct uart_state *state = drv->state + uport->line;
2167 0 : struct tty_port *port = &state->port;
2168 0 : struct device *tty_dev;
2169 0 : struct uart_match match = {uport, drv};
2170 :
2171 0 : mutex_lock(&port->mutex);
2172 :
2173 0 : tty_dev = device_find_child(uport->dev, &match, serial_match_port);
2174 0 : if (tty_dev && device_may_wakeup(tty_dev)) {
2175 0 : enable_irq_wake(uport->irq);
2176 0 : put_device(tty_dev);
2177 0 : mutex_unlock(&port->mutex);
2178 0 : return 0;
2179 : }
2180 0 : put_device(tty_dev);
2181 :
2182 : /* Nothing to do if the console is not suspending */
2183 0 : if (!console_suspend_enabled && uart_console(uport))
2184 0 : goto unlock;
2185 :
2186 0 : uport->suspended = 1;
2187 :
2188 0 : if (tty_port_initialized(port)) {
2189 0 : const struct uart_ops *ops = uport->ops;
2190 0 : int tries;
2191 :
2192 0 : tty_port_set_suspended(port, 1);
2193 0 : tty_port_set_initialized(port, 0);
2194 :
2195 0 : spin_lock_irq(&uport->lock);
2196 0 : ops->stop_tx(uport);
2197 0 : ops->set_mctrl(uport, 0);
2198 0 : ops->stop_rx(uport);
2199 0 : spin_unlock_irq(&uport->lock);
2200 :
2201 : /*
2202 : * Wait for the transmitter to empty.
2203 : */
2204 0 : for (tries = 3; !ops->tx_empty(uport) && tries; tries--)
2205 0 : msleep(10);
2206 0 : if (!tries)
2207 0 : dev_err(uport->dev, "%s: Unable to drain transmitter\n",
2208 : uport->name);
2209 :
2210 0 : ops->shutdown(uport);
2211 : }
2212 :
2213 : /*
2214 : * Disable the console device before suspending.
2215 : */
2216 0 : if (uart_console(uport))
2217 0 : console_stop(uport->cons);
2218 :
2219 0 : uart_change_pm(state, UART_PM_STATE_OFF);
2220 0 : unlock:
2221 0 : mutex_unlock(&port->mutex);
2222 :
2223 0 : return 0;
2224 : }
2225 :
2226 0 : int uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
2227 : {
2228 0 : struct uart_state *state = drv->state + uport->line;
2229 0 : struct tty_port *port = &state->port;
2230 0 : struct device *tty_dev;
2231 0 : struct uart_match match = {uport, drv};
2232 0 : struct ktermios termios;
2233 :
2234 0 : mutex_lock(&port->mutex);
2235 :
2236 0 : tty_dev = device_find_child(uport->dev, &match, serial_match_port);
2237 0 : if (!uport->suspended && device_may_wakeup(tty_dev)) {
2238 0 : if (irqd_is_wakeup_set(irq_get_irq_data((uport->irq))))
2239 0 : disable_irq_wake(uport->irq);
2240 0 : put_device(tty_dev);
2241 0 : mutex_unlock(&port->mutex);
2242 0 : return 0;
2243 : }
2244 0 : put_device(tty_dev);
2245 0 : uport->suspended = 0;
2246 :
2247 : /*
2248 : * Re-enable the console device after suspending.
2249 : */
2250 0 : if (uart_console(uport)) {
2251 : /*
2252 : * First try to use the console cflag setting.
2253 : */
2254 0 : memset(&termios, 0, sizeof(struct ktermios));
2255 0 : termios.c_cflag = uport->cons->cflag;
2256 :
2257 : /*
2258 : * If that's unset, use the tty termios setting.
2259 : */
2260 0 : if (port->tty && termios.c_cflag == 0)
2261 0 : termios = port->tty->termios;
2262 :
2263 0 : if (console_suspend_enabled)
2264 0 : uart_change_pm(state, UART_PM_STATE_ON);
2265 0 : uport->ops->set_termios(uport, &termios, NULL);
2266 0 : if (console_suspend_enabled)
2267 0 : console_start(uport->cons);
2268 : }
2269 :
2270 0 : if (tty_port_suspended(port)) {
2271 0 : const struct uart_ops *ops = uport->ops;
2272 0 : int ret;
2273 :
2274 0 : uart_change_pm(state, UART_PM_STATE_ON);
2275 0 : spin_lock_irq(&uport->lock);
2276 0 : ops->set_mctrl(uport, 0);
2277 0 : spin_unlock_irq(&uport->lock);
2278 0 : if (console_suspend_enabled || !uart_console(uport)) {
2279 : /* Protected by port mutex for now */
2280 0 : struct tty_struct *tty = port->tty;
2281 :
2282 0 : ret = ops->startup(uport);
2283 0 : if (ret == 0) {
2284 0 : if (tty)
2285 0 : uart_change_speed(tty, state, NULL);
2286 0 : spin_lock_irq(&uport->lock);
2287 0 : ops->set_mctrl(uport, uport->mctrl);
2288 0 : ops->start_tx(uport);
2289 0 : spin_unlock_irq(&uport->lock);
2290 0 : tty_port_set_initialized(port, 1);
2291 : } else {
2292 : /*
2293 : * Failed to resume - maybe hardware went away?
2294 : * Clear the "initialized" flag so we won't try
2295 : * to call the low level drivers shutdown method.
2296 : */
2297 0 : uart_shutdown(tty, state);
2298 : }
2299 : }
2300 :
2301 0 : tty_port_set_suspended(port, 0);
2302 : }
2303 :
2304 0 : mutex_unlock(&port->mutex);
2305 :
2306 0 : return 0;
2307 : }
2308 :
2309 : static inline void
2310 1 : uart_report_port(struct uart_driver *drv, struct uart_port *port)
2311 : {
2312 1 : char address[64];
2313 :
2314 1 : switch (port->iotype) {
2315 1 : case UPIO_PORT:
2316 1 : snprintf(address, sizeof(address), "I/O 0x%lx", port->iobase);
2317 1 : break;
2318 0 : case UPIO_HUB6:
2319 0 : snprintf(address, sizeof(address),
2320 0 : "I/O 0x%lx offset 0x%x", port->iobase, port->hub6);
2321 0 : break;
2322 0 : case UPIO_MEM:
2323 : case UPIO_MEM16:
2324 : case UPIO_MEM32:
2325 : case UPIO_MEM32BE:
2326 : case UPIO_AU:
2327 : case UPIO_TSI:
2328 0 : snprintf(address, sizeof(address),
2329 0 : "MMIO 0x%llx", (unsigned long long)port->mapbase);
2330 0 : break;
2331 0 : default:
2332 0 : strlcpy(address, "*unknown*", sizeof(address));
2333 0 : break;
2334 : }
2335 :
2336 2 : 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 1 : }
2342 :
2343 : static void
2344 4 : uart_configure_port(struct uart_driver *drv, struct uart_state *state,
2345 : struct uart_port *port)
2346 : {
2347 4 : unsigned int flags;
2348 :
2349 : /*
2350 : * If there isn't a port here, don't do anything further.
2351 : */
2352 4 : if (!port->iobase && !port->mapbase && !port->membase)
2353 : return;
2354 :
2355 : /*
2356 : * Now do the auto configuration stuff. Note that config_port
2357 : * is expected to claim the resources and map the port for us.
2358 : */
2359 4 : flags = 0;
2360 4 : if (port->flags & UPF_AUTO_IRQ)
2361 0 : flags |= UART_CONFIG_IRQ;
2362 4 : if (port->flags & UPF_BOOT_AUTOCONF) {
2363 4 : if (!(port->flags & UPF_FIXED_TYPE)) {
2364 4 : port->type = PORT_UNKNOWN;
2365 4 : flags |= UART_CONFIG_TYPE;
2366 : }
2367 4 : port->ops->config_port(port, flags);
2368 : }
2369 :
2370 4 : if (port->type != PORT_UNKNOWN) {
2371 1 : unsigned long flags;
2372 :
2373 1 : uart_report_port(drv, port);
2374 :
2375 : /* Power up port for set_mctrl() */
2376 1 : uart_change_pm(state, UART_PM_STATE_ON);
2377 :
2378 : /*
2379 : * Ensure that the modem control lines are de-activated.
2380 : * keep the DTR setting that is set in uart_set_options()
2381 : * We probably don't need a spinlock around this, but
2382 : */
2383 1 : spin_lock_irqsave(&port->lock, flags);
2384 1 : port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR);
2385 1 : spin_unlock_irqrestore(&port->lock, flags);
2386 :
2387 : /*
2388 : * If this driver supports console, and it hasn't been
2389 : * successfully registered yet, try to re-register it.
2390 : * It may be that the port was not available.
2391 : */
2392 1 : if (port->cons && !(port->cons->flags & CON_ENABLED))
2393 0 : register_console(port->cons);
2394 :
2395 : /*
2396 : * Power down all ports by default, except the
2397 : * console if we have one.
2398 : */
2399 1 : if (!uart_console(port))
2400 0 : uart_change_pm(state, UART_PM_STATE_OFF);
2401 : }
2402 : }
2403 :
2404 : #ifdef CONFIG_CONSOLE_POLL
2405 :
2406 : static 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 : * We don't set initialized as we only initialized the hw,
2430 : * e.g. state->xmit is still uninitialized.
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 : }
2440 : out:
2441 : mutex_unlock(&tport->mutex);
2442 : return ret;
2443 : }
2444 :
2445 : static 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 :
2461 : static 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 :
2478 : static 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 :
2514 : static 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 : * uart_register_driver - register a driver with the uart core layer
2523 : * @drv: low level driver structure
2524 : *
2525 : * Register a uart driver with the core driver. We in turn register
2526 : * with the tty layer, and initialise the core driver per-port state.
2527 : *
2528 : * We have a proc file in /proc/tty/driver which is named after the
2529 : * normal driver.
2530 : *
2531 : * drv->port should be NULL, and the per-port structures should be
2532 : * registered using uart_add_one_port after this call has succeeded.
2533 : */
2534 1 : int uart_register_driver(struct uart_driver *drv)
2535 : {
2536 1 : struct tty_driver *normal;
2537 1 : int i, retval = -ENOMEM;
2538 :
2539 1 : BUG_ON(drv->state);
2540 :
2541 : /*
2542 : * Maybe we should be using a slab cache for this, especially if
2543 : * we have a large number of ports to handle.
2544 : */
2545 1 : drv->state = kcalloc(drv->nr, sizeof(struct uart_state), GFP_KERNEL);
2546 1 : if (!drv->state)
2547 0 : goto out;
2548 :
2549 1 : normal = alloc_tty_driver(drv->nr);
2550 1 : if (!normal)
2551 0 : goto out_kfree;
2552 :
2553 1 : drv->tty_driver = normal;
2554 :
2555 1 : normal->driver_name = drv->driver_name;
2556 1 : normal->name = drv->dev_name;
2557 1 : normal->major = drv->major;
2558 1 : normal->minor_start = drv->minor;
2559 1 : normal->type = TTY_DRIVER_TYPE_SERIAL;
2560 1 : normal->subtype = SERIAL_TYPE_NORMAL;
2561 1 : normal->init_termios = tty_std_termios;
2562 1 : normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2563 1 : normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
2564 1 : normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
2565 1 : normal->driver_state = drv;
2566 1 : tty_set_operations(normal, &uart_ops);
2567 :
2568 : /*
2569 : * Initialise the UART state(s).
2570 : */
2571 6 : for (i = 0; i < drv->nr; i++) {
2572 4 : struct uart_state *state = drv->state + i;
2573 4 : struct tty_port *port = &state->port;
2574 :
2575 4 : tty_port_init(port);
2576 4 : port->ops = &uart_port_ops;
2577 : }
2578 :
2579 1 : retval = tty_register_driver(normal);
2580 1 : if (retval >= 0)
2581 : return retval;
2582 :
2583 0 : for (i = 0; i < drv->nr; i++)
2584 0 : tty_port_destroy(&drv->state[i].port);
2585 0 : put_tty_driver(normal);
2586 0 : out_kfree:
2587 0 : kfree(drv->state);
2588 : out:
2589 : return retval;
2590 : }
2591 :
2592 : /**
2593 : * uart_unregister_driver - remove a driver from the uart core layer
2594 : * @drv: low level driver structure
2595 : *
2596 : * Remove all references to a driver from the core driver. The low
2597 : * level driver must have removed all its ports via the
2598 : * uart_remove_one_port() if it registered them with uart_add_one_port().
2599 : * (ie, drv->port == NULL)
2600 : */
2601 0 : void uart_unregister_driver(struct uart_driver *drv)
2602 : {
2603 0 : struct tty_driver *p = drv->tty_driver;
2604 0 : unsigned int i;
2605 :
2606 0 : tty_unregister_driver(p);
2607 0 : put_tty_driver(p);
2608 0 : for (i = 0; i < drv->nr; i++)
2609 0 : tty_port_destroy(&drv->state[i].port);
2610 0 : kfree(drv->state);
2611 0 : drv->state = NULL;
2612 0 : drv->tty_driver = NULL;
2613 0 : }
2614 :
2615 137 : struct tty_driver *uart_console_device(struct console *co, int *index)
2616 : {
2617 137 : struct uart_driver *p = co->data;
2618 137 : *index = co->index;
2619 137 : return p->tty_driver;
2620 : }
2621 : EXPORT_SYMBOL_GPL(uart_console_device);
2622 :
2623 0 : static ssize_t uartclk_show(struct device *dev,
2624 : struct device_attribute *attr, char *buf)
2625 : {
2626 0 : struct serial_struct tmp;
2627 0 : struct tty_port *port = dev_get_drvdata(dev);
2628 :
2629 0 : uart_get_info(port, &tmp);
2630 0 : return sprintf(buf, "%d\n", tmp.baud_base * 16);
2631 : }
2632 :
2633 0 : static ssize_t type_show(struct device *dev,
2634 : struct device_attribute *attr, char *buf)
2635 : {
2636 0 : struct serial_struct tmp;
2637 0 : struct tty_port *port = dev_get_drvdata(dev);
2638 :
2639 0 : uart_get_info(port, &tmp);
2640 0 : return sprintf(buf, "%d\n", tmp.type);
2641 : }
2642 :
2643 0 : static ssize_t line_show(struct device *dev,
2644 : struct device_attribute *attr, char *buf)
2645 : {
2646 0 : struct serial_struct tmp;
2647 0 : struct tty_port *port = dev_get_drvdata(dev);
2648 :
2649 0 : uart_get_info(port, &tmp);
2650 0 : return sprintf(buf, "%d\n", tmp.line);
2651 : }
2652 :
2653 0 : static ssize_t port_show(struct device *dev,
2654 : struct device_attribute *attr, char *buf)
2655 : {
2656 0 : struct serial_struct tmp;
2657 0 : struct tty_port *port = dev_get_drvdata(dev);
2658 0 : unsigned long ioaddr;
2659 :
2660 0 : uart_get_info(port, &tmp);
2661 0 : ioaddr = tmp.port;
2662 0 : if (HIGH_BITS_OFFSET)
2663 0 : ioaddr |= (unsigned long)tmp.port_high << HIGH_BITS_OFFSET;
2664 0 : return sprintf(buf, "0x%lX\n", ioaddr);
2665 : }
2666 :
2667 0 : static ssize_t irq_show(struct device *dev,
2668 : struct device_attribute *attr, char *buf)
2669 : {
2670 0 : struct serial_struct tmp;
2671 0 : struct tty_port *port = dev_get_drvdata(dev);
2672 :
2673 0 : uart_get_info(port, &tmp);
2674 0 : return sprintf(buf, "%d\n", tmp.irq);
2675 : }
2676 :
2677 0 : static ssize_t flags_show(struct device *dev,
2678 : struct device_attribute *attr, char *buf)
2679 : {
2680 0 : struct serial_struct tmp;
2681 0 : struct tty_port *port = dev_get_drvdata(dev);
2682 :
2683 0 : uart_get_info(port, &tmp);
2684 0 : return sprintf(buf, "0x%X\n", tmp.flags);
2685 : }
2686 :
2687 0 : static ssize_t xmit_fifo_size_show(struct device *dev,
2688 : struct device_attribute *attr, char *buf)
2689 : {
2690 0 : struct serial_struct tmp;
2691 0 : struct tty_port *port = dev_get_drvdata(dev);
2692 :
2693 0 : uart_get_info(port, &tmp);
2694 0 : return sprintf(buf, "%d\n", tmp.xmit_fifo_size);
2695 : }
2696 :
2697 0 : static ssize_t close_delay_show(struct device *dev,
2698 : struct device_attribute *attr, char *buf)
2699 : {
2700 0 : struct serial_struct tmp;
2701 0 : struct tty_port *port = dev_get_drvdata(dev);
2702 :
2703 0 : uart_get_info(port, &tmp);
2704 0 : return sprintf(buf, "%d\n", tmp.close_delay);
2705 : }
2706 :
2707 0 : static ssize_t closing_wait_show(struct device *dev,
2708 : struct device_attribute *attr, char *buf)
2709 : {
2710 0 : struct serial_struct tmp;
2711 0 : struct tty_port *port = dev_get_drvdata(dev);
2712 :
2713 0 : uart_get_info(port, &tmp);
2714 0 : return sprintf(buf, "%d\n", tmp.closing_wait);
2715 : }
2716 :
2717 0 : static ssize_t custom_divisor_show(struct device *dev,
2718 : struct device_attribute *attr, char *buf)
2719 : {
2720 0 : struct serial_struct tmp;
2721 0 : struct tty_port *port = dev_get_drvdata(dev);
2722 :
2723 0 : uart_get_info(port, &tmp);
2724 0 : return sprintf(buf, "%d\n", tmp.custom_divisor);
2725 : }
2726 :
2727 0 : static ssize_t io_type_show(struct device *dev,
2728 : struct device_attribute *attr, char *buf)
2729 : {
2730 0 : struct serial_struct tmp;
2731 0 : struct tty_port *port = dev_get_drvdata(dev);
2732 :
2733 0 : uart_get_info(port, &tmp);
2734 0 : return sprintf(buf, "%d\n", tmp.io_type);
2735 : }
2736 :
2737 0 : static ssize_t iomem_base_show(struct device *dev,
2738 : struct device_attribute *attr, char *buf)
2739 : {
2740 0 : struct serial_struct tmp;
2741 0 : struct tty_port *port = dev_get_drvdata(dev);
2742 :
2743 0 : uart_get_info(port, &tmp);
2744 0 : return sprintf(buf, "0x%lX\n", (unsigned long)tmp.iomem_base);
2745 : }
2746 :
2747 0 : static ssize_t iomem_reg_shift_show(struct device *dev,
2748 : struct device_attribute *attr, char *buf)
2749 : {
2750 0 : struct serial_struct tmp;
2751 0 : struct tty_port *port = dev_get_drvdata(dev);
2752 :
2753 0 : uart_get_info(port, &tmp);
2754 0 : return sprintf(buf, "%d\n", tmp.iomem_reg_shift);
2755 : }
2756 :
2757 0 : static ssize_t console_show(struct device *dev,
2758 : struct device_attribute *attr, char *buf)
2759 : {
2760 0 : struct tty_port *port = dev_get_drvdata(dev);
2761 0 : struct uart_state *state = container_of(port, struct uart_state, port);
2762 0 : struct uart_port *uport;
2763 0 : bool console = false;
2764 :
2765 0 : mutex_lock(&port->mutex);
2766 0 : uport = uart_port_check(state);
2767 0 : if (uport)
2768 0 : console = uart_console_enabled(uport);
2769 0 : mutex_unlock(&port->mutex);
2770 :
2771 0 : return sprintf(buf, "%c\n", console ? 'Y' : 'N');
2772 : }
2773 :
2774 0 : static ssize_t console_store(struct device *dev,
2775 : struct device_attribute *attr, const char *buf, size_t count)
2776 : {
2777 0 : struct tty_port *port = dev_get_drvdata(dev);
2778 0 : struct uart_state *state = container_of(port, struct uart_state, port);
2779 0 : struct uart_port *uport;
2780 0 : bool oldconsole, newconsole;
2781 0 : int ret;
2782 :
2783 0 : ret = kstrtobool(buf, &newconsole);
2784 0 : if (ret)
2785 0 : return ret;
2786 :
2787 0 : mutex_lock(&port->mutex);
2788 0 : uport = uart_port_check(state);
2789 0 : if (uport) {
2790 0 : oldconsole = uart_console_enabled(uport);
2791 0 : if (oldconsole && !newconsole) {
2792 0 : ret = unregister_console(uport->cons);
2793 0 : } else if (!oldconsole && newconsole) {
2794 0 : if (uart_console(uport)) {
2795 0 : uport->console_reinit = 1;
2796 0 : register_console(uport->cons);
2797 : } else {
2798 : ret = -ENOENT;
2799 : }
2800 : }
2801 : } else {
2802 : ret = -ENXIO;
2803 : }
2804 0 : mutex_unlock(&port->mutex);
2805 :
2806 0 : return ret < 0 ? ret : count;
2807 : }
2808 :
2809 : static DEVICE_ATTR_RO(uartclk);
2810 : static DEVICE_ATTR_RO(type);
2811 : static DEVICE_ATTR_RO(line);
2812 : static DEVICE_ATTR_RO(port);
2813 : static DEVICE_ATTR_RO(irq);
2814 : static DEVICE_ATTR_RO(flags);
2815 : static DEVICE_ATTR_RO(xmit_fifo_size);
2816 : static DEVICE_ATTR_RO(close_delay);
2817 : static DEVICE_ATTR_RO(closing_wait);
2818 : static DEVICE_ATTR_RO(custom_divisor);
2819 : static DEVICE_ATTR_RO(io_type);
2820 : static DEVICE_ATTR_RO(iomem_base);
2821 : static DEVICE_ATTR_RO(iomem_reg_shift);
2822 : static DEVICE_ATTR_RW(console);
2823 :
2824 : static 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 :
2842 : static const struct attribute_group tty_dev_attr_group = {
2843 : .attrs = tty_dev_attrs,
2844 : };
2845 :
2846 : /**
2847 : * uart_add_one_port - attach a driver-defined port structure
2848 : * @drv: pointer to the uart low level driver structure for this port
2849 : * @uport: uart port structure to use for this port.
2850 : *
2851 : * Context: task context, might sleep
2852 : *
2853 : * This allows the driver to register its own uart_port structure
2854 : * with the core driver. The main purpose is to allow the low
2855 : * level uart drivers to expand uart_port, rather than having yet
2856 : * more levels of structures.
2857 : */
2858 4 : int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
2859 : {
2860 4 : struct uart_state *state;
2861 4 : struct tty_port *port;
2862 4 : int ret = 0;
2863 4 : struct device *tty_dev;
2864 4 : int num_groups;
2865 :
2866 4 : if (uport->line >= drv->nr)
2867 : return -EINVAL;
2868 :
2869 4 : state = drv->state + uport->line;
2870 4 : port = &state->port;
2871 :
2872 4 : mutex_lock(&port_mutex);
2873 4 : mutex_lock(&port->mutex);
2874 4 : if (state->uart_port) {
2875 0 : ret = -EINVAL;
2876 0 : goto out;
2877 : }
2878 :
2879 : /* Link the port to the driver state table and vice versa */
2880 4 : atomic_set(&state->refcount, 1);
2881 4 : init_waitqueue_head(&state->remove_wait);
2882 4 : state->uart_port = uport;
2883 4 : uport->state = state;
2884 :
2885 4 : state->pm_state = UART_PM_STATE_UNDEFINED;
2886 4 : uport->cons = drv->cons;
2887 4 : uport->minor = drv->tty_driver->minor_start + uport->line;
2888 8 : uport->name = kasprintf(GFP_KERNEL, "%s%d", drv->dev_name,
2889 4 : drv->tty_driver->name_base + uport->line);
2890 4 : if (!uport->name) {
2891 0 : ret = -ENOMEM;
2892 0 : goto out;
2893 : }
2894 :
2895 : /*
2896 : * If this port is in use as a console then the spinlock is already
2897 : * initialised.
2898 : */
2899 4 : if (!uart_console_enabled(uport))
2900 3 : uart_port_spin_lock_init(uport);
2901 :
2902 4 : if (uport->cons && uport->dev)
2903 4 : of_console_check(uport->dev->of_node, uport->cons->name, uport->line);
2904 :
2905 4 : tty_port_link_device(port, drv->tty_driver, uport->line);
2906 4 : uart_configure_port(drv, state, uport);
2907 :
2908 4 : port->console = uart_console(uport);
2909 :
2910 4 : num_groups = 2;
2911 4 : if (uport->attr_group)
2912 1 : num_groups++;
2913 :
2914 4 : uport->tty_groups = kcalloc(num_groups, sizeof(*uport->tty_groups),
2915 : GFP_KERNEL);
2916 4 : if (!uport->tty_groups) {
2917 0 : ret = -ENOMEM;
2918 0 : goto out;
2919 : }
2920 4 : uport->tty_groups[0] = &tty_dev_attr_group;
2921 4 : if (uport->attr_group)
2922 1 : uport->tty_groups[1] = uport->attr_group;
2923 :
2924 : /*
2925 : * Register the port whether it's detected or not. This allows
2926 : * setserial to be used to alter this port's parameters.
2927 : */
2928 4 : tty_dev = tty_port_register_device_attr_serdev(port, drv->tty_driver,
2929 : uport->line, uport->dev, port, uport->tty_groups);
2930 4 : if (!IS_ERR(tty_dev)) {
2931 4 : device_set_wakeup_capable(tty_dev, 1);
2932 : } else {
2933 0 : dev_err(uport->dev, "Cannot register tty device on line %d\n",
2934 : uport->line);
2935 : }
2936 :
2937 : /*
2938 : * Ensure UPF_DEAD is not set.
2939 : */
2940 4 : uport->flags &= ~UPF_DEAD;
2941 :
2942 4 : out:
2943 4 : mutex_unlock(&port->mutex);
2944 4 : mutex_unlock(&port_mutex);
2945 :
2946 4 : return ret;
2947 : }
2948 :
2949 : /**
2950 : * uart_remove_one_port - detach a driver defined port structure
2951 : * @drv: pointer to the uart low level driver structure for this port
2952 : * @uport: uart port structure for this port
2953 : *
2954 : * Context: task context, might sleep
2955 : *
2956 : * This unhooks (and hangs up) the specified port structure from the
2957 : * core driver. No further calls will be made to the low-level code
2958 : * for this port.
2959 : */
2960 0 : int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
2961 : {
2962 0 : struct uart_state *state = drv->state + uport->line;
2963 0 : struct tty_port *port = &state->port;
2964 0 : struct uart_port *uart_port;
2965 0 : struct tty_struct *tty;
2966 0 : int ret = 0;
2967 :
2968 0 : mutex_lock(&port_mutex);
2969 :
2970 : /*
2971 : * Mark the port "dead" - this prevents any opens from
2972 : * succeeding while we shut down the port.
2973 : */
2974 0 : mutex_lock(&port->mutex);
2975 0 : uart_port = uart_port_check(state);
2976 0 : if (uart_port != uport)
2977 0 : dev_alert(uport->dev, "Removing wrong port: %p != %p\n",
2978 : uart_port, uport);
2979 :
2980 0 : if (!uart_port) {
2981 0 : mutex_unlock(&port->mutex);
2982 0 : ret = -EINVAL;
2983 0 : goto out;
2984 : }
2985 0 : uport->flags |= UPF_DEAD;
2986 0 : mutex_unlock(&port->mutex);
2987 :
2988 : /*
2989 : * Remove the devices from the tty layer
2990 : */
2991 0 : tty_port_unregister_device(port, drv->tty_driver, uport->line);
2992 :
2993 0 : tty = tty_port_tty_get(port);
2994 0 : if (tty) {
2995 0 : tty_vhangup(port->tty);
2996 0 : tty_kref_put(tty);
2997 : }
2998 :
2999 : /*
3000 : * If the port is used as a console, unregister it
3001 : */
3002 0 : if (uart_console(uport))
3003 0 : unregister_console(uport->cons);
3004 :
3005 : /*
3006 : * Free the port IO and memory resources, if any.
3007 : */
3008 0 : if (uport->type != PORT_UNKNOWN && uport->ops->release_port)
3009 0 : uport->ops->release_port(uport);
3010 0 : kfree(uport->tty_groups);
3011 0 : kfree(uport->name);
3012 :
3013 : /*
3014 : * Indicate that there isn't a port here anymore.
3015 : */
3016 0 : uport->type = PORT_UNKNOWN;
3017 :
3018 0 : mutex_lock(&port->mutex);
3019 0 : WARN_ON(atomic_dec_return(&state->refcount) < 0);
3020 0 : wait_event(state->remove_wait, !atomic_read(&state->refcount));
3021 0 : state->uart_port = NULL;
3022 0 : mutex_unlock(&port->mutex);
3023 0 : out:
3024 0 : mutex_unlock(&port_mutex);
3025 :
3026 0 : return ret;
3027 : }
3028 :
3029 : /*
3030 : * Are the two ports equivalent?
3031 : */
3032 0 : int uart_match_port(struct uart_port *port1, struct uart_port *port2)
3033 : {
3034 0 : if (port1->iotype != port2->iotype)
3035 : return 0;
3036 :
3037 0 : switch (port1->iotype) {
3038 0 : case UPIO_PORT:
3039 0 : return (port1->iobase == port2->iobase);
3040 0 : case UPIO_HUB6:
3041 0 : return (port1->iobase == port2->iobase) &&
3042 0 : (port1->hub6 == port2->hub6);
3043 0 : case UPIO_MEM:
3044 : case UPIO_MEM16:
3045 : case UPIO_MEM32:
3046 : case UPIO_MEM32BE:
3047 : case UPIO_AU:
3048 : case UPIO_TSI:
3049 0 : return (port1->mapbase == port2->mapbase);
3050 : }
3051 : return 0;
3052 : }
3053 : EXPORT_SYMBOL(uart_match_port);
3054 :
3055 : /**
3056 : * uart_handle_dcd_change - handle a change of carrier detect state
3057 : * @uport: uart_port structure for the open port
3058 : * @status: new carrier detect status, nonzero if active
3059 : *
3060 : * Caller must hold uport->lock
3061 : */
3062 0 : void uart_handle_dcd_change(struct uart_port *uport, unsigned int status)
3063 : {
3064 0 : struct tty_port *port = &uport->state->port;
3065 0 : struct tty_struct *tty = port->tty;
3066 0 : struct tty_ldisc *ld;
3067 :
3068 0 : lockdep_assert_held_once(&uport->lock);
3069 :
3070 0 : if (tty) {
3071 0 : ld = tty_ldisc_ref(tty);
3072 0 : if (ld) {
3073 0 : if (ld->ops->dcd_change)
3074 0 : ld->ops->dcd_change(tty, status);
3075 0 : tty_ldisc_deref(ld);
3076 : }
3077 : }
3078 :
3079 0 : uport->icount.dcd++;
3080 :
3081 0 : if (uart_dcd_enabled(uport)) {
3082 0 : if (status)
3083 0 : wake_up_interruptible(&port->open_wait);
3084 0 : else if (tty)
3085 0 : tty_hangup(tty);
3086 : }
3087 0 : }
3088 : EXPORT_SYMBOL_GPL(uart_handle_dcd_change);
3089 :
3090 : /**
3091 : * uart_handle_cts_change - handle a change of clear-to-send state
3092 : * @uport: uart_port structure for the open port
3093 : * @status: new clear to send status, nonzero if active
3094 : *
3095 : * Caller must hold uport->lock
3096 : */
3097 0 : void uart_handle_cts_change(struct uart_port *uport, unsigned int status)
3098 : {
3099 0 : lockdep_assert_held_once(&uport->lock);
3100 :
3101 0 : uport->icount.cts++;
3102 :
3103 0 : if (uart_softcts_mode(uport)) {
3104 0 : if (uport->hw_stopped) {
3105 0 : if (status) {
3106 0 : uport->hw_stopped = 0;
3107 0 : uport->ops->start_tx(uport);
3108 0 : uart_write_wakeup(uport);
3109 : }
3110 : } else {
3111 0 : if (!status) {
3112 0 : uport->hw_stopped = 1;
3113 0 : uport->ops->stop_tx(uport);
3114 : }
3115 : }
3116 :
3117 : }
3118 0 : }
3119 : EXPORT_SYMBOL_GPL(uart_handle_cts_change);
3120 :
3121 : /**
3122 : * uart_insert_char - push a char to the uart layer
3123 : *
3124 : * User is responsible to call tty_flip_buffer_push when they are done with
3125 : * insertion.
3126 : *
3127 : * @port: corresponding port
3128 : * @status: state of the serial port RX buffer (LSR for 8250)
3129 : * @overrun: mask of overrun bits in @status
3130 : * @ch: character to push
3131 : * @flag: flag for the character (see TTY_NORMAL and friends)
3132 : */
3133 0 : void uart_insert_char(struct uart_port *port, unsigned int status,
3134 : unsigned int overrun, unsigned int ch, unsigned int flag)
3135 : {
3136 0 : struct tty_port *tport = &port->state->port;
3137 :
3138 0 : if ((status & port->ignore_status_mask & ~overrun) == 0)
3139 0 : if (tty_insert_flip_char(tport, ch, flag) == 0)
3140 0 : ++port->icount.buf_overrun;
3141 :
3142 : /*
3143 : * Overrun is special. Since it's reported immediately,
3144 : * it doesn't affect the current character.
3145 : */
3146 0 : if (status & ~port->ignore_status_mask & overrun)
3147 0 : if (tty_insert_flip_char(tport, 0, TTY_OVERRUN) == 0)
3148 0 : ++port->icount.buf_overrun;
3149 0 : }
3150 : EXPORT_SYMBOL_GPL(uart_insert_char);
3151 :
3152 : #ifdef CONFIG_MAGIC_SYSRQ_SERIAL
3153 : static const char sysrq_toggle_seq[] = CONFIG_MAGIC_SYSRQ_SERIAL_SEQUENCE;
3154 :
3155 : static 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 : }
3163 : static DECLARE_WORK(sysrq_enable_work, uart_sysrq_on);
3164 :
3165 : /**
3166 : * uart_try_toggle_sysrq - Enables SysRq from serial line
3167 : * @port: uart_port structure where char(s) after BREAK met
3168 : * @ch: new character in the sequence after received BREAK
3169 : *
3170 : * Enables magic SysRq when the required sequence is met on port
3171 : * (see CONFIG_MAGIC_SYSRQ_SERIAL_SEQUENCE).
3172 : *
3173 : * Returns false if @ch is out of enabling sequence and should be
3174 : * handled some other way, true if @ch was consumed.
3175 : */
3176 : bool 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 : }
3199 : EXPORT_SYMBOL_GPL(uart_try_toggle_sysrq);
3200 : #endif
3201 :
3202 : EXPORT_SYMBOL(uart_write_wakeup);
3203 : EXPORT_SYMBOL(uart_register_driver);
3204 : EXPORT_SYMBOL(uart_unregister_driver);
3205 : EXPORT_SYMBOL(uart_suspend_port);
3206 : EXPORT_SYMBOL(uart_resume_port);
3207 : EXPORT_SYMBOL(uart_add_one_port);
3208 : EXPORT_SYMBOL(uart_remove_one_port);
3209 :
3210 : /**
3211 : * uart_get_rs485_mode() - retrieve rs485 properties for given uart
3212 : * @port: uart device's target port
3213 : *
3214 : * This function implements the device tree binding described in
3215 : * Documentation/devicetree/bindings/serial/rs485.txt.
3216 : */
3217 0 : int uart_get_rs485_mode(struct uart_port *port)
3218 : {
3219 0 : struct serial_rs485 *rs485conf = &port->rs485;
3220 0 : struct device *dev = port->dev;
3221 0 : u32 rs485_delay[2];
3222 0 : int ret;
3223 :
3224 0 : ret = device_property_read_u32_array(dev, "rs485-rts-delay",
3225 : rs485_delay, 2);
3226 0 : if (!ret) {
3227 0 : rs485conf->delay_rts_before_send = rs485_delay[0];
3228 0 : rs485conf->delay_rts_after_send = rs485_delay[1];
3229 : } else {
3230 0 : rs485conf->delay_rts_before_send = 0;
3231 0 : rs485conf->delay_rts_after_send = 0;
3232 : }
3233 :
3234 : /*
3235 : * Clear full-duplex and enabled flags, set RTS polarity to active high
3236 : * to get to a defined state with the following properties:
3237 : */
3238 0 : rs485conf->flags &= ~(SER_RS485_RX_DURING_TX | SER_RS485_ENABLED |
3239 : SER_RS485_TERMINATE_BUS |
3240 : SER_RS485_RTS_AFTER_SEND);
3241 0 : rs485conf->flags |= SER_RS485_RTS_ON_SEND;
3242 :
3243 0 : if (device_property_read_bool(dev, "rs485-rx-during-tx"))
3244 0 : rs485conf->flags |= SER_RS485_RX_DURING_TX;
3245 :
3246 0 : if (device_property_read_bool(dev, "linux,rs485-enabled-at-boot-time"))
3247 0 : rs485conf->flags |= SER_RS485_ENABLED;
3248 :
3249 0 : if (device_property_read_bool(dev, "rs485-rts-active-low")) {
3250 0 : rs485conf->flags &= ~SER_RS485_RTS_ON_SEND;
3251 0 : rs485conf->flags |= SER_RS485_RTS_AFTER_SEND;
3252 : }
3253 :
3254 : /*
3255 : * Disabling termination by default is the safe choice: Else if many
3256 : * bus participants enable it, no communication is possible at all.
3257 : * Works fine for short cables and users may enable for longer cables.
3258 : */
3259 0 : port->rs485_term_gpio = devm_gpiod_get_optional(dev, "rs485-term",
3260 : GPIOD_OUT_LOW);
3261 0 : 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 : }
3269 : EXPORT_SYMBOL_GPL(uart_get_rs485_mode);
3270 :
3271 : MODULE_DESCRIPTION("Serial driver core");
3272 : MODULE_LICENSE("GPL");
|
