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