1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Universal/legacy driver for 8250/16550-type serial ports
4 *
5 * Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
6 *
7 * Copyright (C) 2001 Russell King.
8 *
9 * Supports:
10 * early_serial_setup() ports
11 * userspace-configurable "phantom" ports
12 * serial8250_register_8250_port() ports
13 */
14
15 #include <linux/acpi.h>
16 #include <linux/hashtable.h>
17 #include <linux/module.h>
18 #include <linux/moduleparam.h>
19 #include <linux/ioport.h>
20 #include <linux/init.h>
21 #include <linux/console.h>
22 #include <linux/sysrq.h>
23 #include <linux/delay.h>
24 #include <linux/platform_device.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/tty.h>
27 #include <linux/ratelimit.h>
28 #include <linux/tty_flip.h>
29 #include <linux/serial.h>
30 #include <linux/serial_8250.h>
31 #include <linux/nmi.h>
32 #include <linux/mutex.h>
33 #include <linux/slab.h>
34 #include <linux/string_helpers.h>
35 #include <linux/uaccess.h>
36 #include <linux/io.h>
37
38 #include <asm/irq.h>
39
40 #include "8250.h"
41
42 #define PASS_LIMIT 512
43
44 struct irq_info {
45 struct hlist_node node;
46 int irq;
47 spinlock_t lock; /* Protects list not the hash */
48 struct list_head *head;
49 };
50
51 #define IRQ_HASH_BITS 5 /* Can be adjusted later */
52 static DEFINE_HASHTABLE(irq_lists, IRQ_HASH_BITS);
53 static DEFINE_MUTEX(hash_mutex); /* Used to walk the hash */
54
55 static bool skip_txen_test;
56 module_param(skip_txen_test, bool, 0644);
57 MODULE_PARM_DESC(skip_txen_test, "Skip checking for the TXEN bug at init time");
58
59 /*
60 * This is the serial driver's interrupt routine.
61 *
62 * Arjan thinks the old way was overly complex, so it got simplified.
63 * Alan disagrees, saying that need the complexity to handle the weird
64 * nature of ISA shared interrupts. (This is a special exception.)
65 *
66 * In order to handle ISA shared interrupts properly, we need to check
67 * that all ports have been serviced, and therefore the ISA interrupt
68 * line has been de-asserted.
69 *
70 * This means we need to loop through all ports. checking that they
71 * don't have an interrupt pending.
72 */
serial8250_interrupt(int irq,void * dev_id)73 static irqreturn_t serial8250_interrupt(int irq, void *dev_id)
74 {
75 struct irq_info *i = dev_id;
76 struct list_head *l, *end = NULL;
77 int pass_counter = 0, handled = 0;
78
79 guard(spinlock)(&i->lock);
80
81 l = i->head;
82 do {
83 struct uart_8250_port *up = list_entry(l, struct uart_8250_port, list);
84 struct uart_port *port = &up->port;
85
86 if (port->handle_irq(port)) {
87 handled = 1;
88 end = NULL;
89 } else if (end == NULL)
90 end = l;
91
92 l = l->next;
93
94 if (l == i->head && pass_counter++ > PASS_LIMIT)
95 break;
96 } while (l != end);
97
98 return IRQ_RETVAL(handled);
99 }
100
101 /*
102 * To support ISA shared interrupts, we need to have one interrupt
103 * handler that ensures that the IRQ line has been deasserted
104 * before returning. Failing to do this will result in the IRQ
105 * line being stuck active, and, since ISA irqs are edge triggered,
106 * no more IRQs will be seen.
107 */
serial_do_unlink(struct irq_info * i,struct uart_8250_port * up)108 static void serial_do_unlink(struct irq_info *i, struct uart_8250_port *up)
109 {
110 spin_lock_irq(&i->lock);
111
112 if (!list_empty(i->head)) {
113 if (i->head == &up->list)
114 i->head = i->head->next;
115 list_del(&up->list);
116 } else {
117 BUG_ON(i->head != &up->list);
118 i->head = NULL;
119 }
120 spin_unlock_irq(&i->lock);
121 /* List empty so throw away the hash node */
122 if (i->head == NULL) {
123 hlist_del(&i->node);
124 kfree(i);
125 }
126 }
127
128 /*
129 * Either:
130 * - find the corresponding info in the hashtable and return it, or
131 * - allocate a new one, add it to the hashtable and return it.
132 */
serial_get_or_create_irq_info(const struct uart_8250_port * up)133 static struct irq_info *serial_get_or_create_irq_info(const struct uart_8250_port *up)
134 {
135 struct irq_info *i;
136
137 guard(mutex)(&hash_mutex);
138
139 hash_for_each_possible(irq_lists, i, node, up->port.irq)
140 if (i->irq == up->port.irq)
141 return i;
142
143 i = kzalloc(sizeof(*i), GFP_KERNEL);
144 if (i == NULL)
145 return ERR_PTR(-ENOMEM);
146
147 spin_lock_init(&i->lock);
148 i->irq = up->port.irq;
149 hash_add(irq_lists, &i->node, i->irq);
150
151 return i;
152 }
153
serial_link_irq_chain(struct uart_8250_port * up)154 static int serial_link_irq_chain(struct uart_8250_port *up)
155 {
156 struct irq_info *i;
157 int ret;
158
159 i = serial_get_or_create_irq_info(up);
160 if (IS_ERR(i))
161 return PTR_ERR(i);
162
163 scoped_guard(spinlock_irq, &i->lock) {
164 if (i->head) {
165 list_add(&up->list, i->head);
166
167 return 0;
168 }
169
170 INIT_LIST_HEAD(&up->list);
171 i->head = &up->list;
172 }
173
174 ret = request_irq(up->port.irq, serial8250_interrupt, up->port.irqflags, up->port.name, i);
175 if (ret < 0)
176 serial_do_unlink(i, up);
177
178 return ret;
179 }
180
serial_unlink_irq_chain(struct uart_8250_port * up)181 static void serial_unlink_irq_chain(struct uart_8250_port *up)
182 {
183 struct irq_info *i;
184
185 guard(mutex)(&hash_mutex);
186
187 hash_for_each_possible(irq_lists, i, node, up->port.irq)
188 if (i->irq == up->port.irq) {
189 if (WARN_ON(i->head == NULL))
190 return;
191
192 if (list_empty(i->head))
193 free_irq(up->port.irq, i);
194
195 serial_do_unlink(i, up);
196
197 return;
198 }
199
200 WARN_ON(1);
201 }
202
203 /*
204 * This function is used to handle ports that do not have an
205 * interrupt. This doesn't work very well for 16450's, but gives
206 * barely passable results for a 16550A. (Although at the expense
207 * of much CPU overhead).
208 */
serial8250_timeout(struct timer_list * t)209 static void serial8250_timeout(struct timer_list *t)
210 {
211 struct uart_8250_port *up = timer_container_of(up, t, timer);
212
213 up->port.handle_irq(&up->port);
214 mod_timer(&up->timer, jiffies + uart_poll_timeout(&up->port));
215 }
216
serial8250_backup_timeout(struct timer_list * t)217 static void serial8250_backup_timeout(struct timer_list *t)
218 {
219 struct uart_8250_port *up = timer_container_of(up, t, timer);
220 unsigned int iir, ier = 0, lsr;
221 unsigned long flags;
222
223 uart_port_lock_irqsave(&up->port, &flags);
224
225 /*
226 * Must disable interrupts or else we risk racing with the interrupt
227 * based handler.
228 */
229 if (up->port.irq) {
230 ier = serial_in(up, UART_IER);
231 serial_out(up, UART_IER, 0);
232 }
233
234 iir = serial_in(up, UART_IIR);
235
236 /*
237 * This should be a safe test for anyone who doesn't trust the
238 * IIR bits on their UART, but it's specifically designed for
239 * the "Diva" UART used on the management processor on many HP
240 * ia64 and parisc boxes.
241 */
242 lsr = serial_lsr_in(up);
243 if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) &&
244 (!kfifo_is_empty(&up->port.state->port.xmit_fifo) ||
245 up->port.x_char) &&
246 (lsr & UART_LSR_THRE)) {
247 iir &= ~(UART_IIR_ID | UART_IIR_NO_INT);
248 iir |= UART_IIR_THRI;
249 }
250
251 if (!(iir & UART_IIR_NO_INT))
252 serial8250_tx_chars(up);
253
254 if (up->port.irq)
255 serial_out(up, UART_IER, ier);
256
257 uart_port_unlock_irqrestore(&up->port, flags);
258
259 /* Standard timer interval plus 0.2s to keep the port running */
260 mod_timer(&up->timer,
261 jiffies + uart_poll_timeout(&up->port) + HZ / 5);
262 }
263
univ8250_setup_timer(struct uart_8250_port * up)264 static void univ8250_setup_timer(struct uart_8250_port *up)
265 {
266 struct uart_port *port = &up->port;
267
268 /*
269 * The above check will only give an accurate result the first time
270 * the port is opened so this value needs to be preserved.
271 */
272 if (up->bugs & UART_BUG_THRE) {
273 pr_debug("%s - using backup timer\n", port->name);
274
275 up->timer.function = serial8250_backup_timeout;
276 mod_timer(&up->timer, jiffies +
277 uart_poll_timeout(port) + HZ / 5);
278 }
279
280 /*
281 * If the "interrupt" for this port doesn't correspond with any
282 * hardware interrupt, we use a timer-based system. The original
283 * driver used to do this with IRQ0.
284 */
285 if (!port->irq)
286 mod_timer(&up->timer, jiffies + uart_poll_timeout(port));
287 }
288
univ8250_setup_irq(struct uart_8250_port * up)289 static int univ8250_setup_irq(struct uart_8250_port *up)
290 {
291 struct uart_port *port = &up->port;
292
293 if (port->irq)
294 return serial_link_irq_chain(up);
295
296 return 0;
297 }
298
univ8250_release_irq(struct uart_8250_port * up)299 static void univ8250_release_irq(struct uart_8250_port *up)
300 {
301 struct uart_port *port = &up->port;
302
303 timer_delete_sync(&up->timer);
304 up->timer.function = serial8250_timeout;
305 if (port->irq)
306 serial_unlink_irq_chain(up);
307 }
308
309 const struct uart_ops *univ8250_port_base_ops;
310 struct uart_ops univ8250_port_ops;
311
312 static const struct uart_8250_ops univ8250_driver_ops = {
313 .setup_irq = univ8250_setup_irq,
314 .release_irq = univ8250_release_irq,
315 .setup_timer = univ8250_setup_timer,
316 };
317
318 static struct uart_8250_port serial8250_ports[UART_NR];
319
320 /**
321 * serial8250_get_port - retrieve struct uart_8250_port
322 * @line: serial line number
323 *
324 * This function retrieves struct uart_8250_port for the specific line.
325 * This struct *must* *not* be used to perform a 8250 or serial core operation
326 * which is not accessible otherwise. Its only purpose is to make the struct
327 * accessible to the runtime-pm callbacks for context suspend/restore.
328 * The lock assumption made here is none because runtime-pm suspend/resume
329 * callbacks should not be invoked if there is any operation performed on the
330 * port.
331 */
serial8250_get_port(int line)332 struct uart_8250_port *serial8250_get_port(int line)
333 {
334 return &serial8250_ports[line];
335 }
336 EXPORT_SYMBOL_GPL(serial8250_get_port);
337
serial8250_apply_quirks(struct uart_8250_port * up)338 static inline void serial8250_apply_quirks(struct uart_8250_port *up)
339 {
340 up->port.quirks |= skip_txen_test ? UPQ_NO_TXEN_TEST : 0;
341 }
342
serial8250_setup_port(int index)343 struct uart_8250_port *serial8250_setup_port(int index)
344 {
345 struct uart_8250_port *up;
346
347 if (index >= UART_NR)
348 return NULL;
349
350 up = &serial8250_ports[index];
351 up->port.line = index;
352 up->port.port_id = index;
353
354 serial8250_init_port(up);
355 if (!univ8250_port_base_ops)
356 univ8250_port_base_ops = up->port.ops;
357 up->port.ops = &univ8250_port_ops;
358
359 timer_setup(&up->timer, serial8250_timeout, 0);
360
361 up->ops = &univ8250_driver_ops;
362
363 serial8250_set_defaults(up);
364
365 return up;
366 }
367
serial8250_register_ports(struct uart_driver * drv,struct device * dev)368 void __init serial8250_register_ports(struct uart_driver *drv, struct device *dev)
369 {
370 int i;
371
372 for (i = 0; i < nr_uarts; i++) {
373 struct uart_8250_port *up = &serial8250_ports[i];
374
375 if (up->port.type == PORT_8250_CIR)
376 continue;
377
378 if (up->port.dev)
379 continue;
380
381 up->port.dev = dev;
382
383 if (uart_console_registered(&up->port))
384 pm_runtime_get_sync(up->port.dev);
385
386 serial8250_apply_quirks(up);
387 uart_add_one_port(drv, &up->port);
388 }
389 }
390
391 #ifdef CONFIG_SERIAL_8250_CONSOLE
392
univ8250_console_write(struct console * co,const char * s,unsigned int count)393 static void univ8250_console_write(struct console *co, const char *s,
394 unsigned int count)
395 {
396 struct uart_8250_port *up = &serial8250_ports[co->index];
397
398 serial8250_console_write(up, s, count);
399 }
400
univ8250_console_setup(struct console * co,char * options)401 static int univ8250_console_setup(struct console *co, char *options)
402 {
403 struct uart_8250_port *up;
404 struct uart_port *port;
405 int retval, i;
406
407 /*
408 * Check whether an invalid uart number has been specified, and
409 * if so, search for the first available port that does have
410 * console support.
411 */
412 if (co->index < 0 || co->index >= UART_NR)
413 co->index = 0;
414
415 /*
416 * If the console is past the initial isa ports, init more ports up to
417 * co->index as needed and increment nr_uarts accordingly.
418 */
419 for (i = nr_uarts; i <= co->index; i++) {
420 up = serial8250_setup_port(i);
421 if (!up)
422 return -ENODEV;
423 nr_uarts++;
424 }
425
426 port = &serial8250_ports[co->index].port;
427 /* link port to console */
428 uart_port_set_cons(port, co);
429
430 retval = serial8250_console_setup(port, options, false);
431 if (retval != 0)
432 uart_port_set_cons(port, NULL);
433 return retval;
434 }
435
univ8250_console_exit(struct console * co)436 static int univ8250_console_exit(struct console *co)
437 {
438 struct uart_port *port;
439
440 port = &serial8250_ports[co->index].port;
441 return serial8250_console_exit(port);
442 }
443
444 /**
445 * univ8250_console_match - non-standard console matching
446 * @co: registering console
447 * @name: name from console command line
448 * @idx: index from console command line
449 * @options: ptr to option string from console command line
450 *
451 * Only attempts to match console command lines of the form:
452 * console=uart[8250],io|mmio|mmio16|mmio32,<addr>[,<options>]
453 * console=uart[8250],0x<addr>[,<options>]
454 * This form is used to register an initial earlycon boot console and
455 * replace it with the serial8250_console at 8250 driver init.
456 *
457 * Performs console setup for a match (as required by interface)
458 * If no <options> are specified, then assume the h/w is already setup.
459 *
460 * Returns 0 if console matches; otherwise non-zero to use default matching
461 */
univ8250_console_match(struct console * co,char * name,int idx,char * options)462 static int univ8250_console_match(struct console *co, char *name, int idx,
463 char *options)
464 {
465 char match[] = "uart"; /* 8250-specific earlycon name */
466 enum uart_iotype iotype;
467 resource_size_t addr;
468 int i;
469
470 if (strncmp(name, match, 4) != 0)
471 return -ENODEV;
472
473 if (uart_parse_earlycon(options, &iotype, &addr, &options))
474 return -ENODEV;
475
476 /* try to match the port specified on the command line */
477 for (i = 0; i < nr_uarts; i++) {
478 struct uart_port *port = &serial8250_ports[i].port;
479
480 if (port->iotype != iotype)
481 continue;
482 if ((iotype == UPIO_MEM || iotype == UPIO_MEM16 ||
483 iotype == UPIO_MEM32 || iotype == UPIO_MEM32BE)
484 && (port->mapbase != addr))
485 continue;
486 if (iotype == UPIO_PORT && port->iobase != addr)
487 continue;
488
489 co->index = i;
490 uart_port_set_cons(port, co);
491 return serial8250_console_setup(port, options, true);
492 }
493
494 return -ENODEV;
495 }
496
497 static struct console univ8250_console = {
498 .name = "ttyS",
499 .write = univ8250_console_write,
500 .device = uart_console_device,
501 .setup = univ8250_console_setup,
502 .exit = univ8250_console_exit,
503 .match = univ8250_console_match,
504 .flags = CON_PRINTBUFFER | CON_ANYTIME,
505 .index = -1,
506 .data = &serial8250_reg,
507 };
508
univ8250_console_init(void)509 static int __init univ8250_console_init(void)
510 {
511 if (nr_uarts == 0)
512 return -ENODEV;
513
514 serial8250_isa_init_ports();
515 register_console(&univ8250_console);
516 return 0;
517 }
518 console_initcall(univ8250_console_init);
519
520 #define SERIAL8250_CONSOLE (&univ8250_console)
521 #else
522 #define SERIAL8250_CONSOLE NULL
523 #endif
524
525 struct uart_driver serial8250_reg = {
526 .owner = THIS_MODULE,
527 .driver_name = "serial",
528 .dev_name = "ttyS",
529 .major = TTY_MAJOR,
530 .minor = 64,
531 .cons = SERIAL8250_CONSOLE,
532 };
533
534 /*
535 * early_serial_setup - early registration for 8250 ports
536 *
537 * Setup an 8250 port structure prior to console initialisation. Use
538 * after console initialisation will cause undefined behaviour.
539 */
early_serial_setup(struct uart_port * port)540 int __init early_serial_setup(struct uart_port *port)
541 {
542 struct uart_port *p;
543
544 if (port->line >= ARRAY_SIZE(serial8250_ports) || nr_uarts == 0)
545 return -ENODEV;
546
547 serial8250_isa_init_ports();
548 p = &serial8250_ports[port->line].port;
549 p->iobase = port->iobase;
550 p->membase = port->membase;
551 p->irq = port->irq;
552 p->irqflags = port->irqflags;
553 p->uartclk = port->uartclk;
554 p->fifosize = port->fifosize;
555 p->regshift = port->regshift;
556 p->iotype = port->iotype;
557 p->flags = port->flags;
558 p->mapbase = port->mapbase;
559 p->mapsize = port->mapsize;
560 p->private_data = port->private_data;
561 p->type = port->type;
562 p->line = port->line;
563
564 serial8250_set_defaults(up_to_u8250p(p));
565
566 if (port->serial_in)
567 p->serial_in = port->serial_in;
568 if (port->serial_out)
569 p->serial_out = port->serial_out;
570 if (port->handle_irq)
571 p->handle_irq = port->handle_irq;
572
573 return 0;
574 }
575
576 /**
577 * serial8250_suspend_port - suspend one serial port
578 * @line: serial line number
579 *
580 * Suspend one serial port.
581 */
serial8250_suspend_port(int line)582 void serial8250_suspend_port(int line)
583 {
584 struct uart_8250_port *up = &serial8250_ports[line];
585 struct uart_port *port = &up->port;
586
587 if (!console_suspend_enabled && uart_console(port) &&
588 port->type != PORT_8250) {
589 unsigned char canary = 0xa5;
590
591 serial_out(up, UART_SCR, canary);
592 if (serial_in(up, UART_SCR) == canary)
593 up->canary = canary;
594 }
595
596 uart_suspend_port(&serial8250_reg, port);
597 }
598 EXPORT_SYMBOL(serial8250_suspend_port);
599
600 /**
601 * serial8250_resume_port - resume one serial port
602 * @line: serial line number
603 *
604 * Resume one serial port.
605 */
serial8250_resume_port(int line)606 void serial8250_resume_port(int line)
607 {
608 struct uart_8250_port *up = &serial8250_ports[line];
609 struct uart_port *port = &up->port;
610
611 up->canary = 0;
612
613 if (up->capabilities & UART_NATSEMI) {
614 /* Ensure it's still in high speed mode */
615 serial_port_out(port, UART_LCR, 0xE0);
616
617 ns16550a_goto_highspeed(up);
618
619 serial_port_out(port, UART_LCR, 0);
620 port->uartclk = 921600*16;
621 }
622 uart_resume_port(&serial8250_reg, port);
623 }
624 EXPORT_SYMBOL(serial8250_resume_port);
625
626 /*
627 * serial8250_register_8250_port and serial8250_unregister_port allows for
628 * 16x50 serial ports to be configured at run-time, to support PCMCIA
629 * modems and PCI multiport cards.
630 */
631 static DEFINE_MUTEX(serial_mutex);
632
serial8250_find_match_or_unused(const struct uart_port * port)633 static struct uart_8250_port *serial8250_find_match_or_unused(const struct uart_port *port)
634 {
635 int i;
636
637 /*
638 * First, find a port entry which matches.
639 */
640 for (i = 0; i < nr_uarts; i++)
641 if (uart_match_port(&serial8250_ports[i].port, port))
642 return &serial8250_ports[i];
643
644 /* try line number first if still available */
645 i = port->line;
646 if (i < nr_uarts && serial8250_ports[i].port.type == PORT_UNKNOWN &&
647 serial8250_ports[i].port.iobase == 0)
648 return &serial8250_ports[i];
649 /*
650 * We didn't find a matching entry, so look for the first
651 * free entry. We look for one which hasn't been previously
652 * used (indicated by zero iobase).
653 */
654 for (i = 0; i < nr_uarts; i++)
655 if (serial8250_ports[i].port.type == PORT_UNKNOWN &&
656 serial8250_ports[i].port.iobase == 0)
657 return &serial8250_ports[i];
658
659 /*
660 * That also failed. Last resort is to find any entry which
661 * doesn't have a real port associated with it.
662 */
663 for (i = 0; i < nr_uarts; i++)
664 if (serial8250_ports[i].port.type == PORT_UNKNOWN)
665 return &serial8250_ports[i];
666
667 return NULL;
668 }
669
serial_8250_overrun_backoff_work(struct work_struct * work)670 static void serial_8250_overrun_backoff_work(struct work_struct *work)
671 {
672 struct uart_8250_port *up = container_of(to_delayed_work(work), struct uart_8250_port,
673 overrun_backoff);
674
675 guard(uart_port_lock_irqsave)(&up->port);
676 up->ier |= UART_IER_RLSI | UART_IER_RDI;
677 serial_out(up, UART_IER, up->ier);
678 }
679
680 /**
681 * serial8250_register_8250_port - register a serial port
682 * @up: serial port template
683 *
684 * Configure the serial port specified by the request. If the
685 * port exists and is in use, it is hung up and unregistered
686 * first.
687 *
688 * The port is then probed and if necessary the IRQ is autodetected
689 * If this fails an error is returned.
690 *
691 * On success the port is ready to use and the line number is returned.
692 */
serial8250_register_8250_port(const struct uart_8250_port * up)693 int serial8250_register_8250_port(const struct uart_8250_port *up)
694 {
695 struct uart_8250_port *uart;
696 int ret;
697
698 if (up->port.uartclk == 0)
699 return -EINVAL;
700
701 guard(mutex)(&serial_mutex);
702
703 uart = serial8250_find_match_or_unused(&up->port);
704 if (!uart) {
705 /*
706 * If the port is past the initial isa ports, initialize a new
707 * port and increment nr_uarts accordingly.
708 */
709 uart = serial8250_setup_port(nr_uarts);
710 if (!uart)
711 return -ENOSPC;
712 nr_uarts++;
713 }
714
715 /* Check if it is CIR already. We check this below again, see there why. */
716 if (uart->port.type == PORT_8250_CIR)
717 return -ENODEV;
718
719 if (uart->port.dev)
720 uart_remove_one_port(&serial8250_reg, &uart->port);
721
722 uart->port.ctrl_id = up->port.ctrl_id;
723 uart->port.port_id = up->port.port_id;
724 uart->port.iobase = up->port.iobase;
725 uart->port.membase = up->port.membase;
726 uart->port.irq = up->port.irq;
727 uart->port.irqflags = up->port.irqflags;
728 uart->port.uartclk = up->port.uartclk;
729 uart->port.fifosize = up->port.fifosize;
730 uart->port.regshift = up->port.regshift;
731 uart->port.iotype = up->port.iotype;
732 uart->port.flags = up->port.flags | UPF_BOOT_AUTOCONF;
733 uart->bugs = up->bugs;
734 uart->port.mapbase = up->port.mapbase;
735 uart->port.mapsize = up->port.mapsize;
736 uart->port.private_data = up->port.private_data;
737 uart->tx_loadsz = up->tx_loadsz;
738 uart->capabilities = up->capabilities;
739 uart->port.throttle = up->port.throttle;
740 uart->port.unthrottle = up->port.unthrottle;
741 uart->port.rs485_config = up->port.rs485_config;
742 uart->port.rs485_supported = up->port.rs485_supported;
743 uart->port.rs485 = up->port.rs485;
744 uart->rs485_start_tx = up->rs485_start_tx;
745 uart->rs485_stop_tx = up->rs485_stop_tx;
746 uart->lsr_save_mask = up->lsr_save_mask;
747 uart->dma = up->dma;
748
749 /* Take tx_loadsz from fifosize if it wasn't set separately */
750 if (uart->port.fifosize && !uart->tx_loadsz)
751 uart->tx_loadsz = uart->port.fifosize;
752
753 if (up->port.dev) {
754 uart->port.dev = up->port.dev;
755 ret = uart_get_rs485_mode(&uart->port);
756 if (ret)
757 goto err;
758 }
759
760 if (up->port.flags & UPF_FIXED_TYPE)
761 uart->port.type = up->port.type;
762
763 /*
764 * Only call mctrl_gpio_init(), if the device has no ACPI
765 * companion device
766 */
767 if (!has_acpi_companion(uart->port.dev)) {
768 struct mctrl_gpios *gpios = mctrl_gpio_init(&uart->port, 0);
769 if (IS_ERR(gpios)) {
770 ret = PTR_ERR(gpios);
771 goto err;
772 } else {
773 uart->gpios = gpios;
774 }
775 }
776
777 serial8250_set_defaults(uart);
778
779 /* Possibly override default I/O functions. */
780 if (up->port.serial_in)
781 uart->port.serial_in = up->port.serial_in;
782 if (up->port.serial_out)
783 uart->port.serial_out = up->port.serial_out;
784 if (up->port.handle_irq)
785 uart->port.handle_irq = up->port.handle_irq;
786 /* Possibly override set_termios call */
787 if (up->port.set_termios)
788 uart->port.set_termios = up->port.set_termios;
789 if (up->port.set_ldisc)
790 uart->port.set_ldisc = up->port.set_ldisc;
791 if (up->port.get_mctrl)
792 uart->port.get_mctrl = up->port.get_mctrl;
793 if (up->port.set_mctrl)
794 uart->port.set_mctrl = up->port.set_mctrl;
795 if (up->port.get_divisor)
796 uart->port.get_divisor = up->port.get_divisor;
797 if (up->port.set_divisor)
798 uart->port.set_divisor = up->port.set_divisor;
799 if (up->port.startup)
800 uart->port.startup = up->port.startup;
801 if (up->port.shutdown)
802 uart->port.shutdown = up->port.shutdown;
803 if (up->port.pm)
804 uart->port.pm = up->port.pm;
805 if (up->port.handle_break)
806 uart->port.handle_break = up->port.handle_break;
807 if (up->dl_read)
808 uart->dl_read = up->dl_read;
809 if (up->dl_write)
810 uart->dl_write = up->dl_write;
811
812 /* Check the type (again)! It might have changed by the port.type assignment above. */
813 if (uart->port.type != PORT_8250_CIR) {
814 if (uart_console_registered(&uart->port))
815 pm_runtime_get_sync(uart->port.dev);
816
817 if (serial8250_isa_config != NULL)
818 serial8250_isa_config(0, &uart->port,
819 &uart->capabilities);
820
821 serial8250_apply_quirks(uart);
822 ret = uart_add_one_port(&serial8250_reg,
823 &uart->port);
824 if (ret)
825 goto err;
826
827 ret = uart->port.line;
828 } else {
829 dev_info(uart->port.dev,
830 "skipping CIR port at 0x%lx / 0x%llx, IRQ %d\n",
831 uart->port.iobase,
832 (unsigned long long)uart->port.mapbase,
833 uart->port.irq);
834
835 ret = 0;
836 }
837
838 if (!uart->lsr_save_mask)
839 uart->lsr_save_mask = LSR_SAVE_FLAGS; /* Use default LSR mask */
840
841 /* Initialise interrupt backoff work if required */
842 if (up->overrun_backoff_time_ms > 0) {
843 uart->overrun_backoff_time_ms =
844 up->overrun_backoff_time_ms;
845 INIT_DELAYED_WORK(&uart->overrun_backoff,
846 serial_8250_overrun_backoff_work);
847 } else {
848 uart->overrun_backoff_time_ms = 0;
849 }
850
851 return ret;
852
853 err:
854 uart->port.dev = NULL;
855 return ret;
856 }
857 EXPORT_SYMBOL(serial8250_register_8250_port);
858
859 /**
860 * serial8250_unregister_port - remove a 16x50 serial port at runtime
861 * @line: serial line number
862 *
863 * Remove one serial port. This may not be called from interrupt
864 * context. We hand the port back to the our control.
865 */
serial8250_unregister_port(int line)866 void serial8250_unregister_port(int line)
867 {
868 struct uart_8250_port *uart = &serial8250_ports[line];
869
870 guard(mutex)(&serial_mutex);
871
872 if (uart->em485) {
873 guard(uart_port_lock_irqsave)(&uart->port);
874 serial8250_em485_destroy(uart);
875 }
876
877 uart_remove_one_port(&serial8250_reg, &uart->port);
878 if (serial8250_isa_devs) {
879 uart->port.flags &= ~UPF_BOOT_AUTOCONF;
880 uart->port.type = PORT_UNKNOWN;
881 uart->port.dev = &serial8250_isa_devs->dev;
882 uart->port.port_id = line;
883 uart->capabilities = 0;
884 serial8250_init_port(uart);
885 serial8250_apply_quirks(uart);
886 uart_add_one_port(&serial8250_reg, &uart->port);
887 } else {
888 uart->port.dev = NULL;
889 }
890 }
891 EXPORT_SYMBOL(serial8250_unregister_port);
892
893 MODULE_LICENSE("GPL");
894 MODULE_DESCRIPTION("Generic 8250/16x50 serial driver");
895