1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
47
48
49
50static unsigned int share_irqs = SERIAL8250_SHARE_IRQS;
51
52static unsigned int nr_uarts = CONFIG_SERIAL_8250_RUNTIME_UARTS;
53
54static struct uart_driver serial8250_reg;
55
56static unsigned int skip_txen_test;
57
58#define PASS_LIMIT 512
59
60#include <asm/serial.h>
61
62
63
64
65
66#ifndef SERIAL_PORT_DFNS
67#define SERIAL_PORT_DFNS
68#endif
69
70static const struct old_serial_port old_serial_port[] = {
71 SERIAL_PORT_DFNS
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
79static unsigned long probe_rsa[PORT_RSA_MAX];
80static unsigned int probe_rsa_count;
81#endif
82
83struct irq_info {
84 struct hlist_node node;
85 int irq;
86 spinlock_t lock;
87 struct list_head *head;
88};
89
90#define NR_IRQ_HASH 32
91static struct hlist_head irq_lists[NR_IRQ_HASH];
92static DEFINE_MUTEX(hash_mutex);
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108static 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 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 port = &up->port;
125
126 if (port->handle_irq(port)) {
127 handled = 1;
128 end = NULL;
129 } else if (end == NULL)
130 end = l;
131
132 l = l->next;
133
134 if (l == i->head && pass_counter++ > PASS_LIMIT)
135 break;
136 } while (l != end);
137
138 spin_unlock(&i->lock);
139
140 pr_debug("%s(%d): end\n", __func__, irq);
141
142 return IRQ_RETVAL(handled);
143}
144
145
146
147
148
149
150
151
152static void serial_do_unlink(struct irq_info *i, struct uart_8250_port *up)
153{
154 spin_lock_irq(&i->lock);
155
156 if (!list_empty(i->head)) {
157 if (i->head == &up->list)
158 i->head = i->head->next;
159 list_del(&up->list);
160 } else {
161 BUG_ON(i->head != &up->list);
162 i->head = NULL;
163 }
164 spin_unlock_irq(&i->lock);
165
166 if (i->head == NULL) {
167 hlist_del(&i->node);
168 kfree(i);
169 }
170}
171
172static int serial_link_irq_chain(struct uart_8250_port *up)
173{
174 struct hlist_head *h;
175 struct irq_info *i;
176 int ret;
177
178 mutex_lock(&hash_mutex);
179
180 h = &irq_lists[up->port.irq % NR_IRQ_HASH];
181
182 hlist_for_each_entry(i, h, node)
183 if (i->irq == up->port.irq)
184 break;
185
186 if (i == NULL) {
187 i = kzalloc(sizeof(struct irq_info), GFP_KERNEL);
188 if (i == NULL) {
189 mutex_unlock(&hash_mutex);
190 return -ENOMEM;
191 }
192 spin_lock_init(&i->lock);
193 i->irq = up->port.irq;
194 hlist_add_head(&i->node, h);
195 }
196 mutex_unlock(&hash_mutex);
197
198 spin_lock_irq(&i->lock);
199
200 if (i->head) {
201 list_add(&up->list, i->head);
202 spin_unlock_irq(&i->lock);
203
204 ret = 0;
205 } else {
206 INIT_LIST_HEAD(&up->list);
207 i->head = &up->list;
208 spin_unlock_irq(&i->lock);
209 ret = request_irq(up->port.irq, serial8250_interrupt,
210 up->port.irqflags, up->port.name, i);
211 if (ret < 0)
212 serial_do_unlink(i, up);
213 }
214
215 return ret;
216}
217
218static void serial_unlink_irq_chain(struct uart_8250_port *up)
219{
220 struct irq_info *i;
221 struct hlist_head *h;
222
223 mutex_lock(&hash_mutex);
224
225 h = &irq_lists[up->port.irq % NR_IRQ_HASH];
226
227 hlist_for_each_entry(i, h, node)
228 if (i->irq == up->port.irq)
229 break;
230
231 BUG_ON(i == NULL);
232 BUG_ON(i->head == NULL);
233
234 if (list_empty(i->head))
235 free_irq(up->port.irq, i);
236
237 serial_do_unlink(i, up);
238 mutex_unlock(&hash_mutex);
239}
240
241
242
243
244
245
246
247static void serial8250_timeout(struct timer_list *t)
248{
249 struct uart_8250_port *up = from_timer(up, t, timer);
250
251 up->port.handle_irq(&up->port);
252 mod_timer(&up->timer, jiffies + uart_poll_timeout(&up->port));
253}
254
255static void serial8250_backup_timeout(struct timer_list *t)
256{
257 struct uart_8250_port *up = from_timer(up, t, timer);
258 unsigned int iir, ier = 0, lsr;
259 unsigned long flags;
260
261 spin_lock_irqsave(&up->port.lock, flags);
262
263
264
265
266
267 if (up->port.irq) {
268 ier = serial_in(up, UART_IER);
269 serial_out(up, UART_IER, 0);
270 }
271
272 iir = serial_in(up, UART_IIR);
273
274
275
276
277
278
279
280 lsr = serial_in(up, UART_LSR);
281 up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
282 if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) &&
283 (!uart_circ_empty(&up->port.state->xmit) || up->port.x_char) &&
284 (lsr & UART_LSR_THRE)) {
285 iir &= ~(UART_IIR_ID | UART_IIR_NO_INT);
286 iir |= UART_IIR_THRI;
287 }
288
289 if (!(iir & UART_IIR_NO_INT))
290 serial8250_tx_chars(up);
291
292 if (up->port.irq)
293 serial_out(up, UART_IER, ier);
294
295 spin_unlock_irqrestore(&up->port.lock, flags);
296
297
298 mod_timer(&up->timer,
299 jiffies + uart_poll_timeout(&up->port) + HZ / 5);
300}
301
302static int univ8250_setup_irq(struct uart_8250_port *up)
303{
304 struct uart_port *port = &up->port;
305 int retval = 0;
306
307
308
309
310
311 if (up->bugs & UART_BUG_THRE) {
312 pr_debug("%s - using backup timer\n", port->name);
313
314 up->timer.function = serial8250_backup_timeout;
315 mod_timer(&up->timer, jiffies +
316 uart_poll_timeout(port) + HZ / 5);
317 }
318
319
320
321
322
323
324 if (!port->irq)
325 mod_timer(&up->timer, jiffies + uart_poll_timeout(port));
326 else
327 retval = serial_link_irq_chain(up);
328
329 return retval;
330}
331
332static void univ8250_release_irq(struct uart_8250_port *up)
333{
334 struct uart_port *port = &up->port;
335
336 del_timer_sync(&up->timer);
337 up->timer.function = serial8250_timeout;
338 if (port->irq)
339 serial_unlink_irq_chain(up);
340}
341
342#ifdef CONFIG_SERIAL_8250_RSA
343static int serial8250_request_rsa_resource(struct uart_8250_port *up)
344{
345 unsigned long start = UART_RSA_BASE << up->port.regshift;
346 unsigned int size = 8 << up->port.regshift;
347 struct uart_port *port = &up->port;
348 int ret = -EINVAL;
349
350 switch (port->iotype) {
351 case UPIO_HUB6:
352 case UPIO_PORT:
353 start += port->iobase;
354 if (request_region(start, size, "serial-rsa"))
355 ret = 0;
356 else
357 ret = -EBUSY;
358 break;
359 }
360
361 return ret;
362}
363
364static void serial8250_release_rsa_resource(struct uart_8250_port *up)
365{
366 unsigned long offset = UART_RSA_BASE << up->port.regshift;
367 unsigned int size = 8 << up->port.regshift;
368 struct uart_port *port = &up->port;
369
370 switch (port->iotype) {
371 case UPIO_HUB6:
372 case UPIO_PORT:
373 release_region(port->iobase + offset, size);
374 break;
375 }
376}
377#endif
378
379static const struct uart_ops *base_ops;
380static struct uart_ops univ8250_port_ops;
381
382static const struct uart_8250_ops univ8250_driver_ops = {
383 .setup_irq = univ8250_setup_irq,
384 .release_irq = univ8250_release_irq,
385};
386
387static struct uart_8250_port serial8250_ports[UART_NR];
388
389
390
391
392
393
394
395
396
397
398
399
400
401struct uart_8250_port *serial8250_get_port(int line)
402{
403 return &serial8250_ports[line];
404}
405EXPORT_SYMBOL_GPL(serial8250_get_port);
406
407static void (*serial8250_isa_config)(int port, struct uart_port *up,
408 u32 *capabilities);
409
410void serial8250_set_isa_configurator(
411 void (*v)(int port, struct uart_port *up, u32 *capabilities))
412{
413 serial8250_isa_config = v;
414}
415EXPORT_SYMBOL(serial8250_set_isa_configurator);
416
417#ifdef CONFIG_SERIAL_8250_RSA
418
419static void univ8250_config_port(struct uart_port *port, int flags)
420{
421 struct uart_8250_port *up = up_to_u8250p(port);
422
423 up->probe &= ~UART_PROBE_RSA;
424 if (port->type == PORT_RSA) {
425 if (serial8250_request_rsa_resource(up) == 0)
426 up->probe |= UART_PROBE_RSA;
427 } else if (flags & UART_CONFIG_TYPE) {
428 int i;
429
430 for (i = 0; i < probe_rsa_count; i++) {
431 if (probe_rsa[i] == up->port.iobase) {
432 if (serial8250_request_rsa_resource(up) == 0)
433 up->probe |= UART_PROBE_RSA;
434 break;
435 }
436 }
437 }
438
439 base_ops->config_port(port, flags);
440
441 if (port->type != PORT_RSA && up->probe & UART_PROBE_RSA)
442 serial8250_release_rsa_resource(up);
443}
444
445static int univ8250_request_port(struct uart_port *port)
446{
447 struct uart_8250_port *up = up_to_u8250p(port);
448 int ret;
449
450 ret = base_ops->request_port(port);
451 if (ret == 0 && port->type == PORT_RSA) {
452 ret = serial8250_request_rsa_resource(up);
453 if (ret < 0)
454 base_ops->release_port(port);
455 }
456
457 return ret;
458}
459
460static void univ8250_release_port(struct uart_port *port)
461{
462 struct uart_8250_port *up = up_to_u8250p(port);
463
464 if (port->type == PORT_RSA)
465 serial8250_release_rsa_resource(up);
466 base_ops->release_port(port);
467}
468
469static void univ8250_rsa_support(struct uart_ops *ops)
470{
471 ops->config_port = univ8250_config_port;
472 ops->request_port = univ8250_request_port;
473 ops->release_port = univ8250_release_port;
474}
475
476#else
477#define univ8250_rsa_support(x) do { } while (0)
478#endif
479
480static inline void serial8250_apply_quirks(struct uart_8250_port *up)
481{
482 up->port.quirks |= skip_txen_test ? UPQ_NO_TXEN_TEST : 0;
483}
484
485static void __init serial8250_isa_init_ports(void)
486{
487 struct uart_8250_port *up;
488 static int first = 1;
489 int i, irqflag = 0;
490
491 if (!first)
492 return;
493 first = 0;
494
495 if (nr_uarts > UART_NR)
496 nr_uarts = UART_NR;
497
498 for (i = 0; i < nr_uarts; i++) {
499 struct uart_8250_port *up = &serial8250_ports[i];
500 struct uart_port *port = &up->port;
501
502 port->line = i;
503 serial8250_init_port(up);
504 if (!base_ops)
505 base_ops = port->ops;
506 port->ops = &univ8250_port_ops;
507
508 timer_setup(&up->timer, serial8250_timeout, 0);
509
510 up->ops = &univ8250_driver_ops;
511
512
513
514
515 up->mcr_mask = ~ALPHA_KLUDGE_MCR;
516 up->mcr_force = ALPHA_KLUDGE_MCR;
517 serial8250_set_defaults(up);
518 }
519
520
521 univ8250_port_ops = *base_ops;
522 univ8250_rsa_support(&univ8250_port_ops);
523
524 if (share_irqs)
525 irqflag = IRQF_SHARED;
526
527 for (i = 0, up = serial8250_ports;
528 i < ARRAY_SIZE(old_serial_port) && i < nr_uarts;
529 i++, up++) {
530 struct uart_port *port = &up->port;
531
532 port->iobase = old_serial_port[i].port;
533 port->irq = irq_canonicalize(old_serial_port[i].irq);
534 port->irqflags = 0;
535 port->uartclk = old_serial_port[i].baud_base * 16;
536 port->flags = old_serial_port[i].flags;
537 port->hub6 = 0;
538 port->membase = old_serial_port[i].iomem_base;
539 port->iotype = old_serial_port[i].io_type;
540 port->regshift = old_serial_port[i].iomem_reg_shift;
541
542 port->irqflags |= irqflag;
543 if (serial8250_isa_config != NULL)
544 serial8250_isa_config(i, &up->port, &up->capabilities);
545 }
546}
547
548static void __init
549serial8250_register_ports(struct uart_driver *drv, struct device *dev)
550{
551 int i;
552
553 for (i = 0; i < nr_uarts; i++) {
554 struct uart_8250_port *up = &serial8250_ports[i];
555
556 if (up->port.type == PORT_8250_CIR)
557 continue;
558
559 if (up->port.dev)
560 continue;
561
562 up->port.dev = dev;
563
564 serial8250_apply_quirks(up);
565 uart_add_one_port(drv, &up->port);
566 }
567}
568
569#ifdef CONFIG_SERIAL_8250_CONSOLE
570
571static void univ8250_console_write(struct console *co, const char *s,
572 unsigned int count)
573{
574 struct uart_8250_port *up = &serial8250_ports[co->index];
575
576 serial8250_console_write(up, s, count);
577}
578
579static int univ8250_console_setup(struct console *co, char *options)
580{
581 struct uart_port *port;
582 int retval;
583
584
585
586
587
588
589 if (co->index >= nr_uarts)
590 co->index = 0;
591 port = &serial8250_ports[co->index].port;
592
593 port->cons = co;
594
595 retval = serial8250_console_setup(port, options, false);
596 if (retval != 0)
597 port->cons = NULL;
598 return retval;
599}
600
601static int univ8250_console_exit(struct console *co)
602{
603 struct uart_port *port;
604
605 port = &serial8250_ports[co->index].port;
606 return serial8250_console_exit(port);
607}
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627static int univ8250_console_match(struct console *co, char *name, int idx,
628 char *options)
629{
630 char match[] = "uart";
631 unsigned char iotype;
632 resource_size_t addr;
633 int i;
634
635 if (strncmp(name, match, 4) != 0)
636 return -ENODEV;
637
638 if (uart_parse_earlycon(options, &iotype, &addr, &options))
639 return -ENODEV;
640
641
642 for (i = 0; i < nr_uarts; i++) {
643 struct uart_port *port = &serial8250_ports[i].port;
644
645 if (port->iotype != iotype)
646 continue;
647 if ((iotype == UPIO_MEM || iotype == UPIO_MEM16 ||
648 iotype == UPIO_MEM32 || iotype == UPIO_MEM32BE)
649 && (port->mapbase != addr))
650 continue;
651 if (iotype == UPIO_PORT && port->iobase != addr)
652 continue;
653
654 co->index = i;
655 port->cons = co;
656 return serial8250_console_setup(port, options, true);
657 }
658
659 return -ENODEV;
660}
661
662static struct console univ8250_console = {
663 .name = "ttyS",
664 .write = univ8250_console_write,
665 .device = uart_console_device,
666 .setup = univ8250_console_setup,
667 .exit = univ8250_console_exit,
668 .match = univ8250_console_match,
669 .flags = CON_PRINTBUFFER | CON_ANYTIME,
670 .index = -1,
671 .data = &serial8250_reg,
672};
673
674static int __init univ8250_console_init(void)
675{
676 if (nr_uarts == 0)
677 return -ENODEV;
678
679 serial8250_isa_init_ports();
680 register_console(&univ8250_console);
681 return 0;
682}
683console_initcall(univ8250_console_init);
684
685#define SERIAL8250_CONSOLE (&univ8250_console)
686#else
687#define SERIAL8250_CONSOLE NULL
688#endif
689
690static struct uart_driver serial8250_reg = {
691 .owner = THIS_MODULE,
692 .driver_name = "serial",
693 .dev_name = "ttyS",
694 .major = TTY_MAJOR,
695 .minor = 64,
696 .cons = SERIAL8250_CONSOLE,
697};
698
699
700
701
702
703
704
705int __init early_serial_setup(struct uart_port *port)
706{
707 struct uart_port *p;
708
709 if (port->line >= ARRAY_SIZE(serial8250_ports) || nr_uarts == 0)
710 return -ENODEV;
711
712 serial8250_isa_init_ports();
713 p = &serial8250_ports[port->line].port;
714 p->iobase = port->iobase;
715 p->membase = port->membase;
716 p->irq = port->irq;
717 p->irqflags = port->irqflags;
718 p->uartclk = port->uartclk;
719 p->fifosize = port->fifosize;
720 p->regshift = port->regshift;
721 p->iotype = port->iotype;
722 p->flags = port->flags;
723 p->mapbase = port->mapbase;
724 p->mapsize = port->mapsize;
725 p->private_data = port->private_data;
726 p->type = port->type;
727 p->line = port->line;
728
729 serial8250_set_defaults(up_to_u8250p(p));
730
731 if (port->serial_in)
732 p->serial_in = port->serial_in;
733 if (port->serial_out)
734 p->serial_out = port->serial_out;
735 if (port->handle_irq)
736 p->handle_irq = port->handle_irq;
737
738 return 0;
739}
740
741
742
743
744
745
746
747void serial8250_suspend_port(int line)
748{
749 struct uart_8250_port *up = &serial8250_ports[line];
750 struct uart_port *port = &up->port;
751
752 if (!console_suspend_enabled && uart_console(port) &&
753 port->type != PORT_8250) {
754 unsigned char canary = 0xa5;
755
756 serial_out(up, UART_SCR, canary);
757 if (serial_in(up, UART_SCR) == canary)
758 up->canary = canary;
759 }
760
761 uart_suspend_port(&serial8250_reg, port);
762}
763EXPORT_SYMBOL(serial8250_suspend_port);
764
765
766
767
768
769
770
771void serial8250_resume_port(int line)
772{
773 struct uart_8250_port *up = &serial8250_ports[line];
774 struct uart_port *port = &up->port;
775
776 up->canary = 0;
777
778 if (up->capabilities & UART_NATSEMI) {
779
780 serial_port_out(port, UART_LCR, 0xE0);
781
782 ns16550a_goto_highspeed(up);
783
784 serial_port_out(port, UART_LCR, 0);
785 port->uartclk = 921600*16;
786 }
787 uart_resume_port(&serial8250_reg, port);
788}
789EXPORT_SYMBOL(serial8250_resume_port);
790
791
792
793
794
795
796static 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 memset(&uart, 0, sizeof(uart));
803
804 if (share_irqs)
805 irqflag = IRQF_SHARED;
806
807 for (i = 0; p && p->flags != 0; p++, i++) {
808 uart.port.iobase = p->iobase;
809 uart.port.membase = p->membase;
810 uart.port.irq = p->irq;
811 uart.port.irqflags = p->irqflags;
812 uart.port.uartclk = p->uartclk;
813 uart.port.regshift = p->regshift;
814 uart.port.iotype = p->iotype;
815 uart.port.flags = p->flags;
816 uart.port.mapbase = p->mapbase;
817 uart.port.hub6 = p->hub6;
818 uart.port.has_sysrq = p->has_sysrq;
819 uart.port.private_data = p->private_data;
820 uart.port.type = p->type;
821 uart.port.serial_in = p->serial_in;
822 uart.port.serial_out = p->serial_out;
823 uart.port.handle_irq = p->handle_irq;
824 uart.port.handle_break = p->handle_break;
825 uart.port.set_termios = p->set_termios;
826 uart.port.set_ldisc = p->set_ldisc;
827 uart.port.get_mctrl = p->get_mctrl;
828 uart.port.pm = p->pm;
829 uart.port.dev = &dev->dev;
830 uart.port.irqflags |= irqflag;
831 ret = serial8250_register_8250_port(&uart);
832 if (ret < 0) {
833 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 return 0;
840}
841
842
843
844
845static int serial8250_remove(struct platform_device *dev)
846{
847 int i;
848
849 for (i = 0; i < nr_uarts; i++) {
850 struct uart_8250_port *up = &serial8250_ports[i];
851
852 if (up->port.dev == &dev->dev)
853 serial8250_unregister_port(i);
854 }
855 return 0;
856}
857
858static int serial8250_suspend(struct platform_device *dev, pm_message_t state)
859{
860 int i;
861
862 for (i = 0; i < UART_NR; i++) {
863 struct uart_8250_port *up = &serial8250_ports[i];
864
865 if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
866 uart_suspend_port(&serial8250_reg, &up->port);
867 }
868
869 return 0;
870}
871
872static int serial8250_resume(struct platform_device *dev)
873{
874 int i;
875
876 for (i = 0; i < UART_NR; i++) {
877 struct uart_8250_port *up = &serial8250_ports[i];
878
879 if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
880 serial8250_resume_port(i);
881 }
882
883 return 0;
884}
885
886static 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
898
899
900static struct platform_device *serial8250_isa_devs;
901
902
903
904
905
906
907static DEFINE_MUTEX(serial_mutex);
908
909static struct uart_8250_port *serial8250_find_match_or_unused(const struct uart_port *port)
910{
911 int i;
912
913
914
915
916 for (i = 0; i < nr_uarts; i++)
917 if (uart_match_port(&serial8250_ports[i].port, port))
918 return &serial8250_ports[i];
919
920
921 i = port->line;
922 if (i < nr_uarts && serial8250_ports[i].port.type == PORT_UNKNOWN &&
923 serial8250_ports[i].port.iobase == 0)
924 return &serial8250_ports[i];
925
926
927
928
929
930 for (i = 0; i < nr_uarts; i++)
931 if (serial8250_ports[i].port.type == PORT_UNKNOWN &&
932 serial8250_ports[i].port.iobase == 0)
933 return &serial8250_ports[i];
934
935
936
937
938
939 for (i = 0; i < nr_uarts; i++)
940 if (serial8250_ports[i].port.type == PORT_UNKNOWN)
941 return &serial8250_ports[i];
942
943 return NULL;
944}
945
946static void serial_8250_overrun_backoff_work(struct work_struct *work)
947{
948 struct uart_8250_port *up =
949 container_of(to_delayed_work(work), struct uart_8250_port,
950 overrun_backoff);
951 struct uart_port *port = &up->port;
952 unsigned long flags;
953
954 spin_lock_irqsave(&port->lock, flags);
955 up->ier |= UART_IER_RLSI | UART_IER_RDI;
956 up->port.read_status_mask |= UART_LSR_DR;
957 serial_out(up, UART_IER, up->ier);
958 spin_unlock_irqrestore(&port->lock, flags);
959}
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974int serial8250_register_8250_port(const struct uart_8250_port *up)
975{
976 struct uart_8250_port *uart;
977 int ret = -ENOSPC;
978
979 if (up->port.uartclk == 0)
980 return -EINVAL;
981
982 mutex_lock(&serial_mutex);
983
984 uart = serial8250_find_match_or_unused(&up->port);
985 if (uart && uart->port.type != PORT_8250_CIR) {
986 struct mctrl_gpios *gpios;
987
988 if (uart->port.dev)
989 uart_remove_one_port(&serial8250_reg, &uart->port);
990
991 uart->port.iobase = up->port.iobase;
992 uart->port.membase = up->port.membase;
993 uart->port.irq = up->port.irq;
994 uart->port.irqflags = up->port.irqflags;
995 uart->port.uartclk = up->port.uartclk;
996 uart->port.fifosize = up->port.fifosize;
997 uart->port.regshift = up->port.regshift;
998 uart->port.iotype = up->port.iotype;
999 uart->port.flags = up->port.flags | UPF_BOOT_AUTOCONF;
1000 uart->bugs = up->bugs;
1001 uart->port.mapbase = up->port.mapbase;
1002 uart->port.mapsize = up->port.mapsize;
1003 uart->port.private_data = up->port.private_data;
1004 uart->tx_loadsz = up->tx_loadsz;
1005 uart->capabilities = up->capabilities;
1006 uart->port.throttle = up->port.throttle;
1007 uart->port.unthrottle = up->port.unthrottle;
1008 uart->port.rs485_config = up->port.rs485_config;
1009 uart->port.rs485 = up->port.rs485;
1010 uart->rs485_start_tx = up->rs485_start_tx;
1011 uart->rs485_stop_tx = up->rs485_stop_tx;
1012 uart->dma = up->dma;
1013
1014
1015 if (uart->port.fifosize && !uart->tx_loadsz)
1016 uart->tx_loadsz = uart->port.fifosize;
1017
1018 if (up->port.dev) {
1019 uart->port.dev = up->port.dev;
1020 ret = uart_get_rs485_mode(&uart->port);
1021 if (ret)
1022 goto err;
1023 }
1024
1025 if (up->port.flags & UPF_FIXED_TYPE)
1026 uart->port.type = up->port.type;
1027
1028
1029
1030
1031
1032 if (!has_acpi_companion(uart->port.dev)) {
1033 gpios = mctrl_gpio_init(&uart->port, 0);
1034 if (IS_ERR(gpios)) {
1035 ret = PTR_ERR(gpios);
1036 goto err;
1037 } else {
1038 uart->gpios = gpios;
1039 }
1040 }
1041
1042 serial8250_set_defaults(uart);
1043
1044
1045 if (up->port.serial_in)
1046 uart->port.serial_in = up->port.serial_in;
1047 if (up->port.serial_out)
1048 uart->port.serial_out = up->port.serial_out;
1049 if (up->port.handle_irq)
1050 uart->port.handle_irq = up->port.handle_irq;
1051
1052 if (up->port.set_termios)
1053 uart->port.set_termios = up->port.set_termios;
1054 if (up->port.set_ldisc)
1055 uart->port.set_ldisc = up->port.set_ldisc;
1056 if (up->port.get_mctrl)
1057 uart->port.get_mctrl = up->port.get_mctrl;
1058 if (up->port.set_mctrl)
1059 uart->port.set_mctrl = up->port.set_mctrl;
1060 if (up->port.get_divisor)
1061 uart->port.get_divisor = up->port.get_divisor;
1062 if (up->port.set_divisor)
1063 uart->port.set_divisor = up->port.set_divisor;
1064 if (up->port.startup)
1065 uart->port.startup = up->port.startup;
1066 if (up->port.shutdown)
1067 uart->port.shutdown = up->port.shutdown;
1068 if (up->port.pm)
1069 uart->port.pm = up->port.pm;
1070 if (up->port.handle_break)
1071 uart->port.handle_break = up->port.handle_break;
1072 if (up->dl_read)
1073 uart->dl_read = up->dl_read;
1074 if (up->dl_write)
1075 uart->dl_write = up->dl_write;
1076
1077 if (uart->port.type != PORT_8250_CIR) {
1078 if (serial8250_isa_config != NULL)
1079 serial8250_isa_config(0, &uart->port,
1080 &uart->capabilities);
1081
1082 serial8250_apply_quirks(uart);
1083 ret = uart_add_one_port(&serial8250_reg,
1084 &uart->port);
1085 if (ret)
1086 goto err;
1087
1088 ret = uart->port.line;
1089 } else {
1090 dev_info(uart->port.dev,
1091 "skipping CIR port at 0x%lx / 0x%llx, IRQ %d\n",
1092 uart->port.iobase,
1093 (unsigned long long)uart->port.mapbase,
1094 uart->port.irq);
1095
1096 ret = 0;
1097 }
1098
1099
1100 if (up->overrun_backoff_time_ms > 0) {
1101 uart->overrun_backoff_time_ms =
1102 up->overrun_backoff_time_ms;
1103 INIT_DELAYED_WORK(&uart->overrun_backoff,
1104 serial_8250_overrun_backoff_work);
1105 } else {
1106 uart->overrun_backoff_time_ms = 0;
1107 }
1108 }
1109
1110 mutex_unlock(&serial_mutex);
1111
1112 return ret;
1113
1114err:
1115 uart->port.dev = NULL;
1116 mutex_unlock(&serial_mutex);
1117 return ret;
1118}
1119EXPORT_SYMBOL(serial8250_register_8250_port);
1120
1121
1122
1123
1124
1125
1126
1127
1128void serial8250_unregister_port(int line)
1129{
1130 struct uart_8250_port *uart = &serial8250_ports[line];
1131
1132 mutex_lock(&serial_mutex);
1133
1134 if (uart->em485) {
1135 unsigned long flags;
1136
1137 spin_lock_irqsave(&uart->port.lock, flags);
1138 serial8250_em485_destroy(uart);
1139 spin_unlock_irqrestore(&uart->port.lock, flags);
1140 }
1141
1142 uart_remove_one_port(&serial8250_reg, &uart->port);
1143 if (serial8250_isa_devs) {
1144 uart->port.flags &= ~UPF_BOOT_AUTOCONF;
1145 uart->port.type = PORT_UNKNOWN;
1146 uart->port.dev = &serial8250_isa_devs->dev;
1147 uart->capabilities = 0;
1148 serial8250_apply_quirks(uart);
1149 uart_add_one_port(&serial8250_reg, &uart->port);
1150 } else {
1151 uart->port.dev = NULL;
1152 }
1153 mutex_unlock(&serial_mutex);
1154}
1155EXPORT_SYMBOL(serial8250_unregister_port);
1156
1157static int __init serial8250_init(void)
1158{
1159 int ret;
1160
1161 if (nr_uarts == 0)
1162 return -ENODEV;
1163
1164 serial8250_isa_init_ports();
1165
1166 pr_info("Serial: 8250/16550 driver, %d ports, IRQ sharing %sabled\n",
1167 nr_uarts, share_irqs ? "en" : "dis");
1168
1169#ifdef CONFIG_SPARC
1170 ret = sunserial_register_minors(&serial8250_reg, UART_NR);
1171#else
1172 serial8250_reg.nr = UART_NR;
1173 ret = uart_register_driver(&serial8250_reg);
1174#endif
1175 if (ret)
1176 goto out;
1177
1178 ret = serial8250_pnp_init();
1179 if (ret)
1180 goto unreg_uart_drv;
1181
1182 serial8250_isa_devs = platform_device_alloc("serial8250",
1183 PLAT8250_DEV_LEGACY);
1184 if (!serial8250_isa_devs) {
1185 ret = -ENOMEM;
1186 goto unreg_pnp;
1187 }
1188
1189 ret = platform_device_add(serial8250_isa_devs);
1190 if (ret)
1191 goto put_dev;
1192
1193 serial8250_register_ports(&serial8250_reg, &serial8250_isa_devs->dev);
1194
1195 ret = platform_driver_register(&serial8250_isa_driver);
1196 if (ret == 0)
1197 goto out;
1198
1199 platform_device_del(serial8250_isa_devs);
1200put_dev:
1201 platform_device_put(serial8250_isa_devs);
1202unreg_pnp:
1203 serial8250_pnp_exit();
1204unreg_uart_drv:
1205#ifdef CONFIG_SPARC
1206 sunserial_unregister_minors(&serial8250_reg, UART_NR);
1207#else
1208 uart_unregister_driver(&serial8250_reg);
1209#endif
1210out:
1211 return ret;
1212}
1213
1214static void __exit serial8250_exit(void)
1215{
1216 struct platform_device *isa_dev = serial8250_isa_devs;
1217
1218
1219
1220
1221
1222
1223 serial8250_isa_devs = NULL;
1224
1225 platform_driver_unregister(&serial8250_isa_driver);
1226 platform_device_unregister(isa_dev);
1227
1228 serial8250_pnp_exit();
1229
1230#ifdef CONFIG_SPARC
1231 sunserial_unregister_minors(&serial8250_reg, UART_NR);
1232#else
1233 uart_unregister_driver(&serial8250_reg);
1234#endif
1235}
1236
1237module_init(serial8250_init);
1238module_exit(serial8250_exit);
1239
1240MODULE_LICENSE("GPL");
1241MODULE_DESCRIPTION("Generic 8250/16x50 serial driver");
1242
1243module_param_hw(share_irqs, uint, other, 0644);
1244MODULE_PARM_DESC(share_irqs, "Share IRQs with other non-8250/16x50 devices (unsafe)");
1245
1246module_param(nr_uarts, uint, 0644);
1247MODULE_PARM_DESC(nr_uarts, "Maximum number of UARTs supported. (1-" __MODULE_STRING(CONFIG_SERIAL_8250_NR_UARTS) ")");
1248
1249module_param(skip_txen_test, uint, 0644);
1250MODULE_PARM_DESC(skip_txen_test, "Skip checking for the TXEN bug at init time");
1251
1252#ifdef CONFIG_SERIAL_8250_RSA
1253module_param_hw_array(probe_rsa, ulong, ioport, &probe_rsa_count, 0444);
1254MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA");
1255#endif
1256MODULE_ALIAS_CHARDEV_MAJOR(TTY_MAJOR);
1257
1258#ifdef CONFIG_SERIAL_8250_DEPRECATED_OPTIONS
1259#ifndef MODULE
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270static void __used s8250_options(void)
1271{
1272#undef MODULE_PARAM_PREFIX
1273#define MODULE_PARAM_PREFIX "8250_core."
1274
1275 module_param_cb(share_irqs, ¶m_ops_uint, &share_irqs, 0644);
1276 module_param_cb(nr_uarts, ¶m_ops_uint, &nr_uarts, 0644);
1277 module_param_cb(skip_txen_test, ¶m_ops_uint, &skip_txen_test, 0644);
1278#ifdef CONFIG_SERIAL_8250_RSA
1279 __module_param_call(MODULE_PARAM_PREFIX, probe_rsa,
1280 ¶m_array_ops, .arr = &__param_arr_probe_rsa,
1281 0444, -1, 0);
1282#endif
1283}
1284#else
1285MODULE_ALIAS("8250_core");
1286#endif
1287#endif
1288