2 * Blackfin On-Chip Serial Driver
4 * Copyright 2006-2011 Analog Devices Inc.
6 * Enter bugs at http://blackfin.uclinux.org/
8 * Licensed under the GPL-2 or later.
11 #if defined(CONFIG_SERIAL_BFIN_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
15 #define DRIVER_NAME "bfin-uart"
16 #define pr_fmt(fmt) DRIVER_NAME ": " fmt
18 #include <linux/module.h>
19 #include <linux/ioport.h>
20 #include <linux/gfp.h>
22 #include <linux/init.h>
23 #include <linux/console.h>
24 #include <linux/sysrq.h>
25 #include <linux/platform_device.h>
26 #include <linux/tty.h>
27 #include <linux/tty_flip.h>
28 #include <linux/serial_core.h>
29 #include <linux/gpio.h>
30 #include <linux/irq.h>
31 #include <linux/kgdb.h>
32 #include <linux/slab.h>
33 #include <linux/dma-mapping.h>
35 #include <asm/portmux.h>
36 #include <asm/cacheflush.h>
38 #include <asm/bfin_serial.h>
40 #ifdef CONFIG_SERIAL_BFIN_MODULE
41 # undef CONFIG_EARLY_PRINTK
44 /* UART name and device definitions */
45 #define BFIN_SERIAL_DEV_NAME "ttyBF"
46 #define BFIN_SERIAL_MAJOR 204
47 #define BFIN_SERIAL_MINOR 64
49 static struct bfin_serial_port *bfin_serial_ports[BFIN_UART_NR_PORTS];
51 #if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
52 defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
54 # ifndef CONFIG_SERIAL_BFIN_PIO
55 # error KGDB only support UART in PIO mode.
58 static int kgdboc_port_line;
59 static int kgdboc_break_enabled;
62 * Setup for console. Argument comes from the menuconfig
64 #define DMA_RX_XCOUNT 512
65 #define DMA_RX_YCOUNT (PAGE_SIZE / DMA_RX_XCOUNT)
67 #define DMA_RX_FLUSH_JIFFIES (HZ / 50)
69 #ifdef CONFIG_SERIAL_BFIN_DMA
70 static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart);
72 static void bfin_serial_tx_chars(struct bfin_serial_port *uart);
75 static void bfin_serial_reset_irda(struct uart_port *port);
77 #if defined(CONFIG_SERIAL_BFIN_CTSRTS) || \
78 defined(CONFIG_SERIAL_BFIN_HARD_CTSRTS)
79 static unsigned int bfin_serial_get_mctrl(struct uart_port *port)
81 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
82 if (uart->cts_pin < 0)
83 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
85 /* CTS PIN is negative assertive. */
86 if (UART_GET_CTS(uart))
87 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
89 return TIOCM_DSR | TIOCM_CAR;
92 static void bfin_serial_set_mctrl(struct uart_port *port, unsigned int mctrl)
94 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
95 if (uart->rts_pin < 0)
98 /* RTS PIN is negative assertive. */
99 if (mctrl & TIOCM_RTS)
100 UART_ENABLE_RTS(uart);
102 UART_DISABLE_RTS(uart);
106 * Handle any change of modem status signal.
108 static irqreturn_t bfin_serial_mctrl_cts_int(int irq, void *dev_id)
110 struct bfin_serial_port *uart = dev_id;
111 struct uart_port *uport = &uart->port;
112 unsigned int status = bfin_serial_get_mctrl(uport);
113 #ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
115 UART_CLEAR_SCTS(uart);
116 if (uport->hw_stopped) {
118 uport->hw_stopped = 0;
119 uart_write_wakeup(uport);
123 uport->hw_stopped = 1;
126 uart_handle_cts_change(uport, status & TIOCM_CTS);
132 static unsigned int bfin_serial_get_mctrl(struct uart_port *port)
134 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
137 static void bfin_serial_set_mctrl(struct uart_port *port, unsigned int mctrl)
143 * interrupts are disabled on entry
145 static void bfin_serial_stop_tx(struct uart_port *port)
147 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
148 #ifdef CONFIG_SERIAL_BFIN_DMA
149 struct circ_buf *xmit = &uart->port.state->xmit;
152 while (!(UART_GET_LSR(uart) & TEMT))
155 #ifdef CONFIG_SERIAL_BFIN_DMA
156 disable_dma(uart->tx_dma_channel);
157 xmit->tail = (xmit->tail + uart->tx_count) & (UART_XMIT_SIZE - 1);
158 uart->port.icount.tx += uart->tx_count;
162 #if defined(CONFIG_BF54x) || defined(CONFIG_BF60x)
164 UART_PUT_LSR(uart, TFI);
166 UART_CLEAR_IER(uart, ETBEI);
171 * port is locked and interrupts are disabled
173 static void bfin_serial_start_tx(struct uart_port *port)
175 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
176 struct tty_struct *tty = uart->port.state->port.tty;
179 * To avoid losting RX interrupt, we reset IR function
180 * before sending data.
182 if (tty->termios.c_line == N_IRDA)
183 bfin_serial_reset_irda(port);
185 #ifdef CONFIG_SERIAL_BFIN_DMA
187 bfin_serial_dma_tx_chars(uart);
189 UART_SET_IER(uart, ETBEI);
190 bfin_serial_tx_chars(uart);
195 * Interrupts are enabled
197 static void bfin_serial_stop_rx(struct uart_port *port)
199 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
201 UART_CLEAR_IER(uart, ERBFI);
204 #if ANOMALY_05000363 && defined(CONFIG_SERIAL_BFIN_PIO)
205 # define UART_GET_ANOMALY_THRESHOLD(uart) ((uart)->anomaly_threshold)
206 # define UART_SET_ANOMALY_THRESHOLD(uart, v) ((uart)->anomaly_threshold = (v))
208 # define UART_GET_ANOMALY_THRESHOLD(uart) 0
209 # define UART_SET_ANOMALY_THRESHOLD(uart, v)
212 #ifdef CONFIG_SERIAL_BFIN_PIO
213 static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
215 unsigned int status, ch, flg;
216 static struct timeval anomaly_start = { .tv_sec = 0 };
218 status = UART_GET_LSR(uart);
219 UART_CLEAR_LSR(uart);
221 ch = UART_GET_CHAR(uart);
222 uart->port.icount.rx++;
224 #if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
225 defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
226 if (kgdb_connected && kgdboc_port_line == uart->port.line
227 && kgdboc_break_enabled)
228 if (ch == 0x3) {/* Ctrl + C */
233 if (!uart->port.state)
236 if (ANOMALY_05000363) {
237 /* The BF533 (and BF561) family of processors have a nice anomaly
238 * where they continuously generate characters for a "single" break.
239 * We have to basically ignore this flood until the "next" valid
240 * character comes across. Due to the nature of the flood, it is
241 * not possible to reliably catch bytes that are sent too quickly
242 * after this break. So application code talking to the Blackfin
243 * which sends a break signal must allow at least 1.5 character
244 * times after the end of the break for things to stabilize. This
245 * timeout was picked as it must absolutely be larger than 1
246 * character time +/- some percent. So 1.5 sounds good. All other
247 * Blackfin families operate properly. Woo.
249 if (anomaly_start.tv_sec) {
253 if ((~ch & (~ch + 1)) & 0xff)
254 goto known_good_char;
256 do_gettimeofday(&curr);
257 if (curr.tv_sec - anomaly_start.tv_sec > 1)
258 goto known_good_char;
261 if (curr.tv_sec != anomaly_start.tv_sec)
262 usecs += USEC_PER_SEC;
263 usecs += curr.tv_usec - anomaly_start.tv_usec;
265 if (usecs > UART_GET_ANOMALY_THRESHOLD(uart))
266 goto known_good_char;
269 anomaly_start.tv_sec = 0;
271 anomaly_start = curr;
277 anomaly_start.tv_sec = 0;
282 if (ANOMALY_05000363)
283 if (bfin_revid() < 5)
284 do_gettimeofday(&anomaly_start);
285 uart->port.icount.brk++;
286 if (uart_handle_break(&uart->port))
288 status &= ~(PE | FE);
291 uart->port.icount.parity++;
293 uart->port.icount.overrun++;
295 uart->port.icount.frame++;
297 status &= uart->port.read_status_mask;
301 else if (status & PE)
303 else if (status & FE)
308 if (uart_handle_sysrq_char(&uart->port, ch))
311 uart_insert_char(&uart->port, status, OE, ch, flg);
314 tty_flip_buffer_push(&uart->port.state->port);
317 static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
319 struct circ_buf *xmit = &uart->port.state->xmit;
321 if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
322 #if defined(CONFIG_BF54x) || defined(CONFIG_BF60x)
324 UART_PUT_LSR(uart, TFI);
327 * 05000215 - we always clear ETBEI within last UART TX
328 * interrupt to end a string. It is always set
329 * when start a new tx.
331 UART_CLEAR_IER(uart, ETBEI);
335 if (uart->port.x_char) {
336 UART_PUT_CHAR(uart, uart->port.x_char);
337 uart->port.icount.tx++;
338 uart->port.x_char = 0;
341 while ((UART_GET_LSR(uart) & THRE) && xmit->tail != xmit->head) {
342 UART_PUT_CHAR(uart, xmit->buf[xmit->tail]);
343 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
344 uart->port.icount.tx++;
347 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
348 uart_write_wakeup(&uart->port);
351 static irqreturn_t bfin_serial_rx_int(int irq, void *dev_id)
353 struct bfin_serial_port *uart = dev_id;
355 while (UART_GET_LSR(uart) & DR)
356 bfin_serial_rx_chars(uart);
361 static irqreturn_t bfin_serial_tx_int(int irq, void *dev_id)
363 struct bfin_serial_port *uart = dev_id;
365 spin_lock(&uart->port.lock);
366 if (UART_GET_LSR(uart) & THRE)
367 bfin_serial_tx_chars(uart);
368 spin_unlock(&uart->port.lock);
374 #ifdef CONFIG_SERIAL_BFIN_DMA
375 static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
377 struct circ_buf *xmit = &uart->port.state->xmit;
381 if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
387 if (uart->port.x_char) {
388 UART_PUT_CHAR(uart, uart->port.x_char);
389 uart->port.icount.tx++;
390 uart->port.x_char = 0;
393 uart->tx_count = CIRC_CNT(xmit->head, xmit->tail, UART_XMIT_SIZE);
394 if (uart->tx_count > (UART_XMIT_SIZE - xmit->tail))
395 uart->tx_count = UART_XMIT_SIZE - xmit->tail;
396 blackfin_dcache_flush_range((unsigned long)(xmit->buf+xmit->tail),
397 (unsigned long)(xmit->buf+xmit->tail+uart->tx_count));
398 set_dma_config(uart->tx_dma_channel,
399 set_bfin_dma_config(DIR_READ, DMA_FLOW_STOP,
404 set_dma_start_addr(uart->tx_dma_channel, (unsigned long)(xmit->buf+xmit->tail));
405 set_dma_x_count(uart->tx_dma_channel, uart->tx_count);
406 set_dma_x_modify(uart->tx_dma_channel, 1);
408 enable_dma(uart->tx_dma_channel);
410 UART_SET_IER(uart, ETBEI);
413 static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart)
417 status = UART_GET_LSR(uart);
418 UART_CLEAR_LSR(uart);
420 uart->port.icount.rx +=
421 CIRC_CNT(uart->rx_dma_buf.head, uart->rx_dma_buf.tail,
425 uart->port.icount.brk++;
426 if (uart_handle_break(&uart->port))
427 goto dma_ignore_char;
428 status &= ~(PE | FE);
431 uart->port.icount.parity++;
433 uart->port.icount.overrun++;
435 uart->port.icount.frame++;
437 status &= uart->port.read_status_mask;
441 else if (status & PE)
443 else if (status & FE)
448 for (i = uart->rx_dma_buf.tail; ; i++) {
449 if (i >= UART_XMIT_SIZE)
451 if (i == uart->rx_dma_buf.head)
453 if (!uart_handle_sysrq_char(&uart->port, uart->rx_dma_buf.buf[i]))
454 uart_insert_char(&uart->port, status, OE,
455 uart->rx_dma_buf.buf[i], flg);
459 tty_flip_buffer_push(&uart->port.state->port);
462 void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
467 spin_lock_irqsave(&uart->rx_lock, flags);
469 /* 2D DMA RX buffer ring is used. Because curr_y_count and
470 * curr_x_count can't be read as an atomic operation,
471 * curr_y_count should be read before curr_x_count. When
472 * curr_x_count is read, curr_y_count may already indicate
473 * next buffer line. But, the position calculated here is
474 * still indicate the old line. The wrong position data may
475 * be smaller than current buffer tail, which cause garbages
476 * are received if it is not prohibit.
478 uart->rx_dma_nrows = get_dma_curr_ycount(uart->rx_dma_channel);
479 x_pos = get_dma_curr_xcount(uart->rx_dma_channel);
480 uart->rx_dma_nrows = DMA_RX_YCOUNT - uart->rx_dma_nrows;
481 if (uart->rx_dma_nrows == DMA_RX_YCOUNT || x_pos == 0)
482 uart->rx_dma_nrows = 0;
483 x_pos = DMA_RX_XCOUNT - x_pos;
484 if (x_pos == DMA_RX_XCOUNT)
487 pos = uart->rx_dma_nrows * DMA_RX_XCOUNT + x_pos;
488 /* Ignore receiving data if new position is in the same line of
489 * current buffer tail and small.
491 if (pos > uart->rx_dma_buf.tail ||
492 uart->rx_dma_nrows < (uart->rx_dma_buf.tail/DMA_RX_XCOUNT)) {
493 uart->rx_dma_buf.head = pos;
494 bfin_serial_dma_rx_chars(uart);
495 uart->rx_dma_buf.tail = uart->rx_dma_buf.head;
498 spin_unlock_irqrestore(&uart->rx_lock, flags);
500 mod_timer(&(uart->rx_dma_timer), jiffies + DMA_RX_FLUSH_JIFFIES);
503 static irqreturn_t bfin_serial_dma_tx_int(int irq, void *dev_id)
505 struct bfin_serial_port *uart = dev_id;
506 struct circ_buf *xmit = &uart->port.state->xmit;
508 spin_lock(&uart->port.lock);
509 if (!(get_dma_curr_irqstat(uart->tx_dma_channel)&DMA_RUN)) {
510 disable_dma(uart->tx_dma_channel);
511 clear_dma_irqstat(uart->tx_dma_channel);
513 * 05000215 - we always clear ETBEI within last UART TX
514 * interrupt to end a string. It is always set
515 * when start a new tx.
517 UART_CLEAR_IER(uart, ETBEI);
518 uart->port.icount.tx += uart->tx_count;
519 if (!(xmit->tail == 0 && xmit->head == 0)) {
520 xmit->tail = (xmit->tail + uart->tx_count) & (UART_XMIT_SIZE - 1);
522 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
523 uart_write_wakeup(&uart->port);
526 bfin_serial_dma_tx_chars(uart);
529 spin_unlock(&uart->port.lock);
533 static irqreturn_t bfin_serial_dma_rx_int(int irq, void *dev_id)
535 struct bfin_serial_port *uart = dev_id;
536 unsigned int irqstat;
539 spin_lock(&uart->rx_lock);
540 irqstat = get_dma_curr_irqstat(uart->rx_dma_channel);
541 clear_dma_irqstat(uart->rx_dma_channel);
543 uart->rx_dma_nrows = get_dma_curr_ycount(uart->rx_dma_channel);
544 x_pos = get_dma_curr_xcount(uart->rx_dma_channel);
545 uart->rx_dma_nrows = DMA_RX_YCOUNT - uart->rx_dma_nrows;
546 if (uart->rx_dma_nrows == DMA_RX_YCOUNT || x_pos == 0)
547 uart->rx_dma_nrows = 0;
549 pos = uart->rx_dma_nrows * DMA_RX_XCOUNT;
550 if (pos > uart->rx_dma_buf.tail ||
551 uart->rx_dma_nrows < (uart->rx_dma_buf.tail/DMA_RX_XCOUNT)) {
552 uart->rx_dma_buf.head = pos;
553 bfin_serial_dma_rx_chars(uart);
554 uart->rx_dma_buf.tail = uart->rx_dma_buf.head;
557 spin_unlock(&uart->rx_lock);
564 * Return TIOCSER_TEMT when transmitter is not busy.
566 static unsigned int bfin_serial_tx_empty(struct uart_port *port)
568 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
571 lsr = UART_GET_LSR(uart);
578 static void bfin_serial_break_ctl(struct uart_port *port, int break_state)
580 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
581 u32 lcr = UART_GET_LCR(uart);
586 UART_PUT_LCR(uart, lcr);
590 static int bfin_serial_startup(struct uart_port *port)
592 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
594 #ifdef CONFIG_SERIAL_BFIN_DMA
595 dma_addr_t dma_handle;
597 if (request_dma(uart->rx_dma_channel, "BFIN_UART_RX") < 0) {
598 printk(KERN_NOTICE "Unable to attach Blackfin UART RX DMA channel\n");
602 if (request_dma(uart->tx_dma_channel, "BFIN_UART_TX") < 0) {
603 printk(KERN_NOTICE "Unable to attach Blackfin UART TX DMA channel\n");
604 free_dma(uart->rx_dma_channel);
608 set_dma_callback(uart->rx_dma_channel, bfin_serial_dma_rx_int, uart);
609 set_dma_callback(uart->tx_dma_channel, bfin_serial_dma_tx_int, uart);
611 uart->rx_dma_buf.buf = (unsigned char *)dma_alloc_coherent(NULL, PAGE_SIZE, &dma_handle, GFP_DMA);
612 uart->rx_dma_buf.head = 0;
613 uart->rx_dma_buf.tail = 0;
614 uart->rx_dma_nrows = 0;
616 set_dma_config(uart->rx_dma_channel,
617 set_bfin_dma_config(DIR_WRITE, DMA_FLOW_AUTO,
618 INTR_ON_ROW, DIMENSION_2D,
621 set_dma_x_count(uart->rx_dma_channel, DMA_RX_XCOUNT);
622 set_dma_x_modify(uart->rx_dma_channel, 1);
623 set_dma_y_count(uart->rx_dma_channel, DMA_RX_YCOUNT);
624 set_dma_y_modify(uart->rx_dma_channel, 1);
625 set_dma_start_addr(uart->rx_dma_channel, (unsigned long)uart->rx_dma_buf.buf);
626 enable_dma(uart->rx_dma_channel);
628 uart->rx_dma_timer.data = (unsigned long)(uart);
629 uart->rx_dma_timer.function = (void *)bfin_serial_rx_dma_timeout;
630 uart->rx_dma_timer.expires = jiffies + DMA_RX_FLUSH_JIFFIES;
631 add_timer(&(uart->rx_dma_timer));
633 # if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
634 defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
635 if (kgdboc_port_line == uart->port.line && kgdboc_break_enabled)
636 kgdboc_break_enabled = 0;
639 if (request_irq(uart->rx_irq, bfin_serial_rx_int, 0,
640 "BFIN_UART_RX", uart)) {
641 printk(KERN_NOTICE "Unable to attach BlackFin UART RX interrupt\n");
646 (uart->tx_irq, bfin_serial_tx_int, 0,
647 "BFIN_UART_TX", uart)) {
648 printk(KERN_NOTICE "Unable to attach BlackFin UART TX interrupt\n");
649 free_irq(uart->rx_irq, uart);
656 * UART2 and UART3 on BF548 share interrupt PINs and DMA
657 * controllers with SPORT2 and SPORT3. UART rx and tx
658 * interrupts are generated in PIO mode only when configure
659 * their peripheral mapping registers properly, which means
660 * request corresponding DMA channels in PIO mode as well.
662 unsigned uart_dma_ch_rx, uart_dma_ch_tx;
664 switch (uart->rx_irq) {
666 uart_dma_ch_rx = CH_UART3_RX;
667 uart_dma_ch_tx = CH_UART3_TX;
670 uart_dma_ch_rx = CH_UART2_RX;
671 uart_dma_ch_tx = CH_UART2_TX;
674 uart_dma_ch_rx = uart_dma_ch_tx = 0;
678 if (uart_dma_ch_rx &&
679 request_dma(uart_dma_ch_rx, "BFIN_UART_RX") < 0) {
680 printk(KERN_NOTICE"Fail to attach UART interrupt\n");
681 free_irq(uart->rx_irq, uart);
682 free_irq(uart->tx_irq, uart);
685 if (uart_dma_ch_tx &&
686 request_dma(uart_dma_ch_tx, "BFIN_UART_TX") < 0) {
687 printk(KERN_NOTICE "Fail to attach UART interrupt\n");
688 free_dma(uart_dma_ch_rx);
689 free_irq(uart->rx_irq, uart);
690 free_irq(uart->tx_irq, uart);
695 # if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
696 defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
701 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
702 if (uart->cts_pin >= 0) {
703 if (request_irq(gpio_to_irq(uart->cts_pin),
704 bfin_serial_mctrl_cts_int,
705 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
706 0, "BFIN_UART_CTS", uart)) {
708 pr_info("Unable to attach BlackFin UART CTS interrupt. So, disable it.\n");
711 if (uart->rts_pin >= 0) {
712 if (gpio_request(uart->rts_pin, DRIVER_NAME)) {
713 pr_info("fail to request RTS PIN at GPIO_%d\n", uart->rts_pin);
716 gpio_direction_output(uart->rts_pin, 0);
719 #ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
720 if (uart->cts_pin >= 0) {
721 if (request_irq(uart->status_irq, bfin_serial_mctrl_cts_int,
722 0, "BFIN_UART_MODEM_STATUS", uart)) {
724 dev_info(port->dev, "Unable to attach BlackFin UART Modem Status interrupt.\n");
727 /* CTS RTS PINs are negative assertive. */
728 UART_PUT_MCR(uart, UART_GET_MCR(uart) | ACTS);
729 UART_SET_IER(uart, EDSSI);
733 UART_SET_IER(uart, ERBFI);
737 static void bfin_serial_shutdown(struct uart_port *port)
739 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
741 #ifdef CONFIG_SERIAL_BFIN_DMA
742 disable_dma(uart->tx_dma_channel);
743 free_dma(uart->tx_dma_channel);
744 disable_dma(uart->rx_dma_channel);
745 free_dma(uart->rx_dma_channel);
746 del_timer(&(uart->rx_dma_timer));
747 dma_free_coherent(NULL, PAGE_SIZE, uart->rx_dma_buf.buf, 0);
750 switch (uart->port.irq) {
752 free_dma(CH_UART3_RX);
753 free_dma(CH_UART3_TX);
756 free_dma(CH_UART2_RX);
757 free_dma(CH_UART2_TX);
763 free_irq(uart->rx_irq, uart);
764 free_irq(uart->tx_irq, uart);
767 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
768 if (uart->cts_pin >= 0)
769 free_irq(gpio_to_irq(uart->cts_pin), uart);
770 if (uart->rts_pin >= 0)
771 gpio_free(uart->rts_pin);
773 #ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
774 if (uart->cts_pin >= 0)
775 free_irq(uart->status_irq, uart);
780 bfin_serial_set_termios(struct uart_port *port, struct ktermios *termios,
781 struct ktermios *old)
783 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
785 unsigned int baud, quot;
786 unsigned int ier, lcr = 0;
787 unsigned long timeout;
789 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
790 if (old == NULL && uart->cts_pin != -1)
791 termios->c_cflag |= CRTSCTS;
792 else if (uart->cts_pin == -1)
793 termios->c_cflag &= ~CRTSCTS;
796 switch (termios->c_cflag & CSIZE) {
810 printk(KERN_ERR "%s: word length not supported\n",
815 * 05000231 - STOP bit is always set to 1 whatever the user is set.
817 if (termios->c_cflag & CSTOPB) {
818 if (ANOMALY_05000231)
819 printk(KERN_WARNING "STOP bits other than 1 is not "
820 "supported in case of anomaly 05000231.\n");
824 if (termios->c_cflag & PARENB)
826 if (!(termios->c_cflag & PARODD))
828 if (termios->c_cflag & CMSPAR)
831 spin_lock_irqsave(&uart->port.lock, flags);
833 port->read_status_mask = OE;
834 if (termios->c_iflag & INPCK)
835 port->read_status_mask |= (FE | PE);
836 if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
837 port->read_status_mask |= BI;
840 * Characters to ignore
842 port->ignore_status_mask = 0;
843 if (termios->c_iflag & IGNPAR)
844 port->ignore_status_mask |= FE | PE;
845 if (termios->c_iflag & IGNBRK) {
846 port->ignore_status_mask |= BI;
848 * If we're ignoring parity and break indicators,
849 * ignore overruns too (for real raw support).
851 if (termios->c_iflag & IGNPAR)
852 port->ignore_status_mask |= OE;
855 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
856 quot = uart_get_divisor(port, baud);
858 /* If discipline is not IRDA, apply ANOMALY_05000230 */
859 if (termios->c_line != N_IRDA)
860 quot -= ANOMALY_05000230;
862 UART_SET_ANOMALY_THRESHOLD(uart, USEC_PER_SEC / baud * 15);
864 /* Wait till the transfer buffer is empty */
865 timeout = jiffies + msecs_to_jiffies(10);
866 while (UART_GET_GCTL(uart) & UCEN && !(UART_GET_LSR(uart) & TEMT))
867 if (time_after(jiffies, timeout)) {
868 dev_warn(port->dev, "timeout waiting for TX buffer empty\n");
873 ier = UART_GET_IER(uart);
874 UART_PUT_GCTL(uart, UART_GET_GCTL(uart) & ~UCEN);
875 UART_DISABLE_INTS(uart);
877 /* Set DLAB in LCR to Access CLK */
880 UART_PUT_CLK(uart, quot);
883 /* Clear DLAB in LCR to Access THR RBR IER */
884 UART_CLEAR_DLAB(uart);
886 UART_PUT_LCR(uart, (UART_GET_LCR(uart) & ~LCR_MASK) | lcr);
889 UART_ENABLE_INTS(uart, ier);
890 UART_PUT_GCTL(uart, UART_GET_GCTL(uart) | UCEN);
892 /* Port speed changed, update the per-port timeout. */
893 uart_update_timeout(port, termios->c_cflag, baud);
895 spin_unlock_irqrestore(&uart->port.lock, flags);
898 static const char *bfin_serial_type(struct uart_port *port)
900 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
902 return uart->port.type == PORT_BFIN ? "BFIN-UART" : NULL;
906 * Release the memory region(s) being used by 'port'.
908 static void bfin_serial_release_port(struct uart_port *port)
913 * Request the memory region(s) being used by 'port'.
915 static int bfin_serial_request_port(struct uart_port *port)
921 * Configure/autoconfigure the port.
923 static void bfin_serial_config_port(struct uart_port *port, int flags)
925 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
927 if (flags & UART_CONFIG_TYPE &&
928 bfin_serial_request_port(&uart->port) == 0)
929 uart->port.type = PORT_BFIN;
933 * Verify the new serial_struct (for TIOCSSERIAL).
934 * The only change we allow are to the flags and type, and
935 * even then only between PORT_BFIN and PORT_UNKNOWN
938 bfin_serial_verify_port(struct uart_port *port, struct serial_struct *ser)
944 * Enable the IrDA function if tty->ldisc.num is N_IRDA.
945 * In other cases, disable IrDA function.
947 static void bfin_serial_set_ldisc(struct uart_port *port, int ld)
949 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
954 val = UART_GET_GCTL(uart);
955 val |= (UMOD_IRDA | RPOLC);
956 UART_PUT_GCTL(uart, val);
959 val = UART_GET_GCTL(uart);
960 val &= ~(UMOD_MASK | RPOLC);
961 UART_PUT_GCTL(uart, val);
965 static void bfin_serial_reset_irda(struct uart_port *port)
967 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
970 val = UART_GET_GCTL(uart);
971 val &= ~(UMOD_MASK | RPOLC);
972 UART_PUT_GCTL(uart, val);
974 val |= (UMOD_IRDA | RPOLC);
975 UART_PUT_GCTL(uart, val);
979 #ifdef CONFIG_CONSOLE_POLL
981 * 05000099 - Because we only use THRE in poll_put and DR in poll_get,
982 * losing other bits of UART_LSR is not a problem here.
984 static void bfin_serial_poll_put_char(struct uart_port *port, unsigned char chr)
986 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
988 while (!(UART_GET_LSR(uart) & THRE))
991 UART_CLEAR_DLAB(uart);
992 UART_PUT_CHAR(uart, (unsigned char)chr);
995 static int bfin_serial_poll_get_char(struct uart_port *port)
997 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
1000 while (!(UART_GET_LSR(uart) & DR))
1003 UART_CLEAR_DLAB(uart);
1004 chr = UART_GET_CHAR(uart);
1010 static struct uart_ops bfin_serial_pops = {
1011 .tx_empty = bfin_serial_tx_empty,
1012 .set_mctrl = bfin_serial_set_mctrl,
1013 .get_mctrl = bfin_serial_get_mctrl,
1014 .stop_tx = bfin_serial_stop_tx,
1015 .start_tx = bfin_serial_start_tx,
1016 .stop_rx = bfin_serial_stop_rx,
1017 .break_ctl = bfin_serial_break_ctl,
1018 .startup = bfin_serial_startup,
1019 .shutdown = bfin_serial_shutdown,
1020 .set_termios = bfin_serial_set_termios,
1021 .set_ldisc = bfin_serial_set_ldisc,
1022 .type = bfin_serial_type,
1023 .release_port = bfin_serial_release_port,
1024 .request_port = bfin_serial_request_port,
1025 .config_port = bfin_serial_config_port,
1026 .verify_port = bfin_serial_verify_port,
1027 #ifdef CONFIG_CONSOLE_POLL
1028 .poll_put_char = bfin_serial_poll_put_char,
1029 .poll_get_char = bfin_serial_poll_get_char,
1033 #if defined(CONFIG_SERIAL_BFIN_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
1035 * If the port was already initialised (eg, by a boot loader),
1036 * try to determine the current setup.
1039 bfin_serial_console_get_options(struct bfin_serial_port *uart, int *baud,
1040 int *parity, int *bits)
1042 unsigned int status;
1044 status = UART_GET_IER(uart) & (ERBFI | ETBEI);
1045 if (status == (ERBFI | ETBEI)) {
1046 /* ok, the port was enabled */
1049 lcr = UART_GET_LCR(uart);
1058 *bits = ((lcr & WLS_MASK) >> WLS_OFFSET) + 5;
1060 /* Set DLAB in LCR to Access CLK */
1061 UART_SET_DLAB(uart);
1063 clk = UART_GET_CLK(uart);
1065 /* Clear DLAB in LCR to Access THR RBR IER */
1066 UART_CLEAR_DLAB(uart);
1068 *baud = get_sclk() / (16*clk);
1070 pr_debug("%s:baud = %d, parity = %c, bits= %d\n", __func__, *baud, *parity, *bits);
1073 static struct uart_driver bfin_serial_reg;
1075 static void bfin_serial_console_putchar(struct uart_port *port, int ch)
1077 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
1078 while (!(UART_GET_LSR(uart) & THRE))
1080 UART_PUT_CHAR(uart, ch);
1083 #endif /* defined (CONFIG_SERIAL_BFIN_CONSOLE) ||
1084 defined (CONFIG_EARLY_PRINTK) */
1086 #ifdef CONFIG_SERIAL_BFIN_CONSOLE
1087 #define CLASS_BFIN_CONSOLE "bfin-console"
1089 * Interrupts are disabled on entering
1092 bfin_serial_console_write(struct console *co, const char *s, unsigned int count)
1094 struct bfin_serial_port *uart = bfin_serial_ports[co->index];
1095 unsigned long flags;
1097 spin_lock_irqsave(&uart->port.lock, flags);
1098 uart_console_write(&uart->port, s, count, bfin_serial_console_putchar);
1099 spin_unlock_irqrestore(&uart->port.lock, flags);
1104 bfin_serial_console_setup(struct console *co, char *options)
1106 struct bfin_serial_port *uart;
1110 # if defined(CONFIG_SERIAL_BFIN_CTSRTS) || \
1111 defined(CONFIG_SERIAL_BFIN_HARD_CTSRTS)
1118 * Check whether an invalid uart number has been specified, and
1119 * if so, search for the first available port that does have
1122 if (co->index < 0 || co->index >= BFIN_UART_NR_PORTS)
1125 uart = bfin_serial_ports[co->index];
1130 uart_parse_options(options, &baud, &parity, &bits, &flow);
1132 bfin_serial_console_get_options(uart, &baud, &parity, &bits);
1134 return uart_set_options(&uart->port, co, baud, parity, bits, flow);
1137 static struct console bfin_serial_console = {
1138 .name = BFIN_SERIAL_DEV_NAME,
1139 .write = bfin_serial_console_write,
1140 .device = uart_console_device,
1141 .setup = bfin_serial_console_setup,
1142 .flags = CON_PRINTBUFFER,
1144 .data = &bfin_serial_reg,
1146 #define BFIN_SERIAL_CONSOLE (&bfin_serial_console)
1148 #define BFIN_SERIAL_CONSOLE NULL
1149 #endif /* CONFIG_SERIAL_BFIN_CONSOLE */
1151 #ifdef CONFIG_EARLY_PRINTK
1152 static struct bfin_serial_port bfin_earlyprintk_port;
1153 #define CLASS_BFIN_EARLYPRINTK "bfin-earlyprintk"
1156 * Interrupts are disabled on entering
1159 bfin_earlyprintk_console_write(struct console *co, const char *s, unsigned int count)
1161 unsigned long flags;
1163 if (bfin_earlyprintk_port.port.line != co->index)
1166 spin_lock_irqsave(&bfin_earlyprintk_port.port.lock, flags);
1167 uart_console_write(&bfin_earlyprintk_port.port, s, count,
1168 bfin_serial_console_putchar);
1169 spin_unlock_irqrestore(&bfin_earlyprintk_port.port.lock, flags);
1173 * This should have a .setup or .early_setup in it, but then things get called
1174 * without the command line options, and the baud rate gets messed up - so
1175 * don't let the common infrastructure play with things. (see calls to setup
1176 * & earlysetup in ./kernel/printk.c:register_console()
1178 static struct console bfin_early_serial_console __initdata = {
1179 .name = "early_BFuart",
1180 .write = bfin_earlyprintk_console_write,
1181 .device = uart_console_device,
1182 .flags = CON_PRINTBUFFER,
1184 .data = &bfin_serial_reg,
1188 static struct uart_driver bfin_serial_reg = {
1189 .owner = THIS_MODULE,
1190 .driver_name = DRIVER_NAME,
1191 .dev_name = BFIN_SERIAL_DEV_NAME,
1192 .major = BFIN_SERIAL_MAJOR,
1193 .minor = BFIN_SERIAL_MINOR,
1194 .nr = BFIN_UART_NR_PORTS,
1195 .cons = BFIN_SERIAL_CONSOLE,
1198 static int bfin_serial_suspend(struct platform_device *pdev, pm_message_t state)
1200 struct bfin_serial_port *uart = platform_get_drvdata(pdev);
1202 return uart_suspend_port(&bfin_serial_reg, &uart->port);
1205 static int bfin_serial_resume(struct platform_device *pdev)
1207 struct bfin_serial_port *uart = platform_get_drvdata(pdev);
1209 return uart_resume_port(&bfin_serial_reg, &uart->port);
1212 static int bfin_serial_probe(struct platform_device *pdev)
1214 struct resource *res;
1215 struct bfin_serial_port *uart = NULL;
1218 if (pdev->id < 0 || pdev->id >= BFIN_UART_NR_PORTS) {
1219 dev_err(&pdev->dev, "Wrong bfin uart platform device id.\n");
1223 if (bfin_serial_ports[pdev->id] == NULL) {
1225 uart = kzalloc(sizeof(*uart), GFP_KERNEL);
1228 "fail to malloc bfin_serial_port\n");
1231 bfin_serial_ports[pdev->id] = uart;
1233 #ifdef CONFIG_EARLY_PRINTK
1234 if (!(bfin_earlyprintk_port.port.membase
1235 && bfin_earlyprintk_port.port.line == pdev->id)) {
1237 * If the peripheral PINs of current port is allocated
1238 * in earlyprintk probe stage, don't do it again.
1241 ret = peripheral_request_list(
1242 dev_get_platdata(&pdev->dev),
1246 "fail to request bfin serial peripherals\n");
1247 goto out_error_free_mem;
1249 #ifdef CONFIG_EARLY_PRINTK
1253 spin_lock_init(&uart->port.lock);
1254 uart->port.uartclk = get_sclk();
1255 uart->port.fifosize = BFIN_UART_TX_FIFO_SIZE;
1256 uart->port.ops = &bfin_serial_pops;
1257 uart->port.line = pdev->id;
1258 uart->port.iotype = UPIO_MEM;
1259 uart->port.flags = UPF_BOOT_AUTOCONF;
1261 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1263 dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM\n");
1265 goto out_error_free_peripherals;
1268 uart->port.membase = ioremap(res->start, resource_size(res));
1269 if (!uart->port.membase) {
1270 dev_err(&pdev->dev, "Cannot map uart IO\n");
1272 goto out_error_free_peripherals;
1274 uart->port.mapbase = res->start;
1276 uart->tx_irq = platform_get_irq(pdev, 0);
1277 if (uart->tx_irq < 0) {
1278 dev_err(&pdev->dev, "No uart TX IRQ specified\n");
1280 goto out_error_unmap;
1283 uart->rx_irq = platform_get_irq(pdev, 1);
1284 if (uart->rx_irq < 0) {
1285 dev_err(&pdev->dev, "No uart RX IRQ specified\n");
1287 goto out_error_unmap;
1289 uart->port.irq = uart->rx_irq;
1291 uart->status_irq = platform_get_irq(pdev, 2);
1292 if (uart->status_irq < 0) {
1293 dev_err(&pdev->dev, "No uart status IRQ specified\n");
1295 goto out_error_unmap;
1298 #ifdef CONFIG_SERIAL_BFIN_DMA
1299 spin_lock_init(&uart->rx_lock);
1303 res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
1305 dev_err(&pdev->dev, "No uart TX DMA channel specified\n");
1307 goto out_error_unmap;
1309 uart->tx_dma_channel = res->start;
1311 res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
1313 dev_err(&pdev->dev, "No uart RX DMA channel specified\n");
1315 goto out_error_unmap;
1317 uart->rx_dma_channel = res->start;
1319 init_timer(&(uart->rx_dma_timer));
1322 #if defined(CONFIG_SERIAL_BFIN_CTSRTS) || \
1323 defined(CONFIG_SERIAL_BFIN_HARD_CTSRTS)
1324 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
1328 uart->cts_pin = res->start;
1330 res = platform_get_resource(pdev, IORESOURCE_IO, 1);
1334 uart->rts_pin = res->start;
1338 #ifdef CONFIG_SERIAL_BFIN_CONSOLE
1339 if (!is_early_platform_device(pdev)) {
1341 uart = bfin_serial_ports[pdev->id];
1342 uart->port.dev = &pdev->dev;
1343 dev_set_drvdata(&pdev->dev, uart);
1344 ret = uart_add_one_port(&bfin_serial_reg, &uart->port);
1345 #ifdef CONFIG_SERIAL_BFIN_CONSOLE
1354 iounmap(uart->port.membase);
1355 out_error_free_peripherals:
1356 peripheral_free_list(dev_get_platdata(&pdev->dev));
1359 bfin_serial_ports[pdev->id] = NULL;
1365 static int bfin_serial_remove(struct platform_device *pdev)
1367 struct bfin_serial_port *uart = platform_get_drvdata(pdev);
1369 dev_set_drvdata(&pdev->dev, NULL);
1372 uart_remove_one_port(&bfin_serial_reg, &uart->port);
1373 iounmap(uart->port.membase);
1374 peripheral_free_list(dev_get_platdata(&pdev->dev));
1376 bfin_serial_ports[pdev->id] = NULL;
1382 static struct platform_driver bfin_serial_driver = {
1383 .probe = bfin_serial_probe,
1384 .remove = bfin_serial_remove,
1385 .suspend = bfin_serial_suspend,
1386 .resume = bfin_serial_resume,
1388 .name = DRIVER_NAME,
1389 .owner = THIS_MODULE,
1393 #if defined(CONFIG_SERIAL_BFIN_CONSOLE)
1394 static struct early_platform_driver early_bfin_serial_driver __initdata = {
1395 .class_str = CLASS_BFIN_CONSOLE,
1396 .pdrv = &bfin_serial_driver,
1397 .requested_id = EARLY_PLATFORM_ID_UNSET,
1400 static int __init bfin_serial_rs_console_init(void)
1402 early_platform_driver_register(&early_bfin_serial_driver, DRIVER_NAME);
1404 early_platform_driver_probe(CLASS_BFIN_CONSOLE, BFIN_UART_NR_PORTS, 0);
1406 register_console(&bfin_serial_console);
1410 console_initcall(bfin_serial_rs_console_init);
1413 #ifdef CONFIG_EARLY_PRINTK
1415 * Memory can't be allocated dynamically during earlyprink init stage.
1416 * So, do individual probe for earlyprink with a static uart port variable.
1418 static int bfin_earlyprintk_probe(struct platform_device *pdev)
1420 struct resource *res;
1423 if (pdev->id < 0 || pdev->id >= BFIN_UART_NR_PORTS) {
1424 dev_err(&pdev->dev, "Wrong earlyprintk platform device id.\n");
1428 ret = peripheral_request_list(dev_get_platdata(&pdev->dev),
1432 "fail to request bfin serial peripherals\n");
1436 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1438 dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM\n");
1440 goto out_error_free_peripherals;
1443 bfin_earlyprintk_port.port.membase = ioremap(res->start,
1444 resource_size(res));
1445 if (!bfin_earlyprintk_port.port.membase) {
1446 dev_err(&pdev->dev, "Cannot map uart IO\n");
1448 goto out_error_free_peripherals;
1450 bfin_earlyprintk_port.port.mapbase = res->start;
1451 bfin_earlyprintk_port.port.line = pdev->id;
1452 bfin_earlyprintk_port.port.uartclk = get_sclk();
1453 bfin_earlyprintk_port.port.fifosize = BFIN_UART_TX_FIFO_SIZE;
1454 spin_lock_init(&bfin_earlyprintk_port.port.lock);
1458 out_error_free_peripherals:
1459 peripheral_free_list(dev_get_platdata(&pdev->dev));
1464 static struct platform_driver bfin_earlyprintk_driver = {
1465 .probe = bfin_earlyprintk_probe,
1467 .name = DRIVER_NAME,
1468 .owner = THIS_MODULE,
1472 static struct early_platform_driver early_bfin_earlyprintk_driver __initdata = {
1473 .class_str = CLASS_BFIN_EARLYPRINTK,
1474 .pdrv = &bfin_earlyprintk_driver,
1475 .requested_id = EARLY_PLATFORM_ID_UNSET,
1478 struct console __init *bfin_earlyserial_init(unsigned int port,
1484 if (port < 0 || port >= BFIN_UART_NR_PORTS)
1488 * Only probe resource of the given port in earlyprintk boot arg.
1489 * The expected port id should be indicated in port name string.
1491 snprintf(port_name, 20, DRIVER_NAME ".%d", port);
1492 early_platform_driver_register(&early_bfin_earlyprintk_driver,
1494 early_platform_driver_probe(CLASS_BFIN_EARLYPRINTK, 1, 0);
1496 if (!bfin_earlyprintk_port.port.membase)
1499 #ifdef CONFIG_SERIAL_BFIN_CONSOLE
1501 * If we are using early serial, don't let the normal console rewind
1502 * log buffer, since that causes things to be printed multiple times
1504 bfin_serial_console.flags &= ~CON_PRINTBUFFER;
1507 bfin_early_serial_console.index = port;
1513 bfin_serial_set_termios(&bfin_earlyprintk_port.port, &t, &t);
1515 return &bfin_early_serial_console;
1517 #endif /* CONFIG_EARLY_PRINTK */
1519 static int __init bfin_serial_init(void)
1523 pr_info("Blackfin serial driver\n");
1525 ret = uart_register_driver(&bfin_serial_reg);
1527 pr_err("failed to register %s:%d\n",
1528 bfin_serial_reg.driver_name, ret);
1531 ret = platform_driver_register(&bfin_serial_driver);
1533 pr_err("fail to register bfin uart\n");
1534 uart_unregister_driver(&bfin_serial_reg);
1540 static void __exit bfin_serial_exit(void)
1542 platform_driver_unregister(&bfin_serial_driver);
1543 uart_unregister_driver(&bfin_serial_reg);
1547 module_init(bfin_serial_init);
1548 module_exit(bfin_serial_exit);
1550 MODULE_AUTHOR("Sonic Zhang, Aubrey Li");
1551 MODULE_DESCRIPTION("Blackfin generic serial port driver");
1552 MODULE_LICENSE("GPL");
1553 MODULE_ALIAS_CHARDEV_MAJOR(BFIN_SERIAL_MAJOR);
1554 MODULE_ALIAS("platform:bfin-uart");