?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
"[PATCH] Fix leaks on /proc/{*/sched,sched_debug,timer_list,timer_stats}" and
[mmotm.git] / arch / mn10300 / kernel / mn10300-serial.c
blob229b710fc5d5a65c0c6ed20f269fbb60dc709e31
1 /* MN10300 On-chip serial port UART driver
2 *
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
10 */
11
12 static const char serial_name[] = "MN10300 Serial driver";
13 static const char serial_version[] = "mn10300_serial-1.0";
14 static const char serial_revdate[] = "2007-11-06";
15
16 #if defined(CONFIG_MN10300_TTYSM_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
17 #define SUPPORT_SYSRQ
18 #endif
19
20 #include <linux/module.h>
21 #include <linux/serial.h>
22 #include <linux/circ_buf.h>
23 #include <linux/errno.h>
24 #include <linux/signal.h>
25 #include <linux/sched.h>
26 #include <linux/timer.h>
27 #include <linux/interrupt.h>
28 #include <linux/tty.h>
29 #include <linux/tty_flip.h>
30 #include <linux/major.h>
31 #include <linux/string.h>
32 #include <linux/ioport.h>
33 #include <linux/mm.h>
34 #include <linux/slab.h>
35 #include <linux/init.h>
36 #include <linux/console.h>
37 #include <linux/sysrq.h>
38
39 #include <asm/system.h>
40 #include <asm/io.h>
41 #include <asm/irq.h>
42 #include <asm/bitops.h>
43 #include <asm/serial-regs.h>
44 #include <unit/timex.h>
45 #include "mn10300-serial.h"
46
47 static inline __attribute__((format(printf, 1, 2)))
48 void no_printk(const char *fmt, ...)
49 {
50 }
51
52 #define kenter(FMT, ...) \
53 printk(KERN_DEBUG "-->%s(" FMT ")\n", __func__, ##__VA_ARGS__)
54 #define _enter(FMT, ...) \
55 no_printk(KERN_DEBUG "-->%s(" FMT ")\n", __func__, ##__VA_ARGS__)
56 #define kdebug(FMT, ...) \
57 printk(KERN_DEBUG "--- " FMT "\n", ##__VA_ARGS__)
58 #define _debug(FMT, ...) \
59 no_printk(KERN_DEBUG "--- " FMT "\n", ##__VA_ARGS__)
60 #define kproto(FMT, ...) \
61 printk(KERN_DEBUG "### MNSERIAL " FMT " ###\n", ##__VA_ARGS__)
62 #define _proto(FMT, ...) \
63 no_printk(KERN_DEBUG "### MNSERIAL " FMT " ###\n", ##__VA_ARGS__)
64
65 #define NR_UARTS 3
66
67 #ifdef CONFIG_MN10300_TTYSM_CONSOLE
68 static void mn10300_serial_console_write(struct console *co,
69 const char *s, unsigned count);
70 static int __init mn10300_serial_console_setup(struct console *co,
71 char *options);
72
73 static struct uart_driver mn10300_serial_driver;
74 static struct console mn10300_serial_console = {
75 .name = "ttySM",
76 .write = mn10300_serial_console_write,
77 .device = uart_console_device,
78 .setup = mn10300_serial_console_setup,
79 .flags = CON_PRINTBUFFER,
80 .index = -1,
81 .data = &mn10300_serial_driver,
82 };
83 #endif
84
85 static struct uart_driver mn10300_serial_driver = {
86 .owner = NULL,
87 .driver_name = "mn10300-serial",
88 .dev_name = "ttySM",
89 .major = TTY_MAJOR,
90 .minor = 128,
91 .nr = NR_UARTS,
92 #ifdef CONFIG_MN10300_TTYSM_CONSOLE
93 .cons = &mn10300_serial_console,
94 #endif
95 };
96
97 static unsigned int mn10300_serial_tx_empty(struct uart_port *);
98 static void mn10300_serial_set_mctrl(struct uart_port *, unsigned int mctrl);
99 static unsigned int mn10300_serial_get_mctrl(struct uart_port *);
100 static void mn10300_serial_stop_tx(struct uart_port *);
101 static void mn10300_serial_start_tx(struct uart_port *);
102 static void mn10300_serial_send_xchar(struct uart_port *, char ch);
103 static void mn10300_serial_stop_rx(struct uart_port *);
104 static void mn10300_serial_enable_ms(struct uart_port *);
105 static void mn10300_serial_break_ctl(struct uart_port *, int ctl);
106 static int mn10300_serial_startup(struct uart_port *);
107 static void mn10300_serial_shutdown(struct uart_port *);
108 static void mn10300_serial_set_termios(struct uart_port *,
109 struct ktermios *new,
110 struct ktermios *old);
111 static const char *mn10300_serial_type(struct uart_port *);
112 static void mn10300_serial_release_port(struct uart_port *);
113 static int mn10300_serial_request_port(struct uart_port *);
114 static void mn10300_serial_config_port(struct uart_port *, int);
115 static int mn10300_serial_verify_port(struct uart_port *,
116 struct serial_struct *);
117
118 static const struct uart_ops mn10300_serial_ops = {
119 .tx_empty = mn10300_serial_tx_empty,
120 .set_mctrl = mn10300_serial_set_mctrl,
121 .get_mctrl = mn10300_serial_get_mctrl,
122 .stop_tx = mn10300_serial_stop_tx,
123 .start_tx = mn10300_serial_start_tx,
124 .send_xchar = mn10300_serial_send_xchar,
125 .stop_rx = mn10300_serial_stop_rx,
126 .enable_ms = mn10300_serial_enable_ms,
127 .break_ctl = mn10300_serial_break_ctl,
128 .startup = mn10300_serial_startup,
129 .shutdown = mn10300_serial_shutdown,
130 .set_termios = mn10300_serial_set_termios,
131 .type = mn10300_serial_type,
132 .release_port = mn10300_serial_release_port,
133 .request_port = mn10300_serial_request_port,
134 .config_port = mn10300_serial_config_port,
135 .verify_port = mn10300_serial_verify_port,
136 };
137
138 static irqreturn_t mn10300_serial_interrupt(int irq, void *dev_id);
139
140 /*
141 * the first on-chip serial port: ttySM0 (aka SIF0)
142 */
143 #ifdef CONFIG_MN10300_TTYSM0
144 struct mn10300_serial_port mn10300_serial_port_sif0 = {
145 .uart.ops = &mn10300_serial_ops,
146 .uart.membase = (void __iomem *) &SC0CTR,
147 .uart.mapbase = (unsigned long) &SC0CTR,
148 .uart.iotype = UPIO_MEM,
149 .uart.irq = 0,
150 .uart.uartclk = 0, /* MN10300_IOCLK, */
151 .uart.fifosize = 1,
152 .uart.flags = UPF_BOOT_AUTOCONF,
153 .uart.line = 0,
154 .uart.type = PORT_MN10300,
155 .uart.lock =
156 __SPIN_LOCK_UNLOCKED(mn10300_serial_port_sif0.uart.lock),
157 .name = "ttySM0",
158 ._iobase = &SC0CTR,
159 ._control = &SC0CTR,
160 ._status = (volatile u8 *) &SC0STR,
161 ._intr = &SC0ICR,
162 ._rxb = &SC0RXB,
163 ._txb = &SC0TXB,
164 .rx_name = "ttySM0/Rx",
165 .tx_name = "ttySM0/Tx",
166 #ifdef CONFIG_MN10300_TTYSM0_TIMER8
167 .tm_name = "ttySM0/Timer8",
168 ._tmxmd = &TM8MD,
169 ._tmxbr = &TM8BR,
170 ._tmicr = &TM8ICR,
171 .tm_irq = TM8IRQ,
172 .div_timer = MNSCx_DIV_TIMER_16BIT,
173 #else /* CONFIG_MN10300_TTYSM0_TIMER2 */
174 .tm_name = "ttySM0/Timer2",
175 ._tmxmd = &TM2MD,
176 ._tmxbr = (volatile u16 *) &TM2BR,
177 ._tmicr = &TM2ICR,
178 .tm_irq = TM2IRQ,
179 .div_timer = MNSCx_DIV_TIMER_8BIT,
180 #endif
181 .rx_irq = SC0RXIRQ,
182 .tx_irq = SC0TXIRQ,
183 .rx_icr = &GxICR(SC0RXIRQ),
184 .tx_icr = &GxICR(SC0TXIRQ),
185 .clock_src = MNSCx_CLOCK_SRC_IOCLK,
186 .options = 0,
187 #ifdef CONFIG_GDBSTUB_ON_TTYSM0
188 .gdbstub = 1,
189 #endif
190 };
191 #endif /* CONFIG_MN10300_TTYSM0 */
192
193 /*
194 * the second on-chip serial port: ttySM1 (aka SIF1)
195 */
196 #ifdef CONFIG_MN10300_TTYSM1
197 struct mn10300_serial_port mn10300_serial_port_sif1 = {
198 .uart.ops = &mn10300_serial_ops,
199 .uart.membase = (void __iomem *) &SC1CTR,
200 .uart.mapbase = (unsigned long) &SC1CTR,
201 .uart.iotype = UPIO_MEM,
202 .uart.irq = 0,
203 .uart.uartclk = 0, /* MN10300_IOCLK, */
204 .uart.fifosize = 1,
205 .uart.flags = UPF_BOOT_AUTOCONF,
206 .uart.line = 1,
207 .uart.type = PORT_MN10300,
208 .uart.lock =
209 __SPIN_LOCK_UNLOCKED(mn10300_serial_port_sif1.uart.lock),
210 .name = "ttySM1",
211 ._iobase = &SC1CTR,
212 ._control = &SC1CTR,
213 ._status = (volatile u8 *) &SC1STR,
214 ._intr = &SC1ICR,
215 ._rxb = &SC1RXB,
216 ._txb = &SC1TXB,
217 .rx_name = "ttySM1/Rx",
218 .tx_name = "ttySM1/Tx",
219 #ifdef CONFIG_MN10300_TTYSM1_TIMER9
220 .tm_name = "ttySM1/Timer9",
221 ._tmxmd = &TM9MD,
222 ._tmxbr = &TM9BR,
223 ._tmicr = &TM9ICR,
224 .tm_irq = TM9IRQ,
225 .div_timer = MNSCx_DIV_TIMER_16BIT,
226 #else /* CONFIG_MN10300_TTYSM1_TIMER3 */
227 .tm_name = "ttySM1/Timer3",
228 ._tmxmd = &TM3MD,
229 ._tmxbr = (volatile u16 *) &TM3BR,
230 ._tmicr = &TM3ICR,
231 .tm_irq = TM3IRQ,
232 .div_timer = MNSCx_DIV_TIMER_8BIT,
233 #endif
234 .rx_irq = SC1RXIRQ,
235 .tx_irq = SC1TXIRQ,
236 .rx_icr = &GxICR(SC1RXIRQ),
237 .tx_icr = &GxICR(SC1TXIRQ),
238 .clock_src = MNSCx_CLOCK_SRC_IOCLK,
239 .options = 0,
240 #ifdef CONFIG_GDBSTUB_ON_TTYSM1
241 .gdbstub = 1,
242 #endif
243 };
244 #endif /* CONFIG_MN10300_TTYSM1 */
245
246 /*
247 * the third on-chip serial port: ttySM2 (aka SIF2)
248 */
249 #ifdef CONFIG_MN10300_TTYSM2
250 struct mn10300_serial_port mn10300_serial_port_sif2 = {
251 .uart.ops = &mn10300_serial_ops,
252 .uart.membase = (void __iomem *) &SC2CTR,
253 .uart.mapbase = (unsigned long) &SC2CTR,
254 .uart.iotype = UPIO_MEM,
255 .uart.irq = 0,
256 .uart.uartclk = 0, /* MN10300_IOCLK, */
257 .uart.fifosize = 1,
258 .uart.flags = UPF_BOOT_AUTOCONF,
259 .uart.line = 2,
260 #ifdef CONFIG_MN10300_TTYSM2_CTS
261 .uart.type = PORT_MN10300_CTS,
262 #else
263 .uart.type = PORT_MN10300,
264 #endif
265 .uart.lock =
266 __SPIN_LOCK_UNLOCKED(mn10300_serial_port_sif2.uart.lock),
267 .name = "ttySM2",
268 .rx_name = "ttySM2/Rx",
269 .tx_name = "ttySM2/Tx",
270 .tm_name = "ttySM2/Timer10",
271 ._iobase = &SC2CTR,
272 ._control = &SC2CTR,
273 ._status = &SC2STR,
274 ._intr = &SC2ICR,
275 ._rxb = &SC2RXB,
276 ._txb = &SC2TXB,
277 ._tmxmd = &TM10MD,
278 ._tmxbr = &TM10BR,
279 ._tmicr = &TM10ICR,
280 .tm_irq = TM10IRQ,
281 .div_timer = MNSCx_DIV_TIMER_16BIT,
282 .rx_irq = SC2RXIRQ,
283 .tx_irq = SC2TXIRQ,
284 .rx_icr = &GxICR(SC2RXIRQ),
285 .tx_icr = &GxICR(SC2TXIRQ),
286 .clock_src = MNSCx_CLOCK_SRC_IOCLK,
287 #ifdef CONFIG_MN10300_TTYSM2_CTS
288 .options = MNSCx_OPT_CTS,
289 #else
290 .options = 0,
291 #endif
292 #ifdef CONFIG_GDBSTUB_ON_TTYSM2
293 .gdbstub = 1,
294 #endif
295 };
296 #endif /* CONFIG_MN10300_TTYSM2 */
297
298
299 /*
300 * list of available serial ports
301 */
302 struct mn10300_serial_port *mn10300_serial_ports[NR_UARTS + 1] = {
303 #ifdef CONFIG_MN10300_TTYSM0
304 [0] = &mn10300_serial_port_sif0,
305 #endif
306 #ifdef CONFIG_MN10300_TTYSM1
307 [1] = &mn10300_serial_port_sif1,
308 #endif
309 #ifdef CONFIG_MN10300_TTYSM2
310 [2] = &mn10300_serial_port_sif2,
311 #endif
312 [NR_UARTS] = NULL,
313 };
314
315
316 /*
317 * we abuse the serial ports' baud timers' interrupt lines to get the ability
318 * to deliver interrupts to userspace as we use the ports' interrupt lines to
319 * do virtual DMA on account of the ports having no hardware FIFOs
320 *
321 * we can generate an interrupt manually in the assembly stubs by writing to
322 * the enable and detect bits in the interrupt control register, so all we need
323 * to do here is disable the interrupt line
324 *
325 * note that we can't just leave the line enabled as the baud rate timer *also*
326 * generates interrupts
327 */
328 static void mn10300_serial_mask_ack(unsigned int irq)
329 {
330 u16 tmp;
331 GxICR(irq) = GxICR_LEVEL_6;
332 tmp = GxICR(irq); /* flush write buffer */
333 }
334
335 static void mn10300_serial_nop(unsigned int irq)
336 {
337 }
338
339 static struct irq_chip mn10300_serial_pic = {
340 .name = "mnserial",
341 .ack = mn10300_serial_mask_ack,
342 .mask = mn10300_serial_mask_ack,
343 .mask_ack = mn10300_serial_mask_ack,
344 .unmask = mn10300_serial_nop,
345 .end = mn10300_serial_nop,
346 };
347
348
349 /*
350 * serial virtual DMA interrupt jump table
351 */
352 struct mn10300_serial_int mn10300_serial_int_tbl[NR_IRQS];
353
354 static void mn10300_serial_dis_tx_intr(struct mn10300_serial_port *port)
355 {
356 u16 x;
357 *port->tx_icr = GxICR_LEVEL_1 | GxICR_DETECT;
358 x = *port->tx_icr;
359 }
360
361 static void mn10300_serial_en_tx_intr(struct mn10300_serial_port *port)
362 {
363 u16 x;
364 *port->tx_icr = GxICR_LEVEL_1 | GxICR_ENABLE;
365 x = *port->tx_icr;
366 }
367
368 static void mn10300_serial_dis_rx_intr(struct mn10300_serial_port *port)
369 {
370 u16 x;
371 *port->rx_icr = GxICR_LEVEL_1 | GxICR_DETECT;
372 x = *port->rx_icr;
373 }
374
375 /*
376 * multi-bit equivalent of test_and_clear_bit()
377 */
378 static int mask_test_and_clear(volatile u8 *ptr, u8 mask)
379 {
380 u32 epsw;
381 asm volatile(" bclr %1,(%2) \n"
382 " mov epsw,%0 \n"
383 : "=d"(epsw) : "d"(mask), "a"(ptr));
384 return !(epsw & EPSW_FLAG_Z);
385 }
386
387 /*
388 * receive chars from the ring buffer for this serial port
389 * - must do break detection here (not done in the UART)
390 */
391 static void mn10300_serial_receive_interrupt(struct mn10300_serial_port *port)
392 {
393 struct uart_icount *icount = &port->uart.icount;
394 struct tty_struct *tty = port->uart.state->port.tty;
395 unsigned ix;
396 int count;
397 u8 st, ch, push, status, overrun;
398
399 _enter("%s", port->name);
400
401 push = 0;
402
403 count = CIRC_CNT(port->rx_inp, port->rx_outp, MNSC_BUFFER_SIZE);
404 count = tty_buffer_request_room(tty, count);
405 if (count == 0) {
406 if (!tty->low_latency)
407 tty_flip_buffer_push(tty);
408 return;
409 }
410
411 try_again:
412 /* pull chars out of the hat */
413 ix = port->rx_outp;
414 if (ix == port->rx_inp) {
415 if (push && !tty->low_latency)
416 tty_flip_buffer_push(tty);
417 return;
418 }
419
420 ch = port->rx_buffer[ix++];
421 st = port->rx_buffer[ix++];
422 smp_rmb();
423 port->rx_outp = ix & (MNSC_BUFFER_SIZE - 1);
424 port->uart.icount.rx++;
425
426 st &= SC01STR_FEF | SC01STR_PEF | SC01STR_OEF;
427 status = 0;
428 overrun = 0;
429
430 /* the UART doesn't detect BREAK, so we have to do that ourselves
431 * - it starts as a framing error on a NUL character
432 * - then we count another two NUL characters before issuing TTY_BREAK
433 * - then we end on a normal char or one that has all the bottom bits
434 * zero and the top bits set
435 */
436 switch (port->rx_brk) {
437 case 0:
438 /* not breaking at the moment */
439 break;
440
441 case 1:
442 if (st & SC01STR_FEF && ch == 0) {
443 port->rx_brk = 2;
444 goto try_again;
445 }
446 goto not_break;
447
448 case 2:
449 if (st & SC01STR_FEF && ch == 0) {
450 port->rx_brk = 3;
451 _proto("Rx Break Detected");
452 icount->brk++;
453 if (uart_handle_break(&port->uart))
454 goto ignore_char;
455 status |= 1 << TTY_BREAK;
456 goto insert;
457 }
458 goto not_break;
459
460 default:
461 if (st & (SC01STR_FEF | SC01STR_PEF | SC01STR_OEF))
462 goto try_again; /* still breaking */
463
464 port->rx_brk = 0; /* end of the break */
465
466 switch (ch) {
467 case 0xFF:
468 case 0xFE:
469 case 0xFC:
470 case 0xF8:
471 case 0xF0:
472 case 0xE0:
473 case 0xC0:
474 case 0x80:
475 case 0x00:
476 /* discard char at probable break end */
477 goto try_again;
478 }
479 break;
480 }
481
482 process_errors:
483 /* handle framing error */
484 if (st & SC01STR_FEF) {
485 if (ch == 0) {
486 /* framing error with NUL char is probably a BREAK */
487 port->rx_brk = 1;
488 goto try_again;
489 }
490
491 _proto("Rx Framing Error");
492 icount->frame++;
493 status |= 1 << TTY_FRAME;
494 }
495
496 /* handle parity error */
497 if (st & SC01STR_PEF) {
498 _proto("Rx Parity Error");
499 icount->parity++;
500 status = TTY_PARITY;
501 }
502
503 /* handle normal char */
504 if (status == 0) {
505 if (uart_handle_sysrq_char(&port->uart, ch))
506 goto ignore_char;
507 status = (1 << TTY_NORMAL);
508 }
509
510 /* handle overrun error */
511 if (st & SC01STR_OEF) {
512 if (port->rx_brk)
513 goto try_again;
514
515 _proto("Rx Overrun Error");
516 icount->overrun++;
517 overrun = 1;
518 }
519
520 insert:
521 status &= port->uart.read_status_mask;
522
523 if (!overrun && !(status & port->uart.ignore_status_mask)) {
524 int flag;
525
526 if (status & (1 << TTY_BREAK))
527 flag = TTY_BREAK;
528 else if (status & (1 << TTY_PARITY))
529 flag = TTY_PARITY;
530 else if (status & (1 << TTY_FRAME))
531 flag = TTY_FRAME;
532 else
533 flag = TTY_NORMAL;
534
535 tty_insert_flip_char(tty, ch, flag);
536 }
537
538 /* overrun is special, since it's reported immediately, and doesn't
539 * affect the current character
540 */
541 if (overrun)
542 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
543
544 count--;
545 if (count <= 0) {
546 if (!tty->low_latency)
547 tty_flip_buffer_push(tty);
548 return;
549 }
550
551 ignore_char:
552 push = 1;
553 goto try_again;
554
555 not_break:
556 port->rx_brk = 0;
557 goto process_errors;
558 }
559
560 /*
561 * handle an interrupt from the serial transmission "virtual DMA" driver
562 * - note: the interrupt routine will disable its own interrupts when the Tx
563 * buffer is empty
564 */
565 static void mn10300_serial_transmit_interrupt(struct mn10300_serial_port *port)
566 {
567 _enter("%s", port->name);
568
569 if (!port->uart.state || !port->uart.state->port.tty) {
570 mn10300_serial_dis_tx_intr(port);
571 return;
572 }
573
574 if (uart_tx_stopped(&port->uart) ||
575 uart_circ_empty(&port->uart.state->xmit))
576 mn10300_serial_dis_tx_intr(port);
577
578 if (uart_circ_chars_pending(&port->uart.state->xmit) < WAKEUP_CHARS)
579 uart_write_wakeup(&port->uart);
580 }
581
582 /*
583 * deal with a change in the status of the CTS line
584 */
585 static void mn10300_serial_cts_changed(struct mn10300_serial_port *port, u8 st)
586 {
587 u16 ctr;
588
589 port->tx_cts = st;
590 port->uart.icount.cts++;
591
592 /* flip the CTS state selector flag to interrupt when it changes
593 * back */
594 ctr = *port->_control;
595 ctr ^= SC2CTR_TWS;
596 *port->_control = ctr;
597
598 uart_handle_cts_change(&port->uart, st & SC2STR_CTS);
599 wake_up_interruptible(&port->uart.state->port.delta_msr_wait);
600 }
601
602 /*
603 * handle a virtual interrupt generated by the lower level "virtual DMA"
604 * routines (irq is the baud timer interrupt)
605 */
606 static irqreturn_t mn10300_serial_interrupt(int irq, void *dev_id)
607 {
608 struct mn10300_serial_port *port = dev_id;
609 u8 st;
610
611 spin_lock(&port->uart.lock);
612
613 if (port->intr_flags) {
614 _debug("INT %s: %x", port->name, port->intr_flags);
615
616 if (mask_test_and_clear(&port->intr_flags, MNSCx_RX_AVAIL))
617 mn10300_serial_receive_interrupt(port);
618
619 if (mask_test_and_clear(&port->intr_flags,
620 MNSCx_TX_SPACE | MNSCx_TX_EMPTY))
621 mn10300_serial_transmit_interrupt(port);
622 }
623
624 /* the only modem control line amongst the whole lot is CTS on
625 * serial port 2 */
626 if (port->type == PORT_MN10300_CTS) {
627 st = *port->_status;
628 if ((port->tx_cts ^ st) & SC2STR_CTS)
629 mn10300_serial_cts_changed(port, st);
630 }
631
632 spin_unlock(&port->uart.lock);
633
634 return IRQ_HANDLED;
635 }
636
637 /*
638 * return indication of whether the hardware transmit buffer is empty
639 */
640 static unsigned int mn10300_serial_tx_empty(struct uart_port *_port)
641 {
642 struct mn10300_serial_port *port =
643 container_of(_port, struct mn10300_serial_port, uart);
644
645 _enter("%s", port->name);
646
647 return (*port->_status & (SC01STR_TXF | SC01STR_TBF)) ?
648 0 : TIOCSER_TEMT;
649 }
650
651 /*
652 * set the modem control lines (we don't have any)
653 */
654 static void mn10300_serial_set_mctrl(struct uart_port *_port,
655 unsigned int mctrl)
656 {
657 struct mn10300_serial_port *port =
658 container_of(_port, struct mn10300_serial_port, uart);
659
660 _enter("%s,%x", port->name, mctrl);
661 }
662
663 /*
664 * get the modem control line statuses
665 */
666 static unsigned int mn10300_serial_get_mctrl(struct uart_port *_port)
667 {
668 struct mn10300_serial_port *port =
669 container_of(_port, struct mn10300_serial_port, uart);
670
671 _enter("%s", port->name);
672
673 if (port->type == PORT_MN10300_CTS && !(*port->_status & SC2STR_CTS))
674 return TIOCM_CAR | TIOCM_DSR;
675
676 return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR;
677 }
678
679 /*
680 * stop transmitting characters
681 */
682 static void mn10300_serial_stop_tx(struct uart_port *_port)
683 {
684 struct mn10300_serial_port *port =
685 container_of(_port, struct mn10300_serial_port, uart);
686
687 _enter("%s", port->name);
688
689 /* disable the virtual DMA */
690 mn10300_serial_dis_tx_intr(port);
691 }
692
693 /*
694 * start transmitting characters
695 * - jump-start transmission if it has stalled
696 * - enable the serial Tx interrupt (used by the virtual DMA controller)
697 * - force an interrupt to happen if necessary
698 */
699 static void mn10300_serial_start_tx(struct uart_port *_port)
700 {
701 struct mn10300_serial_port *port =
702 container_of(_port, struct mn10300_serial_port, uart);
703
704 u16 x;
705
706 _enter("%s{%lu}",
707 port->name,
708 CIRC_CNT(&port->uart.state->xmit.head,
709 &port->uart.state->xmit.tail,
710 UART_XMIT_SIZE));
711
712 /* kick the virtual DMA controller */
713 x = *port->tx_icr;
714 x |= GxICR_ENABLE;
715
716 if (*port->_status & SC01STR_TBF)
717 x &= ~(GxICR_REQUEST | GxICR_DETECT);
718 else
719 x |= GxICR_REQUEST | GxICR_DETECT;
720
721 _debug("CTR=%04hx ICR=%02hx STR=%04x TMD=%02hx TBR=%04hx ICR=%04hx",
722 *port->_control, *port->_intr, *port->_status,
723 *port->_tmxmd, *port->_tmxbr, *port->tx_icr);
724
725 *port->tx_icr = x;
726 x = *port->tx_icr;
727 }
728
729 /*
730 * transmit a high-priority XON/XOFF character
731 */
732 static void mn10300_serial_send_xchar(struct uart_port *_port, char ch)
733 {
734 struct mn10300_serial_port *port =
735 container_of(_port, struct mn10300_serial_port, uart);
736
737 _enter("%s,%02x", port->name, ch);
738
739 if (likely(port->gdbstub)) {
740 port->tx_xchar = ch;
741 if (ch)
742 mn10300_serial_en_tx_intr(port);
743 }
744 }
745
746 /*
747 * stop receiving characters
748 * - called whilst the port is being closed
749 */
750 static void mn10300_serial_stop_rx(struct uart_port *_port)
751 {
752 struct mn10300_serial_port *port =
753 container_of(_port, struct mn10300_serial_port, uart);
754
755 u16 ctr;
756
757 _enter("%s", port->name);
758
759 ctr = *port->_control;
760 ctr &= ~SC01CTR_RXE;
761 *port->_control = ctr;
762
763 mn10300_serial_dis_rx_intr(port);
764 }
765
766 /*
767 * enable modem status interrupts
768 */
769 static void mn10300_serial_enable_ms(struct uart_port *_port)
770 {
771 struct mn10300_serial_port *port =
772 container_of(_port, struct mn10300_serial_port, uart);
773
774 u16 ctr, cts;
775
776 _enter("%s", port->name);
777
778 if (port->type == PORT_MN10300_CTS) {
779 /* want to interrupt when CTS goes low if CTS is now high and
780 * vice versa
781 */
782 port->tx_cts = *port->_status;
783
784 cts = (port->tx_cts & SC2STR_CTS) ?
785 SC2CTR_TWE : SC2CTR_TWE | SC2CTR_TWS;
786
787 ctr = *port->_control;
788 ctr &= ~SC2CTR_TWS;
789 ctr |= cts;
790 *port->_control = ctr;
791
792 mn10300_serial_en_tx_intr(port);
793 }
794 }
795
796 /*
797 * transmit or cease transmitting a break signal
798 */
799 static void mn10300_serial_break_ctl(struct uart_port *_port, int ctl)
800 {
801 struct mn10300_serial_port *port =
802 container_of(_port, struct mn10300_serial_port, uart);
803
804 _enter("%s,%d", port->name, ctl);
805
806 if (ctl) {
807 /* tell the virtual DMA handler to assert BREAK */
808 port->tx_break = 1;
809 mn10300_serial_en_tx_intr(port);
810 } else {
811 port->tx_break = 0;
812 *port->_control &= ~SC01CTR_BKE;
813 mn10300_serial_en_tx_intr(port);
814 }
815 }
816
817 /*
818 * grab the interrupts and enable the port for reception
819 */
820 static int mn10300_serial_startup(struct uart_port *_port)
821 {
822 struct mn10300_serial_port *port =
823 container_of(_port, struct mn10300_serial_port, uart);
824 struct mn10300_serial_int *pint;
825
826 _enter("%s{%d}", port->name, port->gdbstub);
827
828 if (unlikely(port->gdbstub))
829 return -EBUSY;
830
831 /* allocate an Rx buffer for the virtual DMA handler */
832 port->rx_buffer = kmalloc(MNSC_BUFFER_SIZE, GFP_KERNEL);
833 if (!port->rx_buffer)
834 return -ENOMEM;
835
836 port->rx_inp = port->rx_outp = 0;
837
838 /* finally, enable the device */
839 *port->_intr = SC01ICR_TI;
840 *port->_control |= SC01CTR_TXE | SC01CTR_RXE;
841
842 pint = &mn10300_serial_int_tbl[port->rx_irq];
843 pint->port = port;
844 pint->vdma = mn10300_serial_vdma_rx_handler;
845 pint = &mn10300_serial_int_tbl[port->tx_irq];
846 pint->port = port;
847 pint->vdma = mn10300_serial_vdma_tx_handler;
848
849 set_intr_level(port->rx_irq, GxICR_LEVEL_1);
850 set_intr_level(port->tx_irq, GxICR_LEVEL_1);
851 set_irq_chip(port->tm_irq, &mn10300_serial_pic);
852
853 if (request_irq(port->rx_irq, mn10300_serial_interrupt,
854 IRQF_DISABLED, port->rx_name, port) < 0)
855 goto error;
856
857 if (request_irq(port->tx_irq, mn10300_serial_interrupt,
858 IRQF_DISABLED, port->tx_name, port) < 0)
859 goto error2;
860
861 if (request_irq(port->tm_irq, mn10300_serial_interrupt,
862 IRQF_DISABLED, port->tm_name, port) < 0)
863 goto error3;
864 mn10300_serial_mask_ack(port->tm_irq);
865
866 return 0;
867
868 error3:
869 free_irq(port->tx_irq, port);
870 error2:
871 free_irq(port->rx_irq, port);
872 error:
873 kfree(port->rx_buffer);
874 port->rx_buffer = NULL;
875 return -EBUSY;
876 }
877
878 /*
879 * shutdown the port and release interrupts
880 */
881 static void mn10300_serial_shutdown(struct uart_port *_port)
882 {
883 struct mn10300_serial_port *port =
884 container_of(_port, struct mn10300_serial_port, uart);
885
886 _enter("%s", port->name);
887
888 /* disable the serial port and its baud rate timer */
889 port->tx_break = 0;
890 *port->_control &= ~(SC01CTR_TXE | SC01CTR_RXE | SC01CTR_BKE);
891 *port->_tmxmd = 0;
892
893 if (port->rx_buffer) {
894 void *buf = port->rx_buffer;
895 port->rx_buffer = NULL;
896 kfree(buf);
897 }
898
899 /* disable all intrs */
900 free_irq(port->tm_irq, port);
901 free_irq(port->rx_irq, port);
902 free_irq(port->tx_irq, port);
903
904 *port->rx_icr = GxICR_LEVEL_1;
905 *port->tx_icr = GxICR_LEVEL_1;
906 }
907
908 /*
909 * this routine is called to set the UART divisor registers to match the
910 * specified baud rate for a serial port.
911 */
912 static void mn10300_serial_change_speed(struct mn10300_serial_port *port,
913 struct ktermios *new,
914 struct ktermios *old)
915 {
916 unsigned long flags;
917 unsigned long ioclk = port->ioclk;
918 unsigned cflag;
919 int baud, bits, xdiv, tmp;
920 u16 tmxbr, scxctr;
921 u8 tmxmd, battempt;
922 u8 div_timer = port->div_timer;
923
924 _enter("%s{%lu}", port->name, ioclk);
925
926 /* byte size and parity */
927 cflag = new->c_cflag;
928 switch (cflag & CSIZE) {
929 case CS7: scxctr = SC01CTR_CLN_7BIT; bits = 9; break;
930 case CS8: scxctr = SC01CTR_CLN_8BIT; bits = 10; break;
931 default: scxctr = SC01CTR_CLN_8BIT; bits = 10; break;
932 }
933
934 if (cflag & CSTOPB) {
935 scxctr |= SC01CTR_STB_2BIT;
936 bits++;
937 }
938
939 if (cflag & PARENB) {
940 bits++;
941 if (cflag & PARODD)
942 scxctr |= SC01CTR_PB_ODD;
943 #ifdef CMSPAR
944 else if (cflag & CMSPAR)
945 scxctr |= SC01CTR_PB_FIXED0;
946 #endif
947 else
948 scxctr |= SC01CTR_PB_EVEN;
949 }
950
951 /* Determine divisor based on baud rate */
952 battempt = 0;
953
954 if (div_timer == MNSCx_DIV_TIMER_16BIT)
955 scxctr |= SC0CTR_CK_TM8UFLOW_8; /* ( == SC1CTR_CK_TM9UFLOW_8
956 * == SC2CTR_CK_TM10UFLOW) */
957 else if (div_timer == MNSCx_DIV_TIMER_8BIT)
958 scxctr |= SC0CTR_CK_TM2UFLOW_8;
959
960 try_alternative:
961 baud = uart_get_baud_rate(&port->uart, new, old, 0,
962 port->ioclk / 8);
963
964 _debug("ALT %d [baud %d]", battempt, baud);
965
966 if (!baud)
967 baud = 9600; /* B0 transition handled in rs_set_termios */
968 xdiv = 1;
969 if (baud == 134) {
970 baud = 269; /* 134 is really 134.5 */
971 xdiv = 2;
972 }
973
974 if (baud == 38400 &&
975 (port->uart.flags & UPF_SPD_MASK) == UPF_SPD_CUST
976 ) {
977 _debug("CUSTOM %u", port->uart.custom_divisor);
978
979 if (div_timer == MNSCx_DIV_TIMER_16BIT) {
980 if (port->uart.custom_divisor <= 65535) {
981 tmxmd = TM8MD_SRC_IOCLK;
982 tmxbr = port->uart.custom_divisor;
983 port->uart.uartclk = ioclk;
984 goto timer_okay;
985 }
986 if (port->uart.custom_divisor / 8 <= 65535) {
987 tmxmd = TM8MD_SRC_IOCLK_8;
988 tmxbr = port->uart.custom_divisor / 8;
989 port->uart.custom_divisor = tmxbr * 8;
990 port->uart.uartclk = ioclk / 8;
991 goto timer_okay;
992 }
993 if (port->uart.custom_divisor / 32 <= 65535) {
994 tmxmd = TM8MD_SRC_IOCLK_32;
995 tmxbr = port->uart.custom_divisor / 32;
996 port->uart.custom_divisor = tmxbr * 32;
997 port->uart.uartclk = ioclk / 32;
998 goto timer_okay;
999 }
1000
1001 } else if (div_timer == MNSCx_DIV_TIMER_8BIT) {
1002 if (port->uart.custom_divisor <= 255) {
1003 tmxmd = TM2MD_SRC_IOCLK;
1004 tmxbr = port->uart.custom_divisor;
1005 port->uart.uartclk = ioclk;
1006 goto timer_okay;
1007 }
1008 if (port->uart.custom_divisor / 8 <= 255) {
1009 tmxmd = TM2MD_SRC_IOCLK_8;
1010 tmxbr = port->uart.custom_divisor / 8;
1011 port->uart.custom_divisor = tmxbr * 8;
1012 port->uart.uartclk = ioclk / 8;
1013 goto timer_okay;
1014 }
1015 if (port->uart.custom_divisor / 32 <= 255) {
1016 tmxmd = TM2MD_SRC_IOCLK_32;
1017 tmxbr = port->uart.custom_divisor / 32;
1018 port->uart.custom_divisor = tmxbr * 32;
1019 port->uart.uartclk = ioclk / 32;
1020 goto timer_okay;
1021 }
1022 }
1023 }
1024
1025 switch (div_timer) {
1026 case MNSCx_DIV_TIMER_16BIT:
1027 port->uart.uartclk = ioclk;
1028 tmxmd = TM8MD_SRC_IOCLK;
1029 tmxbr = tmp = (ioclk / (baud * xdiv) + 4) / 8 - 1;
1030 if (tmp > 0 && tmp <= 65535)
1031 goto timer_okay;
1032
1033 port->uart.uartclk = ioclk / 8;
1034 tmxmd = TM8MD_SRC_IOCLK_8;
1035 tmxbr = tmp = (ioclk / (baud * 8 * xdiv) + 4) / 8 - 1;
1036 if (tmp > 0 && tmp <= 65535)
1037 goto timer_okay;
1038
1039 port->uart.uartclk = ioclk / 32;
1040 tmxmd = TM8MD_SRC_IOCLK_32;
1041 tmxbr = tmp = (ioclk / (baud * 32 * xdiv) + 4) / 8 - 1;
1042 if (tmp > 0 && tmp <= 65535)
1043 goto timer_okay;
1044 break;
1045
1046 case MNSCx_DIV_TIMER_8BIT:
1047 port->uart.uartclk = ioclk;
1048 tmxmd = TM2MD_SRC_IOCLK;
1049 tmxbr = tmp = (ioclk / (baud * xdiv) + 4) / 8 - 1;
1050 if (tmp > 0 && tmp <= 255)
1051 goto timer_okay;
1052
1053 port->uart.uartclk = ioclk / 8;
1054 tmxmd = TM2MD_SRC_IOCLK_8;
1055 tmxbr = tmp = (ioclk / (baud * 8 * xdiv) + 4) / 8 - 1;
1056 if (tmp > 0 && tmp <= 255)
1057 goto timer_okay;
1058
1059 port->uart.uartclk = ioclk / 32;
1060 tmxmd = TM2MD_SRC_IOCLK_32;
1061 tmxbr = tmp = (ioclk / (baud * 32 * xdiv) + 4) / 8 - 1;
1062 if (tmp > 0 && tmp <= 255)
1063 goto timer_okay;
1064 break;
1065
1066 default:
1067 BUG();
1068 return;
1069 }
1070
1071 /* refuse to change to a baud rate we can't support */
1072 _debug("CAN'T SUPPORT");
1073
1074 switch (battempt) {
1075 case 0:
1076 if (old) {
1077 new->c_cflag &= ~CBAUD;
1078 new->c_cflag |= (old->c_cflag & CBAUD);
1079 battempt = 1;
1080 goto try_alternative;
1081 }
1082
1083 case 1:
1084 /* as a last resort, if the quotient is zero, default to 9600
1085 * bps */
1086 new->c_cflag &= ~CBAUD;
1087 new->c_cflag |= B9600;
1088 battempt = 2;
1089 goto try_alternative;
1090
1091 default:
1092 /* hmmm... can't seem to support 9600 either
1093 * - we could try iterating through the speeds we know about to
1094 * find the lowest
1095 */
1096 new->c_cflag &= ~CBAUD;
1097 new->c_cflag |= B0;
1098
1099 if (div_timer == MNSCx_DIV_TIMER_16BIT)
1100 tmxmd = TM8MD_SRC_IOCLK_32;
1101 else if (div_timer == MNSCx_DIV_TIMER_8BIT)
1102 tmxmd = TM2MD_SRC_IOCLK_32;
1103 tmxbr = 1;
1104
1105 port->uart.uartclk = ioclk / 32;
1106 break;
1107 }
1108 timer_okay:
1109
1110 _debug("UARTCLK: %u / %hu", port->uart.uartclk, tmxbr);
1111
1112 /* make the changes */
1113 spin_lock_irqsave(&port->uart.lock, flags);
1114
1115 uart_update_timeout(&port->uart, new->c_cflag, baud);
1116
1117 /* set the timer to produce the required baud rate */
1118 switch (div_timer) {
1119 case MNSCx_DIV_TIMER_16BIT:
1120 *port->_tmxmd = 0;
1121 *port->_tmxbr = tmxbr;
1122 *port->_tmxmd = TM8MD_INIT_COUNTER;
1123 *port->_tmxmd = tmxmd | TM8MD_COUNT_ENABLE;
1124 break;
1125
1126 case MNSCx_DIV_TIMER_8BIT:
1127 *port->_tmxmd = 0;
1128 *(volatile u8 *) port->_tmxbr = (u8) tmxbr;
1129 *port->_tmxmd = TM2MD_INIT_COUNTER;
1130 *port->_tmxmd = tmxmd | TM2MD_COUNT_ENABLE;
1131 break;
1132 }
1133
1134 /* CTS flow control flag and modem status interrupts */
1135 scxctr &= ~(SC2CTR_TWE | SC2CTR_TWS);
1136
1137 if (port->type == PORT_MN10300_CTS && cflag & CRTSCTS) {
1138 /* want to interrupt when CTS goes low if CTS is now
1139 * high and vice versa
1140 */
1141 port->tx_cts = *port->_status;
1142
1143 if (port->tx_cts & SC2STR_CTS)
1144 scxctr |= SC2CTR_TWE;
1145 else
1146 scxctr |= SC2CTR_TWE | SC2CTR_TWS;
1147 }
1148
1149 /* set up parity check flag */
1150 port->uart.read_status_mask = (1 << TTY_NORMAL) | (1 << TTY_OVERRUN);
1151 if (new->c_iflag & INPCK)
1152 port->uart.read_status_mask |=
1153 (1 << TTY_PARITY) | (1 << TTY_FRAME);
1154 if (new->c_iflag & (BRKINT | PARMRK))
1155 port->uart.read_status_mask |= (1 << TTY_BREAK);
1156
1157 /* characters to ignore */
1158 port->uart.ignore_status_mask = 0;
1159 if (new->c_iflag & IGNPAR)
1160 port->uart.ignore_status_mask |=
1161 (1 << TTY_PARITY) | (1 << TTY_FRAME);
1162 if (new->c_iflag & IGNBRK) {
1163 port->uart.ignore_status_mask |= (1 << TTY_BREAK);
1164 /*
1165 * If we're ignoring parity and break indicators,
1166 * ignore overruns to (for real raw support).
1167 */
1168 if (new->c_iflag & IGNPAR)
1169 port->uart.ignore_status_mask |= (1 << TTY_OVERRUN);
1170 }
1171
1172 /* Ignore all characters if CREAD is not set */
1173 if ((new->c_cflag & CREAD) == 0)
1174 port->uart.ignore_status_mask |= (1 << TTY_NORMAL);
1175
1176 scxctr |= *port->_control & (SC01CTR_TXE | SC01CTR_RXE | SC01CTR_BKE);
1177 *port->_control = scxctr;
1178
1179 spin_unlock_irqrestore(&port->uart.lock, flags);
1180 }
1181
1182 /*
1183 * set the terminal I/O parameters
1184 */
1185 static void mn10300_serial_set_termios(struct uart_port *_port,
1186 struct ktermios *new,
1187 struct ktermios *old)
1188 {
1189 struct mn10300_serial_port *port =
1190 container_of(_port, struct mn10300_serial_port, uart);
1191
1192 _enter("%s,%p,%p", port->name, new, old);
1193
1194 mn10300_serial_change_speed(port, new, old);
1195
1196 /* handle turning off CRTSCTS */
1197 if (!(new->c_cflag & CRTSCTS)) {
1198 u16 ctr = *port->_control;
1199 ctr &= ~SC2CTR_TWE;
1200 *port->_control = ctr;
1201 }
1202 }
1203
1204 /*
1205 * return description of port type
1206 */
1207 static const char *mn10300_serial_type(struct uart_port *_port)
1208 {
1209 struct mn10300_serial_port *port =
1210 container_of(_port, struct mn10300_serial_port, uart);
1211
1212 if (port->uart.type == PORT_MN10300_CTS)
1213 return "MN10300 SIF_CTS";
1214
1215 return "MN10300 SIF";
1216 }
1217
1218 /*
1219 * release I/O and memory regions in use by port
1220 */
1221 static void mn10300_serial_release_port(struct uart_port *_port)
1222 {
1223 struct mn10300_serial_port *port =
1224 container_of(_port, struct mn10300_serial_port, uart);
1225
1226 _enter("%s", port->name);
1227
1228 release_mem_region((unsigned long) port->_iobase, 16);
1229 }
1230
1231 /*
1232 * request I/O and memory regions for port
1233 */
1234 static int mn10300_serial_request_port(struct uart_port *_port)
1235 {
1236 struct mn10300_serial_port *port =
1237 container_of(_port, struct mn10300_serial_port, uart);
1238
1239 _enter("%s", port->name);
1240
1241 request_mem_region((unsigned long) port->_iobase, 16, port->name);
1242 return 0;
1243 }
1244
1245 /*
1246 * configure the type and reserve the ports
1247 */
1248 static void mn10300_serial_config_port(struct uart_port *_port, int type)
1249 {
1250 struct mn10300_serial_port *port =
1251 container_of(_port, struct mn10300_serial_port, uart);
1252
1253 _enter("%s", port->name);
1254
1255 port->uart.type = PORT_MN10300;
1256
1257 if (port->options & MNSCx_OPT_CTS)
1258 port->uart.type = PORT_MN10300_CTS;
1259
1260 mn10300_serial_request_port(_port);
1261 }
1262
1263 /*
1264 * verify serial parameters are suitable for this port type
1265 */
1266 static int mn10300_serial_verify_port(struct uart_port *_port,
1267 struct serial_struct *ss)
1268 {
1269 struct mn10300_serial_port *port =
1270 container_of(_port, struct mn10300_serial_port, uart);
1271 void *mapbase = (void *) (unsigned long) port->uart.mapbase;
1272
1273 _enter("%s", port->name);
1274
1275 /* these things may not be changed */
1276 if (ss->irq != port->uart.irq ||
1277 ss->port != port->uart.iobase ||
1278 ss->io_type != port->uart.iotype ||
1279 ss->iomem_base != mapbase ||
1280 ss->iomem_reg_shift != port->uart.regshift ||
1281 ss->hub6 != port->uart.hub6 ||
1282 ss->xmit_fifo_size != port->uart.fifosize)
1283 return -EINVAL;
1284
1285 /* type may be changed on a port that supports CTS */
1286 if (ss->type != port->uart.type) {
1287 if (!(port->options & MNSCx_OPT_CTS))
1288 return -EINVAL;
1289
1290 if (ss->type != PORT_MN10300 &&
1291 ss->type != PORT_MN10300_CTS)
1292 return -EINVAL;
1293 }
1294
1295 return 0;
1296 }
1297
1298 /*
1299 * initialise the MN10300 on-chip UARTs
1300 */
1301 static int __init mn10300_serial_init(void)
1302 {
1303 struct mn10300_serial_port *port;
1304 int ret, i;
1305
1306 printk(KERN_INFO "%s version %s (%s)\n",
1307 serial_name, serial_version, serial_revdate);
1308
1309 #ifdef CONFIG_MN10300_TTYSM2
1310 SC2TIM = 8; /* make the baud base of timer 2 IOCLK/8 */
1311 #endif
1312
1313 set_intr_stub(EXCEP_IRQ_LEVEL1, mn10300_serial_vdma_interrupt);
1314
1315 ret = uart_register_driver(&mn10300_serial_driver);
1316 if (!ret) {
1317 for (i = 0 ; i < NR_PORTS ; i++) {
1318 port = mn10300_serial_ports[i];
1319 if (!port || port->gdbstub)
1320 continue;
1321
1322 switch (port->clock_src) {
1323 case MNSCx_CLOCK_SRC_IOCLK:
1324 port->ioclk = MN10300_IOCLK;
1325 break;
1326
1327 #ifdef MN10300_IOBCLK
1328 case MNSCx_CLOCK_SRC_IOBCLK:
1329 port->ioclk = MN10300_IOBCLK;
1330 break;
1331 #endif
1332 default:
1333 BUG();
1334 }
1335
1336 ret = uart_add_one_port(&mn10300_serial_driver,
1337 &port->uart);
1338
1339 if (ret < 0) {
1340 _debug("ERROR %d", -ret);
1341 break;
1342 }
1343 }
1344
1345 if (ret)
1346 uart_unregister_driver(&mn10300_serial_driver);
1347 }
1348
1349 return ret;
1350 }
1351
1352 __initcall(mn10300_serial_init);
1353
1354
1355 #ifdef CONFIG_MN10300_TTYSM_CONSOLE
1356
1357 /*
1358 * print a string to the serial port without disturbing the real user of the
1359 * port too much
1360 * - the console must be locked by the caller
1361 */
1362 static void mn10300_serial_console_write(struct console *co,
1363 const char *s, unsigned count)
1364 {
1365 struct mn10300_serial_port *port;
1366 unsigned i;
1367 u16 scxctr, txicr, tmp;
1368 u8 tmxmd;
1369
1370 port = mn10300_serial_ports[co->index];
1371
1372 /* firstly hijack the serial port from the "virtual DMA" controller */
1373 txicr = *port->tx_icr;
1374 *port->tx_icr = GxICR_LEVEL_1;
1375 tmp = *port->tx_icr;
1376
1377 /* the transmitter may be disabled */
1378 scxctr = *port->_control;
1379 if (!(scxctr & SC01CTR_TXE)) {
1380 /* restart the UART clock */
1381 tmxmd = *port->_tmxmd;
1382
1383 switch (port->div_timer) {
1384 case MNSCx_DIV_TIMER_16BIT:
1385 *port->_tmxmd = 0;
1386 *port->_tmxmd = TM8MD_INIT_COUNTER;
1387 *port->_tmxmd = tmxmd | TM8MD_COUNT_ENABLE;
1388 break;
1389
1390 case MNSCx_DIV_TIMER_8BIT:
1391 *port->_tmxmd = 0;
1392 *port->_tmxmd = TM2MD_INIT_COUNTER;
1393 *port->_tmxmd = tmxmd | TM2MD_COUNT_ENABLE;
1394 break;
1395 }
1396
1397 /* enable the transmitter */
1398 *port->_control = (scxctr & ~SC01CTR_BKE) | SC01CTR_TXE;
1399
1400 } else if (scxctr & SC01CTR_BKE) {
1401 /* stop transmitting BREAK */
1402 *port->_control = (scxctr & ~SC01CTR_BKE);
1403 }
1404
1405 /* send the chars into the serial port (with LF -> LFCR conversion) */
1406 for (i = 0; i < count; i++) {
1407 char ch = *s++;
1408
1409 while (*port->_status & SC01STR_TBF)
1410 continue;
1411 *(u8 *) port->_txb = ch;
1412
1413 if (ch == 0x0a) {
1414 while (*port->_status & SC01STR_TBF)
1415 continue;
1416 *(u8 *) port->_txb = 0xd;
1417 }
1418 }
1419
1420 /* can't let the transmitter be turned off if it's actually
1421 * transmitting */
1422 while (*port->_status & (SC01STR_TXF | SC01STR_TBF))
1423 continue;
1424
1425 /* disable the transmitter if we re-enabled it */
1426 if (!(scxctr & SC01CTR_TXE))
1427 *port->_control = scxctr;
1428
1429 *port->tx_icr = txicr;
1430 tmp = *port->tx_icr;
1431 }
1432
1433 /*
1434 * set up a serial port as a console
1435 * - construct a cflag setting for the first rs_open()
1436 * - initialize the serial port
1437 * - return non-zero if we didn't find a serial port.
1438 */
1439 static int __init mn10300_serial_console_setup(struct console *co,
1440 char *options)
1441 {
1442 struct mn10300_serial_port *port;
1443 int i, parity = 'n', baud = 9600, bits = 8, flow = 0;
1444
1445 for (i = 0 ; i < NR_PORTS ; i++) {
1446 port = mn10300_serial_ports[i];
1447 if (port && !port->gdbstub && port->uart.line == co->index)
1448 goto found_device;
1449 }
1450
1451 return -ENODEV;
1452
1453 found_device:
1454 switch (port->clock_src) {
1455 case MNSCx_CLOCK_SRC_IOCLK:
1456 port->ioclk = MN10300_IOCLK;
1457 break;
1458
1459 #ifdef MN10300_IOBCLK
1460 case MNSCx_CLOCK_SRC_IOBCLK:
1461 port->ioclk = MN10300_IOBCLK;
1462 break;
1463 #endif
1464 default:
1465 BUG();
1466 }
1467
1468 if (options)
1469 uart_parse_options(options, &baud, &parity, &bits, &flow);
1470
1471 return uart_set_options(&port->uart, co, baud, parity, bits, flow);
1472 }
1473
1474 /*
1475 * register console
1476 */
1477 static int __init mn10300_serial_console_init(void)
1478 {
1479 register_console(&mn10300_serial_console);
1480 return 0;
1481 }
1482
1483 console_initcall(mn10300_serial_console_init);
1484 #endif
mm of the moment repository