projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'v3.12'
[deliverable/linux.git] / drivers / tty / serial / m32r_sio.c
1 /*
2 * m32r_sio.c
3 *
4 * Driver for M32R serial ports
5 *
6 * Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
7 * Based on drivers/serial/8250.c.
8 *
9 * Copyright (C) 2001 Russell King.
10 * Copyright (C) 2004 Hirokazu Takata <takata at linux-m32r.org>
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 */
17
18 /*
19 * A note about mapbase / membase
20 *
21 * mapbase is the physical address of the IO port. Currently, we don't
22 * support this very well, and it may well be dropped from this driver
23 * in future. As such, mapbase should be NULL.
24 *
25 * membase is an 'ioremapped' cookie. This is compatible with the old
26 * serial.c driver, and is currently the preferred form.
27 */
28
29 #if defined(CONFIG_SERIAL_M32R_SIO_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
30 #define SUPPORT_SYSRQ
31 #endif
32
33 #include <linux/module.h>
34 #include <linux/tty.h>
35 #include <linux/tty_flip.h>
36 #include <linux/ioport.h>
37 #include <linux/init.h>
38 #include <linux/console.h>
39 #include <linux/sysrq.h>
40 #include <linux/serial.h>
41 #include <linux/delay.h>
42
43 #include <asm/m32r.h>
44 #include <asm/io.h>
45 #include <asm/irq.h>
46
47 #define BAUD_RATE 115200
48
49 #include <linux/serial_core.h>
50 #include "m32r_sio.h"
51 #include "m32r_sio_reg.h"
52
53 /*
54 * Debugging.
55 */
56 #if 0
57 #define DEBUG_AUTOCONF(fmt...) printk(fmt)
58 #else
59 #define DEBUG_AUTOCONF(fmt...) do { } while (0)
60 #endif
61
62 #if 0
63 #define DEBUG_INTR(fmt...) printk(fmt)
64 #else
65 #define DEBUG_INTR(fmt...) do { } while (0)
66 #endif
67
68 #define PASS_LIMIT 256
69
70 #define BASE_BAUD 115200
71
72 /* Standard COM flags */
73 #define STD_COM_FLAGS (UPF_BOOT_AUTOCONF | UPF_SKIP_TEST)
74
75 /*
76 * SERIAL_PORT_DFNS tells us about built-in ports that have no
77 * standard enumeration mechanism. Platforms that can find all
78 * serial ports via mechanisms like ACPI or PCI need not supply it.
79 */
80 #if defined(CONFIG_PLAT_USRV)
81
82 #define SERIAL_PORT_DFNS \
83 /* UART CLK PORT IRQ FLAGS */ \
84 { 0, BASE_BAUD, 0x3F8, PLD_IRQ_UART0, STD_COM_FLAGS }, /* ttyS0 */ \
85 { 0, BASE_BAUD, 0x2F8, PLD_IRQ_UART1, STD_COM_FLAGS }, /* ttyS1 */
86
87 #else /* !CONFIG_PLAT_USRV */
88
89 #if defined(CONFIG_SERIAL_M32R_PLDSIO)
90 #define SERIAL_PORT_DFNS \
91 { 0, BASE_BAUD, ((unsigned long)PLD_ESIO0CR), PLD_IRQ_SIO0_RCV, \
92 STD_COM_FLAGS }, /* ttyS0 */
93 #else
94 #define SERIAL_PORT_DFNS \
95 { 0, BASE_BAUD, M32R_SIO_OFFSET, M32R_IRQ_SIO0_R, \
96 STD_COM_FLAGS }, /* ttyS0 */
97 #endif
98
99 #endif /* !CONFIG_PLAT_USRV */
100
101 static struct old_serial_port old_serial_port[] = {
102 SERIAL_PORT_DFNS
103 };
104
105 #define UART_NR ARRAY_SIZE(old_serial_port)
106
107 struct uart_sio_port {
108 struct uart_port port;
109 struct timer_list timer; /* "no irq" timer */
110 struct list_head list; /* ports on this IRQ */
111 unsigned short rev;
112 unsigned char acr;
113 unsigned char ier;
114 unsigned char lcr;
115 unsigned char mcr_mask; /* mask of user bits */
116 unsigned char mcr_force; /* mask of forced bits */
117 unsigned char lsr_break_flag;
118
119 /*
120 * We provide a per-port pm hook.
121 */
122 void (*pm)(struct uart_port *port,
123 unsigned int state, unsigned int old);
124 };
125
126 struct irq_info {
127 spinlock_t lock;
128 struct list_head *head;
129 };
130
131 static struct irq_info irq_lists[NR_IRQS];
132
133 #ifdef CONFIG_SERIAL_M32R_PLDSIO
134
135 #define __sio_in(x) inw((unsigned long)(x))
136 #define __sio_out(v,x) outw((v),(unsigned long)(x))
137
138 static inline void sio_set_baud_rate(unsigned long baud)
139 {
140 unsigned short sbaud;
141 sbaud = (boot_cpu_data.bus_clock / (baud * 4))-1;
142 __sio_out(sbaud, PLD_ESIO0BAUR);
143 }
144
145 static void sio_reset(void)
146 {
147 unsigned short tmp;
148
149 tmp = __sio_in(PLD_ESIO0RXB);
150 tmp = __sio_in(PLD_ESIO0RXB);
151 tmp = __sio_in(PLD_ESIO0CR);
152 sio_set_baud_rate(BAUD_RATE);
153 __sio_out(0x0300, PLD_ESIO0CR);
154 __sio_out(0x0003, PLD_ESIO0CR);
155 }
156
157 static void sio_init(void)
158 {
159 unsigned short tmp;
160
161 tmp = __sio_in(PLD_ESIO0RXB);
162 tmp = __sio_in(PLD_ESIO0RXB);
163 tmp = __sio_in(PLD_ESIO0CR);
164 __sio_out(0x0300, PLD_ESIO0CR);
165 __sio_out(0x0003, PLD_ESIO0CR);
166 }
167
168 static void sio_error(int *status)
169 {
170 printk("SIO0 error[%04x]\n", *status);
171 do {
172 sio_init();
173 } while ((*status = __sio_in(PLD_ESIO0CR)) != 3);
174 }
175
176 #else /* not CONFIG_SERIAL_M32R_PLDSIO */
177
178 #define __sio_in(x) inl(x)
179 #define __sio_out(v,x) outl((v),(x))
180
181 static inline void sio_set_baud_rate(unsigned long baud)
182 {
183 unsigned long i, j;
184
185 i = boot_cpu_data.bus_clock / (baud * 16);
186 j = (boot_cpu_data.bus_clock - (i * baud * 16)) / baud;
187 i -= 1;
188 j = (j + 1) >> 1;
189
190 __sio_out(i, M32R_SIO0_BAUR_PORTL);
191 __sio_out(j, M32R_SIO0_RBAUR_PORTL);
192 }
193
194 static void sio_reset(void)
195 {
196 __sio_out(0x00000300, M32R_SIO0_CR_PORTL); /* init status */
197 __sio_out(0x00000800, M32R_SIO0_MOD1_PORTL); /* 8bit */
198 __sio_out(0x00000080, M32R_SIO0_MOD0_PORTL); /* 1stop non */
199 sio_set_baud_rate(BAUD_RATE);
200 __sio_out(0x00000000, M32R_SIO0_TRCR_PORTL);
201 __sio_out(0x00000003, M32R_SIO0_CR_PORTL); /* RXCEN */
202 }
203
204 static void sio_init(void)
205 {
206 unsigned int tmp;
207
208 tmp = __sio_in(M32R_SIO0_RXB_PORTL);
209 tmp = __sio_in(M32R_SIO0_RXB_PORTL);
210 tmp = __sio_in(M32R_SIO0_STS_PORTL);
211 __sio_out(0x00000003, M32R_SIO0_CR_PORTL);
212 }
213
214 static void sio_error(int *status)
215 {
216 printk("SIO0 error[%04x]\n", *status);
217 do {
218 sio_init();
219 } while ((*status = __sio_in(M32R_SIO0_CR_PORTL)) != 3);
220 }
221
222 #endif /* CONFIG_SERIAL_M32R_PLDSIO */
223
224 static unsigned int sio_in(struct uart_sio_port *up, int offset)
225 {
226 return __sio_in(up->port.iobase + offset);
227 }
228
229 static void sio_out(struct uart_sio_port *up, int offset, int value)
230 {
231 __sio_out(value, up->port.iobase + offset);
232 }
233
234 static unsigned int serial_in(struct uart_sio_port *up, int offset)
235 {
236 if (!offset)
237 return 0;
238
239 return __sio_in(offset);
240 }
241
242 static void serial_out(struct uart_sio_port *up, int offset, int value)
243 {
244 if (!offset)
245 return;
246
247 __sio_out(value, offset);
248 }
249
250 static void m32r_sio_stop_tx(struct uart_port *port)
251 {
252 struct uart_sio_port *up = (struct uart_sio_port *)port;
253
254 if (up->ier & UART_IER_THRI) {
255 up->ier &= ~UART_IER_THRI;
256 serial_out(up, UART_IER, up->ier);
257 }
258 }
259
260 static void m32r_sio_start_tx(struct uart_port *port)
261 {
262 #ifdef CONFIG_SERIAL_M32R_PLDSIO
263 struct uart_sio_port *up = (struct uart_sio_port *)port;
264 struct circ_buf *xmit = &up->port.state->xmit;
265
266 if (!(up->ier & UART_IER_THRI)) {
267 up->ier |= UART_IER_THRI;
268 serial_out(up, UART_IER, up->ier);
269 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
270 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
271 up->port.icount.tx++;
272 }
273 while((serial_in(up, UART_LSR) & UART_EMPTY) != UART_EMPTY);
274 #else
275 struct uart_sio_port *up = (struct uart_sio_port *)port;
276
277 if (!(up->ier & UART_IER_THRI)) {
278 up->ier |= UART_IER_THRI;
279 serial_out(up, UART_IER, up->ier);
280 }
281 #endif
282 }
283
284 static void m32r_sio_stop_rx(struct uart_port *port)
285 {
286 struct uart_sio_port *up = (struct uart_sio_port *)port;
287
288 up->ier &= ~UART_IER_RLSI;
289 up->port.read_status_mask &= ~UART_LSR_DR;
290 serial_out(up, UART_IER, up->ier);
291 }
292
293 static void m32r_sio_enable_ms(struct uart_port *port)
294 {
295 struct uart_sio_port *up = (struct uart_sio_port *)port;
296
297 up->ier |= UART_IER_MSI;
298 serial_out(up, UART_IER, up->ier);
299 }
300
301 static void receive_chars(struct uart_sio_port *up, int *status)
302 {
303 struct tty_port *port = &up->port.state->port;
304 unsigned char ch;
305 unsigned char flag;
306 int max_count = 256;
307
308 do {
309 ch = sio_in(up, SIORXB);
310 flag = TTY_NORMAL;
311 up->port.icount.rx++;
312
313 if (unlikely(*status & (UART_LSR_BI | UART_LSR_PE |
314 UART_LSR_FE | UART_LSR_OE))) {
315 /*
316 * For statistics only
317 */
318 if (*status & UART_LSR_BI) {
319 *status &= ~(UART_LSR_FE | UART_LSR_PE);
320 up->port.icount.brk++;
321 /*
322 * We do the SysRQ and SAK checking
323 * here because otherwise the break
324 * may get masked by ignore_status_mask
325 * or read_status_mask.
326 */
327 if (uart_handle_break(&up->port))
328 goto ignore_char;
329 } else if (*status & UART_LSR_PE)
330 up->port.icount.parity++;
331 else if (*status & UART_LSR_FE)
332 up->port.icount.frame++;
333 if (*status & UART_LSR_OE)
334 up->port.icount.overrun++;
335
336 /*
337 * Mask off conditions which should be ingored.
338 */
339 *status &= up->port.read_status_mask;
340
341 if (up->port.line == up->port.cons->index) {
342 /* Recover the break flag from console xmit */
343 *status |= up->lsr_break_flag;
344 up->lsr_break_flag = 0;
345 }
346
347 if (*status & UART_LSR_BI) {
348 DEBUG_INTR("handling break....");
349 flag = TTY_BREAK;
350 } else if (*status & UART_LSR_PE)
351 flag = TTY_PARITY;
352 else if (*status & UART_LSR_FE)
353 flag = TTY_FRAME;
354 }
355 if (uart_handle_sysrq_char(&up->port, ch))
356 goto ignore_char;
357 if ((*status & up->port.ignore_status_mask) == 0)
358 tty_insert_flip_char(port, ch, flag);
359
360 if (*status & UART_LSR_OE) {
361 /*
362 * Overrun is special, since it's reported
363 * immediately, and doesn't affect the current
364 * character.
365 */
366 tty_insert_flip_char(port, 0, TTY_OVERRUN);
367 }
368 ignore_char:
369 *status = serial_in(up, UART_LSR);
370 } while ((*status & UART_LSR_DR) && (max_count-- > 0));
371
372 spin_unlock(&up->port.lock);
373 tty_flip_buffer_push(port);
374 spin_lock(&up->port.lock);
375 }
376
377 static void transmit_chars(struct uart_sio_port *up)
378 {
379 struct circ_buf *xmit = &up->port.state->xmit;
380 int count;
381
382 if (up->port.x_char) {
383 #ifndef CONFIG_SERIAL_M32R_PLDSIO /* XXX */
384 serial_out(up, UART_TX, up->port.x_char);
385 #endif
386 up->port.icount.tx++;
387 up->port.x_char = 0;
388 return;
389 }
390 if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) {
391 m32r_sio_stop_tx(&up->port);
392 return;
393 }
394
395 count = up->port.fifosize;
396 do {
397 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
398 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
399 up->port.icount.tx++;
400 if (uart_circ_empty(xmit))
401 break;
402 while (!(serial_in(up, UART_LSR) & UART_LSR_THRE));
403
404 } while (--count > 0);
405
406 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
407 uart_write_wakeup(&up->port);
408
409 DEBUG_INTR("THRE...");
410
411 if (uart_circ_empty(xmit))
412 m32r_sio_stop_tx(&up->port);
413 }
414
415 /*
416 * This handles the interrupt from one port.
417 */
418 static inline void m32r_sio_handle_port(struct uart_sio_port *up,
419 unsigned int status)
420 {
421 DEBUG_INTR("status = %x...", status);
422
423 if (status & 0x04)
424 receive_chars(up, &status);
425 if (status & 0x01)
426 transmit_chars(up);
427 }
428
429 /*
430 * This is the serial driver's interrupt routine.
431 *
432 * Arjan thinks the old way was overly complex, so it got simplified.
433 * Alan disagrees, saying that need the complexity to handle the weird
434 * nature of ISA shared interrupts. (This is a special exception.)
435 *
436 * In order to handle ISA shared interrupts properly, we need to check
437 * that all ports have been serviced, and therefore the ISA interrupt
438 * line has been de-asserted.
439 *
440 * This means we need to loop through all ports. checking that they
441 * don't have an interrupt pending.
442 */
443 static irqreturn_t m32r_sio_interrupt(int irq, void *dev_id)
444 {
445 struct irq_info *i = dev_id;
446 struct list_head *l, *end = NULL;
447 int pass_counter = 0;
448
449 DEBUG_INTR("m32r_sio_interrupt(%d)...", irq);
450
451 #ifdef CONFIG_SERIAL_M32R_PLDSIO
452 // if (irq == PLD_IRQ_SIO0_SND)
453 // irq = PLD_IRQ_SIO0_RCV;
454 #else
455 if (irq == M32R_IRQ_SIO0_S)
456 irq = M32R_IRQ_SIO0_R;
457 #endif
458
459 spin_lock(&i->lock);
460
461 l = i->head;
462 do {
463 struct uart_sio_port *up;
464 unsigned int sts;
465
466 up = list_entry(l, struct uart_sio_port, list);
467
468 sts = sio_in(up, SIOSTS);
469 if (sts & 0x5) {
470 spin_lock(&up->port.lock);
471 m32r_sio_handle_port(up, sts);
472 spin_unlock(&up->port.lock);
473
474 end = NULL;
475 } else if (end == NULL)
476 end = l;
477
478 l = l->next;
479
480 if (l == i->head && pass_counter++ > PASS_LIMIT) {
481 if (sts & 0xe0)
482 sio_error(&sts);
483 break;
484 }
485 } while (l != end);
486
487 spin_unlock(&i->lock);
488
489 DEBUG_INTR("end.\n");
490
491 return IRQ_HANDLED;
492 }
493
494 /*
495 * To support ISA shared interrupts, we need to have one interrupt
496 * handler that ensures that the IRQ line has been deasserted
497 * before returning. Failing to do this will result in the IRQ
498 * line being stuck active, and, since ISA irqs are edge triggered,
499 * no more IRQs will be seen.
500 */
501 static void serial_do_unlink(struct irq_info *i, struct uart_sio_port *up)
502 {
503 spin_lock_irq(&i->lock);
504
505 if (!list_empty(i->head)) {
506 if (i->head == &up->list)
507 i->head = i->head->next;
508 list_del(&up->list);
509 } else {
510 BUG_ON(i->head != &up->list);
511 i->head = NULL;
512 }
513
514 spin_unlock_irq(&i->lock);
515 }
516
517 static int serial_link_irq_chain(struct uart_sio_port *up)
518 {
519 struct irq_info *i = irq_lists + up->port.irq;
520 int ret, irq_flags = 0;
521
522 spin_lock_irq(&i->lock);
523
524 if (i->head) {
525 list_add(&up->list, i->head);
526 spin_unlock_irq(&i->lock);
527
528 ret = 0;
529 } else {
530 INIT_LIST_HEAD(&up->list);
531 i->head = &up->list;
532 spin_unlock_irq(&i->lock);
533
534 ret = request_irq(up->port.irq, m32r_sio_interrupt,
535 irq_flags, "SIO0-RX", i);
536 ret |= request_irq(up->port.irq + 1, m32r_sio_interrupt,
537 irq_flags, "SIO0-TX", i);
538 if (ret < 0)
539 serial_do_unlink(i, up);
540 }
541
542 return ret;
543 }
544
545 static void serial_unlink_irq_chain(struct uart_sio_port *up)
546 {
547 struct irq_info *i = irq_lists + up->port.irq;
548
549 BUG_ON(i->head == NULL);
550
551 if (list_empty(i->head)) {
552 free_irq(up->port.irq, i);
553 free_irq(up->port.irq + 1, i);
554 }
555
556 serial_do_unlink(i, up);
557 }
558
559 /*
560 * This function is used to handle ports that do not have an interrupt.
561 */
562 static void m32r_sio_timeout(unsigned long data)
563 {
564 struct uart_sio_port *up = (struct uart_sio_port *)data;
565 unsigned int timeout;
566 unsigned int sts;
567
568 sts = sio_in(up, SIOSTS);
569 if (sts & 0x5) {
570 spin_lock(&up->port.lock);
571 m32r_sio_handle_port(up, sts);
572 spin_unlock(&up->port.lock);
573 }
574
575 timeout = up->port.timeout;
576 timeout = timeout > 6 ? (timeout / 2 - 2) : 1;
577 mod_timer(&up->timer, jiffies + timeout);
578 }
579
580 static unsigned int m32r_sio_tx_empty(struct uart_port *port)
581 {
582 struct uart_sio_port *up = (struct uart_sio_port *)port;
583 unsigned long flags;
584 unsigned int ret;
585
586 spin_lock_irqsave(&up->port.lock, flags);
587 ret = serial_in(up, UART_LSR) & UART_LSR_TEMT ? TIOCSER_TEMT : 0;
588 spin_unlock_irqrestore(&up->port.lock, flags);
589
590 return ret;
591 }
592
593 static unsigned int m32r_sio_get_mctrl(struct uart_port *port)
594 {
595 return 0;
596 }
597
598 static void m32r_sio_set_mctrl(struct uart_port *port, unsigned int mctrl)
599 {
600
601 }
602
603 static void m32r_sio_break_ctl(struct uart_port *port, int break_state)
604 {
605
606 }
607
608 static int m32r_sio_startup(struct uart_port *port)
609 {
610 struct uart_sio_port *up = (struct uart_sio_port *)port;
611 int retval;
612
613 sio_init();
614
615 /*
616 * If the "interrupt" for this port doesn't correspond with any
617 * hardware interrupt, we use a timer-based system. The original
618 * driver used to do this with IRQ0.
619 */
620 if (!up->port.irq) {
621 unsigned int timeout = up->port.timeout;
622
623 timeout = timeout > 6 ? (timeout / 2 - 2) : 1;
624
625 up->timer.data = (unsigned long)up;
626 mod_timer(&up->timer, jiffies + timeout);
627 } else {
628 retval = serial_link_irq_chain(up);
629 if (retval)
630 return retval;
631 }
632
633 /*
634 * Finally, enable interrupts. Note: Modem status interrupts
635 * are set via set_termios(), which will be occurring imminently
636 * anyway, so we don't enable them here.
637 * - M32R_SIO: 0x0c
638 * - M32R_PLDSIO: 0x04
639 */
640 up->ier = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
641 sio_out(up, SIOTRCR, up->ier);
642
643 /*
644 * And clear the interrupt registers again for luck.
645 */
646 sio_reset();
647
648 return 0;
649 }
650
651 static void m32r_sio_shutdown(struct uart_port *port)
652 {
653 struct uart_sio_port *up = (struct uart_sio_port *)port;
654
655 /*
656 * Disable interrupts from this port
657 */
658 up->ier = 0;
659 sio_out(up, SIOTRCR, 0);
660
661 /*
662 * Disable break condition and FIFOs
663 */
664
665 sio_init();
666
667 if (!up->port.irq)
668 del_timer_sync(&up->timer);
669 else
670 serial_unlink_irq_chain(up);
671 }
672
673 static unsigned int m32r_sio_get_divisor(struct uart_port *port,
674 unsigned int baud)
675 {
676 return uart_get_divisor(port, baud);
677 }
678
679 static void m32r_sio_set_termios(struct uart_port *port,
680 struct ktermios *termios, struct ktermios *old)
681 {
682 struct uart_sio_port *up = (struct uart_sio_port *)port;
683 unsigned char cval = 0;
684 unsigned long flags;
685 unsigned int baud, quot;
686
687 switch (termios->c_cflag & CSIZE) {
688 case CS5:
689 cval = UART_LCR_WLEN5;
690 break;
691 case CS6:
692 cval = UART_LCR_WLEN6;
693 break;
694 case CS7:
695 cval = UART_LCR_WLEN7;
696 break;
697 default:
698 case CS8:
699 cval = UART_LCR_WLEN8;
700 break;
701 }
702
703 if (termios->c_cflag & CSTOPB)
704 cval |= UART_LCR_STOP;
705 if (termios->c_cflag & PARENB)
706 cval |= UART_LCR_PARITY;
707 if (!(termios->c_cflag & PARODD))
708 cval |= UART_LCR_EPAR;
709 #ifdef CMSPAR
710 if (termios->c_cflag & CMSPAR)
711 cval |= UART_LCR_SPAR;
712 #endif
713
714 /*
715 * Ask the core to calculate the divisor for us.
716 */
717 #ifdef CONFIG_SERIAL_M32R_PLDSIO
718 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/4);
719 #else
720 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
721 #endif
722 quot = m32r_sio_get_divisor(port, baud);
723
724 /*
725 * Ok, we're now changing the port state. Do it with
726 * interrupts disabled.
727 */
728 spin_lock_irqsave(&up->port.lock, flags);
729
730 sio_set_baud_rate(baud);
731
732 /*
733 * Update the per-port timeout.
734 */
735 uart_update_timeout(port, termios->c_cflag, baud);
736
737 up->port.read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
738 if (termios->c_iflag & INPCK)
739 up->port.read_status_mask |= UART_LSR_FE | UART_LSR_PE;
740 if (termios->c_iflag & (BRKINT | PARMRK))
741 up->port.read_status_mask |= UART_LSR_BI;
742
743 /*
744 * Characteres to ignore
745 */
746 up->port.ignore_status_mask = 0;
747 if (termios->c_iflag & IGNPAR)
748 up->port.ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
749 if (termios->c_iflag & IGNBRK) {
750 up->port.ignore_status_mask |= UART_LSR_BI;
751 /*
752 * If we're ignoring parity and break indicators,
753 * ignore overruns too (for real raw support).
754 */
755 if (termios->c_iflag & IGNPAR)
756 up->port.ignore_status_mask |= UART_LSR_OE;
757 }
758
759 /*
760 * ignore all characters if CREAD is not set
761 */
762 if ((termios->c_cflag & CREAD) == 0)
763 up->port.ignore_status_mask |= UART_LSR_DR;
764
765 /*
766 * CTS flow control flag and modem status interrupts
767 */
768 up->ier &= ~UART_IER_MSI;
769 if (UART_ENABLE_MS(&up->port, termios->c_cflag))
770 up->ier |= UART_IER_MSI;
771
772 serial_out(up, UART_IER, up->ier);
773
774 up->lcr = cval; /* Save LCR */
775 spin_unlock_irqrestore(&up->port.lock, flags);
776 }
777
778 static void m32r_sio_pm(struct uart_port *port, unsigned int state,
779 unsigned int oldstate)
780 {
781 struct uart_sio_port *up = (struct uart_sio_port *)port;
782
783 if (up->pm)
784 up->pm(port, state, oldstate);
785 }
786
787 /*
788 * Resource handling. This is complicated by the fact that resources
789 * depend on the port type. Maybe we should be claiming the standard
790 * 8250 ports, and then trying to get other resources as necessary?
791 */
792 static int
793 m32r_sio_request_std_resource(struct uart_sio_port *up, struct resource **res)
794 {
795 unsigned int size = 8 << up->port.regshift;
796 #ifndef CONFIG_SERIAL_M32R_PLDSIO
797 unsigned long start;
798 #endif
799 int ret = 0;
800
801 switch (up->port.iotype) {
802 case UPIO_MEM:
803 if (up->port.mapbase) {
804 #ifdef CONFIG_SERIAL_M32R_PLDSIO
805 *res = request_mem_region(up->port.mapbase, size, "serial");
806 #else
807 start = up->port.mapbase;
808 *res = request_mem_region(start, size, "serial");
809 #endif
810 if (!*res)
811 ret = -EBUSY;
812 }
813 break;
814
815 case UPIO_PORT:
816 *res = request_region(up->port.iobase, size, "serial");
817 if (!*res)
818 ret = -EBUSY;
819 break;
820 }
821 return ret;
822 }
823
824 static void m32r_sio_release_port(struct uart_port *port)
825 {
826 struct uart_sio_port *up = (struct uart_sio_port *)port;
827 unsigned long start, offset = 0, size = 0;
828
829 size <<= up->port.regshift;
830
831 switch (up->port.iotype) {
832 case UPIO_MEM:
833 if (up->port.mapbase) {
834 /*
835 * Unmap the area.
836 */
837 iounmap(up->port.membase);
838 up->port.membase = NULL;
839
840 start = up->port.mapbase;
841
842 if (size)
843 release_mem_region(start + offset, size);
844 release_mem_region(start, 8 << up->port.regshift);
845 }
846 break;
847
848 case UPIO_PORT:
849 start = up->port.iobase;
850
851 if (size)
852 release_region(start + offset, size);
853 release_region(start + offset, 8 << up->port.regshift);
854 break;
855
856 default:
857 break;
858 }
859 }
860
861 static int m32r_sio_request_port(struct uart_port *port)
862 {
863 struct uart_sio_port *up = (struct uart_sio_port *)port;
864 struct resource *res = NULL;
865 int ret = 0;
866
867 ret = m32r_sio_request_std_resource(up, &res);
868
869 /*
870 * If we have a mapbase, then request that as well.
871 */
872 if (ret == 0 && up->port.flags & UPF_IOREMAP) {
873 int size = resource_size(res);
874
875 up->port.membase = ioremap(up->port.mapbase, size);
876 if (!up->port.membase)
877 ret = -ENOMEM;
878 }
879
880 if (ret < 0) {
881 if (res)
882 release_resource(res);
883 }
884
885 return ret;
886 }
887
888 static void m32r_sio_config_port(struct uart_port *port, int unused)
889 {
890 struct uart_sio_port *up = (struct uart_sio_port *)port;
891 unsigned long flags;
892
893 spin_lock_irqsave(&up->port.lock, flags);
894
895 up->port.fifosize = 1;
896
897 spin_unlock_irqrestore(&up->port.lock, flags);
898 }
899
900 static int
901 m32r_sio_verify_port(struct uart_port *port, struct serial_struct *ser)
902 {
903 if (ser->irq >= nr_irqs || ser->irq < 0 || ser->baud_base < 9600)
904 return -EINVAL;
905 return 0;
906 }
907
908 static struct uart_ops m32r_sio_pops = {
909 .tx_empty = m32r_sio_tx_empty,
910 .set_mctrl = m32r_sio_set_mctrl,
911 .get_mctrl = m32r_sio_get_mctrl,
912 .stop_tx = m32r_sio_stop_tx,
913 .start_tx = m32r_sio_start_tx,
914 .stop_rx = m32r_sio_stop_rx,
915 .enable_ms = m32r_sio_enable_ms,
916 .break_ctl = m32r_sio_break_ctl,
917 .startup = m32r_sio_startup,
918 .shutdown = m32r_sio_shutdown,
919 .set_termios = m32r_sio_set_termios,
920 .pm = m32r_sio_pm,
921 .release_port = m32r_sio_release_port,
922 .request_port = m32r_sio_request_port,
923 .config_port = m32r_sio_config_port,
924 .verify_port = m32r_sio_verify_port,
925 };
926
927 static struct uart_sio_port m32r_sio_ports[UART_NR];
928
929 static void __init m32r_sio_init_ports(void)
930 {
931 struct uart_sio_port *up;
932 static int first = 1;
933 int i;
934
935 if (!first)
936 return;
937 first = 0;
938
939 for (i = 0, up = m32r_sio_ports; i < ARRAY_SIZE(old_serial_port);
940 i++, up++) {
941 up->port.iobase = old_serial_port[i].port;
942 up->port.irq = irq_canonicalize(old_serial_port[i].irq);
943 up->port.uartclk = old_serial_port[i].baud_base * 16;
944 up->port.flags = old_serial_port[i].flags;
945 up->port.membase = old_serial_port[i].iomem_base;
946 up->port.iotype = old_serial_port[i].io_type;
947 up->port.regshift = old_serial_port[i].iomem_reg_shift;
948 up->port.ops = &m32r_sio_pops;
949 }
950 }
951
952 static void __init m32r_sio_register_ports(struct uart_driver *drv)
953 {
954 int i;
955
956 m32r_sio_init_ports();
957
958 for (i = 0; i < UART_NR; i++) {
959 struct uart_sio_port *up = &m32r_sio_ports[i];
960
961 up->port.line = i;
962 up->port.ops = &m32r_sio_pops;
963 init_timer(&up->timer);
964 up->timer.function = m32r_sio_timeout;
965
966 up->mcr_mask = ~0;
967 up->mcr_force = 0;
968
969 uart_add_one_port(drv, &up->port);
970 }
971 }
972
973 #ifdef CONFIG_SERIAL_M32R_SIO_CONSOLE
974
975 /*
976 * Wait for transmitter & holding register to empty
977 */
978 static inline void wait_for_xmitr(struct uart_sio_port *up)
979 {
980 unsigned int status, tmout = 10000;
981
982 /* Wait up to 10ms for the character(s) to be sent. */
983 do {
984 status = sio_in(up, SIOSTS);
985
986 if (--tmout == 0)
987 break;
988 udelay(1);
989 } while ((status & UART_EMPTY) != UART_EMPTY);
990
991 /* Wait up to 1s for flow control if necessary */
992 if (up->port.flags & UPF_CONS_FLOW) {
993 tmout = 1000000;
994 while (--tmout)
995 udelay(1);
996 }
997 }
998
999 static void m32r_sio_console_putchar(struct uart_port *port, int ch)
1000 {
1001 struct uart_sio_port *up = (struct uart_sio_port *)port;
1002
1003 wait_for_xmitr(up);
1004 sio_out(up, SIOTXB, ch);
1005 }
1006
1007 /*
1008 * Print a string to the serial port trying not to disturb
1009 * any possible real use of the port...
1010 *
1011 * The console_lock must be held when we get here.
1012 */
1013 static void m32r_sio_console_write(struct console *co, const char *s,
1014 unsigned int count)
1015 {
1016 struct uart_sio_port *up = &m32r_sio_ports[co->index];
1017 unsigned int ier;
1018
1019 /*
1020 * First save the UER then disable the interrupts
1021 */
1022 ier = sio_in(up, SIOTRCR);
1023 sio_out(up, SIOTRCR, 0);
1024
1025 uart_console_write(&up->port, s, count, m32r_sio_console_putchar);
1026
1027 /*
1028 * Finally, wait for transmitter to become empty
1029 * and restore the IER
1030 */
1031 wait_for_xmitr(up);
1032 sio_out(up, SIOTRCR, ier);
1033 }
1034
1035 static int __init m32r_sio_console_setup(struct console *co, char *options)
1036 {
1037 struct uart_port *port;
1038 int baud = 9600;
1039 int bits = 8;
1040 int parity = 'n';
1041 int flow = 'n';
1042
1043 /*
1044 * Check whether an invalid uart number has been specified, and
1045 * if so, search for the first available port that does have
1046 * console support.
1047 */
1048 if (co->index >= UART_NR)
1049 co->index = 0;
1050 port = &m32r_sio_ports[co->index].port;
1051
1052 /*
1053 * Temporary fix.
1054 */
1055 spin_lock_init(&port->lock);
1056
1057 if (options)
1058 uart_parse_options(options, &baud, &parity, &bits, &flow);
1059
1060 return uart_set_options(port, co, baud, parity, bits, flow);
1061 }
1062
1063 static struct uart_driver m32r_sio_reg;
1064 static struct console m32r_sio_console = {
1065 .name = "ttyS",
1066 .write = m32r_sio_console_write,
1067 .device = uart_console_device,
1068 .setup = m32r_sio_console_setup,
1069 .flags = CON_PRINTBUFFER,
1070 .index = -1,
1071 .data = &m32r_sio_reg,
1072 };
1073
1074 static int __init m32r_sio_console_init(void)
1075 {
1076 sio_reset();
1077 sio_init();
1078 m32r_sio_init_ports();
1079 register_console(&m32r_sio_console);
1080 return 0;
1081 }
1082 console_initcall(m32r_sio_console_init);
1083
1084 #define M32R_SIO_CONSOLE &m32r_sio_console
1085 #else
1086 #define M32R_SIO_CONSOLE NULL
1087 #endif
1088
1089 static struct uart_driver m32r_sio_reg = {
1090 .owner = THIS_MODULE,
1091 .driver_name = "sio",
1092 .dev_name = "ttyS",
1093 .major = TTY_MAJOR,
1094 .minor = 64,
1095 .nr = UART_NR,
1096 .cons = M32R_SIO_CONSOLE,
1097 };
1098
1099 /**
1100 * m32r_sio_suspend_port - suspend one serial port
1101 * @line: serial line number
1102 *
1103 * Suspend one serial port.
1104 */
1105 void m32r_sio_suspend_port(int line)
1106 {
1107 uart_suspend_port(&m32r_sio_reg, &m32r_sio_ports[line].port);
1108 }
1109
1110 /**
1111 * m32r_sio_resume_port - resume one serial port
1112 * @line: serial line number
1113 *
1114 * Resume one serial port.
1115 */
1116 void m32r_sio_resume_port(int line)
1117 {
1118 uart_resume_port(&m32r_sio_reg, &m32r_sio_ports[line].port);
1119 }
1120
1121 static int __init m32r_sio_init(void)
1122 {
1123 int ret, i;
1124
1125 printk(KERN_INFO "Serial: M32R SIO driver\n");
1126
1127 for (i = 0; i < nr_irqs; i++)
1128 spin_lock_init(&irq_lists[i].lock);
1129
1130 ret = uart_register_driver(&m32r_sio_reg);
1131 if (ret >= 0)
1132 m32r_sio_register_ports(&m32r_sio_reg);
1133
1134 return ret;
1135 }
1136
1137 static void __exit m32r_sio_exit(void)
1138 {
1139 int i;
1140
1141 for (i = 0; i < UART_NR; i++)
1142 uart_remove_one_port(&m32r_sio_reg, &m32r_sio_ports[i].port);
1143
1144 uart_unregister_driver(&m32r_sio_reg);
1145 }
1146
1147 module_init(m32r_sio_init);
1148 module_exit(m32r_sio_exit);
1149
1150 EXPORT_SYMBOL(m32r_sio_suspend_port);
1151 EXPORT_SYMBOL(m32r_sio_resume_port);
1152
1153 MODULE_LICENSE("GPL");
1154 MODULE_DESCRIPTION("Generic M32R SIO serial driver");
Linux kernel - Deliverables
This page took 0.053703 seconds and 6 git commands to generate.