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