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