Branch data Line data Source code
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: ISA-compatible 8250/16550 ports
10 : : * PNP 8250/16550 ports
11 : : * early_serial_setup() ports
12 : : * userspace-configurable "phantom" ports
13 : : * "serial8250" platform devices
14 : : * serial8250_register_8250_port() ports
15 : : */
16 : :
17 : : #include <linux/acpi.h>
18 : : #include <linux/module.h>
19 : : #include <linux/moduleparam.h>
20 : : #include <linux/ioport.h>
21 : : #include <linux/init.h>
22 : : #include <linux/console.h>
23 : : #include <linux/sysrq.h>
24 : : #include <linux/delay.h>
25 : : #include <linux/platform_device.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/uaccess.h>
35 : : #include <linux/pm_runtime.h>
36 : : #include <linux/io.h>
37 : : #ifdef CONFIG_SPARC
38 : : #include <linux/sunserialcore.h>
39 : : #endif
40 : :
41 : : #include <asm/irq.h>
42 : :
43 : : #include "8250.h"
44 : :
45 : : /*
46 : : * Configuration:
47 : : * share_irqs - whether we pass IRQF_SHARED to request_irq(). This option
48 : : * is unsafe when used on edge-triggered interrupts.
49 : : */
50 : : static unsigned int share_irqs = SERIAL8250_SHARE_IRQS;
51 : :
52 : : static unsigned int nr_uarts = CONFIG_SERIAL_8250_RUNTIME_UARTS;
53 : :
54 : : static struct uart_driver serial8250_reg;
55 : :
56 : : static unsigned int skip_txen_test; /* force skip of txen test at init time */
57 : :
58 : : #define PASS_LIMIT 512
59 : :
60 : : #include <asm/serial.h>
61 : : /*
62 : : * SERIAL_PORT_DFNS tells us about built-in ports that have no
63 : : * standard enumeration mechanism. Platforms that can find all
64 : : * serial ports via mechanisms like ACPI or PCI need not supply it.
65 : : */
66 : : #ifndef SERIAL_PORT_DFNS
67 : : #define SERIAL_PORT_DFNS
68 : : #endif
69 : :
70 : : static const struct old_serial_port old_serial_port[] = {
71 : : SERIAL_PORT_DFNS /* defined in asm/serial.h */
72 : : };
73 : :
74 : : #define UART_NR CONFIG_SERIAL_8250_NR_UARTS
75 : :
76 : : #ifdef CONFIG_SERIAL_8250_RSA
77 : :
78 : : #define PORT_RSA_MAX 4
79 : : static unsigned long probe_rsa[PORT_RSA_MAX];
80 : : static unsigned int probe_rsa_count;
81 : : #endif /* CONFIG_SERIAL_8250_RSA */
82 : :
83 : : struct irq_info {
84 : : struct hlist_node node;
85 : : int irq;
86 : : spinlock_t lock; /* Protects list not the hash */
87 : : struct list_head *head;
88 : : };
89 : :
90 : : #define NR_IRQ_HASH 32 /* Can be adjusted later */
91 : : static struct hlist_head irq_lists[NR_IRQ_HASH];
92 : : static DEFINE_MUTEX(hash_mutex); /* Used to walk the hash */
93 : :
94 : : /*
95 : : * This is the serial driver's interrupt routine.
96 : : *
97 : : * Arjan thinks the old way was overly complex, so it got simplified.
98 : : * Alan disagrees, saying that need the complexity to handle the weird
99 : : * nature of ISA shared interrupts. (This is a special exception.)
100 : : *
101 : : * In order to handle ISA shared interrupts properly, we need to check
102 : : * that all ports have been serviced, and therefore the ISA interrupt
103 : : * line has been de-asserted.
104 : : *
105 : : * This means we need to loop through all ports. checking that they
106 : : * don't have an interrupt pending.
107 : : */
108 : 3828 : static irqreturn_t serial8250_interrupt(int irq, void *dev_id)
109 : : {
110 : 3828 : struct irq_info *i = dev_id;
111 : 3828 : struct list_head *l, *end = NULL;
112 : 3828 : int pass_counter = 0, handled = 0;
113 : :
114 : 3828 : pr_debug("%s(%d): start\n", __func__, irq);
115 : :
116 : 3828 : spin_lock(&i->lock);
117 : :
118 : 3828 : l = i->head;
119 : 7338 : do {
120 : 7338 : struct uart_8250_port *up;
121 : 7338 : struct uart_port *port;
122 : :
123 : 7338 : up = list_entry(l, struct uart_8250_port, list);
124 : 7338 : port = &up->port;
125 : :
126 [ + + ]: 7338 : if (port->handle_irq(port)) {
127 : : handled = 1;
128 : : end = NULL;
129 [ + - ]: 3828 : } else if (end == NULL)
130 : 3828 : end = l;
131 : :
132 : 7338 : l = l->next;
133 : :
134 [ + - + - ]: 7338 : if (l == i->head && pass_counter++ > PASS_LIMIT)
135 : : break;
136 [ + + ]: 7338 : } while (l != end);
137 : :
138 : 3828 : spin_unlock(&i->lock);
139 : :
140 : 3828 : pr_debug("%s(%d): end\n", __func__, irq);
141 : :
142 : 3828 : return IRQ_RETVAL(handled);
143 : : }
144 : :
145 : : /*
146 : : * To support ISA shared interrupts, we need to have one interrupt
147 : : * handler that ensures that the IRQ line has been deasserted
148 : : * before returning. Failing to do this will result in the IRQ
149 : : * line being stuck active, and, since ISA irqs are edge triggered,
150 : : * no more IRQs will be seen.
151 : : */
152 : 0 : static void serial_do_unlink(struct irq_info *i, struct uart_8250_port *up)
153 : : {
154 : 0 : spin_lock_irq(&i->lock);
155 : :
156 [ # # ]: 0 : if (!list_empty(i->head)) {
157 [ # # ]: 0 : if (i->head == &up->list)
158 : 0 : i->head = i->head->next;
159 : 0 : list_del(&up->list);
160 : : } else {
161 [ # # ]: 0 : BUG_ON(i->head != &up->list);
162 : 0 : i->head = NULL;
163 : : }
164 : 0 : spin_unlock_irq(&i->lock);
165 : : /* List empty so throw away the hash node */
166 [ # # ]: 0 : if (i->head == NULL) {
167 [ # # ]: 0 : hlist_del(&i->node);
168 : 0 : kfree(i);
169 : : }
170 : 0 : }
171 : :
172 : 3 : static int serial_link_irq_chain(struct uart_8250_port *up)
173 : : {
174 : 3 : struct hlist_head *h;
175 : 3 : struct hlist_node *n;
176 : 3 : struct irq_info *i;
177 : 3 : int ret;
178 : :
179 : 3 : mutex_lock(&hash_mutex);
180 : :
181 : 3 : h = &irq_lists[up->port.irq % NR_IRQ_HASH];
182 : :
183 [ - + ]: 3 : hlist_for_each(n, h) {
184 : 0 : i = hlist_entry(n, struct irq_info, node);
185 [ # # ]: 0 : if (i->irq == up->port.irq)
186 : : break;
187 : : }
188 : :
189 [ + - ]: 3 : if (n == NULL) {
190 : 3 : i = kzalloc(sizeof(struct irq_info), GFP_KERNEL);
191 [ - + ]: 3 : if (i == NULL) {
192 : 0 : mutex_unlock(&hash_mutex);
193 : 0 : return -ENOMEM;
194 : : }
195 [ - + ]: 3 : spin_lock_init(&i->lock);
196 : 3 : i->irq = up->port.irq;
197 [ - + ]: 3 : hlist_add_head(&i->node, h);
198 : : }
199 : 3 : mutex_unlock(&hash_mutex);
200 : :
201 : 3 : spin_lock_irq(&i->lock);
202 : :
203 [ - + ]: 3 : if (i->head) {
204 : 0 : list_add(&up->list, i->head);
205 : 0 : spin_unlock_irq(&i->lock);
206 : :
207 : 0 : ret = 0;
208 : : } else {
209 : 3 : INIT_LIST_HEAD(&up->list);
210 : 3 : i->head = &up->list;
211 : 3 : spin_unlock_irq(&i->lock);
212 : 3 : ret = request_irq(up->port.irq, serial8250_interrupt,
213 : : up->port.irqflags, up->port.name, i);
214 [ - + ]: 3 : if (ret < 0)
215 : 0 : serial_do_unlink(i, up);
216 : : }
217 : :
218 : : return ret;
219 : : }
220 : :
221 : 0 : static void serial_unlink_irq_chain(struct uart_8250_port *up)
222 : : {
223 : : /*
224 : : * yes, some broken gcc emit "warning: 'i' may be used uninitialized"
225 : : * but no, we are not going to take a patch that assigns NULL below.
226 : : */
227 : 0 : struct irq_info *i;
228 : 0 : struct hlist_node *n;
229 : 0 : struct hlist_head *h;
230 : :
231 : 0 : mutex_lock(&hash_mutex);
232 : :
233 : 0 : h = &irq_lists[up->port.irq % NR_IRQ_HASH];
234 : :
235 [ # # ]: 0 : hlist_for_each(n, h) {
236 : 0 : i = hlist_entry(n, struct irq_info, node);
237 [ # # ]: 0 : if (i->irq == up->port.irq)
238 : : break;
239 : : }
240 : :
241 [ # # ]: 0 : BUG_ON(n == NULL);
242 [ # # ]: 0 : BUG_ON(i->head == NULL);
243 : :
244 [ # # ]: 0 : if (list_empty(i->head))
245 : 0 : free_irq(up->port.irq, i);
246 : :
247 : 0 : serial_do_unlink(i, up);
248 : 0 : mutex_unlock(&hash_mutex);
249 : 0 : }
250 : :
251 : : /*
252 : : * This function is used to handle ports that do not have an
253 : : * interrupt. This doesn't work very well for 16450's, but gives
254 : : * barely passable results for a 16550A. (Although at the expense
255 : : * of much CPU overhead).
256 : : */
257 : 0 : static void serial8250_timeout(struct timer_list *t)
258 : : {
259 : 0 : struct uart_8250_port *up = from_timer(up, t, timer);
260 : :
261 : 0 : up->port.handle_irq(&up->port);
262 [ # # ]: 0 : mod_timer(&up->timer, jiffies + uart_poll_timeout(&up->port));
263 : 0 : }
264 : :
265 : 0 : static void serial8250_backup_timeout(struct timer_list *t)
266 : : {
267 : 0 : struct uart_8250_port *up = from_timer(up, t, timer);
268 : 0 : unsigned int iir, ier = 0, lsr;
269 : 0 : unsigned long flags;
270 : :
271 : 0 : spin_lock_irqsave(&up->port.lock, flags);
272 : :
273 : : /*
274 : : * Must disable interrupts or else we risk racing with the interrupt
275 : : * based handler.
276 : : */
277 [ # # ]: 0 : if (up->port.irq) {
278 : 0 : ier = serial_in(up, UART_IER);
279 : 0 : serial_out(up, UART_IER, 0);
280 : : }
281 : :
282 : 0 : iir = serial_in(up, UART_IIR);
283 : :
284 : : /*
285 : : * This should be a safe test for anyone who doesn't trust the
286 : : * IIR bits on their UART, but it's specifically designed for
287 : : * the "Diva" UART used on the management processor on many HP
288 : : * ia64 and parisc boxes.
289 : : */
290 : 0 : lsr = serial_in(up, UART_LSR);
291 : 0 : up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
292 [ # # # # ]: 0 : if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) &&
293 [ # # # # ]: 0 : (!uart_circ_empty(&up->port.state->xmit) || up->port.x_char) &&
294 [ # # ]: 0 : (lsr & UART_LSR_THRE)) {
295 : 0 : iir &= ~(UART_IIR_ID | UART_IIR_NO_INT);
296 : 0 : iir |= UART_IIR_THRI;
297 : : }
298 : :
299 [ # # ]: 0 : if (!(iir & UART_IIR_NO_INT))
300 : 0 : serial8250_tx_chars(up);
301 : :
302 [ # # ]: 0 : if (up->port.irq)
303 : 0 : serial_out(up, UART_IER, ier);
304 : :
305 : 0 : spin_unlock_irqrestore(&up->port.lock, flags);
306 : :
307 : : /* Standard timer interval plus 0.2s to keep the port running */
308 : 0 : mod_timer(&up->timer,
309 [ # # ]: 0 : jiffies + uart_poll_timeout(&up->port) + HZ / 5);
310 : 0 : }
311 : :
312 : 3 : static int univ8250_setup_irq(struct uart_8250_port *up)
313 : : {
314 : 3 : struct uart_port *port = &up->port;
315 : 3 : int retval = 0;
316 : :
317 : : /*
318 : : * The above check will only give an accurate result the first time
319 : : * the port is opened so this value needs to be preserved.
320 : : */
321 [ - + ]: 3 : if (up->bugs & UART_BUG_THRE) {
322 : 0 : pr_debug("%s - using backup timer\n", port->name);
323 : :
324 : 0 : up->timer.function = serial8250_backup_timeout;
325 : 0 : mod_timer(&up->timer, jiffies +
326 [ # # ]: 0 : uart_poll_timeout(port) + HZ / 5);
327 : : }
328 : :
329 : : /*
330 : : * If the "interrupt" for this port doesn't correspond with any
331 : : * hardware interrupt, we use a timer-based system. The original
332 : : * driver used to do this with IRQ0.
333 : : */
334 [ - + ]: 3 : if (!port->irq) {
335 [ # # ]: 0 : mod_timer(&up->timer, jiffies + uart_poll_timeout(port));
336 : : } else
337 : 3 : retval = serial_link_irq_chain(up);
338 : :
339 : 3 : return retval;
340 : : }
341 : :
342 : 0 : static void univ8250_release_irq(struct uart_8250_port *up)
343 : : {
344 : 0 : struct uart_port *port = &up->port;
345 : :
346 : 0 : del_timer_sync(&up->timer);
347 : 0 : up->timer.function = serial8250_timeout;
348 [ # # ]: 0 : if (port->irq)
349 : 0 : serial_unlink_irq_chain(up);
350 : 0 : }
351 : :
352 : : #ifdef CONFIG_SERIAL_8250_RSA
353 : 0 : static int serial8250_request_rsa_resource(struct uart_8250_port *up)
354 : : {
355 : 0 : unsigned long start = UART_RSA_BASE << up->port.regshift;
356 : 0 : unsigned int size = 8 << up->port.regshift;
357 : 0 : struct uart_port *port = &up->port;
358 : 0 : int ret = -EINVAL;
359 : :
360 [ # # ]: 0 : switch (port->iotype) {
361 : 0 : case UPIO_HUB6:
362 : : case UPIO_PORT:
363 : 0 : start += port->iobase;
364 [ # # ]: 0 : if (request_region(start, size, "serial-rsa"))
365 : : ret = 0;
366 : : else
367 : 0 : ret = -EBUSY;
368 : : break;
369 : : }
370 : :
371 : 0 : return ret;
372 : : }
373 : :
374 : 0 : static void serial8250_release_rsa_resource(struct uart_8250_port *up)
375 : : {
376 : 0 : unsigned long offset = UART_RSA_BASE << up->port.regshift;
377 : 0 : unsigned int size = 8 << up->port.regshift;
378 : 0 : struct uart_port *port = &up->port;
379 : :
380 [ # # ]: 0 : switch (port->iotype) {
381 : 0 : case UPIO_HUB6:
382 : : case UPIO_PORT:
383 : 0 : release_region(port->iobase + offset, size);
384 : 0 : break;
385 : : }
386 : 0 : }
387 : : #endif
388 : :
389 : : static const struct uart_ops *base_ops;
390 : : static struct uart_ops univ8250_port_ops;
391 : :
392 : : static const struct uart_8250_ops univ8250_driver_ops = {
393 : : .setup_irq = univ8250_setup_irq,
394 : : .release_irq = univ8250_release_irq,
395 : : };
396 : :
397 : : static struct uart_8250_port serial8250_ports[UART_NR];
398 : :
399 : : /**
400 : : * serial8250_get_port - retrieve struct uart_8250_port
401 : : * @line: serial line number
402 : : *
403 : : * This function retrieves struct uart_8250_port for the specific line.
404 : : * This struct *must* *not* be used to perform a 8250 or serial core operation
405 : : * which is not accessible otherwise. Its only purpose is to make the struct
406 : : * accessible to the runtime-pm callbacks for context suspend/restore.
407 : : * The lock assumption made here is none because runtime-pm suspend/resume
408 : : * callbacks should not be invoked if there is any operation performed on the
409 : : * port.
410 : : */
411 : 3 : struct uart_8250_port *serial8250_get_port(int line)
412 : : {
413 : 3 : return &serial8250_ports[line];
414 : : }
415 : : EXPORT_SYMBOL_GPL(serial8250_get_port);
416 : :
417 : : static void (*serial8250_isa_config)(int port, struct uart_port *up,
418 : : u32 *capabilities);
419 : :
420 : 0 : void serial8250_set_isa_configurator(
421 : : void (*v)(int port, struct uart_port *up, u32 *capabilities))
422 : : {
423 : 0 : serial8250_isa_config = v;
424 : 0 : }
425 : : EXPORT_SYMBOL(serial8250_set_isa_configurator);
426 : :
427 : : #ifdef CONFIG_SERIAL_8250_RSA
428 : :
429 : 12 : static void univ8250_config_port(struct uart_port *port, int flags)
430 : : {
431 [ - + ]: 12 : struct uart_8250_port *up = up_to_u8250p(port);
432 : :
433 : 12 : up->probe &= ~UART_PROBE_RSA;
434 [ - + ]: 12 : if (port->type == PORT_RSA) {
435 [ # # ]: 0 : if (serial8250_request_rsa_resource(up) == 0)
436 : 0 : up->probe |= UART_PROBE_RSA;
437 [ + - ]: 12 : } else if (flags & UART_CONFIG_TYPE) {
438 : : int i;
439 : :
440 [ - + ]: 12 : for (i = 0; i < probe_rsa_count; i++) {
441 [ # # ]: 0 : if (probe_rsa[i] == up->port.iobase) {
442 [ # # ]: 0 : if (serial8250_request_rsa_resource(up) == 0)
443 : 0 : up->probe |= UART_PROBE_RSA;
444 : : break;
445 : : }
446 : : }
447 : : }
448 : :
449 : 12 : base_ops->config_port(port, flags);
450 : :
451 [ + - - + ]: 12 : if (port->type != PORT_RSA && up->probe & UART_PROBE_RSA)
452 : 0 : serial8250_release_rsa_resource(up);
453 : 12 : }
454 : :
455 : 0 : static int univ8250_request_port(struct uart_port *port)
456 : : {
457 : 0 : struct uart_8250_port *up = up_to_u8250p(port);
458 : 0 : int ret;
459 : :
460 : 0 : ret = base_ops->request_port(port);
461 [ # # # # ]: 0 : if (ret == 0 && port->type == PORT_RSA) {
462 : 0 : ret = serial8250_request_rsa_resource(up);
463 [ # # ]: 0 : if (ret < 0)
464 : 0 : base_ops->release_port(port);
465 : : }
466 : :
467 : 0 : return ret;
468 : : }
469 : :
470 : 0 : static void univ8250_release_port(struct uart_port *port)
471 : : {
472 [ # # ]: 0 : struct uart_8250_port *up = up_to_u8250p(port);
473 : :
474 [ # # ]: 0 : if (port->type == PORT_RSA)
475 : 0 : serial8250_release_rsa_resource(up);
476 : 0 : base_ops->release_port(port);
477 : 0 : }
478 : :
479 : 3 : static void univ8250_rsa_support(struct uart_ops *ops)
480 : : {
481 : 3 : ops->config_port = univ8250_config_port;
482 : 3 : ops->request_port = univ8250_request_port;
483 : 3 : ops->release_port = univ8250_release_port;
484 : : }
485 : :
486 : : #else
487 : : #define univ8250_rsa_support(x) do { } while (0)
488 : : #endif /* CONFIG_SERIAL_8250_RSA */
489 : :
490 : 12 : static inline void serial8250_apply_quirks(struct uart_8250_port *up)
491 : : {
492 : 24 : up->port.quirks |= skip_txen_test ? UPQ_NO_TXEN_TEST : 0;
493 : : }
494 : :
495 : 6 : static void __init serial8250_isa_init_ports(void)
496 : : {
497 : 6 : struct uart_8250_port *up;
498 : 6 : static int first = 1;
499 : 6 : int i, irqflag = 0;
500 : :
501 [ + + ]: 6 : if (!first)
502 : : return;
503 : 3 : first = 0;
504 : :
505 [ - + ]: 3 : if (nr_uarts > UART_NR)
506 : 0 : nr_uarts = UART_NR;
507 : :
508 [ + + ]: 15 : for (i = 0; i < nr_uarts; i++) {
509 : 12 : struct uart_8250_port *up = &serial8250_ports[i];
510 : 12 : struct uart_port *port = &up->port;
511 : :
512 : 12 : port->line = i;
513 : 12 : serial8250_init_port(up);
514 [ + + ]: 12 : if (!base_ops)
515 : 3 : base_ops = port->ops;
516 : 12 : port->ops = &univ8250_port_ops;
517 : :
518 : 12 : timer_setup(&up->timer, serial8250_timeout, 0);
519 : :
520 : 12 : up->ops = &univ8250_driver_ops;
521 : :
522 : : /*
523 : : * ALPHA_KLUDGE_MCR needs to be killed.
524 : : */
525 : 12 : up->mcr_mask = ~ALPHA_KLUDGE_MCR;
526 : 12 : up->mcr_force = ALPHA_KLUDGE_MCR;
527 : : }
528 : :
529 : : /* chain base port ops to support Remote Supervisor Adapter */
530 : 3 : univ8250_port_ops = *base_ops;
531 : 3 : univ8250_rsa_support(&univ8250_port_ops);
532 : :
533 [ + - ]: 3 : if (share_irqs)
534 : 3 : irqflag = IRQF_SHARED;
535 : :
536 : 3 : for (i = 0, up = serial8250_ports;
537 [ + + + - ]: 15 : i < ARRAY_SIZE(old_serial_port) && i < nr_uarts;
538 : 12 : i++, up++) {
539 : 12 : struct uart_port *port = &up->port;
540 : :
541 : 12 : port->iobase = old_serial_port[i].port;
542 [ - + ]: 12 : port->irq = irq_canonicalize(old_serial_port[i].irq);
543 : 12 : port->irqflags = 0;
544 : 12 : port->uartclk = old_serial_port[i].baud_base * 16;
545 : 12 : port->flags = old_serial_port[i].flags;
546 : 12 : port->hub6 = 0;
547 : 12 : port->membase = old_serial_port[i].iomem_base;
548 : 12 : port->iotype = old_serial_port[i].io_type;
549 : 12 : port->regshift = old_serial_port[i].iomem_reg_shift;
550 : 12 : serial8250_set_defaults(up);
551 : :
552 : 12 : port->irqflags |= irqflag;
553 [ - + ]: 12 : if (serial8250_isa_config != NULL)
554 : 0 : serial8250_isa_config(i, &up->port, &up->capabilities);
555 : : }
556 : : }
557 : :
558 : : static void __init
559 : 3 : serial8250_register_ports(struct uart_driver *drv, struct device *dev)
560 : : {
561 : 3 : int i;
562 : :
563 [ + + ]: 15 : for (i = 0; i < nr_uarts; i++) {
564 : 12 : struct uart_8250_port *up = &serial8250_ports[i];
565 : :
566 [ - + ]: 12 : if (up->port.type == PORT_8250_CIR)
567 : 0 : continue;
568 : :
569 [ + + ]: 12 : if (up->port.dev)
570 : 3 : continue;
571 : :
572 : 9 : up->port.dev = dev;
573 : :
574 [ + - ]: 9 : serial8250_apply_quirks(up);
575 : 9 : uart_add_one_port(drv, &up->port);
576 : : }
577 : 3 : }
578 : :
579 : : #ifdef CONFIG_SERIAL_8250_CONSOLE
580 : :
581 : 977 : static void univ8250_console_write(struct console *co, const char *s,
582 : : unsigned int count)
583 : : {
584 : 977 : struct uart_8250_port *up = &serial8250_ports[co->index];
585 : :
586 : 977 : serial8250_console_write(up, s, count);
587 : 977 : }
588 : :
589 : 3 : static int univ8250_console_setup(struct console *co, char *options)
590 : : {
591 : 3 : struct uart_port *port;
592 : 3 : int retval;
593 : :
594 : : /*
595 : : * Check whether an invalid uart number has been specified, and
596 : : * if so, search for the first available port that does have
597 : : * console support.
598 : : */
599 [ - + ]: 3 : if (co->index >= nr_uarts)
600 : 0 : co->index = 0;
601 : 3 : port = &serial8250_ports[co->index].port;
602 : : /* link port to console */
603 : 3 : port->cons = co;
604 : :
605 : 3 : retval = serial8250_console_setup(port, options, false);
606 [ - + ]: 3 : if (retval != 0)
607 : 0 : port->cons = NULL;
608 : 3 : return retval;
609 : : }
610 : :
611 : : /**
612 : : * univ8250_console_match - non-standard console matching
613 : : * @co: registering console
614 : : * @name: name from console command line
615 : : * @idx: index from console command line
616 : : * @options: ptr to option string from console command line
617 : : *
618 : : * Only attempts to match console command lines of the form:
619 : : * console=uart[8250],io|mmio|mmio16|mmio32,<addr>[,<options>]
620 : : * console=uart[8250],0x<addr>[,<options>]
621 : : * This form is used to register an initial earlycon boot console and
622 : : * replace it with the serial8250_console at 8250 driver init.
623 : : *
624 : : * Performs console setup for a match (as required by interface)
625 : : * If no <options> are specified, then assume the h/w is already setup.
626 : : *
627 : : * Returns 0 if console matches; otherwise non-zero to use default matching
628 : : */
629 : 3 : static int univ8250_console_match(struct console *co, char *name, int idx,
630 : : char *options)
631 : : {
632 : 3 : char match[] = "uart"; /* 8250-specific earlycon name */
633 : 3 : unsigned char iotype;
634 : 3 : resource_size_t addr;
635 : 3 : int i;
636 : :
637 [ - + ]: 3 : if (strncmp(name, match, 4) != 0)
638 : : return -ENODEV;
639 : :
640 [ # # ]: 0 : if (uart_parse_earlycon(options, &iotype, &addr, &options))
641 : : return -ENODEV;
642 : :
643 : : /* try to match the port specified on the command line */
644 [ # # ]: 0 : for (i = 0; i < nr_uarts; i++) {
645 : 0 : struct uart_port *port = &serial8250_ports[i].port;
646 : :
647 [ # # ]: 0 : if (port->iotype != iotype)
648 : 0 : continue;
649 [ # # # # ]: 0 : if ((iotype == UPIO_MEM || iotype == UPIO_MEM16 ||
650 [ # # ]: 0 : iotype == UPIO_MEM32 || iotype == UPIO_MEM32BE)
651 [ # # ]: 0 : && (port->mapbase != addr))
652 : 0 : continue;
653 [ # # # # ]: 0 : if (iotype == UPIO_PORT && port->iobase != addr)
654 : 0 : continue;
655 : :
656 : 0 : co->index = i;
657 : 0 : port->cons = co;
658 : 0 : return serial8250_console_setup(port, options, true);
659 : : }
660 : :
661 : : return -ENODEV;
662 : : }
663 : :
664 : : static struct console univ8250_console = {
665 : : .name = "ttyS",
666 : : .write = univ8250_console_write,
667 : : .device = uart_console_device,
668 : : .setup = univ8250_console_setup,
669 : : .match = univ8250_console_match,
670 : : .flags = CON_PRINTBUFFER | CON_ANYTIME,
671 : : .index = -1,
672 : : .data = &serial8250_reg,
673 : : };
674 : :
675 : 3 : static int __init univ8250_console_init(void)
676 : : {
677 [ + - ]: 3 : if (nr_uarts == 0)
678 : : return -ENODEV;
679 : :
680 : 3 : serial8250_isa_init_ports();
681 : 3 : register_console(&univ8250_console);
682 : 3 : return 0;
683 : : }
684 : : console_initcall(univ8250_console_init);
685 : :
686 : : #define SERIAL8250_CONSOLE (&univ8250_console)
687 : : #else
688 : : #define SERIAL8250_CONSOLE NULL
689 : : #endif
690 : :
691 : : static struct uart_driver serial8250_reg = {
692 : : .owner = THIS_MODULE,
693 : : .driver_name = "serial",
694 : : .dev_name = "ttyS",
695 : : .major = TTY_MAJOR,
696 : : .minor = 64,
697 : : .cons = SERIAL8250_CONSOLE,
698 : : };
699 : :
700 : : /*
701 : : * early_serial_setup - early registration for 8250 ports
702 : : *
703 : : * Setup an 8250 port structure prior to console initialisation. Use
704 : : * after console initialisation will cause undefined behaviour.
705 : : */
706 : 0 : int __init early_serial_setup(struct uart_port *port)
707 : : {
708 : 0 : struct uart_port *p;
709 : :
710 [ # # # # ]: 0 : if (port->line >= ARRAY_SIZE(serial8250_ports) || nr_uarts == 0)
711 : : return -ENODEV;
712 : :
713 : 0 : serial8250_isa_init_ports();
714 : 0 : p = &serial8250_ports[port->line].port;
715 : 0 : p->iobase = port->iobase;
716 : 0 : p->membase = port->membase;
717 : 0 : p->irq = port->irq;
718 : 0 : p->irqflags = port->irqflags;
719 : 0 : p->uartclk = port->uartclk;
720 : 0 : p->fifosize = port->fifosize;
721 : 0 : p->regshift = port->regshift;
722 : 0 : p->iotype = port->iotype;
723 : 0 : p->flags = port->flags;
724 : 0 : p->mapbase = port->mapbase;
725 : 0 : p->mapsize = port->mapsize;
726 : 0 : p->private_data = port->private_data;
727 : 0 : p->type = port->type;
728 : 0 : p->line = port->line;
729 : :
730 : 0 : serial8250_set_defaults(up_to_u8250p(p));
731 : :
732 [ # # ]: 0 : if (port->serial_in)
733 : 0 : p->serial_in = port->serial_in;
734 [ # # ]: 0 : if (port->serial_out)
735 : 0 : p->serial_out = port->serial_out;
736 [ # # ]: 0 : if (port->handle_irq)
737 : 0 : p->handle_irq = port->handle_irq;
738 : :
739 : : return 0;
740 : : }
741 : :
742 : : /**
743 : : * serial8250_suspend_port - suspend one serial port
744 : : * @line: serial line number
745 : : *
746 : : * Suspend one serial port.
747 : : */
748 : 0 : void serial8250_suspend_port(int line)
749 : : {
750 : 0 : struct uart_8250_port *up = &serial8250_ports[line];
751 : 0 : struct uart_port *port = &up->port;
752 : :
753 [ # # # # : 0 : if (!console_suspend_enabled && uart_console(port) &&
# # ]
754 [ # # ]: 0 : port->type != PORT_8250) {
755 : 0 : unsigned char canary = 0xa5;
756 : 0 : serial_out(up, UART_SCR, canary);
757 [ # # ]: 0 : if (serial_in(up, UART_SCR) == canary)
758 : 0 : up->canary = canary;
759 : : }
760 : :
761 : 0 : uart_suspend_port(&serial8250_reg, port);
762 : 0 : }
763 : : EXPORT_SYMBOL(serial8250_suspend_port);
764 : :
765 : : /**
766 : : * serial8250_resume_port - resume one serial port
767 : : * @line: serial line number
768 : : *
769 : : * Resume one serial port.
770 : : */
771 : 0 : void serial8250_resume_port(int line)
772 : : {
773 : 0 : struct uart_8250_port *up = &serial8250_ports[line];
774 : 0 : struct uart_port *port = &up->port;
775 : :
776 : 0 : up->canary = 0;
777 : :
778 [ # # ]: 0 : if (up->capabilities & UART_NATSEMI) {
779 : : /* Ensure it's still in high speed mode */
780 : 0 : serial_port_out(port, UART_LCR, 0xE0);
781 : :
782 : 0 : ns16550a_goto_highspeed(up);
783 : :
784 : 0 : serial_port_out(port, UART_LCR, 0);
785 : 0 : port->uartclk = 921600*16;
786 : : }
787 : 0 : uart_resume_port(&serial8250_reg, port);
788 : 0 : }
789 : : EXPORT_SYMBOL(serial8250_resume_port);
790 : :
791 : : /*
792 : : * Register a set of serial devices attached to a platform device. The
793 : : * list is terminated with a zero flags entry, which means we expect
794 : : * all entries to have at least UPF_BOOT_AUTOCONF set.
795 : : */
796 : 3 : static int serial8250_probe(struct platform_device *dev)
797 : : {
798 [ + - ]: 3 : struct plat_serial8250_port *p = dev_get_platdata(&dev->dev);
799 : 3 : struct uart_8250_port uart;
800 : 3 : int ret, i, irqflag = 0;
801 : :
802 : 3 : memset(&uart, 0, sizeof(uart));
803 : :
804 [ + - ]: 3 : if (share_irqs)
805 : 3 : irqflag = IRQF_SHARED;
806 : :
807 [ - + - - ]: 3 : for (i = 0; p && p->flags != 0; p++, i++) {
808 : 0 : uart.port.iobase = p->iobase;
809 : 0 : uart.port.membase = p->membase;
810 : 0 : uart.port.irq = p->irq;
811 : 0 : uart.port.irqflags = p->irqflags;
812 : 0 : uart.port.uartclk = p->uartclk;
813 : 0 : uart.port.regshift = p->regshift;
814 : 0 : uart.port.iotype = p->iotype;
815 : 0 : uart.port.flags = p->flags;
816 : 0 : uart.port.mapbase = p->mapbase;
817 : 0 : uart.port.hub6 = p->hub6;
818 : 0 : uart.port.has_sysrq = p->has_sysrq;
819 : 0 : uart.port.private_data = p->private_data;
820 : 0 : uart.port.type = p->type;
821 : 0 : uart.port.serial_in = p->serial_in;
822 : 0 : uart.port.serial_out = p->serial_out;
823 : 0 : uart.port.handle_irq = p->handle_irq;
824 : 0 : uart.port.handle_break = p->handle_break;
825 : 0 : uart.port.set_termios = p->set_termios;
826 : 0 : uart.port.set_ldisc = p->set_ldisc;
827 : 0 : uart.port.get_mctrl = p->get_mctrl;
828 : 0 : uart.port.pm = p->pm;
829 : 0 : uart.port.dev = &dev->dev;
830 : 0 : uart.port.irqflags |= irqflag;
831 : 0 : ret = serial8250_register_8250_port(&uart);
832 [ # # ]: 0 : if (ret < 0) {
833 : 0 : dev_err(&dev->dev, "unable to register port at index %d "
834 : : "(IO%lx MEM%llx IRQ%d): %d\n", i,
835 : : p->iobase, (unsigned long long)p->mapbase,
836 : : p->irq, ret);
837 : : }
838 : : }
839 : 3 : return 0;
840 : : }
841 : :
842 : : /*
843 : : * Remove serial ports registered against a platform device.
844 : : */
845 : 0 : static int serial8250_remove(struct platform_device *dev)
846 : : {
847 : 0 : int i;
848 : :
849 [ # # ]: 0 : for (i = 0; i < nr_uarts; i++) {
850 : 0 : struct uart_8250_port *up = &serial8250_ports[i];
851 : :
852 [ # # ]: 0 : if (up->port.dev == &dev->dev)
853 : 0 : serial8250_unregister_port(i);
854 : : }
855 : 0 : return 0;
856 : : }
857 : :
858 : 0 : static int serial8250_suspend(struct platform_device *dev, pm_message_t state)
859 : : {
860 : 0 : int i;
861 : :
862 [ # # ]: 0 : for (i = 0; i < UART_NR; i++) {
863 : 0 : struct uart_8250_port *up = &serial8250_ports[i];
864 : :
865 [ # # # # ]: 0 : if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
866 : 0 : uart_suspend_port(&serial8250_reg, &up->port);
867 : : }
868 : :
869 : 0 : return 0;
870 : : }
871 : :
872 : 0 : static int serial8250_resume(struct platform_device *dev)
873 : : {
874 : 0 : int i;
875 : :
876 [ # # ]: 0 : for (i = 0; i < UART_NR; i++) {
877 : 0 : struct uart_8250_port *up = &serial8250_ports[i];
878 : :
879 [ # # # # ]: 0 : if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
880 : 0 : serial8250_resume_port(i);
881 : : }
882 : :
883 : 0 : return 0;
884 : : }
885 : :
886 : : static struct platform_driver serial8250_isa_driver = {
887 : : .probe = serial8250_probe,
888 : : .remove = serial8250_remove,
889 : : .suspend = serial8250_suspend,
890 : : .resume = serial8250_resume,
891 : : .driver = {
892 : : .name = "serial8250",
893 : : },
894 : : };
895 : :
896 : : /*
897 : : * This "device" covers _all_ ISA 8250-compatible serial devices listed
898 : : * in the table in include/asm/serial.h
899 : : */
900 : : static struct platform_device *serial8250_isa_devs;
901 : :
902 : : /*
903 : : * serial8250_register_8250_port and serial8250_unregister_port allows for
904 : : * 16x50 serial ports to be configured at run-time, to support PCMCIA
905 : : * modems and PCI multiport cards.
906 : : */
907 : : static DEFINE_MUTEX(serial_mutex);
908 : :
909 : 3 : static struct uart_8250_port *serial8250_find_match_or_unused(struct uart_port *port)
910 : : {
911 : 3 : int i;
912 : :
913 : : /*
914 : : * First, find a port entry which matches.
915 : : */
916 [ + - ]: 3 : for (i = 0; i < nr_uarts; i++)
917 [ + - ]: 3 : if (uart_match_port(&serial8250_ports[i].port, port))
918 : 3 : return &serial8250_ports[i];
919 : :
920 : : /* try line number first if still available */
921 : 0 : i = port->line;
922 [ # # # # ]: 0 : if (i < nr_uarts && serial8250_ports[i].port.type == PORT_UNKNOWN &&
923 [ # # ]: 0 : serial8250_ports[i].port.iobase == 0)
924 : 0 : return &serial8250_ports[i];
925 : : /*
926 : : * We didn't find a matching entry, so look for the first
927 : : * free entry. We look for one which hasn't been previously
928 : : * used (indicated by zero iobase).
929 : : */
930 [ # # ]: 0 : for (i = 0; i < nr_uarts; i++)
931 [ # # ]: 0 : if (serial8250_ports[i].port.type == PORT_UNKNOWN &&
932 [ # # ]: 0 : serial8250_ports[i].port.iobase == 0)
933 : 0 : return &serial8250_ports[i];
934 : :
935 : : /*
936 : : * That also failed. Last resort is to find any entry which
937 : : * doesn't have a real port associated with it.
938 : : */
939 [ # # ]: 0 : for (i = 0; i < nr_uarts; i++)
940 [ # # ]: 0 : if (serial8250_ports[i].port.type == PORT_UNKNOWN)
941 : 0 : return &serial8250_ports[i];
942 : :
943 : : return NULL;
944 : : }
945 : :
946 : 0 : static void serial_8250_overrun_backoff_work(struct work_struct *work)
947 : : {
948 : 0 : struct uart_8250_port *up =
949 : 0 : container_of(to_delayed_work(work), struct uart_8250_port,
950 : : overrun_backoff);
951 : 0 : struct uart_port *port = &up->port;
952 : 0 : unsigned long flags;
953 : :
954 : 0 : spin_lock_irqsave(&port->lock, flags);
955 : 0 : up->ier |= UART_IER_RLSI | UART_IER_RDI;
956 : 0 : up->port.read_status_mask |= UART_LSR_DR;
957 : 0 : serial_out(up, UART_IER, up->ier);
958 : 0 : spin_unlock_irqrestore(&port->lock, flags);
959 : 0 : }
960 : :
961 : : /**
962 : : * serial8250_register_8250_port - register a serial port
963 : : * @up: serial port template
964 : : *
965 : : * Configure the serial port specified by the request. If the
966 : : * port exists and is in use, it is hung up and unregistered
967 : : * first.
968 : : *
969 : : * The port is then probed and if necessary the IRQ is autodetected
970 : : * If this fails an error is returned.
971 : : *
972 : : * On success the port is ready to use and the line number is returned.
973 : : */
974 : 3 : int serial8250_register_8250_port(struct uart_8250_port *up)
975 : : {
976 : 3 : struct uart_8250_port *uart;
977 : 3 : int ret = -ENOSPC;
978 : :
979 [ + - ]: 3 : if (up->port.uartclk == 0)
980 : : return -EINVAL;
981 : :
982 : 3 : mutex_lock(&serial_mutex);
983 : :
984 : 3 : uart = serial8250_find_match_or_unused(&up->port);
985 [ - + - + ]: 3 : if (uart && uart->port.type != PORT_8250_CIR) {
986 : 3 : struct mctrl_gpios *gpios;
987 : :
988 [ - + ]: 3 : if (uart->port.dev)
989 : 0 : uart_remove_one_port(&serial8250_reg, &uart->port);
990 : :
991 : 3 : uart->port.iobase = up->port.iobase;
992 : 3 : uart->port.membase = up->port.membase;
993 : 3 : uart->port.irq = up->port.irq;
994 : 3 : uart->port.irqflags = up->port.irqflags;
995 : 3 : uart->port.uartclk = up->port.uartclk;
996 : 3 : uart->port.fifosize = up->port.fifosize;
997 : 3 : uart->port.regshift = up->port.regshift;
998 : 3 : uart->port.iotype = up->port.iotype;
999 : 3 : uart->port.flags = up->port.flags | UPF_BOOT_AUTOCONF;
1000 : 3 : uart->bugs = up->bugs;
1001 : 3 : uart->port.mapbase = up->port.mapbase;
1002 : 3 : uart->port.mapsize = up->port.mapsize;
1003 : 3 : uart->port.private_data = up->port.private_data;
1004 : 3 : uart->tx_loadsz = up->tx_loadsz;
1005 : 3 : uart->capabilities = up->capabilities;
1006 : 3 : uart->port.throttle = up->port.throttle;
1007 : 3 : uart->port.unthrottle = up->port.unthrottle;
1008 : 3 : uart->port.rs485_config = up->port.rs485_config;
1009 : 3 : uart->port.rs485 = up->port.rs485;
1010 : 3 : uart->dma = up->dma;
1011 : :
1012 : : /* Take tx_loadsz from fifosize if it wasn't set separately */
1013 [ - + - - ]: 3 : if (uart->port.fifosize && !uart->tx_loadsz)
1014 : 0 : uart->tx_loadsz = uart->port.fifosize;
1015 : :
1016 [ + - ]: 3 : if (up->port.dev)
1017 : 3 : uart->port.dev = up->port.dev;
1018 : :
1019 [ - + ]: 3 : if (up->port.flags & UPF_FIXED_TYPE)
1020 : 0 : uart->port.type = up->port.type;
1021 : :
1022 : : /*
1023 : : * Only call mctrl_gpio_init(), if the device has no ACPI
1024 : : * companion device
1025 : : */
1026 [ - + ]: 3 : if (!has_acpi_companion(uart->port.dev)) {
1027 : 0 : gpios = mctrl_gpio_init(&uart->port, 0);
1028 : 0 : if (IS_ERR(gpios)) {
1029 : : ret = PTR_ERR(gpios);
1030 : : goto out_unlock;
1031 : : } else {
1032 : 0 : uart->gpios = gpios;
1033 : : }
1034 : : }
1035 : :
1036 : 3 : serial8250_set_defaults(uart);
1037 : :
1038 : : /* Possibly override default I/O functions. */
1039 [ - + ]: 3 : if (up->port.serial_in)
1040 : 0 : uart->port.serial_in = up->port.serial_in;
1041 [ - + ]: 3 : if (up->port.serial_out)
1042 : 0 : uart->port.serial_out = up->port.serial_out;
1043 [ - + ]: 3 : if (up->port.handle_irq)
1044 : 0 : uart->port.handle_irq = up->port.handle_irq;
1045 : : /* Possibly override set_termios call */
1046 [ - + ]: 3 : if (up->port.set_termios)
1047 : 0 : uart->port.set_termios = up->port.set_termios;
1048 [ - + ]: 3 : if (up->port.set_ldisc)
1049 : 0 : uart->port.set_ldisc = up->port.set_ldisc;
1050 [ - + ]: 3 : if (up->port.get_mctrl)
1051 : 0 : uart->port.get_mctrl = up->port.get_mctrl;
1052 [ - + ]: 3 : if (up->port.set_mctrl)
1053 : 0 : uart->port.set_mctrl = up->port.set_mctrl;
1054 [ - + ]: 3 : if (up->port.get_divisor)
1055 : 0 : uart->port.get_divisor = up->port.get_divisor;
1056 [ - + ]: 3 : if (up->port.set_divisor)
1057 : 0 : uart->port.set_divisor = up->port.set_divisor;
1058 [ - + ]: 3 : if (up->port.startup)
1059 : 0 : uart->port.startup = up->port.startup;
1060 [ - + ]: 3 : if (up->port.shutdown)
1061 : 0 : uart->port.shutdown = up->port.shutdown;
1062 [ - + ]: 3 : if (up->port.pm)
1063 : 0 : uart->port.pm = up->port.pm;
1064 [ - + ]: 3 : if (up->port.handle_break)
1065 : 0 : uart->port.handle_break = up->port.handle_break;
1066 [ - + ]: 3 : if (up->dl_read)
1067 : 0 : uart->dl_read = up->dl_read;
1068 [ - + ]: 3 : if (up->dl_write)
1069 : 0 : uart->dl_write = up->dl_write;
1070 : :
1071 [ + - ]: 3 : if (uart->port.type != PORT_8250_CIR) {
1072 [ - + ]: 3 : if (serial8250_isa_config != NULL)
1073 : 0 : serial8250_isa_config(0, &uart->port,
1074 : : &uart->capabilities);
1075 : :
1076 [ + - ]: 3 : serial8250_apply_quirks(uart);
1077 : 3 : ret = uart_add_one_port(&serial8250_reg,
1078 : : &uart->port);
1079 [ + - ]: 3 : if (ret == 0)
1080 : 3 : ret = uart->port.line;
1081 : : } else {
1082 : 0 : dev_info(uart->port.dev,
1083 : : "skipping CIR port at 0x%lx / 0x%llx, IRQ %d\n",
1084 : : uart->port.iobase,
1085 : : (unsigned long long)uart->port.mapbase,
1086 : : uart->port.irq);
1087 : :
1088 : 0 : ret = 0;
1089 : : }
1090 : :
1091 : : /* Initialise interrupt backoff work if required */
1092 [ - + ]: 3 : if (up->overrun_backoff_time_ms > 0) {
1093 : 0 : uart->overrun_backoff_time_ms =
1094 : : up->overrun_backoff_time_ms;
1095 : 0 : INIT_DELAYED_WORK(&uart->overrun_backoff,
1096 : : serial_8250_overrun_backoff_work);
1097 : : } else {
1098 : 3 : uart->overrun_backoff_time_ms = 0;
1099 : : }
1100 : : }
1101 : :
1102 : 0 : out_unlock:
1103 : 3 : mutex_unlock(&serial_mutex);
1104 : :
1105 : 3 : return ret;
1106 : : }
1107 : : EXPORT_SYMBOL(serial8250_register_8250_port);
1108 : :
1109 : : /**
1110 : : * serial8250_unregister_port - remove a 16x50 serial port at runtime
1111 : : * @line: serial line number
1112 : : *
1113 : : * Remove one serial port. This may not be called from interrupt
1114 : : * context. We hand the port back to the our control.
1115 : : */
1116 : 0 : void serial8250_unregister_port(int line)
1117 : : {
1118 : 0 : struct uart_8250_port *uart = &serial8250_ports[line];
1119 : :
1120 : 0 : mutex_lock(&serial_mutex);
1121 : :
1122 [ # # ]: 0 : if (uart->em485) {
1123 : 0 : unsigned long flags;
1124 : :
1125 : 0 : spin_lock_irqsave(&uart->port.lock, flags);
1126 : 0 : serial8250_em485_destroy(uart);
1127 : 0 : spin_unlock_irqrestore(&uart->port.lock, flags);
1128 : : }
1129 : :
1130 : 0 : uart_remove_one_port(&serial8250_reg, &uart->port);
1131 [ # # ]: 0 : if (serial8250_isa_devs) {
1132 : 0 : uart->port.flags &= ~UPF_BOOT_AUTOCONF;
1133 : 0 : uart->port.type = PORT_UNKNOWN;
1134 : 0 : uart->port.dev = &serial8250_isa_devs->dev;
1135 : 0 : uart->capabilities = 0;
1136 [ # # ]: 0 : serial8250_apply_quirks(uart);
1137 : 0 : uart_add_one_port(&serial8250_reg, &uart->port);
1138 : : } else {
1139 : 0 : uart->port.dev = NULL;
1140 : : }
1141 : 0 : mutex_unlock(&serial_mutex);
1142 : 0 : }
1143 : : EXPORT_SYMBOL(serial8250_unregister_port);
1144 : :
1145 : 3 : static int __init serial8250_init(void)
1146 : : {
1147 : 3 : int ret;
1148 : :
1149 [ + - ]: 3 : if (nr_uarts == 0)
1150 : : return -ENODEV;
1151 : :
1152 : 3 : serial8250_isa_init_ports();
1153 : :
1154 [ - + ]: 3 : pr_info("Serial: 8250/16550 driver, %d ports, IRQ sharing %sabled\n",
1155 : : nr_uarts, share_irqs ? "en" : "dis");
1156 : :
1157 : : #ifdef CONFIG_SPARC
1158 : : ret = sunserial_register_minors(&serial8250_reg, UART_NR);
1159 : : #else
1160 : 3 : serial8250_reg.nr = UART_NR;
1161 : 3 : ret = uart_register_driver(&serial8250_reg);
1162 : : #endif
1163 [ - + ]: 3 : if (ret)
1164 : 0 : goto out;
1165 : :
1166 : 3 : ret = serial8250_pnp_init();
1167 [ - + ]: 3 : if (ret)
1168 : 0 : goto unreg_uart_drv;
1169 : :
1170 : 3 : serial8250_isa_devs = platform_device_alloc("serial8250",
1171 : : PLAT8250_DEV_LEGACY);
1172 [ - + ]: 3 : if (!serial8250_isa_devs) {
1173 : 0 : ret = -ENOMEM;
1174 : 0 : goto unreg_pnp;
1175 : : }
1176 : :
1177 : 3 : ret = platform_device_add(serial8250_isa_devs);
1178 [ - + ]: 3 : if (ret)
1179 : 0 : goto put_dev;
1180 : :
1181 : 3 : serial8250_register_ports(&serial8250_reg, &serial8250_isa_devs->dev);
1182 : :
1183 : 3 : ret = platform_driver_register(&serial8250_isa_driver);
1184 [ + - ]: 3 : if (ret == 0)
1185 : 3 : goto out;
1186 : :
1187 : 0 : platform_device_del(serial8250_isa_devs);
1188 : 0 : put_dev:
1189 : 0 : platform_device_put(serial8250_isa_devs);
1190 : 0 : unreg_pnp:
1191 : 0 : serial8250_pnp_exit();
1192 : 0 : unreg_uart_drv:
1193 : : #ifdef CONFIG_SPARC
1194 : : sunserial_unregister_minors(&serial8250_reg, UART_NR);
1195 : : #else
1196 : 0 : uart_unregister_driver(&serial8250_reg);
1197 : : #endif
1198 : : out:
1199 : : return ret;
1200 : : }
1201 : :
1202 : 0 : static void __exit serial8250_exit(void)
1203 : : {
1204 : 0 : struct platform_device *isa_dev = serial8250_isa_devs;
1205 : :
1206 : : /*
1207 : : * This tells serial8250_unregister_port() not to re-register
1208 : : * the ports (thereby making serial8250_isa_driver permanently
1209 : : * in use.)
1210 : : */
1211 : 0 : serial8250_isa_devs = NULL;
1212 : :
1213 : 0 : platform_driver_unregister(&serial8250_isa_driver);
1214 : 0 : platform_device_unregister(isa_dev);
1215 : :
1216 : 0 : serial8250_pnp_exit();
1217 : :
1218 : : #ifdef CONFIG_SPARC
1219 : : sunserial_unregister_minors(&serial8250_reg, UART_NR);
1220 : : #else
1221 : 0 : uart_unregister_driver(&serial8250_reg);
1222 : : #endif
1223 : 0 : }
1224 : :
1225 : : module_init(serial8250_init);
1226 : : module_exit(serial8250_exit);
1227 : :
1228 : : MODULE_LICENSE("GPL");
1229 : : MODULE_DESCRIPTION("Generic 8250/16x50 serial driver");
1230 : :
1231 : : module_param_hw(share_irqs, uint, other, 0644);
1232 : : MODULE_PARM_DESC(share_irqs, "Share IRQs with other non-8250/16x50 devices (unsafe)");
1233 : :
1234 : : module_param(nr_uarts, uint, 0644);
1235 : : MODULE_PARM_DESC(nr_uarts, "Maximum number of UARTs supported. (1-" __MODULE_STRING(CONFIG_SERIAL_8250_NR_UARTS) ")");
1236 : :
1237 : : module_param(skip_txen_test, uint, 0644);
1238 : : MODULE_PARM_DESC(skip_txen_test, "Skip checking for the TXEN bug at init time");
1239 : :
1240 : : #ifdef CONFIG_SERIAL_8250_RSA
1241 : : module_param_hw_array(probe_rsa, ulong, ioport, &probe_rsa_count, 0444);
1242 : : MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA");
1243 : : #endif
1244 : : MODULE_ALIAS_CHARDEV_MAJOR(TTY_MAJOR);
1245 : :
1246 : : #ifdef CONFIG_SERIAL_8250_DEPRECATED_OPTIONS
1247 : : #ifndef MODULE
1248 : : /* This module was renamed to 8250_core in 3.7. Keep the old "8250" name
1249 : : * working as well for the module options so we don't break people. We
1250 : : * need to keep the names identical and the convenient macros will happily
1251 : : * refuse to let us do that by failing the build with redefinition errors
1252 : : * of global variables. So we stick them inside a dummy function to avoid
1253 : : * those conflicts. The options still get parsed, and the redefined
1254 : : * MODULE_PARAM_PREFIX lets us keep the "8250." syntax alive.
1255 : : *
1256 : : * This is hacky. I'm sorry.
1257 : : */
1258 : 0 : static void __used s8250_options(void)
1259 : : {
1260 : : #undef MODULE_PARAM_PREFIX
1261 : : #define MODULE_PARAM_PREFIX "8250_core."
1262 : :
1263 : 0 : module_param_cb(share_irqs, ¶m_ops_uint, &share_irqs, 0644);
1264 : 0 : module_param_cb(nr_uarts, ¶m_ops_uint, &nr_uarts, 0644);
1265 : 0 : module_param_cb(skip_txen_test, ¶m_ops_uint, &skip_txen_test, 0644);
1266 : : #ifdef CONFIG_SERIAL_8250_RSA
1267 : 0 : __module_param_call(MODULE_PARAM_PREFIX, probe_rsa,
1268 : : ¶m_array_ops, .arr = &__param_arr_probe_rsa,
1269 : : 0444, -1, 0);
1270 : : #endif
1271 : 0 : }
1272 : : #else
1273 : : MODULE_ALIAS("8250_core");
1274 : : #endif
1275 : : #endif
|
