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