4a93eb65ddf7e8d068f3f51ee9c72a3d56c43436
[linux-3.10.git] / drivers / tty / serial / 8250 / 8250_core.c
1 /*
2  *  Driver for 8250/16550-type serial ports
3  *
4  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
5  *
6  *  Copyright (C) 2001 Russell King.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * A note about mapbase / membase
14  *
15  *  mapbase is the physical address of the IO port.
16  *  membase is an 'ioremapped' cookie.
17  */
18
19 #if defined(CONFIG_SERIAL_8250_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
20 #define SUPPORT_SYSRQ
21 #endif
22
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
25 #include <linux/ioport.h>
26 #include <linux/init.h>
27 #include <linux/console.h>
28 #include <linux/sysrq.h>
29 #include <linux/delay.h>
30 #include <linux/platform_device.h>
31 #include <linux/tty.h>
32 #include <linux/ratelimit.h>
33 #include <linux/tty_flip.h>
34 #include <linux/serial_reg.h>
35 #include <linux/serial_core.h>
36 #include <linux/serial.h>
37 #include <linux/serial_8250.h>
38 #include <linux/nmi.h>
39 #include <linux/mutex.h>
40 #include <linux/slab.h>
41 #ifdef CONFIG_SPARC
42 #include <linux/sunserialcore.h>
43 #endif
44
45 #include <asm/io.h>
46 #include <asm/irq.h>
47
48 #include "8250.h"
49
50 /*
51  * Configuration:
52  *   share_irqs - whether we pass IRQF_SHARED to request_irq().  This option
53  *                is unsafe when used on edge-triggered interrupts.
54  */
55 static unsigned int share_irqs = SERIAL8250_SHARE_IRQS;
56
57 static unsigned int nr_uarts = CONFIG_SERIAL_8250_RUNTIME_UARTS;
58
59 static struct uart_driver serial8250_reg;
60
61 static int serial_index(struct uart_port *port)
62 {
63         return (serial8250_reg.minor - 64) + port->line;
64 }
65
66 static unsigned int skip_txen_test; /* force skip of txen test at init time */
67
68 /*
69  * Debugging.
70  */
71 #if 0
72 #define DEBUG_AUTOCONF(fmt...)  printk(fmt)
73 #else
74 #define DEBUG_AUTOCONF(fmt...)  do { } while (0)
75 #endif
76
77 #if 0
78 #define DEBUG_INTR(fmt...)      printk(fmt)
79 #else
80 #define DEBUG_INTR(fmt...)      do { } while (0)
81 #endif
82
83 #define PASS_LIMIT      512
84
85 #define BOTH_EMPTY      (UART_LSR_TEMT | UART_LSR_THRE)
86
87
88 #ifdef CONFIG_SERIAL_8250_DETECT_IRQ
89 #define CONFIG_SERIAL_DETECT_IRQ 1
90 #endif
91 #ifdef CONFIG_SERIAL_8250_MANY_PORTS
92 #define CONFIG_SERIAL_MANY_PORTS 1
93 #endif
94
95 /*
96  * HUB6 is always on.  This will be removed once the header
97  * files have been cleaned.
98  */
99 #define CONFIG_HUB6 1
100
101 #include <asm/serial.h>
102 /*
103  * SERIAL_PORT_DFNS tells us about built-in ports that have no
104  * standard enumeration mechanism.   Platforms that can find all
105  * serial ports via mechanisms like ACPI or PCI need not supply it.
106  */
107 #ifndef SERIAL_PORT_DFNS
108 #define SERIAL_PORT_DFNS
109 #endif
110
111 static const struct old_serial_port old_serial_port[] = {
112         SERIAL_PORT_DFNS /* defined in asm/serial.h */
113 };
114
115 #define UART_NR CONFIG_SERIAL_8250_NR_UARTS
116
117 #ifdef CONFIG_SERIAL_8250_RSA
118
119 #define PORT_RSA_MAX 4
120 static unsigned long probe_rsa[PORT_RSA_MAX];
121 static unsigned int probe_rsa_count;
122 #endif /* CONFIG_SERIAL_8250_RSA  */
123
124 struct irq_info {
125         struct                  hlist_node node;
126         int                     irq;
127         spinlock_t              lock;   /* Protects list not the hash */
128         struct list_head        *head;
129 };
130
131 #define NR_IRQ_HASH             32      /* Can be adjusted later */
132 static struct hlist_head irq_lists[NR_IRQ_HASH];
133 static DEFINE_MUTEX(hash_mutex);        /* Used to walk the hash */
134
135 /*
136  * Here we define the default xmit fifo size used for each type of UART.
137  */
138 static const struct serial8250_config uart_config[] = {
139         [PORT_UNKNOWN] = {
140                 .name           = "unknown",
141                 .fifo_size      = 1,
142                 .tx_loadsz      = 1,
143         },
144         [PORT_8250] = {
145                 .name           = "8250",
146                 .fifo_size      = 1,
147                 .tx_loadsz      = 1,
148         },
149         [PORT_16450] = {
150                 .name           = "16450",
151                 .fifo_size      = 1,
152                 .tx_loadsz      = 1,
153         },
154         [PORT_16550] = {
155                 .name           = "16550",
156                 .fifo_size      = 1,
157                 .tx_loadsz      = 1,
158         },
159         [PORT_16550A] = {
160                 .name           = "16550A",
161                 .fifo_size      = 16,
162                 .tx_loadsz      = 16,
163                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
164                 .flags          = UART_CAP_FIFO,
165         },
166         [PORT_CIRRUS] = {
167                 .name           = "Cirrus",
168                 .fifo_size      = 1,
169                 .tx_loadsz      = 1,
170         },
171         [PORT_16650] = {
172                 .name           = "ST16650",
173                 .fifo_size      = 1,
174                 .tx_loadsz      = 1,
175                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
176         },
177         [PORT_16650V2] = {
178                 .name           = "ST16650V2",
179                 .fifo_size      = 32,
180                 .tx_loadsz      = 16,
181                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
182                                   UART_FCR_T_TRIG_00,
183                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
184         },
185         [PORT_16750] = {
186                 .name           = "TI16750",
187                 .fifo_size      = 64,
188                 .tx_loadsz      = 64,
189                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10 |
190                                   UART_FCR7_64BYTE,
191                 .flags          = UART_CAP_FIFO | UART_CAP_SLEEP | UART_CAP_AFE,
192         },
193         [PORT_STARTECH] = {
194                 .name           = "Startech",
195                 .fifo_size      = 1,
196                 .tx_loadsz      = 1,
197         },
198         [PORT_16C950] = {
199                 .name           = "16C950/954",
200                 .fifo_size      = 128,
201                 .tx_loadsz      = 128,
202                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
203                 /* UART_CAP_EFR breaks billionon CF bluetooth card. */
204                 .flags          = UART_CAP_FIFO | UART_CAP_SLEEP,
205         },
206         [PORT_16654] = {
207                 .name           = "ST16654",
208                 .fifo_size      = 64,
209                 .tx_loadsz      = 32,
210                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
211                                   UART_FCR_T_TRIG_10,
212                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
213         },
214         [PORT_16850] = {
215                 .name           = "XR16850",
216                 .fifo_size      = 128,
217                 .tx_loadsz      = 128,
218                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
219                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
220         },
221         [PORT_RSA] = {
222                 .name           = "RSA",
223                 .fifo_size      = 2048,
224                 .tx_loadsz      = 2048,
225                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_11,
226                 .flags          = UART_CAP_FIFO,
227         },
228         [PORT_NS16550A] = {
229                 .name           = "NS16550A",
230                 .fifo_size      = 16,
231                 .tx_loadsz      = 16,
232                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
233                 .flags          = UART_CAP_FIFO | UART_NATSEMI,
234         },
235         [PORT_XSCALE] = {
236                 .name           = "XScale",
237                 .fifo_size      = 32,
238                 .tx_loadsz      = 32,
239                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
240                 .flags          = UART_CAP_FIFO | UART_CAP_UUE | UART_CAP_RTOIE,
241         },
242         [PORT_OCTEON] = {
243                 .name           = "OCTEON",
244                 .fifo_size      = 64,
245                 .tx_loadsz      = 64,
246                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
247                 .flags          = UART_CAP_FIFO,
248         },
249         [PORT_AR7] = {
250                 .name           = "AR7",
251                 .fifo_size      = 16,
252                 .tx_loadsz      = 16,
253                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_00,
254                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
255         },
256         [PORT_U6_16550A] = {
257                 .name           = "U6_16550A",
258                 .fifo_size      = 64,
259                 .tx_loadsz      = 64,
260                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
261                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
262         },
263         [PORT_TEGRA] = {
264                 .name           = "Tegra",
265                 .fifo_size      = 32,
266                 .tx_loadsz      = 8,
267                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
268                                   UART_FCR_T_TRIG_01,
269                 .flags          = UART_CAP_FIFO | UART_CAP_RTOIE |
270                                   UART_CAP_HW_CTSRTS,
271         },
272         [PORT_XR17D15X] = {
273                 .name           = "XR17D15X",
274                 .fifo_size      = 64,
275                 .tx_loadsz      = 64,
276                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
277                 .flags          = UART_CAP_FIFO | UART_CAP_AFE | UART_CAP_EFR |
278                                   UART_CAP_SLEEP,
279         },
280         [PORT_XR17V35X] = {
281                 .name           = "XR17V35X",
282                 .fifo_size      = 256,
283                 .tx_loadsz      = 256,
284                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_11 |
285                                   UART_FCR_T_TRIG_11,
286                 .flags          = UART_CAP_FIFO | UART_CAP_AFE | UART_CAP_EFR |
287                                   UART_CAP_SLEEP,
288         },
289         [PORT_LPC3220] = {
290                 .name           = "LPC3220",
291                 .fifo_size      = 64,
292                 .tx_loadsz      = 32,
293                 .fcr            = UART_FCR_DMA_SELECT | UART_FCR_ENABLE_FIFO |
294                                   UART_FCR_R_TRIG_00 | UART_FCR_T_TRIG_00,
295                 .flags          = UART_CAP_FIFO,
296         },
297         [PORT_BRCM_TRUMANAGE] = {
298                 .name           = "TruManage",
299                 .fifo_size      = 1,
300                 .tx_loadsz      = 1024,
301                 .flags          = UART_CAP_HFIFO,
302         },
303         [PORT_8250_CIR] = {
304                 .name           = "CIR port"
305         },
306         [PORT_ALTR_16550_F32] = {
307                 .name           = "Altera 16550 FIFO32",
308                 .fifo_size      = 32,
309                 .tx_loadsz      = 32,
310                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
311                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
312         },
313         [PORT_ALTR_16550_F64] = {
314                 .name           = "Altera 16550 FIFO64",
315                 .fifo_size      = 64,
316                 .tx_loadsz      = 64,
317                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
318                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
319         },
320         [PORT_ALTR_16550_F128] = {
321                 .name           = "Altera 16550 FIFO128",
322                 .fifo_size      = 128,
323                 .tx_loadsz      = 128,
324                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
325                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
326         },
327 };
328
329 /* Uart divisor latch read */
330 static int default_serial_dl_read(struct uart_8250_port *up)
331 {
332         return serial_in(up, UART_DLL) | serial_in(up, UART_DLM) << 8;
333 }
334
335 /* Uart divisor latch write */
336 static void default_serial_dl_write(struct uart_8250_port *up, int value)
337 {
338         serial_out(up, UART_DLL, value & 0xff);
339         serial_out(up, UART_DLM, value >> 8 & 0xff);
340 }
341
342 #if defined(CONFIG_MIPS_ALCHEMY) || defined(CONFIG_SERIAL_8250_RT288X)
343
344 /* Au1x00/RT288x UART hardware has a weird register layout */
345 static const u8 au_io_in_map[] = {
346         [UART_RX]  = 0,
347         [UART_IER] = 2,
348         [UART_IIR] = 3,
349         [UART_LCR] = 5,
350         [UART_MCR] = 6,
351         [UART_LSR] = 7,
352         [UART_MSR] = 8,
353 };
354
355 static const u8 au_io_out_map[] = {
356         [UART_TX]  = 1,
357         [UART_IER] = 2,
358         [UART_FCR] = 4,
359         [UART_LCR] = 5,
360         [UART_MCR] = 6,
361 };
362
363 static unsigned int au_serial_in(struct uart_port *p, int offset)
364 {
365         offset = au_io_in_map[offset] << p->regshift;
366         return __raw_readl(p->membase + offset);
367 }
368
369 static void au_serial_out(struct uart_port *p, int offset, int value)
370 {
371         offset = au_io_out_map[offset] << p->regshift;
372         __raw_writel(value, p->membase + offset);
373 }
374
375 /* Au1x00 haven't got a standard divisor latch */
376 static int au_serial_dl_read(struct uart_8250_port *up)
377 {
378         return __raw_readl(up->port.membase + 0x28);
379 }
380
381 static void au_serial_dl_write(struct uart_8250_port *up, int value)
382 {
383         __raw_writel(value, up->port.membase + 0x28);
384 }
385
386 #endif
387
388 static unsigned int hub6_serial_in(struct uart_port *p, int offset)
389 {
390         offset = offset << p->regshift;
391         outb(p->hub6 - 1 + offset, p->iobase);
392         return inb(p->iobase + 1);
393 }
394
395 static void hub6_serial_out(struct uart_port *p, int offset, int value)
396 {
397         offset = offset << p->regshift;
398         outb(p->hub6 - 1 + offset, p->iobase);
399         outb(value, p->iobase + 1);
400 }
401
402 static unsigned int mem_serial_in(struct uart_port *p, int offset)
403 {
404         offset = offset << p->regshift;
405         return readb(p->membase + offset);
406 }
407
408 static void mem_serial_out(struct uart_port *p, int offset, int value)
409 {
410         offset = offset << p->regshift;
411         writeb(value, p->membase + offset);
412 }
413
414 static void mem32_serial_out(struct uart_port *p, int offset, int value)
415 {
416         offset = offset << p->regshift;
417         writel(value, p->membase + offset);
418 }
419
420 static unsigned int mem32_serial_in(struct uart_port *p, int offset)
421 {
422         offset = offset << p->regshift;
423         return readl(p->membase + offset);
424 }
425
426 static unsigned int io_serial_in(struct uart_port *p, int offset)
427 {
428         offset = offset << p->regshift;
429         return inb(p->iobase + offset);
430 }
431
432 static void io_serial_out(struct uart_port *p, int offset, int value)
433 {
434         offset = offset << p->regshift;
435         outb(value, p->iobase + offset);
436 }
437
438 static int serial8250_default_handle_irq(struct uart_port *port);
439 static int exar_handle_irq(struct uart_port *port);
440
441 static void set_io_from_upio(struct uart_port *p)
442 {
443         struct uart_8250_port *up =
444                 container_of(p, struct uart_8250_port, port);
445
446         up->dl_read = default_serial_dl_read;
447         up->dl_write = default_serial_dl_write;
448
449         switch (p->iotype) {
450         case UPIO_HUB6:
451                 p->serial_in = hub6_serial_in;
452                 p->serial_out = hub6_serial_out;
453                 break;
454
455         case UPIO_MEM:
456                 p->serial_in = mem_serial_in;
457                 p->serial_out = mem_serial_out;
458                 break;
459
460         case UPIO_MEM32:
461                 p->serial_in = mem32_serial_in;
462                 p->serial_out = mem32_serial_out;
463                 break;
464
465 #if defined(CONFIG_MIPS_ALCHEMY) || defined(CONFIG_SERIAL_8250_RT288X)
466         case UPIO_AU:
467                 p->serial_in = au_serial_in;
468                 p->serial_out = au_serial_out;
469                 up->dl_read = au_serial_dl_read;
470                 up->dl_write = au_serial_dl_write;
471                 break;
472 #endif
473
474         default:
475                 p->serial_in = io_serial_in;
476                 p->serial_out = io_serial_out;
477                 break;
478         }
479         /* Remember loaded iotype */
480         up->cur_iotype = p->iotype;
481         p->handle_irq = serial8250_default_handle_irq;
482 }
483
484 static void
485 serial_port_out_sync(struct uart_port *p, int offset, int value)
486 {
487         switch (p->iotype) {
488         case UPIO_MEM:
489         case UPIO_MEM32:
490         case UPIO_AU:
491                 p->serial_out(p, offset, value);
492                 p->serial_in(p, UART_LCR);      /* safe, no side-effects */
493                 break;
494         default:
495                 p->serial_out(p, offset, value);
496         }
497 }
498
499 /*
500  * For the 16C950
501  */
502 static void serial_icr_write(struct uart_8250_port *up, int offset, int value)
503 {
504         serial_out(up, UART_SCR, offset);
505         serial_out(up, UART_ICR, value);
506 }
507
508 static unsigned int serial_icr_read(struct uart_8250_port *up, int offset)
509 {
510         unsigned int value;
511
512         serial_icr_write(up, UART_ACR, up->acr | UART_ACR_ICRRD);
513         serial_out(up, UART_SCR, offset);
514         value = serial_in(up, UART_ICR);
515         serial_icr_write(up, UART_ACR, up->acr);
516
517         return value;
518 }
519
520 /*
521  * FIFO support.
522  */
523 static void serial8250_clear_fifos(struct uart_8250_port *p)
524 {
525         if (p->capabilities & UART_CAP_FIFO) {
526                 serial_out(p, UART_FCR, UART_FCR_ENABLE_FIFO);
527                 serial_out(p, UART_FCR, UART_FCR_ENABLE_FIFO |
528                                UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
529                 serial_out(p, UART_FCR, 0);
530         }
531 }
532
533 void serial8250_clear_and_reinit_fifos(struct uart_8250_port *p)
534 {
535         unsigned char fcr;
536
537         serial8250_clear_fifos(p);
538         fcr = uart_config[p->port.type].fcr;
539         serial_out(p, UART_FCR, fcr);
540 }
541 EXPORT_SYMBOL_GPL(serial8250_clear_and_reinit_fifos);
542
543 /*
544  * IER sleep support.  UARTs which have EFRs need the "extended
545  * capability" bit enabled.  Note that on XR16C850s, we need to
546  * reset LCR to write to IER.
547  */
548 static void serial8250_set_sleep(struct uart_8250_port *p, int sleep)
549 {
550         /*
551          * Exar UARTs have a SLEEP register that enables or disables
552          * each UART to enter sleep mode separately.  On the XR17V35x the
553          * register is accessible to each UART at the UART_EXAR_SLEEP
554          * offset but the UART channel may only write to the corresponding
555          * bit.
556          */
557         if ((p->port.type == PORT_XR17V35X) ||
558            (p->port.type == PORT_XR17D15X)) {
559                 serial_out(p, UART_EXAR_SLEEP, 0xff);
560                 return;
561         }
562
563         if (p->capabilities & UART_CAP_SLEEP) {
564                 if (p->capabilities & UART_CAP_EFR) {
565                         serial_out(p, UART_LCR, UART_LCR_CONF_MODE_B);
566                         serial_out(p, UART_EFR, UART_EFR_ECB);
567                         serial_out(p, UART_LCR, 0);
568                 }
569                 serial_out(p, UART_IER, sleep ? UART_IERX_SLEEP : 0);
570                 if (p->capabilities & UART_CAP_EFR) {
571                         serial_out(p, UART_LCR, UART_LCR_CONF_MODE_B);
572                         serial_out(p, UART_EFR, 0);
573                         serial_out(p, UART_LCR, 0);
574                 }
575         }
576 }
577
578 #ifdef CONFIG_SERIAL_8250_RSA
579 /*
580  * Attempts to turn on the RSA FIFO.  Returns zero on failure.
581  * We set the port uart clock rate if we succeed.
582  */
583 static int __enable_rsa(struct uart_8250_port *up)
584 {
585         unsigned char mode;
586         int result;
587
588         mode = serial_in(up, UART_RSA_MSR);
589         result = mode & UART_RSA_MSR_FIFO;
590
591         if (!result) {
592                 serial_out(up, UART_RSA_MSR, mode | UART_RSA_MSR_FIFO);
593                 mode = serial_in(up, UART_RSA_MSR);
594                 result = mode & UART_RSA_MSR_FIFO;
595         }
596
597         if (result)
598                 up->port.uartclk = SERIAL_RSA_BAUD_BASE * 16;
599
600         return result;
601 }
602
603 static void enable_rsa(struct uart_8250_port *up)
604 {
605         if (up->port.type == PORT_RSA) {
606                 if (up->port.uartclk != SERIAL_RSA_BAUD_BASE * 16) {
607                         spin_lock_irq(&up->port.lock);
608                         __enable_rsa(up);
609                         spin_unlock_irq(&up->port.lock);
610                 }
611                 if (up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16)
612                         serial_out(up, UART_RSA_FRR, 0);
613         }
614 }
615
616 /*
617  * Attempts to turn off the RSA FIFO.  Returns zero on failure.
618  * It is unknown why interrupts were disabled in here.  However,
619  * the caller is expected to preserve this behaviour by grabbing
620  * the spinlock before calling this function.
621  */
622 static void disable_rsa(struct uart_8250_port *up)
623 {
624         unsigned char mode;
625         int result;
626
627         if (up->port.type == PORT_RSA &&
628             up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16) {
629                 spin_lock_irq(&up->port.lock);
630
631                 mode = serial_in(up, UART_RSA_MSR);
632                 result = !(mode & UART_RSA_MSR_FIFO);
633
634                 if (!result) {
635                         serial_out(up, UART_RSA_MSR, mode & ~UART_RSA_MSR_FIFO);
636                         mode = serial_in(up, UART_RSA_MSR);
637                         result = !(mode & UART_RSA_MSR_FIFO);
638                 }
639
640                 if (result)
641                         up->port.uartclk = SERIAL_RSA_BAUD_BASE_LO * 16;
642                 spin_unlock_irq(&up->port.lock);
643         }
644 }
645 #endif /* CONFIG_SERIAL_8250_RSA */
646
647 /*
648  * This is a quickie test to see how big the FIFO is.
649  * It doesn't work at all the time, more's the pity.
650  */
651 static int size_fifo(struct uart_8250_port *up)
652 {
653         unsigned char old_fcr, old_mcr, old_lcr;
654         unsigned short old_dl;
655         int count;
656
657         old_lcr = serial_in(up, UART_LCR);
658         serial_out(up, UART_LCR, 0);
659         old_fcr = serial_in(up, UART_FCR);
660         old_mcr = serial_in(up, UART_MCR);
661         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO |
662                     UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
663         serial_out(up, UART_MCR, UART_MCR_LOOP);
664         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
665         old_dl = serial_dl_read(up);
666         serial_dl_write(up, 0x0001);
667         serial_out(up, UART_LCR, 0x03);
668         for (count = 0; count < 256; count++)
669                 serial_out(up, UART_TX, count);
670         mdelay(20);/* FIXME - schedule_timeout */
671         for (count = 0; (serial_in(up, UART_LSR) & UART_LSR_DR) &&
672              (count < 256); count++)
673                 serial_in(up, UART_RX);
674         serial_out(up, UART_FCR, old_fcr);
675         serial_out(up, UART_MCR, old_mcr);
676         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
677         serial_dl_write(up, old_dl);
678         serial_out(up, UART_LCR, old_lcr);
679
680         return count;
681 }
682
683 /*
684  * Read UART ID using the divisor method - set DLL and DLM to zero
685  * and the revision will be in DLL and device type in DLM.  We
686  * preserve the device state across this.
687  */
688 static unsigned int autoconfig_read_divisor_id(struct uart_8250_port *p)
689 {
690         unsigned char old_dll, old_dlm, old_lcr;
691         unsigned int id;
692
693         old_lcr = serial_in(p, UART_LCR);
694         serial_out(p, UART_LCR, UART_LCR_CONF_MODE_A);
695
696         old_dll = serial_in(p, UART_DLL);
697         old_dlm = serial_in(p, UART_DLM);
698
699         serial_out(p, UART_DLL, 0);
700         serial_out(p, UART_DLM, 0);
701
702         id = serial_in(p, UART_DLL) | serial_in(p, UART_DLM) << 8;
703
704         serial_out(p, UART_DLL, old_dll);
705         serial_out(p, UART_DLM, old_dlm);
706         serial_out(p, UART_LCR, old_lcr);
707
708         return id;
709 }
710
711 /*
712  * This is a helper routine to autodetect StarTech/Exar/Oxsemi UART's.
713  * When this function is called we know it is at least a StarTech
714  * 16650 V2, but it might be one of several StarTech UARTs, or one of
715  * its clones.  (We treat the broken original StarTech 16650 V1 as a
716  * 16550, and why not?  Startech doesn't seem to even acknowledge its
717  * existence.)
718  *
719  * What evil have men's minds wrought...
720  */
721 static void autoconfig_has_efr(struct uart_8250_port *up)
722 {
723         unsigned int id1, id2, id3, rev;
724
725         /*
726          * Everything with an EFR has SLEEP
727          */
728         up->capabilities |= UART_CAP_EFR | UART_CAP_SLEEP;
729
730         /*
731          * First we check to see if it's an Oxford Semiconductor UART.
732          *
733          * If we have to do this here because some non-National
734          * Semiconductor clone chips lock up if you try writing to the
735          * LSR register (which serial_icr_read does)
736          */
737
738         /*
739          * Check for Oxford Semiconductor 16C950.
740          *
741          * EFR [4] must be set else this test fails.
742          *
743          * This shouldn't be necessary, but Mike Hudson (Exoray@isys.ca)
744          * claims that it's needed for 952 dual UART's (which are not
745          * recommended for new designs).
746          */
747         up->acr = 0;
748         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
749         serial_out(up, UART_EFR, UART_EFR_ECB);
750         serial_out(up, UART_LCR, 0x00);
751         id1 = serial_icr_read(up, UART_ID1);
752         id2 = serial_icr_read(up, UART_ID2);
753         id3 = serial_icr_read(up, UART_ID3);
754         rev = serial_icr_read(up, UART_REV);
755
756         DEBUG_AUTOCONF("950id=%02x:%02x:%02x:%02x ", id1, id2, id3, rev);
757
758         if (id1 == 0x16 && id2 == 0xC9 &&
759             (id3 == 0x50 || id3 == 0x52 || id3 == 0x54)) {
760                 up->port.type = PORT_16C950;
761
762                 /*
763                  * Enable work around for the Oxford Semiconductor 952 rev B
764                  * chip which causes it to seriously miscalculate baud rates
765                  * when DLL is 0.
766                  */
767                 if (id3 == 0x52 && rev == 0x01)
768                         up->bugs |= UART_BUG_QUOT;
769                 return;
770         }
771
772         /*
773          * We check for a XR16C850 by setting DLL and DLM to 0, and then
774          * reading back DLL and DLM.  The chip type depends on the DLM
775          * value read back:
776          *  0x10 - XR16C850 and the DLL contains the chip revision.
777          *  0x12 - XR16C2850.
778          *  0x14 - XR16C854.
779          */
780         id1 = autoconfig_read_divisor_id(up);
781         DEBUG_AUTOCONF("850id=%04x ", id1);
782
783         id2 = id1 >> 8;
784         if (id2 == 0x10 || id2 == 0x12 || id2 == 0x14) {
785                 up->port.type = PORT_16850;
786                 return;
787         }
788
789         /*
790          * It wasn't an XR16C850.
791          *
792          * We distinguish between the '654 and the '650 by counting
793          * how many bytes are in the FIFO.  I'm using this for now,
794          * since that's the technique that was sent to me in the
795          * serial driver update, but I'm not convinced this works.
796          * I've had problems doing this in the past.  -TYT
797          */
798         if (size_fifo(up) == 64)
799                 up->port.type = PORT_16654;
800         else
801                 up->port.type = PORT_16650V2;
802 }
803
804 /*
805  * We detected a chip without a FIFO.  Only two fall into
806  * this category - the original 8250 and the 16450.  The
807  * 16450 has a scratch register (accessible with LCR=0)
808  */
809 static void autoconfig_8250(struct uart_8250_port *up)
810 {
811         unsigned char scratch, status1, status2;
812
813         up->port.type = PORT_8250;
814
815         scratch = serial_in(up, UART_SCR);
816         serial_out(up, UART_SCR, 0xa5);
817         status1 = serial_in(up, UART_SCR);
818         serial_out(up, UART_SCR, 0x5a);
819         status2 = serial_in(up, UART_SCR);
820         serial_out(up, UART_SCR, scratch);
821
822         if (status1 == 0xa5 && status2 == 0x5a)
823                 up->port.type = PORT_16450;
824 }
825
826 static int broken_efr(struct uart_8250_port *up)
827 {
828         /*
829          * Exar ST16C2550 "A2" devices incorrectly detect as
830          * having an EFR, and report an ID of 0x0201.  See
831          * http://linux.derkeiler.com/Mailing-Lists/Kernel/2004-11/4812.html 
832          */
833         if (autoconfig_read_divisor_id(up) == 0x0201 && size_fifo(up) == 16)
834                 return 1;
835
836         return 0;
837 }
838
839 static inline int ns16550a_goto_highspeed(struct uart_8250_port *up)
840 {
841         unsigned char status;
842
843         status = serial_in(up, 0x04); /* EXCR2 */
844 #define PRESL(x) ((x) & 0x30)
845         if (PRESL(status) == 0x10) {
846                 /* already in high speed mode */
847                 return 0;
848         } else {
849                 status &= ~0xB0; /* Disable LOCK, mask out PRESL[01] */
850                 status |= 0x10;  /* 1.625 divisor for baud_base --> 921600 */
851                 serial_out(up, 0x04, status);
852         }
853         return 1;
854 }
855
856 /*
857  * We know that the chip has FIFOs.  Does it have an EFR?  The
858  * EFR is located in the same register position as the IIR and
859  * we know the top two bits of the IIR are currently set.  The
860  * EFR should contain zero.  Try to read the EFR.
861  */
862 static void autoconfig_16550a(struct uart_8250_port *up)
863 {
864         unsigned char status1, status2;
865         unsigned int iersave;
866
867         up->port.type = PORT_16550A;
868         up->capabilities |= UART_CAP_FIFO;
869
870         /*
871          * XR17V35x UARTs have an extra divisor register, DLD
872          * that gets enabled with when DLAB is set which will
873          * cause the device to incorrectly match and assign
874          * port type to PORT_16650.  The EFR for this UART is
875          * found at offset 0x09. Instead check the Deice ID (DVID)
876          * register for a 2, 4 or 8 port UART.
877          */
878         if (up->port.flags & UPF_EXAR_EFR) {
879                 status1 = serial_in(up, UART_EXAR_DVID);
880                 if (status1 == 0x82 || status1 == 0x84 || status1 == 0x88) {
881                         DEBUG_AUTOCONF("Exar XR17V35x ");
882                         up->port.type = PORT_XR17V35X;
883                         up->capabilities |= UART_CAP_AFE | UART_CAP_EFR |
884                                                 UART_CAP_SLEEP;
885
886                         return;
887                 }
888
889         }
890
891         /*
892          * Check for presence of the EFR when DLAB is set.
893          * Only ST16C650V1 UARTs pass this test.
894          */
895         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
896         if (serial_in(up, UART_EFR) == 0) {
897                 serial_out(up, UART_EFR, 0xA8);
898                 if (serial_in(up, UART_EFR) != 0) {
899                         DEBUG_AUTOCONF("EFRv1 ");
900                         up->port.type = PORT_16650;
901                         up->capabilities |= UART_CAP_EFR | UART_CAP_SLEEP;
902                 } else {
903                         DEBUG_AUTOCONF("Motorola 8xxx DUART ");
904                 }
905                 serial_out(up, UART_EFR, 0);
906                 return;
907         }
908
909         /*
910          * Maybe it requires 0xbf to be written to the LCR.
911          * (other ST16C650V2 UARTs, TI16C752A, etc)
912          */
913         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
914         if (serial_in(up, UART_EFR) == 0 && !broken_efr(up)) {
915                 DEBUG_AUTOCONF("EFRv2 ");
916                 autoconfig_has_efr(up);
917                 return;
918         }
919
920 #ifdef CONFIG_HAS_NS_SUPER_IO_CHIP
921         /*
922          * Check for a National Semiconductor SuperIO chip.
923          * Attempt to switch to bank 2, read the value of the LOOP bit
924          * from EXCR1. Switch back to bank 0, change it in MCR. Then
925          * switch back to bank 2, read it from EXCR1 again and check
926          * it's changed. If so, set baud_base in EXCR2 to 921600. -- dwmw2
927          */
928         serial_out(up, UART_LCR, 0);
929         status1 = serial_in(up, UART_MCR);
930         serial_out(up, UART_LCR, 0xE0);
931         status2 = serial_in(up, 0x02); /* EXCR1 */
932
933         if (!((status2 ^ status1) & UART_MCR_LOOP)) {
934                 serial_out(up, UART_LCR, 0);
935                 serial_out(up, UART_MCR, status1 ^ UART_MCR_LOOP);
936                 serial_out(up, UART_LCR, 0xE0);
937                 status2 = serial_in(up, 0x02); /* EXCR1 */
938                 serial_out(up, UART_LCR, 0);
939                 serial_out(up, UART_MCR, status1);
940
941                 if ((status2 ^ status1) & UART_MCR_LOOP) {
942                         unsigned short quot;
943
944                         serial_out(up, UART_LCR, 0xE0);
945
946                         quot = serial_dl_read(up);
947                         quot <<= 3;
948
949                         if (ns16550a_goto_highspeed(up))
950                                 serial_dl_write(up, quot);
951
952                         serial_out(up, UART_LCR, 0);
953
954                         up->port.uartclk = 921600*16;
955                         up->port.type = PORT_NS16550A;
956                         up->capabilities |= UART_NATSEMI;
957                         return;
958                 }
959         }
960 #endif
961
962         /*
963          * No EFR.  Try to detect a TI16750, which only sets bit 5 of
964          * the IIR when 64 byte FIFO mode is enabled when DLAB is set.
965          * Try setting it with and without DLAB set.  Cheap clones
966          * set bit 5 without DLAB set.
967          */
968         serial_out(up, UART_LCR, 0);
969         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
970         status1 = serial_in(up, UART_IIR) >> 5;
971         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
972         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
973         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
974         status2 = serial_in(up, UART_IIR) >> 5;
975         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
976         serial_out(up, UART_LCR, 0);
977
978         DEBUG_AUTOCONF("iir1=%d iir2=%d ", status1, status2);
979
980         if (status1 == 6 && status2 == 7) {
981                 up->port.type = PORT_16750;
982                 up->capabilities |= UART_CAP_AFE | UART_CAP_SLEEP;
983                 return;
984         }
985
986         /*
987          * Try writing and reading the UART_IER_UUE bit (b6).
988          * If it works, this is probably one of the Xscale platform's
989          * internal UARTs.
990          * We're going to explicitly set the UUE bit to 0 before
991          * trying to write and read a 1 just to make sure it's not
992          * already a 1 and maybe locked there before we even start start.
993          */
994         iersave = serial_in(up, UART_IER);
995         serial_out(up, UART_IER, iersave & ~UART_IER_UUE);
996         if (!(serial_in(up, UART_IER) & UART_IER_UUE)) {
997                 /*
998                  * OK it's in a known zero state, try writing and reading
999                  * without disturbing the current state of the other bits.
1000                  */
1001                 serial_out(up, UART_IER, iersave | UART_IER_UUE);
1002                 if (serial_in(up, UART_IER) & UART_IER_UUE) {
1003                         /*
1004                          * It's an Xscale.
1005                          * We'll leave the UART_IER_UUE bit set to 1 (enabled).
1006                          */
1007                         DEBUG_AUTOCONF("Xscale ");
1008                         up->port.type = PORT_XSCALE;
1009                         up->capabilities |= UART_CAP_UUE | UART_CAP_RTOIE;
1010                         return;
1011                 }
1012         } else {
1013                 /*
1014                  * If we got here we couldn't force the IER_UUE bit to 0.
1015                  * Log it and continue.
1016                  */
1017                 DEBUG_AUTOCONF("Couldn't force IER_UUE to 0 ");
1018         }
1019         serial_out(up, UART_IER, iersave);
1020
1021         /*
1022          * Exar uarts have EFR in a weird location
1023          */
1024         if (up->port.flags & UPF_EXAR_EFR) {
1025                 DEBUG_AUTOCONF("Exar XR17D15x ");
1026                 up->port.type = PORT_XR17D15X;
1027                 up->capabilities |= UART_CAP_AFE | UART_CAP_EFR |
1028                                     UART_CAP_SLEEP;
1029
1030                 return;
1031         }
1032
1033         /*
1034          * We distinguish between 16550A and U6 16550A by counting
1035          * how many bytes are in the FIFO.
1036          */
1037         if (up->port.type == PORT_16550A && size_fifo(up) == 64) {
1038                 up->port.type = PORT_U6_16550A;
1039                 up->capabilities |= UART_CAP_AFE;
1040         }
1041 }
1042
1043 /*
1044  * This routine is called by rs_init() to initialize a specific serial
1045  * port.  It determines what type of UART chip this serial port is
1046  * using: 8250, 16450, 16550, 16550A.  The important question is
1047  * whether or not this UART is a 16550A or not, since this will
1048  * determine whether or not we can use its FIFO features or not.
1049  */
1050 static void autoconfig(struct uart_8250_port *up, unsigned int probeflags)
1051 {
1052         unsigned char status1, scratch, scratch2, scratch3;
1053         unsigned char save_lcr, save_mcr;
1054         struct uart_port *port = &up->port;
1055         unsigned long flags;
1056         unsigned int old_capabilities;
1057
1058         if (!port->iobase && !port->mapbase && !port->membase)
1059                 return;
1060
1061         DEBUG_AUTOCONF("ttyS%d: autoconf (0x%04lx, 0x%p): ",
1062                        serial_index(port), port->iobase, port->membase);
1063
1064         /*
1065          * We really do need global IRQs disabled here - we're going to
1066          * be frobbing the chips IRQ enable register to see if it exists.
1067          */
1068         spin_lock_irqsave(&port->lock, flags);
1069
1070         up->capabilities = 0;
1071         up->bugs = 0;
1072
1073         if (!(port->flags & UPF_BUGGY_UART)) {
1074                 /*
1075                  * Do a simple existence test first; if we fail this,
1076                  * there's no point trying anything else.
1077                  *
1078                  * 0x80 is used as a nonsense port to prevent against
1079                  * false positives due to ISA bus float.  The
1080                  * assumption is that 0x80 is a non-existent port;
1081                  * which should be safe since include/asm/io.h also
1082                  * makes this assumption.
1083                  *
1084                  * Note: this is safe as long as MCR bit 4 is clear
1085                  * and the device is in "PC" mode.
1086                  */
1087                 scratch = serial_in(up, UART_IER);
1088                 serial_out(up, UART_IER, 0);
1089 #ifdef __i386__
1090                 outb(0xff, 0x080);
1091 #endif
1092                 /*
1093                  * Mask out IER[7:4] bits for test as some UARTs (e.g. TL
1094                  * 16C754B) allow only to modify them if an EFR bit is set.
1095                  */
1096                 scratch2 = serial_in(up, UART_IER) & 0x0f;
1097                 serial_out(up, UART_IER, 0x0F);
1098 #ifdef __i386__
1099                 outb(0, 0x080);
1100 #endif
1101                 scratch3 = serial_in(up, UART_IER) & 0x0f;
1102                 serial_out(up, UART_IER, scratch);
1103                 if (scratch2 != 0 || scratch3 != 0x0F) {
1104                         /*
1105                          * We failed; there's nothing here
1106                          */
1107                         spin_unlock_irqrestore(&port->lock, flags);
1108                         DEBUG_AUTOCONF("IER test failed (%02x, %02x) ",
1109                                        scratch2, scratch3);
1110                         goto out;
1111                 }
1112         }
1113
1114         save_mcr = serial_in(up, UART_MCR);
1115         save_lcr = serial_in(up, UART_LCR);
1116
1117         /*
1118          * Check to see if a UART is really there.  Certain broken
1119          * internal modems based on the Rockwell chipset fail this
1120          * test, because they apparently don't implement the loopback
1121          * test mode.  So this test is skipped on the COM 1 through
1122          * COM 4 ports.  This *should* be safe, since no board
1123          * manufacturer would be stupid enough to design a board
1124          * that conflicts with COM 1-4 --- we hope!
1125          */
1126         if (!(port->flags & UPF_SKIP_TEST)) {
1127                 serial_out(up, UART_MCR, UART_MCR_LOOP | 0x0A);
1128                 status1 = serial_in(up, UART_MSR) & 0xF0;
1129                 serial_out(up, UART_MCR, save_mcr);
1130                 if (status1 != 0x90) {
1131                         spin_unlock_irqrestore(&port->lock, flags);
1132                         DEBUG_AUTOCONF("LOOP test failed (%02x) ",
1133                                        status1);
1134                         goto out;
1135                 }
1136         }
1137
1138         /*
1139          * We're pretty sure there's a port here.  Lets find out what
1140          * type of port it is.  The IIR top two bits allows us to find
1141          * out if it's 8250 or 16450, 16550, 16550A or later.  This
1142          * determines what we test for next.
1143          *
1144          * We also initialise the EFR (if any) to zero for later.  The
1145          * EFR occupies the same register location as the FCR and IIR.
1146          */
1147         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1148         serial_out(up, UART_EFR, 0);
1149         serial_out(up, UART_LCR, 0);
1150
1151         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
1152         scratch = serial_in(up, UART_IIR) >> 6;
1153
1154         switch (scratch) {
1155         case 0:
1156                 autoconfig_8250(up);
1157                 break;
1158         case 1:
1159                 port->type = PORT_UNKNOWN;
1160                 break;
1161         case 2:
1162                 port->type = PORT_16550;
1163                 break;
1164         case 3:
1165                 autoconfig_16550a(up);
1166                 break;
1167         }
1168
1169 #ifdef CONFIG_SERIAL_8250_RSA
1170         /*
1171          * Only probe for RSA ports if we got the region.
1172          */
1173         if (port->type == PORT_16550A && probeflags & PROBE_RSA) {
1174                 int i;
1175
1176                 for (i = 0 ; i < probe_rsa_count; ++i) {
1177                         if (probe_rsa[i] == port->iobase && __enable_rsa(up)) {
1178                                 port->type = PORT_RSA;
1179                                 break;
1180                         }
1181                 }
1182         }
1183 #endif
1184
1185         serial_out(up, UART_LCR, save_lcr);
1186
1187         port->fifosize = uart_config[up->port.type].fifo_size;
1188         old_capabilities = up->capabilities; 
1189         up->capabilities = uart_config[port->type].flags;
1190         up->tx_loadsz = uart_config[port->type].tx_loadsz;
1191
1192         if (port->type == PORT_UNKNOWN)
1193                 goto out_lock;
1194
1195         /*
1196          * Reset the UART.
1197          */
1198 #ifdef CONFIG_SERIAL_8250_RSA
1199         if (port->type == PORT_RSA)
1200                 serial_out(up, UART_RSA_FRR, 0);
1201 #endif
1202         serial_out(up, UART_MCR, save_mcr);
1203         serial8250_clear_fifos(up);
1204         serial_in(up, UART_RX);
1205         if (up->capabilities & UART_CAP_UUE)
1206                 serial_out(up, UART_IER, UART_IER_UUE);
1207         else
1208                 serial_out(up, UART_IER, 0);
1209
1210 out_lock:
1211         spin_unlock_irqrestore(&port->lock, flags);
1212         if (up->capabilities != old_capabilities) {
1213                 printk(KERN_WARNING
1214                        "ttyS%d: detected caps %08x should be %08x\n",
1215                        serial_index(port), old_capabilities,
1216                        up->capabilities);
1217         }
1218 out:
1219         DEBUG_AUTOCONF("iir=%d ", scratch);
1220         DEBUG_AUTOCONF("type=%s\n", uart_config[port->type].name);
1221 }
1222
1223 static void autoconfig_irq(struct uart_8250_port *up)
1224 {
1225         struct uart_port *port = &up->port;
1226         unsigned char save_mcr, save_ier;
1227         unsigned char save_ICP = 0;
1228         unsigned int ICP = 0;
1229         unsigned long irqs;
1230         int irq;
1231
1232         if (port->flags & UPF_FOURPORT) {
1233                 ICP = (port->iobase & 0xfe0) | 0x1f;
1234                 save_ICP = inb_p(ICP);
1235                 outb_p(0x80, ICP);
1236                 inb_p(ICP);
1237         }
1238
1239         /* forget possible initially masked and pending IRQ */
1240         probe_irq_off(probe_irq_on());
1241         save_mcr = serial_in(up, UART_MCR);
1242         save_ier = serial_in(up, UART_IER);
1243         serial_out(up, UART_MCR, UART_MCR_OUT1 | UART_MCR_OUT2);
1244
1245         irqs = probe_irq_on();
1246         serial_out(up, UART_MCR, 0);
1247         udelay(10);
1248         if (port->flags & UPF_FOURPORT) {
1249                 serial_out(up, UART_MCR,
1250                             UART_MCR_DTR | UART_MCR_RTS);
1251         } else {
1252                 serial_out(up, UART_MCR,
1253                             UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
1254         }
1255         serial_out(up, UART_IER, 0x0f); /* enable all intrs */
1256         serial_in(up, UART_LSR);
1257         serial_in(up, UART_RX);
1258         serial_in(up, UART_IIR);
1259         serial_in(up, UART_MSR);
1260         serial_out(up, UART_TX, 0xFF);
1261         udelay(20);
1262         irq = probe_irq_off(irqs);
1263
1264         serial_out(up, UART_MCR, save_mcr);
1265         serial_out(up, UART_IER, save_ier);
1266
1267         if (port->flags & UPF_FOURPORT)
1268                 outb_p(save_ICP, ICP);
1269
1270         port->irq = (irq > 0) ? irq : 0;
1271 }
1272
1273 static inline void __stop_tx(struct uart_8250_port *p)
1274 {
1275         if (p->ier & UART_IER_THRI) {
1276                 p->ier &= ~UART_IER_THRI;
1277                 serial_out(p, UART_IER, p->ier);
1278         }
1279 }
1280
1281 static void serial8250_stop_tx(struct uart_port *port)
1282 {
1283         struct uart_8250_port *up =
1284                 container_of(port, struct uart_8250_port, port);
1285
1286         __stop_tx(up);
1287
1288         /*
1289          * We really want to stop the transmitter from sending.
1290          */
1291         if (port->type == PORT_16C950) {
1292                 up->acr |= UART_ACR_TXDIS;
1293                 serial_icr_write(up, UART_ACR, up->acr);
1294         }
1295 }
1296
1297 static void serial8250_start_tx(struct uart_port *port)
1298 {
1299         struct uart_8250_port *up =
1300                 container_of(port, struct uart_8250_port, port);
1301
1302         if (up->dma && !serial8250_tx_dma(up)) {
1303                 return;
1304         } else if (!(up->ier & UART_IER_THRI)) {
1305                 up->ier |= UART_IER_THRI;
1306                 serial_port_out(port, UART_IER, up->ier);
1307
1308                 if (up->bugs & UART_BUG_TXEN) {
1309                         unsigned char lsr;
1310                         lsr = serial_in(up, UART_LSR);
1311                         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
1312                         if (lsr & UART_LSR_TEMT)
1313                                 serial8250_tx_chars(up);
1314                 }
1315         }
1316
1317         /*
1318          * Re-enable the transmitter if we disabled it.
1319          */
1320         if (port->type == PORT_16C950 && up->acr & UART_ACR_TXDIS) {
1321                 up->acr &= ~UART_ACR_TXDIS;
1322                 serial_icr_write(up, UART_ACR, up->acr);
1323         }
1324 }
1325
1326 static void serial8250_stop_rx(struct uart_port *port)
1327 {
1328         struct uart_8250_port *up =
1329                 container_of(port, struct uart_8250_port, port);
1330
1331         up->ier &= ~UART_IER_RLSI;
1332         up->port.read_status_mask &= ~UART_LSR_DR;
1333         serial_port_out(port, UART_IER, up->ier);
1334 }
1335
1336 static void serial8250_enable_ms(struct uart_port *port)
1337 {
1338         struct uart_8250_port *up =
1339                 container_of(port, struct uart_8250_port, port);
1340
1341         /* no MSR capabilities */
1342         if (up->bugs & UART_BUG_NOMSR)
1343                 return;
1344
1345         up->ier |= UART_IER_MSI;
1346         serial_port_out(port, UART_IER, up->ier);
1347 }
1348
1349 /*
1350  * serial8250_rx_chars: processes according to the passed in LSR
1351  * value, and returns the remaining LSR bits not handled
1352  * by this Rx routine.
1353  */
1354 unsigned char
1355 serial8250_rx_chars(struct uart_8250_port *up, unsigned char lsr)
1356 {
1357         struct uart_port *port = &up->port;
1358         unsigned char ch;
1359         int max_count = 256;
1360         char flag;
1361
1362         do {
1363                 if (likely(lsr & UART_LSR_DR))
1364                         ch = serial_in(up, UART_RX);
1365                 else
1366                         /*
1367                          * Intel 82571 has a Serial Over Lan device that will
1368                          * set UART_LSR_BI without setting UART_LSR_DR when
1369                          * it receives a break. To avoid reading from the
1370                          * receive buffer without UART_LSR_DR bit set, we
1371                          * just force the read character to be 0
1372                          */
1373                         ch = 0;
1374
1375                 flag = TTY_NORMAL;
1376                 port->icount.rx++;
1377
1378                 lsr |= up->lsr_saved_flags;
1379                 up->lsr_saved_flags = 0;
1380
1381                 if (unlikely(lsr & UART_LSR_BRK_ERROR_BITS)) {
1382                         if (lsr & UART_LSR_BI) {
1383                                 lsr &= ~(UART_LSR_FE | UART_LSR_PE);
1384                                 port->icount.brk++;
1385                                 /*
1386                                  * We do the SysRQ and SAK checking
1387                                  * here because otherwise the break
1388                                  * may get masked by ignore_status_mask
1389                                  * or read_status_mask.
1390                                  */
1391                                 if (uart_handle_break(port))
1392                                         goto ignore_char;
1393                         } else if (lsr & UART_LSR_PE)
1394                                 port->icount.parity++;
1395                         else if (lsr & UART_LSR_FE)
1396                                 port->icount.frame++;
1397                         if (lsr & UART_LSR_OE)
1398                                 port->icount.overrun++;
1399
1400                         /*
1401                          * Mask off conditions which should be ignored.
1402                          */
1403                         lsr &= port->read_status_mask;
1404
1405                         if (lsr & UART_LSR_BI) {
1406                                 DEBUG_INTR("handling break....");
1407                                 flag = TTY_BREAK;
1408                         } else if (lsr & UART_LSR_PE)
1409                                 flag = TTY_PARITY;
1410                         else if (lsr & UART_LSR_FE)
1411                                 flag = TTY_FRAME;
1412                 }
1413                 if (uart_handle_sysrq_char(port, ch))
1414                         goto ignore_char;
1415
1416                 uart_insert_char(port, lsr, UART_LSR_OE, ch, flag);
1417
1418 ignore_char:
1419                 lsr = serial_in(up, UART_LSR);
1420         } while ((lsr & (UART_LSR_DR | UART_LSR_BI)) && (max_count-- > 0));
1421         spin_unlock(&port->lock);
1422         tty_flip_buffer_push(&port->state->port);
1423         spin_lock(&port->lock);
1424         return lsr;
1425 }
1426 EXPORT_SYMBOL_GPL(serial8250_rx_chars);
1427
1428 void serial8250_tx_chars(struct uart_8250_port *up)
1429 {
1430         struct uart_port *port = &up->port;
1431         struct circ_buf *xmit = &port->state->xmit;
1432         int count;
1433
1434         if (port->x_char) {
1435                 serial_out(up, UART_TX, port->x_char);
1436                 port->icount.tx++;
1437                 port->x_char = 0;
1438                 return;
1439         }
1440         if (uart_tx_stopped(port)) {
1441                 serial8250_stop_tx(port);
1442                 return;
1443         }
1444         if (uart_circ_empty(xmit)) {
1445                 __stop_tx(up);
1446                 return;
1447         }
1448
1449         count = up->tx_loadsz;
1450         do {
1451                 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
1452                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
1453                 port->icount.tx++;
1454                 if (uart_circ_empty(xmit))
1455                         break;
1456                 if (up->capabilities & UART_CAP_HFIFO) {
1457                         if ((serial_port_in(port, UART_LSR) & BOTH_EMPTY) !=
1458                             BOTH_EMPTY)
1459                                 break;
1460                 }
1461         } while (--count > 0);
1462
1463         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
1464                 uart_write_wakeup(port);
1465
1466         DEBUG_INTR("THRE...");
1467
1468         if (uart_circ_empty(xmit))
1469                 __stop_tx(up);
1470 }
1471 EXPORT_SYMBOL_GPL(serial8250_tx_chars);
1472
1473 unsigned int serial8250_modem_status(struct uart_8250_port *up)
1474 {
1475         struct uart_port *port = &up->port;
1476         unsigned int status = serial_in(up, UART_MSR);
1477
1478         status |= up->msr_saved_flags;
1479         up->msr_saved_flags = 0;
1480         if (status & UART_MSR_ANY_DELTA && up->ier & UART_IER_MSI &&
1481             port->state != NULL) {
1482                 if (status & UART_MSR_TERI)
1483                         port->icount.rng++;
1484                 if (status & UART_MSR_DDSR)
1485                         port->icount.dsr++;
1486                 if (status & UART_MSR_DDCD)
1487                         uart_handle_dcd_change(port, status & UART_MSR_DCD);
1488                 if (status & UART_MSR_DCTS)
1489                         uart_handle_cts_change(port, status & UART_MSR_CTS);
1490
1491                 wake_up_interruptible(&port->state->port.delta_msr_wait);
1492         }
1493
1494         return status;
1495 }
1496 EXPORT_SYMBOL_GPL(serial8250_modem_status);
1497
1498 /*
1499  * This handles the interrupt from one port.
1500  */
1501 int serial8250_handle_irq(struct uart_port *port, unsigned int iir)
1502 {
1503         unsigned char status;
1504         unsigned long flags;
1505         struct uart_8250_port *up =
1506                 container_of(port, struct uart_8250_port, port);
1507         int dma_err = 0;
1508
1509         if (iir & UART_IIR_NO_INT)
1510                 return 0;
1511
1512         spin_lock_irqsave(&port->lock, flags);
1513
1514         status = serial_port_in(port, UART_LSR);
1515
1516         DEBUG_INTR("status = %x...", status);
1517
1518         if (status & (UART_LSR_DR | UART_LSR_BI)) {
1519                 if (up->dma)
1520                         dma_err = serial8250_rx_dma(up, iir);
1521
1522                 if (!up->dma || dma_err)
1523                         status = serial8250_rx_chars(up, status);
1524         }
1525         serial8250_modem_status(up);
1526         if (status & UART_LSR_THRE)
1527                 serial8250_tx_chars(up);
1528
1529         spin_unlock_irqrestore(&port->lock, flags);
1530         return 1;
1531 }
1532 EXPORT_SYMBOL_GPL(serial8250_handle_irq);
1533
1534 static int serial8250_default_handle_irq(struct uart_port *port)
1535 {
1536         unsigned int iir = serial_port_in(port, UART_IIR);
1537
1538         return serial8250_handle_irq(port, iir);
1539 }
1540
1541 /*
1542  * These Exar UARTs have an extra interrupt indicator that could
1543  * fire for a few unimplemented interrupts.  One of which is a
1544  * wakeup event when coming out of sleep.  Put this here just
1545  * to be on the safe side that these interrupts don't go unhandled.
1546  */
1547 static int exar_handle_irq(struct uart_port *port)
1548 {
1549         unsigned char int0, int1, int2, int3;
1550         unsigned int iir = serial_port_in(port, UART_IIR);
1551         int ret;
1552
1553         ret = serial8250_handle_irq(port, iir);
1554
1555         if ((port->type == PORT_XR17V35X) ||
1556            (port->type == PORT_XR17D15X)) {
1557                 int0 = serial_port_in(port, 0x80);
1558                 int1 = serial_port_in(port, 0x81);
1559                 int2 = serial_port_in(port, 0x82);
1560                 int3 = serial_port_in(port, 0x83);
1561         }
1562
1563         return ret;
1564 }
1565
1566 /*
1567  * This is the serial driver's interrupt routine.
1568  *
1569  * Arjan thinks the old way was overly complex, so it got simplified.
1570  * Alan disagrees, saying that need the complexity to handle the weird
1571  * nature of ISA shared interrupts.  (This is a special exception.)
1572  *
1573  * In order to handle ISA shared interrupts properly, we need to check
1574  * that all ports have been serviced, and therefore the ISA interrupt
1575  * line has been de-asserted.
1576  *
1577  * This means we need to loop through all ports. checking that they
1578  * don't have an interrupt pending.
1579  */
1580 static irqreturn_t serial8250_interrupt(int irq, void *dev_id)
1581 {
1582         struct irq_info *i = dev_id;
1583         struct list_head *l, *end = NULL;
1584         int pass_counter = 0, handled = 0;
1585
1586         DEBUG_INTR("serial8250_interrupt(%d)...", irq);
1587
1588         spin_lock(&i->lock);
1589
1590         l = i->head;
1591         do {
1592                 struct uart_8250_port *up;
1593                 struct uart_port *port;
1594
1595                 up = list_entry(l, struct uart_8250_port, list);
1596                 port = &up->port;
1597
1598                 if (port->handle_irq(port)) {
1599                         handled = 1;
1600                         end = NULL;
1601                 } else if (end == NULL)
1602                         end = l;
1603
1604                 l = l->next;
1605
1606                 if (l == i->head && pass_counter++ > PASS_LIMIT) {
1607                         /* If we hit this, we're dead. */
1608                         printk_ratelimited(KERN_ERR
1609                                 "serial8250: too much work for irq%d\n", irq);
1610                         break;
1611                 }
1612         } while (l != end);
1613
1614         spin_unlock(&i->lock);
1615
1616         DEBUG_INTR("end.\n");
1617
1618         return IRQ_RETVAL(handled);
1619 }
1620
1621 /*
1622  * To support ISA shared interrupts, we need to have one interrupt
1623  * handler that ensures that the IRQ line has been deasserted
1624  * before returning.  Failing to do this will result in the IRQ
1625  * line being stuck active, and, since ISA irqs are edge triggered,
1626  * no more IRQs will be seen.
1627  */
1628 static void serial_do_unlink(struct irq_info *i, struct uart_8250_port *up)
1629 {
1630         spin_lock_irq(&i->lock);
1631
1632         if (!list_empty(i->head)) {
1633                 if (i->head == &up->list)
1634                         i->head = i->head->next;
1635                 list_del(&up->list);
1636         } else {
1637                 BUG_ON(i->head != &up->list);
1638                 i->head = NULL;
1639         }
1640         spin_unlock_irq(&i->lock);
1641         /* List empty so throw away the hash node */
1642         if (i->head == NULL) {
1643                 hlist_del(&i->node);
1644                 kfree(i);
1645         }
1646 }
1647
1648 static int serial_link_irq_chain(struct uart_8250_port *up)
1649 {
1650         struct hlist_head *h;
1651         struct hlist_node *n;
1652         struct irq_info *i;
1653         int ret, irq_flags = up->port.flags & UPF_SHARE_IRQ ? IRQF_SHARED : 0;
1654
1655         mutex_lock(&hash_mutex);
1656
1657         h = &irq_lists[up->port.irq % NR_IRQ_HASH];
1658
1659         hlist_for_each(n, h) {
1660                 i = hlist_entry(n, struct irq_info, node);
1661                 if (i->irq == up->port.irq)
1662                         break;
1663         }
1664
1665         if (n == NULL) {
1666                 i = kzalloc(sizeof(struct irq_info), GFP_KERNEL);
1667                 if (i == NULL) {
1668                         mutex_unlock(&hash_mutex);
1669                         return -ENOMEM;
1670                 }
1671                 spin_lock_init(&i->lock);
1672                 i->irq = up->port.irq;
1673                 hlist_add_head(&i->node, h);
1674         }
1675         mutex_unlock(&hash_mutex);
1676
1677         spin_lock_irq(&i->lock);
1678
1679         if (i->head) {
1680                 list_add(&up->list, i->head);
1681                 spin_unlock_irq(&i->lock);
1682
1683                 ret = 0;
1684         } else {
1685                 INIT_LIST_HEAD(&up->list);
1686                 i->head = &up->list;
1687                 spin_unlock_irq(&i->lock);
1688                 irq_flags |= up->port.irqflags;
1689                 ret = request_irq(up->port.irq, serial8250_interrupt,
1690                                   irq_flags, "serial", i);
1691                 if (ret < 0)
1692                         serial_do_unlink(i, up);
1693         }
1694
1695         return ret;
1696 }
1697
1698 static void serial_unlink_irq_chain(struct uart_8250_port *up)
1699 {
1700         struct irq_info *i;
1701         struct hlist_node *n;
1702         struct hlist_head *h;
1703
1704         mutex_lock(&hash_mutex);
1705
1706         h = &irq_lists[up->port.irq % NR_IRQ_HASH];
1707
1708         hlist_for_each(n, h) {
1709                 i = hlist_entry(n, struct irq_info, node);
1710                 if (i->irq == up->port.irq)
1711                         break;
1712         }
1713
1714         BUG_ON(n == NULL);
1715         BUG_ON(i->head == NULL);
1716
1717         if (list_empty(i->head))
1718                 free_irq(up->port.irq, i);
1719
1720         serial_do_unlink(i, up);
1721         mutex_unlock(&hash_mutex);
1722 }
1723
1724 /*
1725  * This function is used to handle ports that do not have an
1726  * interrupt.  This doesn't work very well for 16450's, but gives
1727  * barely passable results for a 16550A.  (Although at the expense
1728  * of much CPU overhead).
1729  */
1730 static void serial8250_timeout(unsigned long data)
1731 {
1732         struct uart_8250_port *up = (struct uart_8250_port *)data;
1733
1734         up->port.handle_irq(&up->port);
1735         mod_timer(&up->timer, jiffies + uart_poll_timeout(&up->port));
1736 }
1737
1738 static void serial8250_backup_timeout(unsigned long data)
1739 {
1740         struct uart_8250_port *up = (struct uart_8250_port *)data;
1741         unsigned int iir, ier = 0, lsr;
1742         unsigned long flags;
1743
1744         spin_lock_irqsave(&up->port.lock, flags);
1745
1746         /*
1747          * Must disable interrupts or else we risk racing with the interrupt
1748          * based handler.
1749          */
1750         if (up->port.irq) {
1751                 ier = serial_in(up, UART_IER);
1752                 serial_out(up, UART_IER, 0);
1753         }
1754
1755         iir = serial_in(up, UART_IIR);
1756
1757         /*
1758          * This should be a safe test for anyone who doesn't trust the
1759          * IIR bits on their UART, but it's specifically designed for
1760          * the "Diva" UART used on the management processor on many HP
1761          * ia64 and parisc boxes.
1762          */
1763         lsr = serial_in(up, UART_LSR);
1764         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
1765         if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) &&
1766             (!uart_circ_empty(&up->port.state->xmit) || up->port.x_char) &&
1767             (lsr & UART_LSR_THRE)) {
1768                 iir &= ~(UART_IIR_ID | UART_IIR_NO_INT);
1769                 iir |= UART_IIR_THRI;
1770         }
1771
1772         if (!(iir & UART_IIR_NO_INT))
1773                 serial8250_tx_chars(up);
1774
1775         if (up->port.irq)
1776                 serial_out(up, UART_IER, ier);
1777
1778         spin_unlock_irqrestore(&up->port.lock, flags);
1779
1780         /* Standard timer interval plus 0.2s to keep the port running */
1781         mod_timer(&up->timer,
1782                 jiffies + uart_poll_timeout(&up->port) + HZ / 5);
1783 }
1784
1785 static unsigned int serial8250_tx_empty(struct uart_port *port)
1786 {
1787         struct uart_8250_port *up =
1788                 container_of(port, struct uart_8250_port, port);
1789         unsigned long flags;
1790         unsigned int lsr;
1791
1792         spin_lock_irqsave(&port->lock, flags);
1793         lsr = serial_port_in(port, UART_LSR);
1794         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
1795         spin_unlock_irqrestore(&port->lock, flags);
1796
1797         return (lsr & BOTH_EMPTY) == BOTH_EMPTY ? TIOCSER_TEMT : 0;
1798 }
1799
1800 static unsigned int serial8250_get_mctrl(struct uart_port *port)
1801 {
1802         struct uart_8250_port *up =
1803                 container_of(port, struct uart_8250_port, port);
1804         unsigned int status;
1805         unsigned int ret;
1806
1807         status = serial8250_modem_status(up);
1808
1809         ret = 0;
1810         if (status & UART_MSR_DCD)
1811                 ret |= TIOCM_CAR;
1812         if (status & UART_MSR_RI)
1813                 ret |= TIOCM_RNG;
1814         if (status & UART_MSR_DSR)
1815                 ret |= TIOCM_DSR;
1816         if (status & UART_MSR_CTS)
1817                 ret |= TIOCM_CTS;
1818         return ret;
1819 }
1820
1821 static void serial8250_set_mctrl(struct uart_port *port, unsigned int mctrl)
1822 {
1823         struct uart_8250_port *up =
1824                 container_of(port, struct uart_8250_port, port);
1825         unsigned char mcr = 0;
1826
1827         if (up->port.type == PORT_TEGRA) {
1828                 if (mctrl & TIOCM_RTS)
1829                         mcr |= UART_MCR_HW_RTS;
1830         } else {
1831                 if (mctrl & TIOCM_RTS)
1832                         mcr |= UART_MCR_RTS;
1833         }
1834         if (mctrl & TIOCM_DTR)
1835                 mcr |= UART_MCR_DTR;
1836         if (mctrl & TIOCM_OUT1)
1837                 mcr |= UART_MCR_OUT1;
1838         if (mctrl & TIOCM_OUT2)
1839                 mcr |= UART_MCR_OUT2;
1840         if (mctrl & TIOCM_LOOP)
1841                 mcr |= UART_MCR_LOOP;
1842
1843         mcr = (mcr & up->mcr_mask) | up->mcr_force | up->mcr;
1844
1845         serial_port_out(port, UART_MCR, mcr);
1846 }
1847
1848 static void serial8250_break_ctl(struct uart_port *port, int break_state)
1849 {
1850         struct uart_8250_port *up =
1851                 container_of(port, struct uart_8250_port, port);
1852         unsigned long flags;
1853
1854         spin_lock_irqsave(&port->lock, flags);
1855         if (break_state == -1)
1856                 up->lcr |= UART_LCR_SBC;
1857         else
1858                 up->lcr &= ~UART_LCR_SBC;
1859         serial_port_out(port, UART_LCR, up->lcr);
1860         spin_unlock_irqrestore(&port->lock, flags);
1861 }
1862
1863 /*
1864  *      Wait for transmitter & holding register to empty
1865  */
1866 static void wait_for_xmitr(struct uart_8250_port *up, int bits)
1867 {
1868         unsigned int status, tmout = 10000;
1869
1870         /* Wait up to 10ms for the character(s) to be sent. */
1871         for (;;) {
1872                 status = serial_in(up, UART_LSR);
1873
1874                 up->lsr_saved_flags |= status & LSR_SAVE_FLAGS;
1875
1876                 if ((status & bits) == bits)
1877                         break;
1878                 if (--tmout == 0)
1879                         break;
1880                 udelay(1);
1881         }
1882
1883         /* Wait up to 1s for flow control if necessary */
1884         if (up->port.flags & UPF_CONS_FLOW) {
1885                 unsigned int tmout;
1886                 for (tmout = 1000000; tmout; tmout--) {
1887                         unsigned int msr = serial_in(up, UART_MSR);
1888                         up->msr_saved_flags |= msr & MSR_SAVE_FLAGS;
1889                         if (msr & UART_MSR_CTS)
1890                                 break;
1891                         udelay(1);
1892                         touch_nmi_watchdog();
1893                 }
1894         }
1895 }
1896
1897 #ifdef CONFIG_CONSOLE_POLL
1898 /*
1899  * Console polling routines for writing and reading from the uart while
1900  * in an interrupt or debug context.
1901  */
1902
1903 static int serial8250_get_poll_char(struct uart_port *port)
1904 {
1905         unsigned char lsr = serial_port_in(port, UART_LSR);
1906
1907         if (!(lsr & UART_LSR_DR))
1908                 return NO_POLL_CHAR;
1909
1910         return serial_port_in(port, UART_RX);
1911 }
1912
1913
1914 static void serial8250_put_poll_char(struct uart_port *port,
1915                          unsigned char c)
1916 {
1917         unsigned int ier;
1918         struct uart_8250_port *up =
1919                 container_of(port, struct uart_8250_port, port);
1920
1921         /*
1922          *      First save the IER then disable the interrupts
1923          */
1924         ier = serial_port_in(port, UART_IER);
1925         if (up->capabilities & UART_CAP_UUE)
1926                 serial_port_out(port, UART_IER, UART_IER_UUE);
1927         else
1928                 serial_port_out(port, UART_IER, 0);
1929
1930         wait_for_xmitr(up, BOTH_EMPTY);
1931         /*
1932          *      Send the character out.
1933          *      If a LF, also do CR...
1934          */
1935         serial_port_out(port, UART_TX, c);
1936         if (c == 10) {
1937                 wait_for_xmitr(up, BOTH_EMPTY);
1938                 serial_port_out(port, UART_TX, 13);
1939         }
1940
1941         /*
1942          *      Finally, wait for transmitter to become empty
1943          *      and restore the IER
1944          */
1945         wait_for_xmitr(up, BOTH_EMPTY);
1946         serial_port_out(port, UART_IER, ier);
1947 }
1948
1949 #endif /* CONFIG_CONSOLE_POLL */
1950
1951 static int serial8250_startup(struct uart_port *port)
1952 {
1953         struct uart_8250_port *up =
1954                 container_of(port, struct uart_8250_port, port);
1955         unsigned long flags;
1956         unsigned char lsr, iir;
1957         int retval;
1958
1959         if (port->type == PORT_8250_CIR)
1960                 return -ENODEV;
1961
1962         if (!port->fifosize)
1963                 port->fifosize = uart_config[port->type].fifo_size;
1964         if (!up->tx_loadsz)
1965                 up->tx_loadsz = uart_config[port->type].tx_loadsz;
1966         if (!up->capabilities)
1967                 up->capabilities = uart_config[port->type].flags;
1968         up->mcr = 0;
1969
1970         if (port->iotype != up->cur_iotype)
1971                 set_io_from_upio(port);
1972
1973         if (port->type == PORT_16C950) {
1974                 /* Wake up and initialize UART */
1975                 up->acr = 0;
1976                 serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
1977                 serial_port_out(port, UART_EFR, UART_EFR_ECB);
1978                 serial_port_out(port, UART_IER, 0);
1979                 serial_port_out(port, UART_LCR, 0);
1980                 serial_icr_write(up, UART_CSR, 0); /* Reset the UART */
1981                 serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
1982                 serial_port_out(port, UART_EFR, UART_EFR_ECB);
1983                 serial_port_out(port, UART_LCR, 0);
1984         }
1985
1986 #ifdef CONFIG_SERIAL_8250_RSA
1987         /*
1988          * If this is an RSA port, see if we can kick it up to the
1989          * higher speed clock.
1990          */
1991         enable_rsa(up);
1992 #endif
1993
1994         /*
1995          * Clear the FIFO buffers and disable them.
1996          * (they will be reenabled in set_termios())
1997          */
1998         serial8250_clear_fifos(up);
1999
2000         /*
2001          * Clear the interrupt registers.
2002          */
2003         serial_port_in(port, UART_LSR);
2004         serial_port_in(port, UART_RX);
2005         serial_port_in(port, UART_IIR);
2006         serial_port_in(port, UART_MSR);
2007
2008         /*
2009          * At this point, there's no way the LSR could still be 0xff;
2010          * if it is, then bail out, because there's likely no UART
2011          * here.
2012          */
2013         if (!(port->flags & UPF_BUGGY_UART) &&
2014             (serial_port_in(port, UART_LSR) == 0xff)) {
2015                 printk_ratelimited(KERN_INFO "ttyS%d: LSR safety check engaged!\n",
2016                                    serial_index(port));
2017                 return -ENODEV;
2018         }
2019
2020         /*
2021          * For a XR16C850, we need to set the trigger levels
2022          */
2023         if (port->type == PORT_16850) {
2024                 unsigned char fctr;
2025
2026                 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
2027
2028                 fctr = serial_in(up, UART_FCTR) & ~(UART_FCTR_RX|UART_FCTR_TX);
2029                 serial_port_out(port, UART_FCTR,
2030                                 fctr | UART_FCTR_TRGD | UART_FCTR_RX);
2031                 serial_port_out(port, UART_TRG, UART_TRG_96);
2032                 serial_port_out(port, UART_FCTR,
2033                                 fctr | UART_FCTR_TRGD | UART_FCTR_TX);
2034                 serial_port_out(port, UART_TRG, UART_TRG_96);
2035
2036                 serial_port_out(port, UART_LCR, 0);
2037         }
2038
2039         if (port->irq) {
2040                 unsigned char iir1;
2041                 /*
2042                  * Test for UARTs that do not reassert THRE when the
2043                  * transmitter is idle and the interrupt has already
2044                  * been cleared.  Real 16550s should always reassert
2045                  * this interrupt whenever the transmitter is idle and
2046                  * the interrupt is enabled.  Delays are necessary to
2047                  * allow register changes to become visible.
2048                  */
2049                 spin_lock_irqsave(&port->lock, flags);
2050                 if (up->port.irqflags & IRQF_SHARED)
2051                         disable_irq_nosync(port->irq);
2052
2053                 wait_for_xmitr(up, UART_LSR_THRE);
2054                 serial_port_out_sync(port, UART_IER, UART_IER_THRI);
2055                 udelay(1); /* allow THRE to set */
2056                 iir1 = serial_port_in(port, UART_IIR);
2057                 serial_port_out(port, UART_IER, 0);
2058                 serial_port_out_sync(port, UART_IER, UART_IER_THRI);
2059                 udelay(1); /* allow a working UART time to re-assert THRE */
2060                 iir = serial_port_in(port, UART_IIR);
2061                 serial_port_out(port, UART_IER, 0);
2062
2063                 if (port->irqflags & IRQF_SHARED)
2064                         enable_irq(port->irq);
2065                 spin_unlock_irqrestore(&port->lock, flags);
2066
2067                 /*
2068                  * If the interrupt is not reasserted, or we otherwise
2069                  * don't trust the iir, setup a timer to kick the UART
2070                  * on a regular basis.
2071                  */
2072                 if ((!(iir1 & UART_IIR_NO_INT) && (iir & UART_IIR_NO_INT)) ||
2073                     up->port.flags & UPF_BUG_THRE) {
2074                         up->bugs |= UART_BUG_THRE;
2075                         pr_debug("ttyS%d - using backup timer\n",
2076                                  serial_index(port));
2077                 }
2078         }
2079
2080         /*
2081          * The above check will only give an accurate result the first time
2082          * the port is opened so this value needs to be preserved.
2083          */
2084         if (up->bugs & UART_BUG_THRE) {
2085                 up->timer.function = serial8250_backup_timeout;
2086                 up->timer.data = (unsigned long)up;
2087                 mod_timer(&up->timer, jiffies +
2088                         uart_poll_timeout(port) + HZ / 5);
2089         }
2090
2091         /*
2092          * If the "interrupt" for this port doesn't correspond with any
2093          * hardware interrupt, we use a timer-based system.  The original
2094          * driver used to do this with IRQ0.
2095          */
2096         if (!port->irq) {
2097                 up->timer.data = (unsigned long)up;
2098                 mod_timer(&up->timer, jiffies + uart_poll_timeout(port));
2099         } else {
2100                 retval = serial_link_irq_chain(up);
2101                 if (retval)
2102                         return retval;
2103         }
2104
2105         /*
2106          * Now, initialize the UART
2107          */
2108         serial_port_out(port, UART_LCR, UART_LCR_WLEN8);
2109
2110         spin_lock_irqsave(&port->lock, flags);
2111         if (up->port.flags & UPF_FOURPORT) {
2112                 if (!up->port.irq)
2113                         up->port.mctrl |= TIOCM_OUT1;
2114         } else
2115                 /*
2116                  * Most PC uarts need OUT2 raised to enable interrupts.
2117                  */
2118                 if (port->irq)
2119                         up->port.mctrl |= TIOCM_OUT2;
2120
2121         serial8250_set_mctrl(port, port->mctrl);
2122
2123         /* Serial over Lan (SoL) hack:
2124            Intel 8257x Gigabit ethernet chips have a
2125            16550 emulation, to be used for Serial Over Lan.
2126            Those chips take a longer time than a normal
2127            serial device to signalize that a transmission
2128            data was queued. Due to that, the above test generally
2129            fails. One solution would be to delay the reading of
2130            iir. However, this is not reliable, since the timeout
2131            is variable. So, let's just don't test if we receive
2132            TX irq. This way, we'll never enable UART_BUG_TXEN.
2133          */
2134         if (skip_txen_test || up->port.flags & UPF_NO_TXEN_TEST)
2135                 goto dont_test_tx_en;
2136
2137         /*
2138          * Do a quick test to see if we receive an
2139          * interrupt when we enable the TX irq.
2140          */
2141         serial_port_out(port, UART_IER, UART_IER_THRI);
2142         lsr = serial_port_in(port, UART_LSR);
2143         iir = serial_port_in(port, UART_IIR);
2144         serial_port_out(port, UART_IER, 0);
2145
2146         if (lsr & UART_LSR_TEMT && iir & UART_IIR_NO_INT) {
2147                 if (!(up->bugs & UART_BUG_TXEN)) {
2148                         up->bugs |= UART_BUG_TXEN;
2149                         pr_debug("ttyS%d - enabling bad tx status workarounds\n",
2150                                  serial_index(port));
2151                 }
2152         } else {
2153                 up->bugs &= ~UART_BUG_TXEN;
2154         }
2155
2156 dont_test_tx_en:
2157         spin_unlock_irqrestore(&port->lock, flags);
2158
2159         /*
2160          * Clear the interrupt registers again for luck, and clear the
2161          * saved flags to avoid getting false values from polling
2162          * routines or the previous session.
2163          */
2164         serial_port_in(port, UART_LSR);
2165         serial_port_in(port, UART_RX);
2166         serial_port_in(port, UART_IIR);
2167         serial_port_in(port, UART_MSR);
2168         up->lsr_saved_flags = 0;
2169         up->msr_saved_flags = 0;
2170
2171         /*
2172          * Request DMA channels for both RX and TX.
2173          */
2174         if (up->dma) {
2175                 retval = serial8250_request_dma(up);
2176                 if (retval) {
2177                         pr_warn_ratelimited("ttyS%d - failed to request DMA\n",
2178                                             serial_index(port));
2179                         up->dma = NULL;
2180                 }
2181         }
2182
2183         /*
2184          * Finally, enable interrupts.  Note: Modem status interrupts
2185          * are set via set_termios(), which will be occurring imminently
2186          * anyway, so we don't enable them here.
2187          */
2188         up->ier = UART_IER_RLSI | UART_IER_RDI;
2189         serial_port_out(port, UART_IER, up->ier);
2190
2191         if (port->flags & UPF_FOURPORT) {
2192                 unsigned int icp;
2193                 /*
2194                  * Enable interrupts on the AST Fourport board
2195                  */
2196                 icp = (port->iobase & 0xfe0) | 0x01f;
2197                 outb_p(0x80, icp);
2198                 inb_p(icp);
2199         }
2200
2201         return 0;
2202 }
2203
2204 static void serial8250_shutdown(struct uart_port *port)
2205 {
2206         struct uart_8250_port *up =
2207                 container_of(port, struct uart_8250_port, port);
2208         unsigned long flags;
2209
2210         /*
2211          * Disable interrupts from this port
2212          */
2213         up->ier = 0;
2214         serial_port_out(port, UART_IER, 0);
2215
2216         if (up->dma)
2217                 serial8250_release_dma(up);
2218
2219         spin_lock_irqsave(&port->lock, flags);
2220         if (port->flags & UPF_FOURPORT) {
2221                 /* reset interrupts on the AST Fourport board */
2222                 inb((port->iobase & 0xfe0) | 0x1f);
2223                 port->mctrl |= TIOCM_OUT1;
2224         } else
2225                 port->mctrl &= ~TIOCM_OUT2;
2226
2227         serial8250_set_mctrl(port, port->mctrl);
2228         spin_unlock_irqrestore(&port->lock, flags);
2229
2230         /*
2231          * Disable break condition and FIFOs
2232          */
2233         serial_port_out(port, UART_LCR,
2234                         serial_port_in(port, UART_LCR) & ~UART_LCR_SBC);
2235         serial8250_clear_fifos(up);
2236
2237 #ifdef CONFIG_SERIAL_8250_RSA
2238         /*
2239          * Reset the RSA board back to 115kbps compat mode.
2240          */
2241         disable_rsa(up);
2242 #endif
2243
2244         /*
2245          * Read data port to reset things, and then unlink from
2246          * the IRQ chain.
2247          */
2248         serial_port_in(port, UART_RX);
2249
2250         del_timer_sync(&up->timer);
2251         up->timer.function = serial8250_timeout;
2252         if (port->irq)
2253                 serial_unlink_irq_chain(up);
2254 }
2255
2256 static unsigned int serial8250_get_divisor(struct uart_port *port, unsigned int baud)
2257 {
2258         unsigned int quot;
2259
2260         /*
2261          * Handle magic divisors for baud rates above baud_base on
2262          * SMSC SuperIO chips.
2263          */
2264         if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
2265             baud == (port->uartclk/4))
2266                 quot = 0x8001;
2267         else if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
2268                  baud == (port->uartclk/8))
2269                 quot = 0x8002;
2270         else
2271                 quot = uart_get_divisor(port, baud);
2272
2273         return quot;
2274 }
2275
2276 void
2277 serial8250_do_set_termios(struct uart_port *port, struct ktermios *termios,
2278                           struct ktermios *old)
2279 {
2280         struct uart_8250_port *up =
2281                 container_of(port, struct uart_8250_port, port);
2282         unsigned char cval, fcr = 0;
2283         unsigned long flags;
2284         unsigned int baud, quot;
2285         int fifo_bug = 0;
2286
2287         switch (termios->c_cflag & CSIZE) {
2288         case CS5:
2289                 cval = UART_LCR_WLEN5;
2290                 break;
2291         case CS6:
2292                 cval = UART_LCR_WLEN6;
2293                 break;
2294         case CS7:
2295                 cval = UART_LCR_WLEN7;
2296                 break;
2297         default:
2298         case CS8:
2299                 cval = UART_LCR_WLEN8;
2300                 break;
2301         }
2302
2303         if (termios->c_cflag & CSTOPB)
2304                 cval |= UART_LCR_STOP;
2305         if (termios->c_cflag & PARENB) {
2306                 cval |= UART_LCR_PARITY;
2307                 if (up->bugs & UART_BUG_PARITY)
2308                         fifo_bug = 1;
2309         }
2310         if (!(termios->c_cflag & PARODD))
2311                 cval |= UART_LCR_EPAR;
2312 #ifdef CMSPAR
2313         if (termios->c_cflag & CMSPAR)
2314                 cval |= UART_LCR_SPAR;
2315 #endif
2316
2317         /*
2318          * Ask the core to calculate the divisor for us.
2319          */
2320         baud = uart_get_baud_rate(port, termios, old,
2321                                   port->uartclk / 16 / 0xffff,
2322                                   port->uartclk / 16);
2323         quot = serial8250_get_divisor(port, baud);
2324
2325         /*
2326          * Oxford Semi 952 rev B workaround
2327          */
2328         if (up->bugs & UART_BUG_QUOT && (quot & 0xff) == 0)
2329                 quot++;
2330
2331         if (up->capabilities & UART_CAP_FIFO && port->fifosize > 1) {
2332                 fcr = uart_config[port->type].fcr;
2333                 if (baud < 2400 || fifo_bug) {
2334                         fcr &= ~UART_FCR_TRIGGER_MASK;
2335                         fcr |= UART_FCR_TRIGGER_1;
2336                 }
2337         }
2338
2339         /*
2340          * MCR-based auto flow control.  When AFE is enabled, RTS will be
2341          * deasserted when the receive FIFO contains more characters than
2342          * the trigger, or the MCR RTS bit is cleared.  In the case where
2343          * the remote UART is not using CTS auto flow control, we must
2344          * have sufficient FIFO entries for the latency of the remote
2345          * UART to respond.  IOW, at least 32 bytes of FIFO.
2346          */
2347         if (up->capabilities & UART_CAP_AFE && port->fifosize >= 32) {
2348                 up->mcr &= ~UART_MCR_AFE;
2349                 if (termios->c_cflag & CRTSCTS)
2350                         up->mcr |= UART_MCR_AFE;
2351         }
2352
2353         /*
2354          * Ok, we're now changing the port state.  Do it with
2355          * interrupts disabled.
2356          */
2357         spin_lock_irqsave(&port->lock, flags);
2358
2359         /*
2360          * Update the per-port timeout.
2361          */
2362         uart_update_timeout(port, termios->c_cflag, baud);
2363
2364         port->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
2365         if (termios->c_iflag & INPCK)
2366                 port->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
2367         if (termios->c_iflag & (BRKINT | PARMRK))
2368                 port->read_status_mask |= UART_LSR_BI;
2369
2370         /*
2371          * Characteres to ignore
2372          */
2373         port->ignore_status_mask = 0;
2374         if (termios->c_iflag & IGNPAR)
2375                 port->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
2376         if (termios->c_iflag & IGNBRK) {
2377                 port->ignore_status_mask |= UART_LSR_BI;
2378                 /*
2379                  * If we're ignoring parity and break indicators,
2380                  * ignore overruns too (for real raw support).
2381                  */
2382                 if (termios->c_iflag & IGNPAR)
2383                         port->ignore_status_mask |= UART_LSR_OE;
2384         }
2385
2386         /*
2387          * ignore all characters if CREAD is not set
2388          */
2389         if ((termios->c_cflag & CREAD) == 0)
2390                 port->ignore_status_mask |= UART_LSR_DR;
2391
2392         /*
2393          * CTS flow control flag and modem status interrupts
2394          */
2395         up->ier &= ~UART_IER_MSI;
2396         if (!(up->bugs & UART_BUG_NOMSR) &&
2397                         UART_ENABLE_MS(&up->port, termios->c_cflag))
2398                 up->ier |= UART_IER_MSI;
2399         if (up->capabilities & UART_CAP_UUE)
2400                 up->ier |= UART_IER_UUE;
2401         if (up->capabilities & UART_CAP_RTOIE)
2402                 up->ier |= UART_IER_RTOIE;
2403
2404         serial_port_out(port, UART_IER, up->ier);
2405
2406         if (up->capabilities & UART_CAP_EFR) {
2407                 unsigned char efr = 0;
2408                 /*
2409                  * TI16C752/Startech hardware flow control.  FIXME:
2410                  * - TI16C752 requires control thresholds to be set.
2411                  * - UART_MCR_RTS is ineffective if auto-RTS mode is enabled.
2412                  */
2413                 if (termios->c_cflag & CRTSCTS)
2414                         efr |= UART_EFR_CTS;
2415
2416                 serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
2417                 if (port->flags & UPF_EXAR_EFR)
2418                         serial_port_out(port, UART_XR_EFR, efr);
2419                 else
2420                         serial_port_out(port, UART_EFR, efr);
2421         }
2422
2423         if (up->capabilities & UART_CAP_HW_CTSRTS) {
2424                 unsigned char mcr = serial_port_in(port, UART_MCR);
2425                 /*
2426                  * TEGRA UART core support the auto control of the RTS and CTS
2427                  * flow control.
2428                  */
2429                 if (termios->c_cflag & CRTSCTS)
2430                         mcr |= UART_MCR_HW_CTS;
2431                 else
2432                         mcr &= ~UART_MCR_HW_CTS;
2433                 serial_port_out(port, UART_MCR, mcr);
2434         }
2435
2436         /* Workaround to enable 115200 baud on OMAP1510 internal ports */
2437         if (is_omap1510_8250(up)) {
2438                 if (baud == 115200) {
2439                         quot = 1;
2440                         serial_port_out(port, UART_OMAP_OSC_12M_SEL, 1);
2441                 } else
2442                         serial_port_out(port, UART_OMAP_OSC_12M_SEL, 0);
2443         }
2444
2445         /*
2446          * For NatSemi, switch to bank 2 not bank 1, to avoid resetting EXCR2,
2447          * otherwise just set DLAB
2448          */
2449         if (up->capabilities & UART_NATSEMI)
2450                 serial_port_out(port, UART_LCR, 0xe0);
2451         else
2452                 serial_port_out(port, UART_LCR, cval | UART_LCR_DLAB);
2453
2454         serial_dl_write(up, quot);
2455
2456         /*
2457          * LCR DLAB must be set to enable 64-byte FIFO mode. If the FCR
2458          * is written without DLAB set, this mode will be disabled.
2459          */
2460         if (port->type == PORT_16750)
2461                 serial_port_out(port, UART_FCR, fcr);
2462
2463         serial_port_out(port, UART_LCR, cval);          /* reset DLAB */
2464         up->lcr = cval;                                 /* Save LCR */
2465         if (port->type != PORT_16750) {
2466                 /* emulated UARTs (Lucent Venus 167x) need two steps */
2467                 if (fcr & UART_FCR_ENABLE_FIFO)
2468                         serial_port_out(port, UART_FCR, UART_FCR_ENABLE_FIFO);
2469                 serial_port_out(port, UART_FCR, fcr);           /* set fcr */
2470         }
2471         serial8250_set_mctrl(port, port->mctrl);
2472         spin_unlock_irqrestore(&port->lock, flags);
2473         /* Don't rewrite B0 */
2474         if (tty_termios_baud_rate(termios))
2475                 tty_termios_encode_baud_rate(termios, baud, baud);
2476 }
2477 EXPORT_SYMBOL(serial8250_do_set_termios);
2478
2479 static void
2480 serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
2481                        struct ktermios *old)
2482 {
2483         if (port->set_termios)
2484                 port->set_termios(port, termios, old);
2485         else
2486                 serial8250_do_set_termios(port, termios, old);
2487 }
2488
2489 static void
2490 serial8250_set_ldisc(struct uart_port *port, int new)
2491 {
2492         if (new == N_PPS) {
2493                 port->flags |= UPF_HARDPPS_CD;
2494                 serial8250_enable_ms(port);
2495         } else
2496                 port->flags &= ~UPF_HARDPPS_CD;
2497 }
2498
2499
2500 void serial8250_do_pm(struct uart_port *port, unsigned int state,
2501                       unsigned int oldstate)
2502 {
2503         struct uart_8250_port *p =
2504                 container_of(port, struct uart_8250_port, port);
2505
2506         serial8250_set_sleep(p, state != 0);
2507 }
2508 EXPORT_SYMBOL(serial8250_do_pm);
2509
2510 static void
2511 serial8250_pm(struct uart_port *port, unsigned int state,
2512               unsigned int oldstate)
2513 {
2514         if (port->pm)
2515                 port->pm(port, state, oldstate);
2516         else
2517                 serial8250_do_pm(port, state, oldstate);
2518 }
2519
2520 static unsigned int serial8250_port_size(struct uart_8250_port *pt)
2521 {
2522         if (pt->port.iotype == UPIO_AU)
2523                 return 0x1000;
2524         if (is_omap1_8250(pt))
2525                 return 0x16 << pt->port.regshift;
2526
2527         return 8 << pt->port.regshift;
2528 }
2529
2530 /*
2531  * Resource handling.
2532  */
2533 static int serial8250_request_std_resource(struct uart_8250_port *up)
2534 {
2535         unsigned int size = serial8250_port_size(up);
2536         struct uart_port *port = &up->port;
2537         int ret = 0;
2538
2539         switch (port->iotype) {
2540         case UPIO_AU:
2541         case UPIO_TSI:
2542         case UPIO_MEM32:
2543         case UPIO_MEM:
2544                 if (!port->mapbase)
2545                         break;
2546
2547                 if (!request_mem_region(port->mapbase, size, "serial")) {
2548                         ret = -EBUSY;
2549                         break;
2550                 }
2551
2552                 if (port->flags & UPF_IOREMAP) {
2553                         port->membase = ioremap_nocache(port->mapbase, size);
2554                         if (!port->membase) {
2555                                 release_mem_region(port->mapbase, size);
2556                                 ret = -ENOMEM;
2557                         }
2558                 }
2559                 break;
2560
2561         case UPIO_HUB6:
2562         case UPIO_PORT:
2563                 if (!request_region(port->iobase, size, "serial"))
2564                         ret = -EBUSY;
2565                 break;
2566         }
2567         return ret;
2568 }
2569
2570 static void serial8250_release_std_resource(struct uart_8250_port *up)
2571 {
2572         unsigned int size = serial8250_port_size(up);
2573         struct uart_port *port = &up->port;
2574
2575         switch (port->iotype) {
2576         case UPIO_AU:
2577         case UPIO_TSI:
2578         case UPIO_MEM32:
2579         case UPIO_MEM:
2580                 if (!port->mapbase)
2581                         break;
2582
2583                 if (port->flags & UPF_IOREMAP) {
2584                         iounmap(port->membase);
2585                         port->membase = NULL;
2586                 }
2587
2588                 release_mem_region(port->mapbase, size);
2589                 break;
2590
2591         case UPIO_HUB6:
2592         case UPIO_PORT:
2593                 release_region(port->iobase, size);
2594                 break;
2595         }
2596 }
2597
2598 static int serial8250_request_rsa_resource(struct uart_8250_port *up)
2599 {
2600         unsigned long start = UART_RSA_BASE << up->port.regshift;
2601         unsigned int size = 8 << up->port.regshift;
2602         struct uart_port *port = &up->port;
2603         int ret = -EINVAL;
2604
2605         switch (port->iotype) {
2606         case UPIO_HUB6:
2607         case UPIO_PORT:
2608                 start += port->iobase;
2609                 if (request_region(start, size, "serial-rsa"))
2610                         ret = 0;
2611                 else
2612                         ret = -EBUSY;
2613                 break;
2614         }
2615
2616         return ret;
2617 }
2618
2619 static void serial8250_release_rsa_resource(struct uart_8250_port *up)
2620 {
2621         unsigned long offset = UART_RSA_BASE << up->port.regshift;
2622         unsigned int size = 8 << up->port.regshift;
2623         struct uart_port *port = &up->port;
2624
2625         switch (port->iotype) {
2626         case UPIO_HUB6:
2627         case UPIO_PORT:
2628                 release_region(port->iobase + offset, size);
2629                 break;
2630         }
2631 }
2632
2633 static void serial8250_release_port(struct uart_port *port)
2634 {
2635         struct uart_8250_port *up =
2636                 container_of(port, struct uart_8250_port, port);
2637
2638         serial8250_release_std_resource(up);
2639         if (port->type == PORT_RSA)
2640                 serial8250_release_rsa_resource(up);
2641 }
2642
2643 static int serial8250_request_port(struct uart_port *port)
2644 {
2645         struct uart_8250_port *up =
2646                 container_of(port, struct uart_8250_port, port);
2647         int ret;
2648
2649         if (port->type == PORT_8250_CIR)
2650                 return -ENODEV;
2651
2652         ret = serial8250_request_std_resource(up);
2653         if (ret == 0 && port->type == PORT_RSA) {
2654                 ret = serial8250_request_rsa_resource(up);
2655                 if (ret < 0)
2656                         serial8250_release_std_resource(up);
2657         }
2658
2659         return ret;
2660 }
2661
2662 static void serial8250_config_port(struct uart_port *port, int flags)
2663 {
2664         struct uart_8250_port *up =
2665                 container_of(port, struct uart_8250_port, port);
2666         int probeflags = PROBE_ANY;
2667         int ret;
2668
2669         if (port->type == PORT_8250_CIR)
2670                 return;
2671
2672         /*
2673          * Find the region that we can probe for.  This in turn
2674          * tells us whether we can probe for the type of port.
2675          */
2676         ret = serial8250_request_std_resource(up);
2677         if (ret < 0)
2678                 return;
2679
2680         ret = serial8250_request_rsa_resource(up);
2681         if (ret < 0)
2682                 probeflags &= ~PROBE_RSA;
2683
2684         if (port->iotype != up->cur_iotype)
2685                 set_io_from_upio(port);
2686
2687         if (flags & UART_CONFIG_TYPE)
2688                 autoconfig(up, probeflags);
2689
2690         /* if access method is AU, it is a 16550 with a quirk */
2691         if (port->type == PORT_16550A && port->iotype == UPIO_AU)
2692                 up->bugs |= UART_BUG_NOMSR;
2693
2694         if (port->type == PORT_TEGRA)
2695                 up->bugs |= UART_BUG_NOMSR;
2696
2697         if (port->type != PORT_UNKNOWN && flags & UART_CONFIG_IRQ)
2698                 autoconfig_irq(up);
2699
2700         if (port->type != PORT_RSA && probeflags & PROBE_RSA)
2701                 serial8250_release_rsa_resource(up);
2702         if (port->type == PORT_UNKNOWN)
2703                 serial8250_release_std_resource(up);
2704
2705         /* Fixme: probably not the best place for this */
2706         if ((port->type == PORT_XR17V35X) ||
2707            (port->type == PORT_XR17D15X))
2708                 port->handle_irq = exar_handle_irq;
2709 }
2710
2711 static int
2712 serial8250_verify_port(struct uart_port *port, struct serial_struct *ser)
2713 {
2714         if (ser->irq >= nr_irqs || ser->irq < 0 ||
2715             ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
2716             ser->type >= ARRAY_SIZE(uart_config) || ser->type == PORT_CIRRUS ||
2717             ser->type == PORT_STARTECH)
2718                 return -EINVAL;
2719         return 0;
2720 }
2721
2722 static const char *
2723 serial8250_type(struct uart_port *port)
2724 {
2725         int type = port->type;
2726
2727         if (type >= ARRAY_SIZE(uart_config))
2728                 type = 0;
2729         return uart_config[type].name;
2730 }
2731
2732 static struct uart_ops serial8250_pops = {
2733         .tx_empty       = serial8250_tx_empty,
2734         .set_mctrl      = serial8250_set_mctrl,
2735         .get_mctrl      = serial8250_get_mctrl,
2736         .stop_tx        = serial8250_stop_tx,
2737         .start_tx       = serial8250_start_tx,
2738         .stop_rx        = serial8250_stop_rx,
2739         .enable_ms      = serial8250_enable_ms,
2740         .break_ctl      = serial8250_break_ctl,
2741         .startup        = serial8250_startup,
2742         .shutdown       = serial8250_shutdown,
2743         .set_termios    = serial8250_set_termios,
2744         .set_ldisc      = serial8250_set_ldisc,
2745         .pm             = serial8250_pm,
2746         .type           = serial8250_type,
2747         .release_port   = serial8250_release_port,
2748         .request_port   = serial8250_request_port,
2749         .config_port    = serial8250_config_port,
2750         .verify_port    = serial8250_verify_port,
2751 #ifdef CONFIG_CONSOLE_POLL
2752         .poll_get_char = serial8250_get_poll_char,
2753         .poll_put_char = serial8250_put_poll_char,
2754 #endif
2755 };
2756
2757 static struct uart_8250_port serial8250_ports[UART_NR];
2758
2759 static void (*serial8250_isa_config)(int port, struct uart_port *up,
2760         unsigned short *capabilities);
2761
2762 void serial8250_set_isa_configurator(
2763         void (*v)(int port, struct uart_port *up, unsigned short *capabilities))
2764 {
2765         serial8250_isa_config = v;
2766 }
2767 EXPORT_SYMBOL(serial8250_set_isa_configurator);
2768
2769 static void __init serial8250_isa_init_ports(void)
2770 {
2771         struct uart_8250_port *up;
2772         static int first = 1;
2773         int i, irqflag = 0;
2774
2775         if (!first)
2776                 return;
2777         first = 0;
2778
2779         if (nr_uarts > UART_NR)
2780                 nr_uarts = UART_NR;
2781
2782         for (i = 0; i < nr_uarts; i++) {
2783                 struct uart_8250_port *up = &serial8250_ports[i];
2784                 struct uart_port *port = &up->port;
2785
2786                 port->line = i;
2787                 spin_lock_init(&port->lock);
2788
2789                 init_timer(&up->timer);
2790                 up->timer.function = serial8250_timeout;
2791                 up->cur_iotype = 0xFF;
2792
2793                 /*
2794                  * ALPHA_KLUDGE_MCR needs to be killed.
2795                  */
2796                 up->mcr_mask = ~ALPHA_KLUDGE_MCR;
2797                 up->mcr_force = ALPHA_KLUDGE_MCR;
2798
2799                 port->ops = &serial8250_pops;
2800         }
2801
2802         if (share_irqs)
2803                 irqflag = IRQF_SHARED;
2804
2805         for (i = 0, up = serial8250_ports;
2806              i < ARRAY_SIZE(old_serial_port) && i < nr_uarts;
2807              i++, up++) {
2808                 struct uart_port *port = &up->port;
2809
2810                 port->iobase   = old_serial_port[i].port;
2811                 port->irq      = irq_canonicalize(old_serial_port[i].irq);
2812                 port->irqflags = old_serial_port[i].irqflags;
2813                 port->uartclk  = old_serial_port[i].baud_base * 16;
2814                 port->flags    = old_serial_port[i].flags;
2815                 port->hub6     = old_serial_port[i].hub6;
2816                 port->membase  = old_serial_port[i].iomem_base;
2817                 port->iotype   = old_serial_port[i].io_type;
2818                 port->regshift = old_serial_port[i].iomem_reg_shift;
2819                 set_io_from_upio(port);
2820                 port->irqflags |= irqflag;
2821                 if (serial8250_isa_config != NULL)
2822                         serial8250_isa_config(i, &up->port, &up->capabilities);
2823
2824         }
2825 }
2826
2827 static void
2828 serial8250_init_fixed_type_port(struct uart_8250_port *up, unsigned int type)
2829 {
2830         up->port.type = type;
2831         if (!up->port.fifosize)
2832                 up->port.fifosize = uart_config[type].fifo_size;
2833         if (!up->tx_loadsz)
2834                 up->tx_loadsz = uart_config[type].tx_loadsz;
2835         if (!up->capabilities)
2836                 up->capabilities = uart_config[type].flags;
2837 }
2838
2839 static void __init
2840 serial8250_register_ports(struct uart_driver *drv, struct device *dev)
2841 {
2842         int i;
2843
2844         for (i = 0; i < nr_uarts; i++) {
2845                 struct uart_8250_port *up = &serial8250_ports[i];
2846
2847                 if (up->port.dev)
2848                         continue;
2849
2850                 up->port.dev = dev;
2851
2852                 if (up->port.flags & UPF_FIXED_TYPE)
2853                         serial8250_init_fixed_type_port(up, up->port.type);
2854
2855                 uart_add_one_port(drv, &up->port);
2856         }
2857 }
2858
2859 #ifdef CONFIG_SERIAL_8250_CONSOLE
2860
2861 static void serial8250_console_putchar(struct uart_port *port, int ch)
2862 {
2863         struct uart_8250_port *up =
2864                 container_of(port, struct uart_8250_port, port);
2865
2866         wait_for_xmitr(up, UART_LSR_THRE);
2867         serial_port_out(port, UART_TX, ch);
2868 }
2869
2870 /*
2871  *      Print a string to the serial port trying not to disturb
2872  *      any possible real use of the port...
2873  *
2874  *      The console_lock must be held when we get here.
2875  */
2876 static void
2877 serial8250_console_write(struct console *co, const char *s, unsigned int count)
2878 {
2879         struct uart_8250_port *up = &serial8250_ports[co->index];
2880         struct uart_port *port = &up->port;
2881         unsigned long flags;
2882         unsigned int ier;
2883         int locked = 1;
2884
2885         touch_nmi_watchdog();
2886
2887         local_irq_save(flags);
2888         if (port->sysrq) {
2889                 /* serial8250_handle_irq() already took the lock */
2890                 locked = 0;
2891         } else if (oops_in_progress) {
2892                 locked = spin_trylock(&port->lock);
2893         } else
2894                 spin_lock(&port->lock);
2895
2896         /*
2897          *      First save the IER then disable the interrupts
2898          */
2899         ier = serial_port_in(port, UART_IER);
2900
2901         if (up->capabilities & UART_CAP_UUE)
2902                 serial_port_out(port, UART_IER, UART_IER_UUE);
2903         else
2904                 serial_port_out(port, UART_IER, 0);
2905
2906         uart_console_write(port, s, count, serial8250_console_putchar);
2907
2908         /*
2909          *      Finally, wait for transmitter to become empty
2910          *      and restore the IER
2911          */
2912         wait_for_xmitr(up, BOTH_EMPTY);
2913         serial_port_out(port, UART_IER, ier);
2914
2915         /*
2916          *      The receive handling will happen properly because the
2917          *      receive ready bit will still be set; it is not cleared
2918          *      on read.  However, modem control will not, we must
2919          *      call it if we have saved something in the saved flags
2920          *      while processing with interrupts off.
2921          */
2922         if (up->msr_saved_flags)
2923                 serial8250_modem_status(up);
2924
2925         if (locked)
2926                 spin_unlock(&port->lock);
2927         local_irq_restore(flags);
2928 }
2929
2930 static int __init serial8250_console_setup(struct console *co, char *options)
2931 {
2932         struct uart_port *port;
2933         int baud = 9600;
2934         int bits = 8;
2935         int parity = 'n';
2936         int flow = 'n';
2937
2938         /*
2939          * Check whether an invalid uart number has been specified, and
2940          * if so, search for the first available port that does have
2941          * console support.
2942          */
2943         if (co->index >= nr_uarts)
2944                 co->index = 0;
2945         port = &serial8250_ports[co->index].port;
2946         if (!port->iobase && !port->membase)
2947                 return -ENODEV;
2948
2949         if (options)
2950                 uart_parse_options(options, &baud, &parity, &bits, &flow);
2951
2952         return uart_set_options(port, co, baud, parity, bits, flow);
2953 }
2954
2955 static int serial8250_console_early_setup(void)
2956 {
2957         return serial8250_find_port_for_earlycon();
2958 }
2959
2960 static struct console serial8250_console = {
2961         .name           = "ttyS",
2962         .write          = serial8250_console_write,
2963         .device         = uart_console_device,
2964         .setup          = serial8250_console_setup,
2965         .early_setup    = serial8250_console_early_setup,
2966         .flags          = CON_PRINTBUFFER | CON_ANYTIME,
2967         .index          = -1,
2968         .data           = &serial8250_reg,
2969 };
2970
2971 static int __init serial8250_console_init(void)
2972 {
2973         serial8250_isa_init_ports();
2974         register_console(&serial8250_console);
2975         return 0;
2976 }
2977 console_initcall(serial8250_console_init);
2978
2979 int serial8250_find_port(struct uart_port *p)
2980 {
2981         int line;
2982         struct uart_port *port;
2983
2984         for (line = 0; line < nr_uarts; line++) {
2985                 port = &serial8250_ports[line].port;
2986                 if (uart_match_port(p, port))
2987                         return line;
2988         }
2989         return -ENODEV;
2990 }
2991
2992 #define SERIAL8250_CONSOLE      &serial8250_console
2993 #else
2994 #define SERIAL8250_CONSOLE      NULL
2995 #endif
2996
2997 static struct uart_driver serial8250_reg = {
2998         .owner                  = THIS_MODULE,
2999         .driver_name            = "serial",
3000         .dev_name               = "ttyS",
3001         .major                  = TTY_MAJOR,
3002         .minor                  = 64,
3003         .cons                   = SERIAL8250_CONSOLE,
3004 };
3005
3006 /*
3007  * early_serial_setup - early registration for 8250 ports
3008  *
3009  * Setup an 8250 port structure prior to console initialisation.  Use
3010  * after console initialisation will cause undefined behaviour.
3011  */
3012 int __init early_serial_setup(struct uart_port *port)
3013 {
3014         struct uart_port *p;
3015
3016         if (port->line >= ARRAY_SIZE(serial8250_ports))
3017                 return -ENODEV;
3018
3019         serial8250_isa_init_ports();
3020         p = &serial8250_ports[port->line].port;
3021         p->iobase       = port->iobase;
3022         p->membase      = port->membase;
3023         p->irq          = port->irq;
3024         p->irqflags     = port->irqflags;
3025         p->uartclk      = port->uartclk;
3026         p->fifosize     = port->fifosize;
3027         p->regshift     = port->regshift;
3028         p->iotype       = port->iotype;
3029         p->flags        = port->flags;
3030         p->mapbase      = port->mapbase;
3031         p->private_data = port->private_data;
3032         p->type         = port->type;
3033         p->line         = port->line;
3034
3035         set_io_from_upio(p);
3036         if (port->serial_in)
3037                 p->serial_in = port->serial_in;
3038         if (port->serial_out)
3039                 p->serial_out = port->serial_out;
3040         if (port->handle_irq)
3041                 p->handle_irq = port->handle_irq;
3042         else
3043                 p->handle_irq = serial8250_default_handle_irq;
3044
3045         return 0;
3046 }
3047
3048 /**
3049  *      serial8250_suspend_port - suspend one serial port
3050  *      @line:  serial line number
3051  *
3052  *      Suspend one serial port.
3053  */
3054 void serial8250_suspend_port(int line)
3055 {
3056         uart_suspend_port(&serial8250_reg, &serial8250_ports[line].port);
3057 }
3058
3059 /**
3060  *      serial8250_resume_port - resume one serial port
3061  *      @line:  serial line number
3062  *
3063  *      Resume one serial port.
3064  */
3065 void serial8250_resume_port(int line)
3066 {
3067         struct uart_8250_port *up = &serial8250_ports[line];
3068         struct uart_port *port = &up->port;
3069
3070         if (up->capabilities & UART_NATSEMI) {
3071                 /* Ensure it's still in high speed mode */
3072                 serial_port_out(port, UART_LCR, 0xE0);
3073
3074                 ns16550a_goto_highspeed(up);
3075
3076                 serial_port_out(port, UART_LCR, 0);
3077                 port->uartclk = 921600*16;
3078         }
3079         uart_resume_port(&serial8250_reg, port);
3080 }
3081
3082 /*
3083  * Register a set of serial devices attached to a platform device.  The
3084  * list is terminated with a zero flags entry, which means we expect
3085  * all entries to have at least UPF_BOOT_AUTOCONF set.
3086  */
3087 static int serial8250_probe(struct platform_device *dev)
3088 {
3089         struct plat_serial8250_port *p = dev->dev.platform_data;
3090         struct uart_8250_port uart;
3091         int ret, i, irqflag = 0;
3092
3093         memset(&uart, 0, sizeof(uart));
3094
3095         if (share_irqs)
3096                 irqflag = IRQF_SHARED;
3097
3098         for (i = 0; p && p->flags != 0; p++, i++) {
3099                 uart.port.iobase        = p->iobase;
3100                 uart.port.membase       = p->membase;
3101                 uart.port.irq           = p->irq;
3102                 uart.port.irqflags      = p->irqflags;
3103                 uart.port.uartclk       = p->uartclk;
3104                 uart.port.regshift      = p->regshift;
3105                 uart.port.iotype        = p->iotype;
3106                 uart.port.flags         = p->flags;
3107                 uart.port.mapbase       = p->mapbase;
3108                 uart.port.hub6          = p->hub6;
3109                 uart.port.private_data  = p->private_data;
3110                 uart.port.type          = p->type;
3111                 uart.port.serial_in     = p->serial_in;
3112                 uart.port.serial_out    = p->serial_out;
3113                 uart.port.handle_irq    = p->handle_irq;
3114                 uart.port.handle_break  = p->handle_break;
3115                 uart.port.set_termios   = p->set_termios;
3116                 uart.port.pm            = p->pm;
3117                 uart.port.dev           = &dev->dev;
3118                 uart.port.irqflags      |= irqflag;
3119                 ret = serial8250_register_8250_port(&uart);
3120                 if (ret < 0) {
3121                         dev_err(&dev->dev, "unable to register port at index %d "
3122                                 "(IO%lx MEM%llx IRQ%d): %d\n", i,
3123                                 p->iobase, (unsigned long long)p->mapbase,
3124                                 p->irq, ret);
3125                 }
3126         }
3127         return 0;
3128 }
3129
3130 /*
3131  * Remove serial ports registered against a platform device.
3132  */
3133 static int serial8250_remove(struct platform_device *dev)
3134 {
3135         int i;
3136
3137         for (i = 0; i < nr_uarts; i++) {
3138                 struct uart_8250_port *up = &serial8250_ports[i];
3139
3140                 if (up->port.dev == &dev->dev)
3141                         serial8250_unregister_port(i);
3142         }
3143         return 0;
3144 }
3145
3146 static int serial8250_suspend(struct platform_device *dev, pm_message_t state)
3147 {
3148         int i;
3149
3150         for (i = 0; i < UART_NR; i++) {
3151                 struct uart_8250_port *up = &serial8250_ports[i];
3152
3153                 if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
3154                         uart_suspend_port(&serial8250_reg, &up->port);
3155         }
3156
3157         return 0;
3158 }
3159
3160 static int serial8250_resume(struct platform_device *dev)
3161 {
3162         int i;
3163
3164         for (i = 0; i < UART_NR; i++) {
3165                 struct uart_8250_port *up = &serial8250_ports[i];
3166
3167                 if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
3168                         serial8250_resume_port(i);
3169         }
3170
3171         return 0;
3172 }
3173
3174 static struct platform_driver serial8250_isa_driver = {
3175         .probe          = serial8250_probe,
3176         .remove         = serial8250_remove,
3177         .suspend        = serial8250_suspend,
3178         .resume         = serial8250_resume,
3179         .driver         = {
3180                 .name   = "serial8250",
3181                 .owner  = THIS_MODULE,
3182         },
3183 };
3184
3185 /*
3186  * This "device" covers _all_ ISA 8250-compatible serial devices listed
3187  * in the table in include/asm/serial.h
3188  */
3189 static struct platform_device *serial8250_isa_devs;
3190
3191 /*
3192  * serial8250_register_8250_port and serial8250_unregister_port allows for
3193  * 16x50 serial ports to be configured at run-time, to support PCMCIA
3194  * modems and PCI multiport cards.
3195  */
3196 static DEFINE_MUTEX(serial_mutex);
3197
3198 static struct uart_8250_port *serial8250_find_match_or_unused(struct uart_port *port)
3199 {
3200         int i;
3201
3202         /*
3203          * First, find a port entry which matches.
3204          */
3205         for (i = 0; i < nr_uarts; i++)
3206                 if (uart_match_port(&serial8250_ports[i].port, port))
3207                         return &serial8250_ports[i];
3208
3209         /*
3210          * We didn't find a matching entry, so look for the first
3211          * free entry.  We look for one which hasn't been previously
3212          * used (indicated by zero iobase).
3213          */
3214         for (i = 0; i < nr_uarts; i++)
3215                 if (serial8250_ports[i].port.type == PORT_UNKNOWN &&
3216                     serial8250_ports[i].port.iobase == 0)
3217                         return &serial8250_ports[i];
3218
3219         /*
3220          * That also failed.  Last resort is to find any entry which
3221          * doesn't have a real port associated with it.
3222          */
3223         for (i = 0; i < nr_uarts; i++)
3224                 if (serial8250_ports[i].port.type == PORT_UNKNOWN)
3225                         return &serial8250_ports[i];
3226
3227         return NULL;
3228 }
3229
3230 /**
3231  *      serial8250_register_8250_port - register a serial port
3232  *      @up: serial port template
3233  *
3234  *      Configure the serial port specified by the request. If the
3235  *      port exists and is in use, it is hung up and unregistered
3236  *      first.
3237  *
3238  *      The port is then probed and if necessary the IRQ is autodetected
3239  *      If this fails an error is returned.
3240  *
3241  *      On success the port is ready to use and the line number is returned.
3242  */
3243 int serial8250_register_8250_port(struct uart_8250_port *up)
3244 {
3245         struct uart_8250_port *uart;
3246         int ret = -ENOSPC;
3247
3248         if (up->port.uartclk == 0)
3249                 return -EINVAL;
3250
3251         mutex_lock(&serial_mutex);
3252
3253         uart = serial8250_find_match_or_unused(&up->port);
3254         if (uart && uart->port.type != PORT_8250_CIR) {
3255                 if (uart->port.dev)
3256                         uart_remove_one_port(&serial8250_reg, &uart->port);
3257
3258                 uart->port.iobase       = up->port.iobase;
3259                 uart->port.membase      = up->port.membase;
3260                 uart->port.irq          = up->port.irq;
3261                 uart->port.irqflags     = up->port.irqflags;
3262                 uart->port.uartclk      = up->port.uartclk;
3263                 uart->port.fifosize     = up->port.fifosize;
3264                 uart->port.regshift     = up->port.regshift;
3265                 uart->port.iotype       = up->port.iotype;
3266                 uart->port.flags        = up->port.flags | UPF_BOOT_AUTOCONF;
3267                 uart->bugs              = up->bugs;
3268                 uart->port.mapbase      = up->port.mapbase;
3269                 uart->port.private_data = up->port.private_data;
3270                 uart->port.fifosize     = up->port.fifosize;
3271                 uart->tx_loadsz         = up->tx_loadsz;
3272                 uart->capabilities      = up->capabilities;
3273
3274                 /* Take tx_loadsz from fifosize if it wasn't set separately */
3275                 if (uart->port.fifosize && !uart->tx_loadsz)
3276                         uart->tx_loadsz = uart->port.fifosize;
3277
3278                 if (up->port.dev)
3279                         uart->port.dev = up->port.dev;
3280
3281                 if (up->port.flags & UPF_FIXED_TYPE)
3282                         serial8250_init_fixed_type_port(uart, up->port.type);
3283
3284                 set_io_from_upio(&uart->port);
3285                 /* Possibly override default I/O functions.  */
3286                 if (up->port.serial_in)
3287                         uart->port.serial_in = up->port.serial_in;
3288                 if (up->port.serial_out)
3289                         uart->port.serial_out = up->port.serial_out;
3290                 if (up->port.handle_irq)
3291                         uart->port.handle_irq = up->port.handle_irq;
3292                 /*  Possibly override set_termios call */
3293                 if (up->port.set_termios)
3294                         uart->port.set_termios = up->port.set_termios;
3295                 if (up->port.pm)
3296                         uart->port.pm = up->port.pm;
3297                 if (up->port.handle_break)
3298                         uart->port.handle_break = up->port.handle_break;
3299                 if (up->dl_read)
3300                         uart->dl_read = up->dl_read;
3301                 if (up->dl_write)
3302                         uart->dl_write = up->dl_write;
3303                 if (up->dma)
3304                         uart->dma = up->dma;
3305
3306                 if (serial8250_isa_config != NULL)
3307                         serial8250_isa_config(0, &uart->port,
3308                                         &uart->capabilities);
3309
3310                 ret = uart_add_one_port(&serial8250_reg, &uart->port);
3311                 if (ret == 0)
3312                         ret = uart->port.line;
3313         }
3314         mutex_unlock(&serial_mutex);
3315
3316         return ret;
3317 }
3318 EXPORT_SYMBOL(serial8250_register_8250_port);
3319
3320 /**
3321  *      serial8250_unregister_port - remove a 16x50 serial port at runtime
3322  *      @line: serial line number
3323  *
3324  *      Remove one serial port.  This may not be called from interrupt
3325  *      context.  We hand the port back to the our control.
3326  */
3327 void serial8250_unregister_port(int line)
3328 {
3329         struct uart_8250_port *uart = &serial8250_ports[line];
3330
3331         mutex_lock(&serial_mutex);
3332         uart_remove_one_port(&serial8250_reg, &uart->port);
3333         if (serial8250_isa_devs) {
3334                 uart->port.flags &= ~UPF_BOOT_AUTOCONF;
3335                 uart->port.type = PORT_UNKNOWN;
3336                 uart->port.dev = &serial8250_isa_devs->dev;
3337                 uart->capabilities = uart_config[uart->port.type].flags;
3338                 uart_add_one_port(&serial8250_reg, &uart->port);
3339         } else {
3340                 uart->port.dev = NULL;
3341         }
3342         mutex_unlock(&serial_mutex);
3343 }
3344 EXPORT_SYMBOL(serial8250_unregister_port);
3345
3346 static int __init serial8250_init(void)
3347 {
3348         int ret;
3349
3350         serial8250_isa_init_ports();
3351
3352         printk(KERN_INFO "Serial: 8250/16550 driver, "
3353                 "%d ports, IRQ sharing %sabled\n", nr_uarts,
3354                 share_irqs ? "en" : "dis");
3355
3356 #ifdef CONFIG_SPARC
3357         ret = sunserial_register_minors(&serial8250_reg, UART_NR);
3358 #else
3359         serial8250_reg.nr = UART_NR;
3360         ret = uart_register_driver(&serial8250_reg);
3361 #endif
3362         if (ret)
3363                 goto out;
3364
3365         ret = serial8250_pnp_init();
3366         if (ret)
3367                 goto unreg_uart_drv;
3368
3369         serial8250_isa_devs = platform_device_alloc("serial8250",
3370                                                     PLAT8250_DEV_LEGACY);
3371         if (!serial8250_isa_devs) {
3372                 ret = -ENOMEM;
3373                 goto unreg_pnp;
3374         }
3375
3376         ret = platform_device_add(serial8250_isa_devs);
3377         if (ret)
3378                 goto put_dev;
3379
3380         serial8250_register_ports(&serial8250_reg, &serial8250_isa_devs->dev);
3381
3382         ret = platform_driver_register(&serial8250_isa_driver);
3383         if (ret == 0)
3384                 goto out;
3385
3386         platform_device_del(serial8250_isa_devs);
3387 put_dev:
3388         platform_device_put(serial8250_isa_devs);
3389 unreg_pnp:
3390         serial8250_pnp_exit();
3391 unreg_uart_drv:
3392 #ifdef CONFIG_SPARC
3393         sunserial_unregister_minors(&serial8250_reg, UART_NR);
3394 #else
3395         uart_unregister_driver(&serial8250_reg);
3396 #endif
3397 out:
3398         return ret;
3399 }
3400
3401 #ifdef MODULE
3402 static void __exit serial8250_exit(void)
3403 {
3404         struct platform_device *isa_dev = serial8250_isa_devs;
3405
3406         /*
3407          * This tells serial8250_unregister_port() not to re-register
3408          * the ports (thereby making serial8250_isa_driver permanently
3409          * in use.)
3410          */
3411         serial8250_isa_devs = NULL;
3412
3413         platform_driver_unregister(&serial8250_isa_driver);
3414         platform_device_unregister(isa_dev);
3415
3416         serial8250_pnp_exit();
3417
3418 #ifdef CONFIG_SPARC
3419         sunserial_unregister_minors(&serial8250_reg, UART_NR);
3420 #else
3421         uart_unregister_driver(&serial8250_reg);
3422 #endif
3423 }
3424
3425 module_init(serial8250_init);
3426 module_exit(serial8250_exit);
3427 #else
3428 postcore_initcall(serial8250_init);
3429 #endif
3430
3431 EXPORT_SYMBOL(serial8250_suspend_port);
3432 EXPORT_SYMBOL(serial8250_resume_port);
3433
3434 MODULE_LICENSE("GPL");
3435 MODULE_DESCRIPTION("Generic 8250/16x50 serial driver");
3436
3437 module_param(share_irqs, uint, 0644);
3438 MODULE_PARM_DESC(share_irqs, "Share IRQs with other non-8250/16x50 devices"
3439         " (unsafe)");
3440
3441 module_param(nr_uarts, uint, 0644);
3442 MODULE_PARM_DESC(nr_uarts, "Maximum number of UARTs supported. (1-" __MODULE_STRING(CONFIG_SERIAL_8250_NR_UARTS) ")");
3443
3444 module_param(skip_txen_test, uint, 0644);
3445 MODULE_PARM_DESC(skip_txen_test, "Skip checking for the TXEN bug at init time");
3446
3447 #ifdef CONFIG_SERIAL_8250_RSA
3448 module_param_array(probe_rsa, ulong, &probe_rsa_count, 0444);
3449 MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA");
3450 #endif
3451 MODULE_ALIAS_CHARDEV_MAJOR(TTY_MAJOR);
3452
3453 #ifdef CONFIG_SERIAL_8250_DEPRECATED_OPTIONS
3454 #ifndef MODULE
3455 /* This module was renamed to 8250_core in 3.7.  Keep the old "8250" name
3456  * working as well for the module options so we don't break people.  We
3457  * need to keep the names identical and the convenient macros will happily
3458  * refuse to let us do that by failing the build with redefinition errors
3459  * of global variables.  So we stick them inside a dummy function to avoid
3460  * those conflicts.  The options still get parsed, and the redefined
3461  * MODULE_PARAM_PREFIX lets us keep the "8250." syntax alive.
3462  *
3463  * This is hacky.  I'm sorry.
3464  */
3465 static void __used s8250_options(void)
3466 {
3467 #undef MODULE_PARAM_PREFIX
3468 #define MODULE_PARAM_PREFIX "8250_core."
3469
3470         module_param_cb(share_irqs, &param_ops_uint, &share_irqs, 0644);
3471         module_param_cb(nr_uarts, &param_ops_uint, &nr_uarts, 0644);
3472         module_param_cb(skip_txen_test, &param_ops_uint, &skip_txen_test, 0644);
3473 #ifdef CONFIG_SERIAL_8250_RSA
3474         __module_param_call(MODULE_PARAM_PREFIX, probe_rsa,
3475                 &param_array_ops, .arr = &__param_arr_probe_rsa,
3476                 0444, -1);
3477 #endif
3478 }
3479 #else
3480 MODULE_ALIAS("8250_core");
3481 #endif
3482 #endif