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 : 0 : static irqreturn_t serial8250_interrupt(int irq, void *dev_id)
109 : : {
110 : : struct irq_info *i = dev_id;
111 : : struct list_head *l, *end = NULL;
112 : : int pass_counter = 0, handled = 0;
113 : :
114 : : pr_debug("%s(%d): start\n", __func__, irq);
115 : :
116 : : spin_lock(&i->lock);
117 : :
118 : 0 : l = i->head;
119 : : do {
120 : : struct uart_8250_port *up;
121 : : struct uart_port *port;
122 : :
123 : : up = list_entry(l, struct uart_8250_port, list);
124 : 0 : port = &up->port;
125 : :
126 : 0 : if (port->handle_irq(port)) {
127 : : handled = 1;
128 : : end = NULL;
129 : 0 : } else if (end == NULL)
130 : : end = l;
131 : :
132 : 0 : l = l->next;
133 : :
134 : 0 : if (l == i->head && pass_counter++ > PASS_LIMIT)
135 : : break;
136 : 0 : } while (l != end);
137 : :
138 : : spin_unlock(&i->lock);
139 : :
140 : : pr_debug("%s(%d): end\n", __func__, irq);
141 : :
142 : 0 : 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 : : 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 : : list_del(&up->list);
160 : : } else {
161 : 0 : BUG_ON(i->head != &up->list);
162 : 0 : i->head = NULL;
163 : : }
164 : : spin_unlock_irq(&i->lock);
165 : : /* List empty so throw away the hash node */
166 : 0 : if (i->head == NULL) {
167 : : hlist_del(&i->node);
168 : 0 : kfree(i);
169 : : }
170 : 0 : }
171 : :
172 : 0 : static int serial_link_irq_chain(struct uart_8250_port *up)
173 : : {
174 : : struct hlist_head *h;
175 : : struct hlist_node *n;
176 : : struct irq_info *i;
177 : : int ret;
178 : :
179 : 0 : mutex_lock(&hash_mutex);
180 : :
181 : 0 : h = &irq_lists[up->port.irq % NR_IRQ_HASH];
182 : :
183 : 0 : hlist_for_each(n, h) {
184 : : i = hlist_entry(n, struct irq_info, node);
185 : 0 : if (i->irq == up->port.irq)
186 : : break;
187 : : }
188 : :
189 : 0 : if (n == NULL) {
190 : 0 : i = kzalloc(sizeof(struct irq_info), GFP_KERNEL);
191 : 0 : if (i == NULL) {
192 : 0 : mutex_unlock(&hash_mutex);
193 : 0 : return -ENOMEM;
194 : : }
195 : 0 : spin_lock_init(&i->lock);
196 : 0 : i->irq = up->port.irq;
197 : 0 : hlist_add_head(&i->node, h);
198 : : }
199 : 0 : mutex_unlock(&hash_mutex);
200 : :
201 : : spin_lock_irq(&i->lock);
202 : :
203 : 0 : if (i->head) {
204 : 0 : list_add(&up->list, i->head);
205 : : spin_unlock_irq(&i->lock);
206 : :
207 : : ret = 0;
208 : : } else {
209 : 0 : INIT_LIST_HEAD(&up->list);
210 : 0 : i->head = &up->list;
211 : : spin_unlock_irq(&i->lock);
212 : 0 : ret = request_irq(up->port.irq, serial8250_interrupt,
213 : : up->port.irqflags, up->port.name, i);
214 : 0 : if (ret < 0)
215 : 0 : serial_do_unlink(i, up);
216 : : }
217 : :
218 : 0 : 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 : : struct irq_info *i;
228 : : struct hlist_node *n;
229 : : 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 : : 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 : : 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 : : unsigned int iir, ier = 0, lsr;
269 : : 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 : : ier = serial_in(up, UART_IER);
279 : : serial_out(up, UART_IER, 0);
280 : : }
281 : :
282 : : 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 : : 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 : : 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 : 0 : static int univ8250_setup_irq(struct uart_8250_port *up)
313 : : {
314 : : struct uart_port *port = &up->port;
315 : : 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 : 0 : if (up->bugs & UART_BUG_THRE) {
322 : : 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 : : 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 : 0 : if (!port->irq) {
335 : 0 : mod_timer(&up->timer, jiffies + uart_poll_timeout(port));
336 : : } else
337 : 0 : retval = serial_link_irq_chain(up);
338 : :
339 : 0 : return retval;
340 : : }
341 : :
342 : 0 : static void univ8250_release_irq(struct uart_8250_port *up)
343 : : {
344 : : 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 : : static int serial8250_request_rsa_resource(struct uart_8250_port *up)
354 : : {
355 : : unsigned long start = UART_RSA_BASE << up->port.regshift;
356 : : unsigned int size = 8 << up->port.regshift;
357 : : struct uart_port *port = &up->port;
358 : : int ret = -EINVAL;
359 : :
360 : : switch (port->iotype) {
361 : : case UPIO_HUB6:
362 : : case UPIO_PORT:
363 : : start += port->iobase;
364 : : if (request_region(start, size, "serial-rsa"))
365 : : ret = 0;
366 : : else
367 : : ret = -EBUSY;
368 : : break;
369 : : }
370 : :
371 : : return ret;
372 : : }
373 : :
374 : : static void serial8250_release_rsa_resource(struct uart_8250_port *up)
375 : : {
376 : : unsigned long offset = UART_RSA_BASE << up->port.regshift;
377 : : unsigned int size = 8 << up->port.regshift;
378 : : struct uart_port *port = &up->port;
379 : :
380 : : switch (port->iotype) {
381 : : case UPIO_HUB6:
382 : : case UPIO_PORT:
383 : : release_region(port->iobase + offset, size);
384 : : break;
385 : : }
386 : : }
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 : 0 : struct uart_8250_port *serial8250_get_port(int line)
412 : : {
413 : 0 : 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 : : static void univ8250_config_port(struct uart_port *port, int flags)
430 : : {
431 : : struct uart_8250_port *up = up_to_u8250p(port);
432 : :
433 : : up->probe &= ~UART_PROBE_RSA;
434 : : if (port->type == PORT_RSA) {
435 : : if (serial8250_request_rsa_resource(up) == 0)
436 : : up->probe |= UART_PROBE_RSA;
437 : : } else if (flags & UART_CONFIG_TYPE) {
438 : : int i;
439 : :
440 : : for (i = 0; i < probe_rsa_count; i++) {
441 : : if (probe_rsa[i] == up->port.iobase) {
442 : : if (serial8250_request_rsa_resource(up) == 0)
443 : : up->probe |= UART_PROBE_RSA;
444 : : break;
445 : : }
446 : : }
447 : : }
448 : :
449 : : base_ops->config_port(port, flags);
450 : :
451 : : if (port->type != PORT_RSA && up->probe & UART_PROBE_RSA)
452 : : serial8250_release_rsa_resource(up);
453 : : }
454 : :
455 : : static int univ8250_request_port(struct uart_port *port)
456 : : {
457 : : struct uart_8250_port *up = up_to_u8250p(port);
458 : : int ret;
459 : :
460 : : ret = base_ops->request_port(port);
461 : : if (ret == 0 && port->type == PORT_RSA) {
462 : : ret = serial8250_request_rsa_resource(up);
463 : : if (ret < 0)
464 : : base_ops->release_port(port);
465 : : }
466 : :
467 : : return ret;
468 : : }
469 : :
470 : : static void univ8250_release_port(struct uart_port *port)
471 : : {
472 : : struct uart_8250_port *up = up_to_u8250p(port);
473 : :
474 : : if (port->type == PORT_RSA)
475 : : serial8250_release_rsa_resource(up);
476 : : base_ops->release_port(port);
477 : : }
478 : :
479 : : static void univ8250_rsa_support(struct uart_ops *ops)
480 : : {
481 : : ops->config_port = univ8250_config_port;
482 : : ops->request_port = univ8250_request_port;
483 : : 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 : : static inline void serial8250_apply_quirks(struct uart_8250_port *up)
491 : : {
492 : 0 : up->port.quirks |= skip_txen_test ? UPQ_NO_TXEN_TEST : 0;
493 : : }
494 : :
495 : 0 : static void __init serial8250_isa_init_ports(void)
496 : : {
497 : : struct uart_8250_port *up;
498 : : static int first = 1;
499 : : int i, irqflag = 0;
500 : :
501 : 0 : if (!first)
502 : 0 : return;
503 : 0 : first = 0;
504 : :
505 : 0 : if (nr_uarts > UART_NR)
506 : 0 : nr_uarts = UART_NR;
507 : :
508 : 0 : for (i = 0; i < nr_uarts; i++) {
509 : 0 : struct uart_8250_port *up = &serial8250_ports[i];
510 : : struct uart_port *port = &up->port;
511 : :
512 : 0 : port->line = i;
513 : 0 : serial8250_init_port(up);
514 : 0 : if (!base_ops)
515 : 0 : base_ops = port->ops;
516 : 0 : port->ops = &univ8250_port_ops;
517 : :
518 : 0 : timer_setup(&up->timer, serial8250_timeout, 0);
519 : :
520 : 0 : up->ops = &univ8250_driver_ops;
521 : :
522 : : /*
523 : : * ALPHA_KLUDGE_MCR needs to be killed.
524 : : */
525 : 0 : up->mcr_mask = ~ALPHA_KLUDGE_MCR;
526 : 0 : up->mcr_force = ALPHA_KLUDGE_MCR;
527 : 0 : serial8250_set_defaults(up);
528 : : }
529 : :
530 : : /* chain base port ops to support Remote Supervisor Adapter */
531 : 0 : univ8250_port_ops = *base_ops;
532 : : univ8250_rsa_support(&univ8250_port_ops);
533 : :
534 : : if (share_irqs)
535 : : irqflag = IRQF_SHARED;
536 : :
537 : : for (i = 0, up = serial8250_ports;
538 : : i < ARRAY_SIZE(old_serial_port) && i < nr_uarts;
539 : : i++, up++) {
540 : : struct uart_port *port = &up->port;
541 : :
542 : : port->iobase = old_serial_port[i].port;
543 : : port->irq = irq_canonicalize(old_serial_port[i].irq);
544 : : port->irqflags = 0;
545 : : port->uartclk = old_serial_port[i].baud_base * 16;
546 : : port->flags = old_serial_port[i].flags;
547 : : port->hub6 = 0;
548 : : port->membase = old_serial_port[i].iomem_base;
549 : : port->iotype = old_serial_port[i].io_type;
550 : : port->regshift = old_serial_port[i].iomem_reg_shift;
551 : :
552 : : port->irqflags |= irqflag;
553 : : if (serial8250_isa_config != NULL)
554 : : serial8250_isa_config(i, &up->port, &up->capabilities);
555 : : }
556 : : }
557 : :
558 : : static void __init
559 : 0 : serial8250_register_ports(struct uart_driver *drv, struct device *dev)
560 : : {
561 : : int i;
562 : :
563 : 0 : for (i = 0; i < nr_uarts; i++) {
564 : : struct uart_8250_port *up = &serial8250_ports[i];
565 : :
566 : 0 : if (up->port.type == PORT_8250_CIR)
567 : 0 : continue;
568 : :
569 : 0 : if (up->port.dev)
570 : 0 : continue;
571 : :
572 : 0 : up->port.dev = dev;
573 : :
574 : : serial8250_apply_quirks(up);
575 : 0 : uart_add_one_port(drv, &up->port);
576 : : }
577 : 0 : }
578 : :
579 : : #ifdef CONFIG_SERIAL_8250_CONSOLE
580 : :
581 : 0 : static void univ8250_console_write(struct console *co, const char *s,
582 : : unsigned int count)
583 : : {
584 : 0 : struct uart_8250_port *up = &serial8250_ports[co->index];
585 : :
586 : 0 : serial8250_console_write(up, s, count);
587 : 0 : }
588 : :
589 : 0 : static int univ8250_console_setup(struct console *co, char *options)
590 : : {
591 : : struct uart_port *port;
592 : : 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 : 0 : if (co->index >= nr_uarts)
600 : 0 : co->index = 0;
601 : 0 : port = &serial8250_ports[co->index].port;
602 : : /* link port to console */
603 : 0 : port->cons = co;
604 : :
605 : 0 : retval = serial8250_console_setup(port, options, false);
606 : 0 : if (retval != 0)
607 : 0 : port->cons = NULL;
608 : 0 : 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 : 0 : static int univ8250_console_match(struct console *co, char *name, int idx,
630 : : char *options)
631 : : {
632 : 0 : char match[] = "uart"; /* 8250-specific earlycon name */
633 : : unsigned char iotype;
634 : : resource_size_t addr;
635 : : int i;
636 : :
637 : 0 : 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 : 0 : serial8250_isa_init_ports();
681 : 0 : register_console(&univ8250_console);
682 : 0 : 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 : : 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 : : 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 : : unsigned char canary = 0xa5;
756 : : 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 : : serial_port_out(port, UART_LCR, 0xE0);
781 : :
782 : 0 : ns16550a_goto_highspeed(up);
783 : :
784 : : 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 : 0 : static int serial8250_probe(struct platform_device *dev)
797 : : {
798 : : struct plat_serial8250_port *p = dev_get_platdata(&dev->dev);
799 : : struct uart_8250_port uart;
800 : : int ret, i, irqflag = 0;
801 : :
802 : 0 : memset(&uart, 0, sizeof(uart));
803 : :
804 : 0 : if (share_irqs)
805 : : irqflag = IRQF_SHARED;
806 : :
807 : 0 : 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.private_data = p->private_data;
819 : 0 : uart.port.type = p->type;
820 : 0 : uart.port.serial_in = p->serial_in;
821 : 0 : uart.port.serial_out = p->serial_out;
822 : 0 : uart.port.handle_irq = p->handle_irq;
823 : 0 : uart.port.handle_break = p->handle_break;
824 : 0 : uart.port.set_termios = p->set_termios;
825 : 0 : uart.port.set_ldisc = p->set_ldisc;
826 : 0 : uart.port.get_mctrl = p->get_mctrl;
827 : 0 : uart.port.pm = p->pm;
828 : 0 : uart.port.dev = &dev->dev;
829 : 0 : uart.port.irqflags |= irqflag;
830 : 0 : ret = serial8250_register_8250_port(&uart);
831 : 0 : if (ret < 0) {
832 : 0 : dev_err(&dev->dev, "unable to register port at index %d "
833 : : "(IO%lx MEM%llx IRQ%d): %d\n", i,
834 : : p->iobase, (unsigned long long)p->mapbase,
835 : : p->irq, ret);
836 : : }
837 : : }
838 : 0 : return 0;
839 : : }
840 : :
841 : : /*
842 : : * Remove serial ports registered against a platform device.
843 : : */
844 : 0 : static int serial8250_remove(struct platform_device *dev)
845 : : {
846 : : int i;
847 : :
848 : 0 : for (i = 0; i < nr_uarts; i++) {
849 : : struct uart_8250_port *up = &serial8250_ports[i];
850 : :
851 : 0 : if (up->port.dev == &dev->dev)
852 : 0 : serial8250_unregister_port(i);
853 : : }
854 : 0 : return 0;
855 : : }
856 : :
857 : 0 : static int serial8250_suspend(struct platform_device *dev, pm_message_t state)
858 : : {
859 : : int i;
860 : :
861 : 0 : for (i = 0; i < UART_NR; i++) {
862 : : struct uart_8250_port *up = &serial8250_ports[i];
863 : :
864 : 0 : if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
865 : 0 : uart_suspend_port(&serial8250_reg, &up->port);
866 : : }
867 : :
868 : 0 : return 0;
869 : : }
870 : :
871 : 0 : static int serial8250_resume(struct platform_device *dev)
872 : : {
873 : : int i;
874 : :
875 : 0 : for (i = 0; i < UART_NR; i++) {
876 : : struct uart_8250_port *up = &serial8250_ports[i];
877 : :
878 : 0 : if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
879 : 0 : serial8250_resume_port(i);
880 : : }
881 : :
882 : 0 : return 0;
883 : : }
884 : :
885 : : static struct platform_driver serial8250_isa_driver = {
886 : : .probe = serial8250_probe,
887 : : .remove = serial8250_remove,
888 : : .suspend = serial8250_suspend,
889 : : .resume = serial8250_resume,
890 : : .driver = {
891 : : .name = "serial8250",
892 : : },
893 : : };
894 : :
895 : : /*
896 : : * This "device" covers _all_ ISA 8250-compatible serial devices listed
897 : : * in the table in include/asm/serial.h
898 : : */
899 : : static struct platform_device *serial8250_isa_devs;
900 : :
901 : : /*
902 : : * serial8250_register_8250_port and serial8250_unregister_port allows for
903 : : * 16x50 serial ports to be configured at run-time, to support PCMCIA
904 : : * modems and PCI multiport cards.
905 : : */
906 : : static DEFINE_MUTEX(serial_mutex);
907 : :
908 : 0 : static struct uart_8250_port *serial8250_find_match_or_unused(struct uart_port *port)
909 : : {
910 : : int i;
911 : :
912 : : /*
913 : : * First, find a port entry which matches.
914 : : */
915 : 0 : for (i = 0; i < nr_uarts; i++)
916 : 0 : if (uart_match_port(&serial8250_ports[i].port, port))
917 : 0 : return &serial8250_ports[i];
918 : :
919 : : /* try line number first if still available */
920 : 0 : i = port->line;
921 : 0 : if (i < nr_uarts && serial8250_ports[i].port.type == PORT_UNKNOWN &&
922 : 0 : serial8250_ports[i].port.iobase == 0)
923 : 0 : return &serial8250_ports[i];
924 : : /*
925 : : * We didn't find a matching entry, so look for the first
926 : : * free entry. We look for one which hasn't been previously
927 : : * used (indicated by zero iobase).
928 : : */
929 : 0 : for (i = 0; i < nr_uarts; i++)
930 : 0 : if (serial8250_ports[i].port.type == PORT_UNKNOWN &&
931 : 0 : serial8250_ports[i].port.iobase == 0)
932 : 0 : return &serial8250_ports[i];
933 : :
934 : : /*
935 : : * That also failed. Last resort is to find any entry which
936 : : * doesn't have a real port associated with it.
937 : : */
938 : 0 : for (i = 0; i < nr_uarts; i++)
939 : 0 : if (serial8250_ports[i].port.type == PORT_UNKNOWN)
940 : 0 : return &serial8250_ports[i];
941 : :
942 : : return NULL;
943 : : }
944 : :
945 : 0 : static void serial_8250_overrun_backoff_work(struct work_struct *work)
946 : : {
947 : : struct uart_8250_port *up =
948 : : container_of(to_delayed_work(work), struct uart_8250_port,
949 : : overrun_backoff);
950 : : struct uart_port *port = &up->port;
951 : : unsigned long flags;
952 : :
953 : 0 : spin_lock_irqsave(&port->lock, flags);
954 : 0 : up->ier |= UART_IER_RLSI | UART_IER_RDI;
955 : 0 : up->port.read_status_mask |= UART_LSR_DR;
956 : 0 : serial_out(up, UART_IER, up->ier);
957 : : spin_unlock_irqrestore(&port->lock, flags);
958 : 0 : }
959 : :
960 : : /**
961 : : * serial8250_register_8250_port - register a serial port
962 : : * @up: serial port template
963 : : *
964 : : * Configure the serial port specified by the request. If the
965 : : * port exists and is in use, it is hung up and unregistered
966 : : * first.
967 : : *
968 : : * The port is then probed and if necessary the IRQ is autodetected
969 : : * If this fails an error is returned.
970 : : *
971 : : * On success the port is ready to use and the line number is returned.
972 : : */
973 : 0 : int serial8250_register_8250_port(struct uart_8250_port *up)
974 : : {
975 : : struct uart_8250_port *uart;
976 : : int ret = -ENOSPC;
977 : :
978 : 0 : if (up->port.uartclk == 0)
979 : : return -EINVAL;
980 : :
981 : 0 : mutex_lock(&serial_mutex);
982 : :
983 : 0 : uart = serial8250_find_match_or_unused(&up->port);
984 : 0 : if (uart && uart->port.type != PORT_8250_CIR) {
985 : : struct mctrl_gpios *gpios;
986 : :
987 : 0 : if (uart->port.dev)
988 : 0 : uart_remove_one_port(&serial8250_reg, &uart->port);
989 : :
990 : 0 : uart->port.iobase = up->port.iobase;
991 : 0 : uart->port.membase = up->port.membase;
992 : 0 : uart->port.irq = up->port.irq;
993 : 0 : uart->port.irqflags = up->port.irqflags;
994 : 0 : uart->port.uartclk = up->port.uartclk;
995 : 0 : uart->port.fifosize = up->port.fifosize;
996 : 0 : uart->port.regshift = up->port.regshift;
997 : 0 : uart->port.iotype = up->port.iotype;
998 : 0 : uart->port.flags = up->port.flags | UPF_BOOT_AUTOCONF;
999 : 0 : uart->bugs = up->bugs;
1000 : 0 : uart->port.mapbase = up->port.mapbase;
1001 : 0 : uart->port.mapsize = up->port.mapsize;
1002 : 0 : uart->port.private_data = up->port.private_data;
1003 : 0 : uart->tx_loadsz = up->tx_loadsz;
1004 : 0 : uart->capabilities = up->capabilities;
1005 : 0 : uart->port.throttle = up->port.throttle;
1006 : 0 : uart->port.unthrottle = up->port.unthrottle;
1007 : 0 : uart->port.rs485_config = up->port.rs485_config;
1008 : 0 : uart->port.rs485 = up->port.rs485;
1009 : 0 : uart->dma = up->dma;
1010 : :
1011 : : /* Take tx_loadsz from fifosize if it wasn't set separately */
1012 : 0 : if (uart->port.fifosize && !uart->tx_loadsz)
1013 : 0 : uart->tx_loadsz = uart->port.fifosize;
1014 : :
1015 : 0 : if (up->port.dev)
1016 : 0 : uart->port.dev = up->port.dev;
1017 : :
1018 : 0 : if (up->port.flags & UPF_FIXED_TYPE)
1019 : 0 : uart->port.type = up->port.type;
1020 : :
1021 : : /*
1022 : : * Only call mctrl_gpio_init(), if the device has no ACPI
1023 : : * companion device
1024 : : */
1025 : : if (!has_acpi_companion(uart->port.dev)) {
1026 : 0 : gpios = mctrl_gpio_init(&uart->port, 0);
1027 : 0 : if (IS_ERR(gpios)) {
1028 : : ret = PTR_ERR(gpios);
1029 : 0 : goto err;
1030 : : } else {
1031 : 0 : uart->gpios = gpios;
1032 : : }
1033 : : }
1034 : :
1035 : 0 : serial8250_set_defaults(uart);
1036 : :
1037 : : /* Possibly override default I/O functions. */
1038 : 0 : if (up->port.serial_in)
1039 : 0 : uart->port.serial_in = up->port.serial_in;
1040 : 0 : if (up->port.serial_out)
1041 : 0 : uart->port.serial_out = up->port.serial_out;
1042 : 0 : if (up->port.handle_irq)
1043 : 0 : uart->port.handle_irq = up->port.handle_irq;
1044 : : /* Possibly override set_termios call */
1045 : 0 : if (up->port.set_termios)
1046 : 0 : uart->port.set_termios = up->port.set_termios;
1047 : 0 : if (up->port.set_ldisc)
1048 : 0 : uart->port.set_ldisc = up->port.set_ldisc;
1049 : 0 : if (up->port.get_mctrl)
1050 : 0 : uart->port.get_mctrl = up->port.get_mctrl;
1051 : 0 : if (up->port.set_mctrl)
1052 : 0 : uart->port.set_mctrl = up->port.set_mctrl;
1053 : 0 : if (up->port.get_divisor)
1054 : 0 : uart->port.get_divisor = up->port.get_divisor;
1055 : 0 : if (up->port.set_divisor)
1056 : 0 : uart->port.set_divisor = up->port.set_divisor;
1057 : 0 : if (up->port.startup)
1058 : 0 : uart->port.startup = up->port.startup;
1059 : 0 : if (up->port.shutdown)
1060 : 0 : uart->port.shutdown = up->port.shutdown;
1061 : 0 : if (up->port.pm)
1062 : 0 : uart->port.pm = up->port.pm;
1063 : 0 : if (up->port.handle_break)
1064 : 0 : uart->port.handle_break = up->port.handle_break;
1065 : 0 : if (up->dl_read)
1066 : 0 : uart->dl_read = up->dl_read;
1067 : 0 : if (up->dl_write)
1068 : 0 : uart->dl_write = up->dl_write;
1069 : :
1070 : 0 : if (uart->port.type != PORT_8250_CIR) {
1071 : 0 : if (serial8250_isa_config != NULL)
1072 : 0 : serial8250_isa_config(0, &uart->port,
1073 : : &uart->capabilities);
1074 : :
1075 : : serial8250_apply_quirks(uart);
1076 : 0 : ret = uart_add_one_port(&serial8250_reg,
1077 : : &uart->port);
1078 : 0 : if (ret)
1079 : : goto err;
1080 : :
1081 : 0 : ret = uart->port.line;
1082 : : } else {
1083 : 0 : dev_info(uart->port.dev,
1084 : : "skipping CIR port at 0x%lx / 0x%llx, IRQ %d\n",
1085 : : uart->port.iobase,
1086 : : (unsigned long long)uart->port.mapbase,
1087 : : uart->port.irq);
1088 : :
1089 : : ret = 0;
1090 : : }
1091 : :
1092 : : /* Initialise interrupt backoff work if required */
1093 : 0 : if (up->overrun_backoff_time_ms > 0) {
1094 : 0 : uart->overrun_backoff_time_ms =
1095 : : up->overrun_backoff_time_ms;
1096 : 0 : INIT_DELAYED_WORK(&uart->overrun_backoff,
1097 : : serial_8250_overrun_backoff_work);
1098 : : } else {
1099 : 0 : uart->overrun_backoff_time_ms = 0;
1100 : : }
1101 : : }
1102 : :
1103 : 0 : mutex_unlock(&serial_mutex);
1104 : :
1105 : 0 : return ret;
1106 : :
1107 : : err:
1108 : 0 : uart->port.dev = NULL;
1109 : 0 : mutex_unlock(&serial_mutex);
1110 : 0 : return ret;
1111 : : }
1112 : : EXPORT_SYMBOL(serial8250_register_8250_port);
1113 : :
1114 : : /**
1115 : : * serial8250_unregister_port - remove a 16x50 serial port at runtime
1116 : : * @line: serial line number
1117 : : *
1118 : : * Remove one serial port. This may not be called from interrupt
1119 : : * context. We hand the port back to the our control.
1120 : : */
1121 : 0 : void serial8250_unregister_port(int line)
1122 : : {
1123 : 0 : struct uart_8250_port *uart = &serial8250_ports[line];
1124 : :
1125 : 0 : mutex_lock(&serial_mutex);
1126 : :
1127 : 0 : if (uart->em485) {
1128 : : unsigned long flags;
1129 : :
1130 : 0 : spin_lock_irqsave(&uart->port.lock, flags);
1131 : 0 : serial8250_em485_destroy(uart);
1132 : : spin_unlock_irqrestore(&uart->port.lock, flags);
1133 : : }
1134 : :
1135 : 0 : uart_remove_one_port(&serial8250_reg, &uart->port);
1136 : 0 : if (serial8250_isa_devs) {
1137 : 0 : uart->port.flags &= ~UPF_BOOT_AUTOCONF;
1138 : 0 : uart->port.type = PORT_UNKNOWN;
1139 : 0 : uart->port.dev = &serial8250_isa_devs->dev;
1140 : 0 : uart->capabilities = 0;
1141 : : serial8250_apply_quirks(uart);
1142 : 0 : uart_add_one_port(&serial8250_reg, &uart->port);
1143 : : } else {
1144 : 0 : uart->port.dev = NULL;
1145 : : }
1146 : 0 : mutex_unlock(&serial_mutex);
1147 : 0 : }
1148 : : EXPORT_SYMBOL(serial8250_unregister_port);
1149 : :
1150 : 3 : static int __init serial8250_init(void)
1151 : : {
1152 : : int ret;
1153 : :
1154 : 3 : if (nr_uarts == 0)
1155 : : return -ENODEV;
1156 : :
1157 : 0 : serial8250_isa_init_ports();
1158 : :
1159 : 0 : pr_info("Serial: 8250/16550 driver, %d ports, IRQ sharing %sabled\n",
1160 : : nr_uarts, share_irqs ? "en" : "dis");
1161 : :
1162 : : #ifdef CONFIG_SPARC
1163 : : ret = sunserial_register_minors(&serial8250_reg, UART_NR);
1164 : : #else
1165 : 0 : serial8250_reg.nr = UART_NR;
1166 : 0 : ret = uart_register_driver(&serial8250_reg);
1167 : : #endif
1168 : 0 : if (ret)
1169 : : goto out;
1170 : :
1171 : : ret = serial8250_pnp_init();
1172 : : if (ret)
1173 : : goto unreg_uart_drv;
1174 : :
1175 : 0 : serial8250_isa_devs = platform_device_alloc("serial8250",
1176 : : PLAT8250_DEV_LEGACY);
1177 : 0 : if (!serial8250_isa_devs) {
1178 : : ret = -ENOMEM;
1179 : : goto unreg_pnp;
1180 : : }
1181 : :
1182 : 0 : ret = platform_device_add(serial8250_isa_devs);
1183 : 0 : if (ret)
1184 : : goto put_dev;
1185 : :
1186 : 0 : serial8250_register_ports(&serial8250_reg, &serial8250_isa_devs->dev);
1187 : :
1188 : 0 : ret = platform_driver_register(&serial8250_isa_driver);
1189 : 0 : if (ret == 0)
1190 : : goto out;
1191 : :
1192 : 0 : platform_device_del(serial8250_isa_devs);
1193 : : put_dev:
1194 : 0 : platform_device_put(serial8250_isa_devs);
1195 : : unreg_pnp:
1196 : : serial8250_pnp_exit();
1197 : : unreg_uart_drv:
1198 : : #ifdef CONFIG_SPARC
1199 : : sunserial_unregister_minors(&serial8250_reg, UART_NR);
1200 : : #else
1201 : 0 : uart_unregister_driver(&serial8250_reg);
1202 : : #endif
1203 : : out:
1204 : 0 : return ret;
1205 : : }
1206 : :
1207 : 0 : static void __exit serial8250_exit(void)
1208 : : {
1209 : 0 : struct platform_device *isa_dev = serial8250_isa_devs;
1210 : :
1211 : : /*
1212 : : * This tells serial8250_unregister_port() not to re-register
1213 : : * the ports (thereby making serial8250_isa_driver permanently
1214 : : * in use.)
1215 : : */
1216 : 0 : serial8250_isa_devs = NULL;
1217 : :
1218 : 0 : platform_driver_unregister(&serial8250_isa_driver);
1219 : 0 : platform_device_unregister(isa_dev);
1220 : :
1221 : : serial8250_pnp_exit();
1222 : :
1223 : : #ifdef CONFIG_SPARC
1224 : : sunserial_unregister_minors(&serial8250_reg, UART_NR);
1225 : : #else
1226 : 0 : uart_unregister_driver(&serial8250_reg);
1227 : : #endif
1228 : 0 : }
1229 : :
1230 : : module_init(serial8250_init);
1231 : : module_exit(serial8250_exit);
1232 : :
1233 : : MODULE_LICENSE("GPL");
1234 : : MODULE_DESCRIPTION("Generic 8250/16x50 serial driver");
1235 : :
1236 : : module_param_hw(share_irqs, uint, other, 0644);
1237 : : MODULE_PARM_DESC(share_irqs, "Share IRQs with other non-8250/16x50 devices (unsafe)");
1238 : :
1239 : : module_param(nr_uarts, uint, 0644);
1240 : : MODULE_PARM_DESC(nr_uarts, "Maximum number of UARTs supported. (1-" __MODULE_STRING(CONFIG_SERIAL_8250_NR_UARTS) ")");
1241 : :
1242 : : module_param(skip_txen_test, uint, 0644);
1243 : : MODULE_PARM_DESC(skip_txen_test, "Skip checking for the TXEN bug at init time");
1244 : :
1245 : : #ifdef CONFIG_SERIAL_8250_RSA
1246 : : module_param_hw_array(probe_rsa, ulong, ioport, &probe_rsa_count, 0444);
1247 : : MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA");
1248 : : #endif
1249 : : MODULE_ALIAS_CHARDEV_MAJOR(TTY_MAJOR);
1250 : :
1251 : : #ifdef CONFIG_SERIAL_8250_DEPRECATED_OPTIONS
1252 : : #ifndef MODULE
1253 : : /* This module was renamed to 8250_core in 3.7. Keep the old "8250" name
1254 : : * working as well for the module options so we don't break people. We
1255 : : * need to keep the names identical and the convenient macros will happily
1256 : : * refuse to let us do that by failing the build with redefinition errors
1257 : : * of global variables. So we stick them inside a dummy function to avoid
1258 : : * those conflicts. The options still get parsed, and the redefined
1259 : : * MODULE_PARAM_PREFIX lets us keep the "8250." syntax alive.
1260 : : *
1261 : : * This is hacky. I'm sorry.
1262 : : */
1263 : : static void __used s8250_options(void)
1264 : : {
1265 : : #undef MODULE_PARAM_PREFIX
1266 : : #define MODULE_PARAM_PREFIX "8250_core."
1267 : :
1268 : : module_param_cb(share_irqs, ¶m_ops_uint, &share_irqs, 0644);
1269 : : module_param_cb(nr_uarts, ¶m_ops_uint, &nr_uarts, 0644);
1270 : : module_param_cb(skip_txen_test, ¶m_ops_uint, &skip_txen_test, 0644);
1271 : : #ifdef CONFIG_SERIAL_8250_RSA
1272 : : __module_param_call(MODULE_PARAM_PREFIX, probe_rsa,
1273 : : ¶m_array_ops, .arr = &__param_arr_probe_rsa,
1274 : : 0444, -1, 0);
1275 : : #endif
1276 : : }
1277 : : #else
1278 : : MODULE_ALIAS("8250_core");
1279 : : #endif
1280 : : #endif
|
