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