blob: 6b8795557b388f17f38f4fa009a6c5832e341e68 [file] [log] [blame]
Bryan Wu194de562007-05-06 14:50:30 -07001/*
Mike Frysinger1ba7a3e2008-01-11 15:56:26 +08002 * Blackfin On-Chip Serial Driver
Bryan Wu194de562007-05-06 14:50:30 -07003 *
Mike Frysingerd273e2012008-10-13 10:33:06 +01004 * Copyright 2006-2008 Analog Devices Inc.
Bryan Wu194de562007-05-06 14:50:30 -07005 *
Mike Frysinger1ba7a3e2008-01-11 15:56:26 +08006 * Enter bugs at http://blackfin.uclinux.org/
Bryan Wu194de562007-05-06 14:50:30 -07007 *
Mike Frysinger1ba7a3e2008-01-11 15:56:26 +08008 * Licensed under the GPL-2 or later.
Bryan Wu194de562007-05-06 14:50:30 -07009 */
10
11#if defined(CONFIG_SERIAL_BFIN_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
12#define SUPPORT_SYSRQ
13#endif
14
15#include <linux/module.h>
16#include <linux/ioport.h>
17#include <linux/init.h>
18#include <linux/console.h>
19#include <linux/sysrq.h>
20#include <linux/platform_device.h>
21#include <linux/tty.h>
22#include <linux/tty_flip.h>
23#include <linux/serial_core.h>
24
Sonic Zhang52e15f0e2009-01-02 13:40:14 +000025#if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
26 defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
Sonic Zhang474f1a62007-06-29 16:35:17 +080027#include <linux/kgdb.h>
28#include <asm/irq_regs.h>
29#endif
30
Bryan Wu194de562007-05-06 14:50:30 -070031#include <asm/gpio.h>
Bryan Wu639f6572008-08-27 10:51:02 +080032#include <mach/bfin_serial_5xx.h>
Bryan Wu194de562007-05-06 14:50:30 -070033
34#ifdef CONFIG_SERIAL_BFIN_DMA
35#include <linux/dma-mapping.h>
36#include <asm/io.h>
37#include <asm/irq.h>
38#include <asm/cacheflush.h>
39#endif
40
Mike Frysinger607c2682009-06-22 18:41:47 +010041#ifdef CONFIG_SERIAL_BFIN_MODULE
42# undef CONFIG_EARLY_PRINTK
43#endif
44
Mike Frysinger0271edd2009-08-06 15:20:05 -070045#ifdef CONFIG_SERIAL_BFIN_MODULE
46# undef CONFIG_EARLY_PRINTK
47#endif
48
Bryan Wu194de562007-05-06 14:50:30 -070049/* UART name and device definitions */
50#define BFIN_SERIAL_NAME "ttyBF"
51#define BFIN_SERIAL_MAJOR 204
52#define BFIN_SERIAL_MINOR 64
53
Mike Frysingerc9607ec2008-10-13 10:33:16 +010054static struct bfin_serial_port bfin_serial_ports[BFIN_UART_NR_PORTS];
55static int nr_active_ports = ARRAY_SIZE(bfin_serial_resource);
56
Sonic Zhang52e15f0e2009-01-02 13:40:14 +000057#if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
58 defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
59
60# ifndef CONFIG_SERIAL_BFIN_PIO
61# error KGDB only support UART in PIO mode.
62# endif
63
64static int kgdboc_port_line;
65static int kgdboc_break_enabled;
66#endif
Bryan Wu194de562007-05-06 14:50:30 -070067/*
68 * Setup for console. Argument comes from the menuconfig
69 */
70#define DMA_RX_XCOUNT 512
71#define DMA_RX_YCOUNT (PAGE_SIZE / DMA_RX_XCOUNT)
72
Sonic Zhang0aef4562008-02-29 12:08:42 +080073#define DMA_RX_FLUSH_JIFFIES (HZ / 50)
Bryan Wu194de562007-05-06 14:50:30 -070074
75#ifdef CONFIG_SERIAL_BFIN_DMA
76static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart);
77#else
Bryan Wu194de562007-05-06 14:50:30 -070078static void bfin_serial_tx_chars(struct bfin_serial_port *uart);
Bryan Wu194de562007-05-06 14:50:30 -070079#endif
80
Graf Yang80d5c472009-01-02 13:40:22 +000081static void bfin_serial_reset_irda(struct uart_port *port);
82
Sonic Zhangd307d362009-04-07 16:52:26 +010083#if defined(CONFIG_SERIAL_BFIN_CTSRTS) || \
84 defined(CONFIG_SERIAL_BFIN_HARD_CTSRTS)
85static unsigned int bfin_serial_get_mctrl(struct uart_port *port)
86{
87 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
88 if (uart->cts_pin < 0)
89 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
90
91 /* CTS PIN is negative assertive. */
92 if (UART_GET_CTS(uart))
93 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
94 else
95 return TIOCM_DSR | TIOCM_CAR;
96}
97
98static void bfin_serial_set_mctrl(struct uart_port *port, unsigned int mctrl)
99{
100 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
101 if (uart->rts_pin < 0)
102 return;
103
104 /* RTS PIN is negative assertive. */
105 if (mctrl & TIOCM_RTS)
106 UART_ENABLE_RTS(uart);
107 else
108 UART_DISABLE_RTS(uart);
109}
110
111/*
112 * Handle any change of modem status signal.
113 */
114static irqreturn_t bfin_serial_mctrl_cts_int(int irq, void *dev_id)
115{
116 struct bfin_serial_port *uart = dev_id;
117 unsigned int status;
118
119 status = bfin_serial_get_mctrl(&uart->port);
120 uart_handle_cts_change(&uart->port, status & TIOCM_CTS);
121#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
122 uart->scts = 1;
123 UART_CLEAR_SCTS(uart);
124 UART_CLEAR_IER(uart, EDSSI);
125#endif
126
127 return IRQ_HANDLED;
128}
129#else
130static unsigned int bfin_serial_get_mctrl(struct uart_port *port)
131{
132 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
133}
134
135static void bfin_serial_set_mctrl(struct uart_port *port, unsigned int mctrl)
136{
137}
138#endif
139
Bryan Wu194de562007-05-06 14:50:30 -0700140/*
141 * interrupts are disabled on entry
142 */
143static void bfin_serial_stop_tx(struct uart_port *port)
144{
145 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
Sonic Zhang68a784c2009-01-02 13:40:38 +0000146#ifdef CONFIG_SERIAL_BFIN_DMA
Alan Coxebd2c8f2009-09-19 13:13:28 -0700147 struct circ_buf *xmit = &uart->port.state->xmit;
Sonic Zhang68a784c2009-01-02 13:40:38 +0000148#endif
Bryan Wu194de562007-05-06 14:50:30 -0700149
Roy Huangf4d640c92007-07-12 16:43:46 +0800150 while (!(UART_GET_LSR(uart) & TEMT))
Sonic Zhang0711d852008-02-25 15:16:50 +0800151 cpu_relax();
Roy Huangf4d640c92007-07-12 16:43:46 +0800152
Bryan Wu194de562007-05-06 14:50:30 -0700153#ifdef CONFIG_SERIAL_BFIN_DMA
154 disable_dma(uart->tx_dma_channel);
Sonic Zhang0711d852008-02-25 15:16:50 +0800155 xmit->tail = (xmit->tail + uart->tx_count) & (UART_XMIT_SIZE - 1);
156 uart->port.icount.tx += uart->tx_count;
157 uart->tx_count = 0;
158 uart->tx_done = 1;
Bryan Wu194de562007-05-06 14:50:30 -0700159#else
Roy Huangf4d640c92007-07-12 16:43:46 +0800160#ifdef CONFIG_BF54x
Roy Huangf4d640c92007-07-12 16:43:46 +0800161 /* Clear TFI bit */
162 UART_PUT_LSR(uart, TFI);
Bryan Wu194de562007-05-06 14:50:30 -0700163#endif
Mike Frysinger89bf6dc52008-05-07 11:41:26 +0800164 UART_CLEAR_IER(uart, ETBEI);
Roy Huangf4d640c92007-07-12 16:43:46 +0800165#endif
Bryan Wu194de562007-05-06 14:50:30 -0700166}
167
168/*
169 * port is locked and interrupts are disabled
170 */
171static void bfin_serial_start_tx(struct uart_port *port)
172{
173 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
Alan Coxebd2c8f2009-09-19 13:13:28 -0700174 struct tty_struct *tty = uart->port.state->port.tty;
Graf Yang80d5c472009-01-02 13:40:22 +0000175
Sonic Zhangd307d362009-04-07 16:52:26 +0100176#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
Roel Kluindaba0282009-04-21 12:24:58 -0700177 if (uart->scts && !(bfin_serial_get_mctrl(&uart->port) & TIOCM_CTS)) {
Sonic Zhangd307d362009-04-07 16:52:26 +0100178 uart->scts = 0;
179 uart_handle_cts_change(&uart->port, uart->scts);
180 }
181#endif
182
Graf Yang80d5c472009-01-02 13:40:22 +0000183 /*
184 * To avoid losting RX interrupt, we reset IR function
185 * before sending data.
186 */
187 if (tty->termios->c_line == N_IRDA)
188 bfin_serial_reset_irda(port);
Bryan Wu194de562007-05-06 14:50:30 -0700189
190#ifdef CONFIG_SERIAL_BFIN_DMA
Sonic Zhang0711d852008-02-25 15:16:50 +0800191 if (uart->tx_done)
192 bfin_serial_dma_tx_chars(uart);
Bryan Wu194de562007-05-06 14:50:30 -0700193#else
Roy Huangf4d640c92007-07-12 16:43:46 +0800194 UART_SET_IER(uart, ETBEI);
Sonic Zhanga359cca2007-10-10 16:47:58 +0800195 bfin_serial_tx_chars(uart);
Roy Huangf4d640c92007-07-12 16:43:46 +0800196#endif
Bryan Wu194de562007-05-06 14:50:30 -0700197}
198
199/*
200 * Interrupts are enabled
201 */
202static void bfin_serial_stop_rx(struct uart_port *port)
203{
204 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
Sonic Zhang52e15f0e2009-01-02 13:40:14 +0000205
Roy Huangf4d640c92007-07-12 16:43:46 +0800206 UART_CLEAR_IER(uart, ERBFI);
Bryan Wu194de562007-05-06 14:50:30 -0700207}
208
209/*
210 * Set the modem control timer to fire immediately.
211 */
212static void bfin_serial_enable_ms(struct uart_port *port)
213{
214}
215
Sonic Zhang474f1a62007-06-29 16:35:17 +0800216
Mike Frysinger50e2e152008-04-25 03:03:03 +0800217#if ANOMALY_05000363 && defined(CONFIG_SERIAL_BFIN_PIO)
Mike Frysinger8851c712007-12-24 19:48:04 +0800218# define UART_GET_ANOMALY_THRESHOLD(uart) ((uart)->anomaly_threshold)
219# define UART_SET_ANOMALY_THRESHOLD(uart, v) ((uart)->anomaly_threshold = (v))
220#else
221# define UART_GET_ANOMALY_THRESHOLD(uart) 0
222# define UART_SET_ANOMALY_THRESHOLD(uart, v)
223#endif
224
Bryan Wu194de562007-05-06 14:50:30 -0700225#ifdef CONFIG_SERIAL_BFIN_PIO
Bryan Wu194de562007-05-06 14:50:30 -0700226static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
227{
Sonic Zhang52e15f0e2009-01-02 13:40:14 +0000228 struct tty_struct *tty = NULL;
Bryan Wu194de562007-05-06 14:50:30 -0700229 unsigned int status, ch, flg;
Mike Frysinger8851c712007-12-24 19:48:04 +0800230 static struct timeval anomaly_start = { .tv_sec = 0 };
Bryan Wu194de562007-05-06 14:50:30 -0700231
Sonic Zhang759eb042007-11-21 17:00:32 +0800232 status = UART_GET_LSR(uart);
Mike Frysinger0bcfd702007-12-24 19:40:05 +0800233 UART_CLEAR_LSR(uart);
234
235 ch = UART_GET_CHAR(uart);
Bryan Wu194de562007-05-06 14:50:30 -0700236 uart->port.icount.rx++;
237
Sonic Zhang52e15f0e2009-01-02 13:40:14 +0000238#if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
239 defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
Sonic Zhangcdc592d2010-01-19 06:13:12 -0500240 if (kgdb_connected && kgdboc_port_line == uart->port.line
241 && kgdboc_break_enabled)
Sonic Zhang52e15f0e2009-01-02 13:40:14 +0000242 if (ch == 0x3) {/* Ctrl + C */
243 kgdb_breakpoint();
Sonic Zhang474f1a62007-06-29 16:35:17 +0800244 return;
Sonic Zhang474f1a62007-06-29 16:35:17 +0800245 }
Sonic Zhang52e15f0e2009-01-02 13:40:14 +0000246
Alan Coxebd2c8f2009-09-19 13:13:28 -0700247 if (!uart->port.state || !uart->port.state->port.tty)
Sonic Zhang52e15f0e2009-01-02 13:40:14 +0000248 return;
Sonic Zhang474f1a62007-06-29 16:35:17 +0800249#endif
Alan Coxebd2c8f2009-09-19 13:13:28 -0700250 tty = uart->port.state->port.tty;
Mike Frysingerbbf275f2007-08-05 16:48:08 +0800251
Mike Frysinger50e2e152008-04-25 03:03:03 +0800252 if (ANOMALY_05000363) {
Mike Frysinger8851c712007-12-24 19:48:04 +0800253 /* The BF533 (and BF561) family of processors have a nice anomaly
254 * where they continuously generate characters for a "single" break.
Mike Frysingerbbf275f2007-08-05 16:48:08 +0800255 * We have to basically ignore this flood until the "next" valid
Mike Frysinger8851c712007-12-24 19:48:04 +0800256 * character comes across. Due to the nature of the flood, it is
257 * not possible to reliably catch bytes that are sent too quickly
258 * after this break. So application code talking to the Blackfin
259 * which sends a break signal must allow at least 1.5 character
260 * times after the end of the break for things to stabilize. This
261 * timeout was picked as it must absolutely be larger than 1
262 * character time +/- some percent. So 1.5 sounds good. All other
263 * Blackfin families operate properly. Woo.
Mike Frysingerbbf275f2007-08-05 16:48:08 +0800264 */
Mike Frysinger8851c712007-12-24 19:48:04 +0800265 if (anomaly_start.tv_sec) {
266 struct timeval curr;
267 suseconds_t usecs;
268
269 if ((~ch & (~ch + 1)) & 0xff)
270 goto known_good_char;
271
272 do_gettimeofday(&curr);
273 if (curr.tv_sec - anomaly_start.tv_sec > 1)
274 goto known_good_char;
275
276 usecs = 0;
277 if (curr.tv_sec != anomaly_start.tv_sec)
278 usecs += USEC_PER_SEC;
279 usecs += curr.tv_usec - anomaly_start.tv_usec;
280
281 if (usecs > UART_GET_ANOMALY_THRESHOLD(uart))
282 goto known_good_char;
283
284 if (ch)
285 anomaly_start.tv_sec = 0;
286 else
287 anomaly_start = curr;
288
289 return;
290
291 known_good_char:
Sonic Zhange482a232009-01-02 13:40:45 +0000292 status &= ~BI;
Mike Frysinger8851c712007-12-24 19:48:04 +0800293 anomaly_start.tv_sec = 0;
Mike Frysingerbbf275f2007-08-05 16:48:08 +0800294 }
Bryan Wu194de562007-05-06 14:50:30 -0700295 }
Bryan Wu194de562007-05-06 14:50:30 -0700296
297 if (status & BI) {
Mike Frysinger50e2e152008-04-25 03:03:03 +0800298 if (ANOMALY_05000363)
Mike Frysinger8851c712007-12-24 19:48:04 +0800299 if (bfin_revid() < 5)
300 do_gettimeofday(&anomaly_start);
Bryan Wu194de562007-05-06 14:50:30 -0700301 uart->port.icount.brk++;
302 if (uart_handle_break(&uart->port))
303 goto ignore_char;
Mike Frysinger98089012007-06-11 15:31:30 +0800304 status &= ~(PE | FE);
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800305 }
306 if (status & PE)
Bryan Wu194de562007-05-06 14:50:30 -0700307 uart->port.icount.parity++;
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800308 if (status & OE)
Bryan Wu194de562007-05-06 14:50:30 -0700309 uart->port.icount.overrun++;
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800310 if (status & FE)
Bryan Wu194de562007-05-06 14:50:30 -0700311 uart->port.icount.frame++;
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800312
313 status &= uart->port.read_status_mask;
314
315 if (status & BI)
316 flg = TTY_BREAK;
317 else if (status & PE)
318 flg = TTY_PARITY;
319 else if (status & FE)
320 flg = TTY_FRAME;
321 else
Bryan Wu194de562007-05-06 14:50:30 -0700322 flg = TTY_NORMAL;
323
324 if (uart_handle_sysrq_char(&uart->port, ch))
325 goto ignore_char;
Bryan Wu194de562007-05-06 14:50:30 -0700326
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800327 uart_insert_char(&uart->port, status, OE, ch, flg);
328
329 ignore_char:
330 tty_flip_buffer_push(tty);
Bryan Wu194de562007-05-06 14:50:30 -0700331}
332
333static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
334{
Alan Coxebd2c8f2009-09-19 13:13:28 -0700335 struct circ_buf *xmit = &uart->port.state->xmit;
Bryan Wu194de562007-05-06 14:50:30 -0700336
Bryan Wu194de562007-05-06 14:50:30 -0700337 if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
Sonic Zhang5ffdeea22008-10-13 10:33:33 +0100338#ifdef CONFIG_BF54x
339 /* Clear TFI bit */
340 UART_PUT_LSR(uart, TFI);
341#endif
Sonic Zhang0efa4f22009-06-11 13:45:07 +0100342 /* Anomaly notes:
343 * 05000215 - we always clear ETBEI within last UART TX
344 * interrupt to end a string. It is always set
345 * when start a new tx.
346 */
Sonic Zhang5ffdeea22008-10-13 10:33:33 +0100347 UART_CLEAR_IER(uart, ETBEI);
Bryan Wu194de562007-05-06 14:50:30 -0700348 return;
349 }
350
Sonic Zhangf30ac0c2008-06-19 17:46:39 +0800351 if (uart->port.x_char) {
352 UART_PUT_CHAR(uart, uart->port.x_char);
353 uart->port.icount.tx++;
354 uart->port.x_char = 0;
355 }
356
Sonic Zhang759eb042007-11-21 17:00:32 +0800357 while ((UART_GET_LSR(uart) & THRE) && xmit->tail != xmit->head) {
358 UART_PUT_CHAR(uart, xmit->buf[xmit->tail]);
359 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
360 uart->port.icount.tx++;
361 SSYNC();
362 }
Bryan Wu194de562007-05-06 14:50:30 -0700363
364 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
365 uart_write_wakeup(&uart->port);
Bryan Wu194de562007-05-06 14:50:30 -0700366}
367
Aubrey Li5c4e4722007-05-21 18:09:38 +0800368static irqreturn_t bfin_serial_rx_int(int irq, void *dev_id)
369{
370 struct bfin_serial_port *uart = dev_id;
371
Roy Huangf4d640c92007-07-12 16:43:46 +0800372 spin_lock(&uart->port.lock);
Mike Frysinger0bcfd702007-12-24 19:40:05 +0800373 while (UART_GET_LSR(uart) & DR)
Aubrey Li5c4e4722007-05-21 18:09:38 +0800374 bfin_serial_rx_chars(uart);
375 spin_unlock(&uart->port.lock);
Sonic Zhang759eb042007-11-21 17:00:32 +0800376
Aubrey Li5c4e4722007-05-21 18:09:38 +0800377 return IRQ_HANDLED;
378}
379
380static irqreturn_t bfin_serial_tx_int(int irq, void *dev_id)
Bryan Wu194de562007-05-06 14:50:30 -0700381{
382 struct bfin_serial_port *uart = dev_id;
Bryan Wu194de562007-05-06 14:50:30 -0700383
Sonic Zhangd307d362009-04-07 16:52:26 +0100384#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
Roel Kluindaba0282009-04-21 12:24:58 -0700385 if (uart->scts && !(bfin_serial_get_mctrl(&uart->port) & TIOCM_CTS)) {
Sonic Zhangd307d362009-04-07 16:52:26 +0100386 uart->scts = 0;
387 uart_handle_cts_change(&uart->port, uart->scts);
388 }
389#endif
Roy Huangf4d640c92007-07-12 16:43:46 +0800390 spin_lock(&uart->port.lock);
Mike Frysinger0bcfd702007-12-24 19:40:05 +0800391 if (UART_GET_LSR(uart) & THRE)
Aubrey Li5c4e4722007-05-21 18:09:38 +0800392 bfin_serial_tx_chars(uart);
Bryan Wu194de562007-05-06 14:50:30 -0700393 spin_unlock(&uart->port.lock);
Sonic Zhang759eb042007-11-21 17:00:32 +0800394
Bryan Wu194de562007-05-06 14:50:30 -0700395 return IRQ_HANDLED;
396}
Sonic Zhang4cb4f222008-02-02 14:29:25 +0800397#endif
Bryan Wu194de562007-05-06 14:50:30 -0700398
Bryan Wu194de562007-05-06 14:50:30 -0700399#ifdef CONFIG_SERIAL_BFIN_DMA
400static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
401{
Alan Coxebd2c8f2009-09-19 13:13:28 -0700402 struct circ_buf *xmit = &uart->port.state->xmit;
Bryan Wu194de562007-05-06 14:50:30 -0700403
Bryan Wu194de562007-05-06 14:50:30 -0700404 uart->tx_done = 0;
405
Bryan Wu194de562007-05-06 14:50:30 -0700406 if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
Sonic Zhang0711d852008-02-25 15:16:50 +0800407 uart->tx_count = 0;
Bryan Wu194de562007-05-06 14:50:30 -0700408 uart->tx_done = 1;
409 return;
410 }
411
Sonic Zhang1b733512007-12-21 16:45:12 +0800412 if (uart->port.x_char) {
413 UART_PUT_CHAR(uart, uart->port.x_char);
414 uart->port.icount.tx++;
415 uart->port.x_char = 0;
416 }
417
Bryan Wu194de562007-05-06 14:50:30 -0700418 uart->tx_count = CIRC_CNT(xmit->head, xmit->tail, UART_XMIT_SIZE);
419 if (uart->tx_count > (UART_XMIT_SIZE - xmit->tail))
420 uart->tx_count = UART_XMIT_SIZE - xmit->tail;
421 blackfin_dcache_flush_range((unsigned long)(xmit->buf+xmit->tail),
422 (unsigned long)(xmit->buf+xmit->tail+uart->tx_count));
423 set_dma_config(uart->tx_dma_channel,
424 set_bfin_dma_config(DIR_READ, DMA_FLOW_STOP,
425 INTR_ON_BUF,
426 DIMENSION_LINEAR,
Michael Hennerich2047e402008-01-22 15:29:18 +0800427 DATA_SIZE_8,
428 DMA_SYNC_RESTART));
Bryan Wu194de562007-05-06 14:50:30 -0700429 set_dma_start_addr(uart->tx_dma_channel, (unsigned long)(xmit->buf+xmit->tail));
430 set_dma_x_count(uart->tx_dma_channel, uart->tx_count);
431 set_dma_x_modify(uart->tx_dma_channel, 1);
Graf Yangf9d36da2009-06-11 13:42:17 +0100432 SSYNC();
Bryan Wu194de562007-05-06 14:50:30 -0700433 enable_dma(uart->tx_dma_channel);
Sonic Zhang99ee7b52007-12-21 17:12:55 +0800434
Roy Huangf4d640c92007-07-12 16:43:46 +0800435 UART_SET_IER(uart, ETBEI);
Bryan Wu194de562007-05-06 14:50:30 -0700436}
437
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800438static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart)
Bryan Wu194de562007-05-06 14:50:30 -0700439{
Alan Coxebd2c8f2009-09-19 13:13:28 -0700440 struct tty_struct *tty = uart->port.state->port.tty;
Bryan Wu194de562007-05-06 14:50:30 -0700441 int i, flg, status;
442
443 status = UART_GET_LSR(uart);
Mike Frysinger0bcfd702007-12-24 19:40:05 +0800444 UART_CLEAR_LSR(uart);
445
Sonic Zhang56f5de82008-02-25 15:19:09 +0800446 uart->port.icount.rx +=
447 CIRC_CNT(uart->rx_dma_buf.head, uart->rx_dma_buf.tail,
448 UART_XMIT_SIZE);
Bryan Wu194de562007-05-06 14:50:30 -0700449
450 if (status & BI) {
451 uart->port.icount.brk++;
452 if (uart_handle_break(&uart->port))
453 goto dma_ignore_char;
Mike Frysinger98089012007-06-11 15:31:30 +0800454 status &= ~(PE | FE);
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800455 }
456 if (status & PE)
Bryan Wu194de562007-05-06 14:50:30 -0700457 uart->port.icount.parity++;
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800458 if (status & OE)
Bryan Wu194de562007-05-06 14:50:30 -0700459 uart->port.icount.overrun++;
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800460 if (status & FE)
Bryan Wu194de562007-05-06 14:50:30 -0700461 uart->port.icount.frame++;
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800462
463 status &= uart->port.read_status_mask;
464
465 if (status & BI)
466 flg = TTY_BREAK;
467 else if (status & PE)
468 flg = TTY_PARITY;
469 else if (status & FE)
470 flg = TTY_FRAME;
471 else
Bryan Wu194de562007-05-06 14:50:30 -0700472 flg = TTY_NORMAL;
473
Sonic Zhang8c4210e2009-04-06 17:32:42 +0100474 for (i = uart->rx_dma_buf.tail; ; i++) {
Sonic Zhang56f5de82008-02-25 15:19:09 +0800475 if (i >= UART_XMIT_SIZE)
476 i = 0;
Sonic Zhang8c4210e2009-04-06 17:32:42 +0100477 if (i == uart->rx_dma_buf.head)
478 break;
Sonic Zhang56f5de82008-02-25 15:19:09 +0800479 if (!uart_handle_sysrq_char(&uart->port, uart->rx_dma_buf.buf[i]))
480 uart_insert_char(&uart->port, status, OE,
481 uart->rx_dma_buf.buf[i], flg);
Bryan Wu194de562007-05-06 14:50:30 -0700482 }
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800483
484 dma_ignore_char:
Bryan Wu194de562007-05-06 14:50:30 -0700485 tty_flip_buffer_push(tty);
486}
487
488void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
489{
Mike Frysinger59e4e3e2009-04-06 17:32:28 +0100490 int x_pos, pos;
Sonic Zhang68a784c2009-01-02 13:40:38 +0000491
Graf Yang7ed43f6a2010-01-19 06:13:11 -0500492 dma_disable_irq(uart->tx_dma_channel);
Sonic Zhang2860b792009-06-11 13:51:33 +0100493 dma_disable_irq(uart->rx_dma_channel);
494 spin_lock_bh(&uart->port.lock);
Bryan Wu194de562007-05-06 14:50:30 -0700495
Sonic Zhang8516c562009-06-11 13:38:16 +0100496 /* 2D DMA RX buffer ring is used. Because curr_y_count and
497 * curr_x_count can't be read as an atomic operation,
498 * curr_y_count should be read before curr_x_count. When
499 * curr_x_count is read, curr_y_count may already indicate
500 * next buffer line. But, the position calculated here is
501 * still indicate the old line. The wrong position data may
502 * be smaller than current buffer tail, which cause garbages
503 * are received if it is not prohibit.
504 */
Sonic Zhang56f5de82008-02-25 15:19:09 +0800505 uart->rx_dma_nrows = get_dma_curr_ycount(uart->rx_dma_channel);
506 x_pos = get_dma_curr_xcount(uart->rx_dma_channel);
507 uart->rx_dma_nrows = DMA_RX_YCOUNT - uart->rx_dma_nrows;
Sonic Zhang35ff6932009-06-11 13:42:57 +0100508 if (uart->rx_dma_nrows == DMA_RX_YCOUNT || x_pos == 0)
Sonic Zhang56f5de82008-02-25 15:19:09 +0800509 uart->rx_dma_nrows = 0;
510 x_pos = DMA_RX_XCOUNT - x_pos;
Bryan Wu194de562007-05-06 14:50:30 -0700511 if (x_pos == DMA_RX_XCOUNT)
512 x_pos = 0;
513
514 pos = uart->rx_dma_nrows * DMA_RX_XCOUNT + x_pos;
Sonic Zhang8516c562009-06-11 13:38:16 +0100515 /* Ignore receiving data if new position is in the same line of
516 * current buffer tail and small.
517 */
518 if (pos > uart->rx_dma_buf.tail ||
519 uart->rx_dma_nrows < (uart->rx_dma_buf.tail/DMA_RX_XCOUNT)) {
Sonic Zhang56f5de82008-02-25 15:19:09 +0800520 uart->rx_dma_buf.head = pos;
Bryan Wu194de562007-05-06 14:50:30 -0700521 bfin_serial_dma_rx_chars(uart);
Sonic Zhang56f5de82008-02-25 15:19:09 +0800522 uart->rx_dma_buf.tail = uart->rx_dma_buf.head;
Bryan Wu194de562007-05-06 14:50:30 -0700523 }
Sonic Zhang0aef4562008-02-29 12:08:42 +0800524
Sonic Zhang2860b792009-06-11 13:51:33 +0100525 spin_unlock_bh(&uart->port.lock);
Graf Yang7ed43f6a2010-01-19 06:13:11 -0500526 dma_enable_irq(uart->tx_dma_channel);
Sonic Zhang2860b792009-06-11 13:51:33 +0100527 dma_enable_irq(uart->rx_dma_channel);
Sonic Zhang68a784c2009-01-02 13:40:38 +0000528
Sonic Zhang0a278422008-04-25 04:36:47 +0800529 mod_timer(&(uart->rx_dma_timer), jiffies + DMA_RX_FLUSH_JIFFIES);
Bryan Wu194de562007-05-06 14:50:30 -0700530}
531
532static irqreturn_t bfin_serial_dma_tx_int(int irq, void *dev_id)
533{
534 struct bfin_serial_port *uart = dev_id;
Alan Coxebd2c8f2009-09-19 13:13:28 -0700535 struct circ_buf *xmit = &uart->port.state->xmit;
Bryan Wu194de562007-05-06 14:50:30 -0700536
Sonic Zhangd307d362009-04-07 16:52:26 +0100537#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
Roel Kluindaba0282009-04-21 12:24:58 -0700538 if (uart->scts && !(bfin_serial_get_mctrl(&uart->port)&TIOCM_CTS)) {
Sonic Zhangd307d362009-04-07 16:52:26 +0100539 uart->scts = 0;
540 uart_handle_cts_change(&uart->port, uart->scts);
541 }
542#endif
543
Bryan Wu194de562007-05-06 14:50:30 -0700544 spin_lock(&uart->port.lock);
545 if (!(get_dma_curr_irqstat(uart->tx_dma_channel)&DMA_RUN)) {
Bryan Wu194de562007-05-06 14:50:30 -0700546 disable_dma(uart->tx_dma_channel);
Sonic Zhang0711d852008-02-25 15:16:50 +0800547 clear_dma_irqstat(uart->tx_dma_channel);
Sonic Zhang0efa4f22009-06-11 13:45:07 +0100548 /* Anomaly notes:
549 * 05000215 - we always clear ETBEI within last UART TX
550 * interrupt to end a string. It is always set
551 * when start a new tx.
552 */
Roy Huangf4d640c92007-07-12 16:43:46 +0800553 UART_CLEAR_IER(uart, ETBEI);
Sonic Zhang0711d852008-02-25 15:16:50 +0800554 xmit->tail = (xmit->tail + uart->tx_count) & (UART_XMIT_SIZE - 1);
555 uart->port.icount.tx += uart->tx_count;
Sonic Zhang1b733512007-12-21 16:45:12 +0800556
Sonic Zhang56f5de82008-02-25 15:19:09 +0800557 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
558 uart_write_wakeup(&uart->port);
559
Sonic Zhang1b733512007-12-21 16:45:12 +0800560 bfin_serial_dma_tx_chars(uart);
Bryan Wu194de562007-05-06 14:50:30 -0700561 }
562
563 spin_unlock(&uart->port.lock);
564 return IRQ_HANDLED;
565}
566
567static irqreturn_t bfin_serial_dma_rx_int(int irq, void *dev_id)
568{
569 struct bfin_serial_port *uart = dev_id;
570 unsigned short irqstat;
Sonic Zhang35ff6932009-06-11 13:42:57 +0100571 int x_pos, pos;
Sonic Zhang0711d852008-02-25 15:16:50 +0800572
Bryan Wu194de562007-05-06 14:50:30 -0700573 spin_lock(&uart->port.lock);
574 irqstat = get_dma_curr_irqstat(uart->rx_dma_channel);
575 clear_dma_irqstat(uart->rx_dma_channel);
Sonic Zhang8516c562009-06-11 13:38:16 +0100576
577 uart->rx_dma_nrows = get_dma_curr_ycount(uart->rx_dma_channel);
Sonic Zhang35ff6932009-06-11 13:42:57 +0100578 x_pos = get_dma_curr_xcount(uart->rx_dma_channel);
Sonic Zhang8516c562009-06-11 13:38:16 +0100579 uart->rx_dma_nrows = DMA_RX_YCOUNT - uart->rx_dma_nrows;
Sonic Zhang35ff6932009-06-11 13:42:57 +0100580 if (uart->rx_dma_nrows == DMA_RX_YCOUNT || x_pos == 0)
Sonic Zhang8516c562009-06-11 13:38:16 +0100581 uart->rx_dma_nrows = 0;
582
583 pos = uart->rx_dma_nrows * DMA_RX_XCOUNT;
584 if (pos > uart->rx_dma_buf.tail ||
585 uart->rx_dma_nrows < (uart->rx_dma_buf.tail/DMA_RX_XCOUNT)) {
586 uart->rx_dma_buf.head = pos;
587 bfin_serial_dma_rx_chars(uart);
588 uart->rx_dma_buf.tail = uart->rx_dma_buf.head;
589 }
590
Bryan Wu194de562007-05-06 14:50:30 -0700591 spin_unlock(&uart->port.lock);
Sonic Zhang0aef4562008-02-29 12:08:42 +0800592
Bryan Wu194de562007-05-06 14:50:30 -0700593 return IRQ_HANDLED;
594}
595#endif
596
597/*
598 * Return TIOCSER_TEMT when transmitter is not busy.
599 */
600static unsigned int bfin_serial_tx_empty(struct uart_port *port)
601{
602 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
603 unsigned short lsr;
604
605 lsr = UART_GET_LSR(uart);
606 if (lsr & TEMT)
607 return TIOCSER_TEMT;
608 else
609 return 0;
610}
611
Bryan Wu194de562007-05-06 14:50:30 -0700612static void bfin_serial_break_ctl(struct uart_port *port, int break_state)
613{
Mike Frysingercf686762007-06-11 16:12:49 +0800614 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
615 u16 lcr = UART_GET_LCR(uart);
616 if (break_state)
617 lcr |= SB;
618 else
619 lcr &= ~SB;
620 UART_PUT_LCR(uart, lcr);
621 SSYNC();
Bryan Wu194de562007-05-06 14:50:30 -0700622}
623
624static int bfin_serial_startup(struct uart_port *port)
625{
626 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
627
628#ifdef CONFIG_SERIAL_BFIN_DMA
629 dma_addr_t dma_handle;
630
631 if (request_dma(uart->rx_dma_channel, "BFIN_UART_RX") < 0) {
632 printk(KERN_NOTICE "Unable to attach Blackfin UART RX DMA channel\n");
633 return -EBUSY;
634 }
635
636 if (request_dma(uart->tx_dma_channel, "BFIN_UART_TX") < 0) {
637 printk(KERN_NOTICE "Unable to attach Blackfin UART TX DMA channel\n");
638 free_dma(uart->rx_dma_channel);
639 return -EBUSY;
640 }
641
642 set_dma_callback(uart->rx_dma_channel, bfin_serial_dma_rx_int, uart);
643 set_dma_callback(uart->tx_dma_channel, bfin_serial_dma_tx_int, uart);
644
645 uart->rx_dma_buf.buf = (unsigned char *)dma_alloc_coherent(NULL, PAGE_SIZE, &dma_handle, GFP_DMA);
646 uart->rx_dma_buf.head = 0;
647 uart->rx_dma_buf.tail = 0;
648 uart->rx_dma_nrows = 0;
649
650 set_dma_config(uart->rx_dma_channel,
651 set_bfin_dma_config(DIR_WRITE, DMA_FLOW_AUTO,
652 INTR_ON_ROW, DIMENSION_2D,
Michael Hennerich2047e402008-01-22 15:29:18 +0800653 DATA_SIZE_8,
654 DMA_SYNC_RESTART));
Bryan Wu194de562007-05-06 14:50:30 -0700655 set_dma_x_count(uart->rx_dma_channel, DMA_RX_XCOUNT);
656 set_dma_x_modify(uart->rx_dma_channel, 1);
657 set_dma_y_count(uart->rx_dma_channel, DMA_RX_YCOUNT);
658 set_dma_y_modify(uart->rx_dma_channel, 1);
659 set_dma_start_addr(uart->rx_dma_channel, (unsigned long)uart->rx_dma_buf.buf);
660 enable_dma(uart->rx_dma_channel);
661
662 uart->rx_dma_timer.data = (unsigned long)(uart);
663 uart->rx_dma_timer.function = (void *)bfin_serial_rx_dma_timeout;
664 uart->rx_dma_timer.expires = jiffies + DMA_RX_FLUSH_JIFFIES;
665 add_timer(&(uart->rx_dma_timer));
666#else
Sonic Zhang6f955702009-04-07 16:51:15 +0100667# if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
Sonic Zhang52e15f0e2009-01-02 13:40:14 +0000668 defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
669 if (kgdboc_port_line == uart->port.line && kgdboc_break_enabled)
670 kgdboc_break_enabled = 0;
671 else {
672# endif
Sonic Zhanga359cca2007-10-10 16:47:58 +0800673 if (request_irq(uart->port.irq, bfin_serial_rx_int, IRQF_DISABLED,
Bryan Wu194de562007-05-06 14:50:30 -0700674 "BFIN_UART_RX", uart)) {
675 printk(KERN_NOTICE "Unable to attach BlackFin UART RX interrupt\n");
676 return -EBUSY;
677 }
678
679 if (request_irq
Aubrey Li5c4e4722007-05-21 18:09:38 +0800680 (uart->port.irq+1, bfin_serial_tx_int, IRQF_DISABLED,
Bryan Wu194de562007-05-06 14:50:30 -0700681 "BFIN_UART_TX", uart)) {
682 printk(KERN_NOTICE "Unable to attach BlackFin UART TX interrupt\n");
683 free_irq(uart->port.irq, uart);
684 return -EBUSY;
685 }
Sonic Zhangab2375f2008-10-13 10:33:51 +0100686
687# ifdef CONFIG_BF54x
688 {
689 unsigned uart_dma_ch_rx, uart_dma_ch_tx;
690
691 switch (uart->port.irq) {
692 case IRQ_UART3_RX:
693 uart_dma_ch_rx = CH_UART3_RX;
694 uart_dma_ch_tx = CH_UART3_TX;
695 break;
696 case IRQ_UART2_RX:
697 uart_dma_ch_rx = CH_UART2_RX;
698 uart_dma_ch_tx = CH_UART2_TX;
699 break;
700 default:
701 uart_dma_ch_rx = uart_dma_ch_tx = 0;
702 break;
703 };
704
705 if (uart_dma_ch_rx &&
706 request_dma(uart_dma_ch_rx, "BFIN_UART_RX") < 0) {
707 printk(KERN_NOTICE"Fail to attach UART interrupt\n");
708 free_irq(uart->port.irq, uart);
709 free_irq(uart->port.irq + 1, uart);
710 return -EBUSY;
711 }
712 if (uart_dma_ch_tx &&
713 request_dma(uart_dma_ch_tx, "BFIN_UART_TX") < 0) {
714 printk(KERN_NOTICE "Fail to attach UART interrupt\n");
715 free_dma(uart_dma_ch_rx);
716 free_irq(uart->port.irq, uart);
717 free_irq(uart->port.irq + 1, uart);
718 return -EBUSY;
719 }
720 }
721# endif
Sonic Zhang6f955702009-04-07 16:51:15 +0100722# if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
Sonic Zhang52e15f0e2009-01-02 13:40:14 +0000723 defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
724 }
725# endif
Bryan Wu194de562007-05-06 14:50:30 -0700726#endif
Sonic Zhang6f955702009-04-07 16:51:15 +0100727
728#ifdef CONFIG_SERIAL_BFIN_CTSRTS
729 if (uart->cts_pin >= 0) {
730 if (request_irq(gpio_to_irq(uart->cts_pin),
731 bfin_serial_mctrl_cts_int,
732 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
733 IRQF_DISABLED, "BFIN_UART_CTS", uart)) {
734 uart->cts_pin = -1;
735 pr_info("Unable to attach BlackFin UART CTS interrupt.\
736 So, disable it.\n");
737 }
738 }
739 if (uart->rts_pin >= 0) {
740 gpio_request(uart->rts_pin, DRIVER_NAME);
741 gpio_direction_output(uart->rts_pin, 0);
742 }
743#endif
Sonic Zhangd307d362009-04-07 16:52:26 +0100744#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
745 if (request_irq(uart->status_irq,
746 bfin_serial_mctrl_cts_int,
747 IRQF_DISABLED, "BFIN_UART_MODEM_STATUS", uart)) {
748 pr_info("Unable to attach BlackFin UART Modem \
749 Status interrupt.\n");
750 }
751
Sonic Zhangd307d362009-04-07 16:52:26 +0100752 /* CTS RTS PINs are negative assertive. */
753 UART_PUT_MCR(uart, ACTS);
754 UART_SET_IER(uart, EDSSI);
755#endif
756
Roy Huangf4d640c92007-07-12 16:43:46 +0800757 UART_SET_IER(uart, ERBFI);
Bryan Wu194de562007-05-06 14:50:30 -0700758 return 0;
759}
760
761static void bfin_serial_shutdown(struct uart_port *port)
762{
763 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
764
765#ifdef CONFIG_SERIAL_BFIN_DMA
766 disable_dma(uart->tx_dma_channel);
767 free_dma(uart->tx_dma_channel);
768 disable_dma(uart->rx_dma_channel);
769 free_dma(uart->rx_dma_channel);
770 del_timer(&(uart->rx_dma_timer));
Sonic Zhang75b780b2007-12-21 17:03:39 +0800771 dma_free_coherent(NULL, PAGE_SIZE, uart->rx_dma_buf.buf, 0);
Bryan Wu194de562007-05-06 14:50:30 -0700772#else
Sonic Zhangab2375f2008-10-13 10:33:51 +0100773#ifdef CONFIG_BF54x
774 switch (uart->port.irq) {
775 case IRQ_UART3_RX:
776 free_dma(CH_UART3_RX);
777 free_dma(CH_UART3_TX);
778 break;
779 case IRQ_UART2_RX:
780 free_dma(CH_UART2_RX);
781 free_dma(CH_UART2_TX);
782 break;
783 default:
784 break;
785 };
786#endif
Bryan Wu194de562007-05-06 14:50:30 -0700787 free_irq(uart->port.irq, uart);
788 free_irq(uart->port.irq+1, uart);
789#endif
Sonic Zhang6f955702009-04-07 16:51:15 +0100790
Sonic Zhangd307d362009-04-07 16:52:26 +0100791#ifdef CONFIG_SERIAL_BFIN_CTSRTS
Sonic Zhang6f955702009-04-07 16:51:15 +0100792 if (uart->cts_pin >= 0)
793 free_irq(gpio_to_irq(uart->cts_pin), uart);
794 if (uart->rts_pin >= 0)
795 gpio_free(uart->rts_pin);
Sonic Zhangd307d362009-04-07 16:52:26 +0100796#endif
797#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
Sonic Zhangd307d362009-04-07 16:52:26 +0100798 if (UART_GET_IER(uart) && EDSSI)
799 free_irq(uart->status_irq, uart);
800#endif
Bryan Wu194de562007-05-06 14:50:30 -0700801}
802
803static void
804bfin_serial_set_termios(struct uart_port *port, struct ktermios *termios,
805 struct ktermios *old)
806{
807 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
808 unsigned long flags;
809 unsigned int baud, quot;
Mike Frysinger0c44a862008-04-24 04:56:02 +0800810 unsigned short val, ier, lcr = 0;
Bryan Wu194de562007-05-06 14:50:30 -0700811
812 switch (termios->c_cflag & CSIZE) {
813 case CS8:
814 lcr = WLS(8);
815 break;
816 case CS7:
817 lcr = WLS(7);
818 break;
819 case CS6:
820 lcr = WLS(6);
821 break;
822 case CS5:
823 lcr = WLS(5);
824 break;
825 default:
826 printk(KERN_ERR "%s: word lengh not supported\n",
Harvey Harrison71cc2c22008-04-30 00:55:10 -0700827 __func__);
Bryan Wu194de562007-05-06 14:50:30 -0700828 }
829
Sonic Zhang84507792009-06-11 13:50:20 +0100830 /* Anomaly notes:
831 * 05000231 - STOP bit is always set to 1 whatever the user is set.
832 */
833 if (termios->c_cflag & CSTOPB) {
834 if (ANOMALY_05000231)
835 printk(KERN_WARNING "STOP bits other than 1 is not "
836 "supported in case of anomaly 05000231.\n");
837 else
838 lcr |= STB;
839 }
Mike Frysinger19aa6382007-06-11 16:16:45 +0800840 if (termios->c_cflag & PARENB)
Bryan Wu194de562007-05-06 14:50:30 -0700841 lcr |= PEN;
Mike Frysinger19aa6382007-06-11 16:16:45 +0800842 if (!(termios->c_cflag & PARODD))
843 lcr |= EPS;
844 if (termios->c_cflag & CMSPAR)
845 lcr |= STP;
Bryan Wu194de562007-05-06 14:50:30 -0700846
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800847 port->read_status_mask = OE;
848 if (termios->c_iflag & INPCK)
849 port->read_status_mask |= (FE | PE);
850 if (termios->c_iflag & (BRKINT | PARMRK))
851 port->read_status_mask |= BI;
Bryan Wu194de562007-05-06 14:50:30 -0700852
Mike Frysinger2ac5ee42007-05-21 18:09:39 +0800853 /*
854 * Characters to ignore
855 */
856 port->ignore_status_mask = 0;
857 if (termios->c_iflag & IGNPAR)
858 port->ignore_status_mask |= FE | PE;
859 if (termios->c_iflag & IGNBRK) {
860 port->ignore_status_mask |= BI;
861 /*
862 * If we're ignoring parity and break indicators,
863 * ignore overruns too (for real raw support).
864 */
865 if (termios->c_iflag & IGNPAR)
866 port->ignore_status_mask |= OE;
867 }
Bryan Wu194de562007-05-06 14:50:30 -0700868
869 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
Graf Yangf4487102009-04-06 17:32:49 +0100870 quot = uart_get_divisor(port, baud) - ANOMALY_05000230;
Bryan Wu194de562007-05-06 14:50:30 -0700871 spin_lock_irqsave(&uart->port.lock, flags);
872
Mike Frysinger8851c712007-12-24 19:48:04 +0800873 UART_SET_ANOMALY_THRESHOLD(uart, USEC_PER_SEC / baud * 15);
874
Bryan Wu194de562007-05-06 14:50:30 -0700875 /* Disable UART */
876 ier = UART_GET_IER(uart);
Sonic Zhang1feaa512008-06-03 12:19:45 +0800877 UART_DISABLE_INTS(uart);
Bryan Wu194de562007-05-06 14:50:30 -0700878
879 /* Set DLAB in LCR to Access DLL and DLH */
Mike Frysinger45828b82008-05-07 11:41:26 +0800880 UART_SET_DLAB(uart);
Bryan Wu194de562007-05-06 14:50:30 -0700881
882 UART_PUT_DLL(uart, quot & 0xFF);
Bryan Wu194de562007-05-06 14:50:30 -0700883 UART_PUT_DLH(uart, (quot >> 8) & 0xFF);
884 SSYNC();
885
886 /* Clear DLAB in LCR to Access THR RBR IER */
Mike Frysinger45828b82008-05-07 11:41:26 +0800887 UART_CLEAR_DLAB(uart);
Bryan Wu194de562007-05-06 14:50:30 -0700888
889 UART_PUT_LCR(uart, lcr);
890
891 /* Enable UART */
Sonic Zhang1feaa512008-06-03 12:19:45 +0800892 UART_ENABLE_INTS(uart, ier);
Bryan Wu194de562007-05-06 14:50:30 -0700893
894 val = UART_GET_GCTL(uart);
895 val |= UCEN;
896 UART_PUT_GCTL(uart, val);
897
Graf Yangb3ef5ab2008-10-13 10:33:42 +0100898 /* Port speed changed, update the per-port timeout. */
899 uart_update_timeout(port, termios->c_cflag, baud);
900
Bryan Wu194de562007-05-06 14:50:30 -0700901 spin_unlock_irqrestore(&uart->port.lock, flags);
902}
903
904static const char *bfin_serial_type(struct uart_port *port)
905{
906 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
907
908 return uart->port.type == PORT_BFIN ? "BFIN-UART" : NULL;
909}
910
911/*
912 * Release the memory region(s) being used by 'port'.
913 */
914static void bfin_serial_release_port(struct uart_port *port)
915{
916}
917
918/*
919 * Request the memory region(s) being used by 'port'.
920 */
921static int bfin_serial_request_port(struct uart_port *port)
922{
923 return 0;
924}
925
926/*
927 * Configure/autoconfigure the port.
928 */
929static void bfin_serial_config_port(struct uart_port *port, int flags)
930{
931 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
932
933 if (flags & UART_CONFIG_TYPE &&
934 bfin_serial_request_port(&uart->port) == 0)
935 uart->port.type = PORT_BFIN;
936}
937
938/*
939 * Verify the new serial_struct (for TIOCSSERIAL).
940 * The only change we allow are to the flags and type, and
941 * even then only between PORT_BFIN and PORT_UNKNOWN
942 */
943static int
944bfin_serial_verify_port(struct uart_port *port, struct serial_struct *ser)
945{
946 return 0;
947}
948
Graf Yang7d01b472008-02-29 11:31:08 +0800949/*
950 * Enable the IrDA function if tty->ldisc.num is N_IRDA.
951 * In other cases, disable IrDA function.
952 */
Graf Yang3b8458a2008-06-07 15:36:33 +0800953static void bfin_serial_set_ldisc(struct uart_port *port)
Graf Yang7d01b472008-02-29 11:31:08 +0800954{
Graf Yang3b8458a2008-06-07 15:36:33 +0800955 int line = port->line;
Graf Yang7d01b472008-02-29 11:31:08 +0800956 unsigned short val;
957
Alan Coxebd2c8f2009-09-19 13:13:28 -0700958 if (line >= port->state->port.tty->driver->num)
Graf Yang7d01b472008-02-29 11:31:08 +0800959 return;
960
Alan Coxebd2c8f2009-09-19 13:13:28 -0700961 switch (port->state->port.tty->termios->c_line) {
Graf Yang7d01b472008-02-29 11:31:08 +0800962 case N_IRDA:
963 val = UART_GET_GCTL(&bfin_serial_ports[line]);
964 val |= (IREN | RPOLC);
965 UART_PUT_GCTL(&bfin_serial_ports[line], val);
966 break;
967 default:
968 val = UART_GET_GCTL(&bfin_serial_ports[line]);
969 val &= ~(IREN | RPOLC);
970 UART_PUT_GCTL(&bfin_serial_ports[line], val);
971 }
972}
973
Sonic Zhang6f955702009-04-07 16:51:15 +0100974static void bfin_serial_reset_irda(struct uart_port *port)
975{
976 int line = port->line;
977 unsigned short val;
978
979 val = UART_GET_GCTL(&bfin_serial_ports[line]);
980 val &= ~(IREN | RPOLC);
981 UART_PUT_GCTL(&bfin_serial_ports[line], val);
982 SSYNC();
983 val |= (IREN | RPOLC);
984 UART_PUT_GCTL(&bfin_serial_ports[line], val);
985 SSYNC();
986}
987
Sonic Zhang52e15f0e2009-01-02 13:40:14 +0000988#ifdef CONFIG_CONSOLE_POLL
Sonic Zhang0efa4f22009-06-11 13:45:07 +0100989/* Anomaly notes:
990 * 05000099 - Because we only use THRE in poll_put and DR in poll_get,
991 * losing other bits of UART_LSR is not a problem here.
992 */
Sonic Zhang52e15f0e2009-01-02 13:40:14 +0000993static void bfin_serial_poll_put_char(struct uart_port *port, unsigned char chr)
994{
995 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
996
997 while (!(UART_GET_LSR(uart) & THRE))
998 cpu_relax();
999
1000 UART_CLEAR_DLAB(uart);
1001 UART_PUT_CHAR(uart, (unsigned char)chr);
1002}
1003
1004static int bfin_serial_poll_get_char(struct uart_port *port)
1005{
1006 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
1007 unsigned char chr;
1008
1009 while (!(UART_GET_LSR(uart) & DR))
1010 cpu_relax();
1011
1012 UART_CLEAR_DLAB(uart);
1013 chr = UART_GET_CHAR(uart);
1014
1015 return chr;
1016}
1017#endif
1018
1019#if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
1020 defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
1021static void bfin_kgdboc_port_shutdown(struct uart_port *port)
1022{
1023 if (kgdboc_break_enabled) {
1024 kgdboc_break_enabled = 0;
1025 bfin_serial_shutdown(port);
1026 }
1027}
1028
1029static int bfin_kgdboc_port_startup(struct uart_port *port)
1030{
1031 kgdboc_port_line = port->line;
1032 kgdboc_break_enabled = !bfin_serial_startup(port);
1033 return 0;
1034}
1035#endif
1036
Bryan Wu194de562007-05-06 14:50:30 -07001037static struct uart_ops bfin_serial_pops = {
1038 .tx_empty = bfin_serial_tx_empty,
1039 .set_mctrl = bfin_serial_set_mctrl,
1040 .get_mctrl = bfin_serial_get_mctrl,
1041 .stop_tx = bfin_serial_stop_tx,
1042 .start_tx = bfin_serial_start_tx,
1043 .stop_rx = bfin_serial_stop_rx,
1044 .enable_ms = bfin_serial_enable_ms,
1045 .break_ctl = bfin_serial_break_ctl,
1046 .startup = bfin_serial_startup,
1047 .shutdown = bfin_serial_shutdown,
1048 .set_termios = bfin_serial_set_termios,
Graf Yang3b8458a2008-06-07 15:36:33 +08001049 .set_ldisc = bfin_serial_set_ldisc,
Bryan Wu194de562007-05-06 14:50:30 -07001050 .type = bfin_serial_type,
1051 .release_port = bfin_serial_release_port,
1052 .request_port = bfin_serial_request_port,
1053 .config_port = bfin_serial_config_port,
1054 .verify_port = bfin_serial_verify_port,
Sonic Zhang52e15f0e2009-01-02 13:40:14 +00001055#if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
1056 defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
1057 .kgdboc_port_startup = bfin_kgdboc_port_startup,
1058 .kgdboc_port_shutdown = bfin_kgdboc_port_shutdown,
1059#endif
1060#ifdef CONFIG_CONSOLE_POLL
1061 .poll_put_char = bfin_serial_poll_put_char,
1062 .poll_get_char = bfin_serial_poll_get_char,
1063#endif
Bryan Wu194de562007-05-06 14:50:30 -07001064};
1065
Sonic Zhang6f955702009-04-07 16:51:15 +01001066static void __init bfin_serial_hw_init(void)
1067{
1068#ifdef CONFIG_SERIAL_BFIN_UART0
1069 peripheral_request(P_UART0_TX, DRIVER_NAME);
1070 peripheral_request(P_UART0_RX, DRIVER_NAME);
1071#endif
1072
1073#ifdef CONFIG_SERIAL_BFIN_UART1
1074 peripheral_request(P_UART1_TX, DRIVER_NAME);
1075 peripheral_request(P_UART1_RX, DRIVER_NAME);
1076
1077# if defined(CONFIG_BFIN_UART1_CTSRTS) && defined(CONFIG_BF54x)
1078 peripheral_request(P_UART1_RTS, DRIVER_NAME);
1079 peripheral_request(P_UART1_CTS, DRIVER_NAME);
1080# endif
1081#endif
1082
1083#ifdef CONFIG_SERIAL_BFIN_UART2
1084 peripheral_request(P_UART2_TX, DRIVER_NAME);
1085 peripheral_request(P_UART2_RX, DRIVER_NAME);
1086#endif
1087
1088#ifdef CONFIG_SERIAL_BFIN_UART3
1089 peripheral_request(P_UART3_TX, DRIVER_NAME);
1090 peripheral_request(P_UART3_RX, DRIVER_NAME);
1091
1092# if defined(CONFIG_BFIN_UART3_CTSRTS) && defined(CONFIG_BF54x)
1093 peripheral_request(P_UART3_RTS, DRIVER_NAME);
1094 peripheral_request(P_UART3_CTS, DRIVER_NAME);
1095# endif
1096#endif
1097}
1098
Bryan Wu194de562007-05-06 14:50:30 -07001099static void __init bfin_serial_init_ports(void)
1100{
1101 static int first = 1;
1102 int i;
1103
1104 if (!first)
1105 return;
1106 first = 0;
1107
Sonic Zhang6f955702009-04-07 16:51:15 +01001108 bfin_serial_hw_init();
1109
Mike Frysingerc9607ec2008-10-13 10:33:16 +01001110 for (i = 0; i < nr_active_ports; i++) {
Mike Frysinger9c529a32009-06-22 18:37:24 +01001111 spin_lock_init(&bfin_serial_ports[i].port.lock);
Bryan Wu194de562007-05-06 14:50:30 -07001112 bfin_serial_ports[i].port.uartclk = get_sclk();
Graf Yangb3ef5ab2008-10-13 10:33:42 +01001113 bfin_serial_ports[i].port.fifosize = BFIN_UART_TX_FIFO_SIZE;
Bryan Wu194de562007-05-06 14:50:30 -07001114 bfin_serial_ports[i].port.ops = &bfin_serial_pops;
1115 bfin_serial_ports[i].port.line = i;
1116 bfin_serial_ports[i].port.iotype = UPIO_MEM;
1117 bfin_serial_ports[i].port.membase =
1118 (void __iomem *)bfin_serial_resource[i].uart_base_addr;
1119 bfin_serial_ports[i].port.mapbase =
1120 bfin_serial_resource[i].uart_base_addr;
1121 bfin_serial_ports[i].port.irq =
1122 bfin_serial_resource[i].uart_irq;
Sonic Zhangd307d362009-04-07 16:52:26 +01001123 bfin_serial_ports[i].status_irq =
1124 bfin_serial_resource[i].uart_status_irq;
Bryan Wu194de562007-05-06 14:50:30 -07001125 bfin_serial_ports[i].port.flags = UPF_BOOT_AUTOCONF;
1126#ifdef CONFIG_SERIAL_BFIN_DMA
1127 bfin_serial_ports[i].tx_done = 1;
1128 bfin_serial_ports[i].tx_count = 0;
1129 bfin_serial_ports[i].tx_dma_channel =
1130 bfin_serial_resource[i].uart_tx_dma_channel;
1131 bfin_serial_ports[i].rx_dma_channel =
1132 bfin_serial_resource[i].uart_rx_dma_channel;
1133 init_timer(&(bfin_serial_ports[i].rx_dma_timer));
Bryan Wu194de562007-05-06 14:50:30 -07001134#endif
Sonic Zhangd307d362009-04-07 16:52:26 +01001135#if defined(CONFIG_SERIAL_BFIN_CTSRTS) || \
1136 defined(CONFIG_SERIAL_BFIN_HARD_CTSRTS)
Bryan Wu194de562007-05-06 14:50:30 -07001137 bfin_serial_ports[i].cts_pin =
1138 bfin_serial_resource[i].uart_cts_pin;
1139 bfin_serial_ports[i].rts_pin =
1140 bfin_serial_resource[i].uart_rts_pin;
1141#endif
Bryan Wu194de562007-05-06 14:50:30 -07001142 }
1143}
1144
Sonic Zhangb6efa1e2009-01-02 13:40:31 +00001145#if defined(CONFIG_SERIAL_BFIN_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
Bryan Wu194de562007-05-06 14:50:30 -07001146/*
1147 * If the port was already initialised (eg, by a boot loader),
1148 * try to determine the current setup.
1149 */
1150static void __init
1151bfin_serial_console_get_options(struct bfin_serial_port *uart, int *baud,
1152 int *parity, int *bits)
1153{
1154 unsigned short status;
1155
1156 status = UART_GET_IER(uart) & (ERBFI | ETBEI);
1157 if (status == (ERBFI | ETBEI)) {
1158 /* ok, the port was enabled */
Mike Frysinger45828b82008-05-07 11:41:26 +08001159 u16 lcr, dlh, dll;
Bryan Wu194de562007-05-06 14:50:30 -07001160
1161 lcr = UART_GET_LCR(uart);
1162
1163 *parity = 'n';
1164 if (lcr & PEN) {
1165 if (lcr & EPS)
1166 *parity = 'e';
1167 else
1168 *parity = 'o';
1169 }
1170 switch (lcr & 0x03) {
1171 case 0: *bits = 5; break;
1172 case 1: *bits = 6; break;
1173 case 2: *bits = 7; break;
1174 case 3: *bits = 8; break;
1175 }
1176 /* Set DLAB in LCR to Access DLL and DLH */
Mike Frysinger45828b82008-05-07 11:41:26 +08001177 UART_SET_DLAB(uart);
Bryan Wu194de562007-05-06 14:50:30 -07001178
1179 dll = UART_GET_DLL(uart);
1180 dlh = UART_GET_DLH(uart);
1181
1182 /* Clear DLAB in LCR to Access THR RBR IER */
Mike Frysinger45828b82008-05-07 11:41:26 +08001183 UART_CLEAR_DLAB(uart);
Bryan Wu194de562007-05-06 14:50:30 -07001184
1185 *baud = get_sclk() / (16*(dll | dlh << 8));
1186 }
Harvey Harrison71cc2c22008-04-30 00:55:10 -07001187 pr_debug("%s:baud = %d, parity = %c, bits= %d\n", __func__, *baud, *parity, *bits);
Bryan Wu194de562007-05-06 14:50:30 -07001188}
Robin Getz0ae53642007-10-09 17:24:49 +08001189
Robin Getz0ae53642007-10-09 17:24:49 +08001190static struct uart_driver bfin_serial_reg;
Bryan Wu194de562007-05-06 14:50:30 -07001191
1192static int __init
1193bfin_serial_console_setup(struct console *co, char *options)
1194{
1195 struct bfin_serial_port *uart;
1196 int baud = 57600;
1197 int bits = 8;
1198 int parity = 'n';
Sonic Zhangd307d362009-04-07 16:52:26 +01001199# if defined(CONFIG_SERIAL_BFIN_CTSRTS) || \
1200 defined(CONFIG_SERIAL_BFIN_HARD_CTSRTS)
Bryan Wu194de562007-05-06 14:50:30 -07001201 int flow = 'r';
Sonic Zhangb6efa1e2009-01-02 13:40:31 +00001202# else
Bryan Wu194de562007-05-06 14:50:30 -07001203 int flow = 'n';
Robin Getz0ae53642007-10-09 17:24:49 +08001204# endif
Bryan Wu194de562007-05-06 14:50:30 -07001205
1206 /*
1207 * Check whether an invalid uart number has been specified, and
1208 * if so, search for the first available port that does have
1209 * console support.
1210 */
Mike Frysingerc9607ec2008-10-13 10:33:16 +01001211 if (co->index == -1 || co->index >= nr_active_ports)
Bryan Wu194de562007-05-06 14:50:30 -07001212 co->index = 0;
1213 uart = &bfin_serial_ports[co->index];
1214
1215 if (options)
1216 uart_parse_options(options, &baud, &parity, &bits, &flow);
1217 else
1218 bfin_serial_console_get_options(uart, &baud, &parity, &bits);
1219
1220 return uart_set_options(&uart->port, co, baud, parity, bits, flow);
Robin Getz0ae53642007-10-09 17:24:49 +08001221}
1222#endif /* defined (CONFIG_SERIAL_BFIN_CONSOLE) ||
1223 defined (CONFIG_EARLY_PRINTK) */
1224
1225#ifdef CONFIG_SERIAL_BFIN_CONSOLE
1226static void bfin_serial_console_putchar(struct uart_port *port, int ch)
1227{
1228 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
1229 while (!(UART_GET_LSR(uart) & THRE))
1230 barrier();
1231 UART_PUT_CHAR(uart, ch);
1232 SSYNC();
Bryan Wu194de562007-05-06 14:50:30 -07001233}
1234
Robin Getz0ae53642007-10-09 17:24:49 +08001235/*
1236 * Interrupts are disabled on entering
1237 */
1238static void
1239bfin_serial_console_write(struct console *co, const char *s, unsigned int count)
1240{
1241 struct bfin_serial_port *uart = &bfin_serial_ports[co->index];
Mike Frysinger59e4e3e2009-04-06 17:32:28 +01001242 unsigned long flags;
Robin Getz0ae53642007-10-09 17:24:49 +08001243
1244 spin_lock_irqsave(&uart->port.lock, flags);
1245 uart_console_write(&uart->port, s, count, bfin_serial_console_putchar);
1246 spin_unlock_irqrestore(&uart->port.lock, flags);
1247
1248}
1249
Bryan Wu194de562007-05-06 14:50:30 -07001250static struct console bfin_serial_console = {
1251 .name = BFIN_SERIAL_NAME,
1252 .write = bfin_serial_console_write,
1253 .device = uart_console_device,
1254 .setup = bfin_serial_console_setup,
1255 .flags = CON_PRINTBUFFER,
1256 .index = -1,
1257 .data = &bfin_serial_reg,
1258};
1259
1260static int __init bfin_serial_rs_console_init(void)
1261{
1262 bfin_serial_init_ports();
1263 register_console(&bfin_serial_console);
Sonic Zhang52e15f0e2009-01-02 13:40:14 +00001264
Bryan Wu194de562007-05-06 14:50:30 -07001265 return 0;
1266}
1267console_initcall(bfin_serial_rs_console_init);
1268
1269#define BFIN_SERIAL_CONSOLE &bfin_serial_console
1270#else
1271#define BFIN_SERIAL_CONSOLE NULL
Robin Getz0ae53642007-10-09 17:24:49 +08001272#endif /* CONFIG_SERIAL_BFIN_CONSOLE */
1273
1274
1275#ifdef CONFIG_EARLY_PRINTK
1276static __init void early_serial_putc(struct uart_port *port, int ch)
1277{
1278 unsigned timeout = 0xffff;
1279 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
1280
1281 while ((!(UART_GET_LSR(uart) & THRE)) && --timeout)
1282 cpu_relax();
1283 UART_PUT_CHAR(uart, ch);
1284}
1285
1286static __init void early_serial_write(struct console *con, const char *s,
1287 unsigned int n)
1288{
1289 struct bfin_serial_port *uart = &bfin_serial_ports[con->index];
1290 unsigned int i;
1291
1292 for (i = 0; i < n; i++, s++) {
1293 if (*s == '\n')
1294 early_serial_putc(&uart->port, '\r');
1295 early_serial_putc(&uart->port, *s);
1296 }
1297}
1298
Robin Getz7de7c552009-06-11 13:38:57 +01001299/*
1300 * This should have a .setup or .early_setup in it, but then things get called
1301 * without the command line options, and the baud rate gets messed up - so
1302 * don't let the common infrastructure play with things. (see calls to setup
1303 * & earlysetup in ./kernel/printk.c:register_console()
1304 */
Mike Frysingerc1113402008-10-13 10:32:35 +01001305static struct __initdata console bfin_early_serial_console = {
Robin Getz0ae53642007-10-09 17:24:49 +08001306 .name = "early_BFuart",
1307 .write = early_serial_write,
1308 .device = uart_console_device,
1309 .flags = CON_PRINTBUFFER,
Robin Getz0ae53642007-10-09 17:24:49 +08001310 .index = -1,
1311 .data = &bfin_serial_reg,
1312};
1313
1314struct console __init *bfin_earlyserial_init(unsigned int port,
1315 unsigned int cflag)
1316{
1317 struct bfin_serial_port *uart;
1318 struct ktermios t;
1319
Mike Frysingerc9607ec2008-10-13 10:33:16 +01001320 if (port == -1 || port >= nr_active_ports)
Robin Getz0ae53642007-10-09 17:24:49 +08001321 port = 0;
1322 bfin_serial_init_ports();
1323 bfin_early_serial_console.index = port;
Robin Getz0ae53642007-10-09 17:24:49 +08001324 uart = &bfin_serial_ports[port];
1325 t.c_cflag = cflag;
1326 t.c_iflag = 0;
1327 t.c_oflag = 0;
1328 t.c_lflag = ICANON;
1329 t.c_line = port;
1330 bfin_serial_set_termios(&uart->port, &t, &t);
1331 return &bfin_early_serial_console;
1332}
1333
Sonic Zhangb6efa1e2009-01-02 13:40:31 +00001334#endif /* CONFIG_EARLY_PRINTK */
Bryan Wu194de562007-05-06 14:50:30 -07001335
1336static struct uart_driver bfin_serial_reg = {
1337 .owner = THIS_MODULE,
1338 .driver_name = "bfin-uart",
1339 .dev_name = BFIN_SERIAL_NAME,
1340 .major = BFIN_SERIAL_MAJOR,
1341 .minor = BFIN_SERIAL_MINOR,
Graf Yang2ade9722008-04-25 02:55:49 +08001342 .nr = BFIN_UART_NR_PORTS,
Bryan Wu194de562007-05-06 14:50:30 -07001343 .cons = BFIN_SERIAL_CONSOLE,
1344};
1345
1346static int bfin_serial_suspend(struct platform_device *dev, pm_message_t state)
1347{
Sonic Zhangccfbc3e2008-10-13 10:32:44 +01001348 int i;
Bryan Wu194de562007-05-06 14:50:30 -07001349
Mike Frysingerc9607ec2008-10-13 10:33:16 +01001350 for (i = 0; i < nr_active_ports; i++) {
Sonic Zhangccfbc3e2008-10-13 10:32:44 +01001351 if (bfin_serial_ports[i].port.dev != &dev->dev)
1352 continue;
1353 uart_suspend_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
1354 }
Bryan Wu194de562007-05-06 14:50:30 -07001355
1356 return 0;
1357}
1358
1359static int bfin_serial_resume(struct platform_device *dev)
1360{
Sonic Zhangccfbc3e2008-10-13 10:32:44 +01001361 int i;
Bryan Wu194de562007-05-06 14:50:30 -07001362
Mike Frysingerc9607ec2008-10-13 10:33:16 +01001363 for (i = 0; i < nr_active_ports; i++) {
Sonic Zhangccfbc3e2008-10-13 10:32:44 +01001364 if (bfin_serial_ports[i].port.dev != &dev->dev)
1365 continue;
1366 uart_resume_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
1367 }
Bryan Wu194de562007-05-06 14:50:30 -07001368
1369 return 0;
1370}
1371
1372static int bfin_serial_probe(struct platform_device *dev)
1373{
1374 struct resource *res = dev->resource;
1375 int i;
1376
1377 for (i = 0; i < dev->num_resources; i++, res++)
1378 if (res->flags & IORESOURCE_MEM)
1379 break;
1380
1381 if (i < dev->num_resources) {
Mike Frysingerc9607ec2008-10-13 10:33:16 +01001382 for (i = 0; i < nr_active_ports; i++, res++) {
Bryan Wu194de562007-05-06 14:50:30 -07001383 if (bfin_serial_ports[i].port.mapbase != res->start)
1384 continue;
1385 bfin_serial_ports[i].port.dev = &dev->dev;
1386 uart_add_one_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
Bryan Wu194de562007-05-06 14:50:30 -07001387 }
1388 }
1389
1390 return 0;
1391}
1392
Sonic Zhangccfbc3e2008-10-13 10:32:44 +01001393static int bfin_serial_remove(struct platform_device *dev)
Bryan Wu194de562007-05-06 14:50:30 -07001394{
Sonic Zhangccfbc3e2008-10-13 10:32:44 +01001395 int i;
Bryan Wu194de562007-05-06 14:50:30 -07001396
Mike Frysingerc9607ec2008-10-13 10:33:16 +01001397 for (i = 0; i < nr_active_ports; i++) {
Sonic Zhangccfbc3e2008-10-13 10:32:44 +01001398 if (bfin_serial_ports[i].port.dev != &dev->dev)
1399 continue;
1400 uart_remove_one_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
1401 bfin_serial_ports[i].port.dev = NULL;
Sonic Zhangb2ced4f2010-01-19 06:13:10 -05001402#if defined(CONFIG_SERIAL_BFIN_CTSRTS)
Sonic Zhangccfbc3e2008-10-13 10:32:44 +01001403 gpio_free(bfin_serial_ports[i].cts_pin);
1404 gpio_free(bfin_serial_ports[i].rts_pin);
Bryan Wu194de562007-05-06 14:50:30 -07001405#endif
Sonic Zhangccfbc3e2008-10-13 10:32:44 +01001406 }
Bryan Wu194de562007-05-06 14:50:30 -07001407
1408 return 0;
1409}
1410
1411static struct platform_driver bfin_serial_driver = {
1412 .probe = bfin_serial_probe,
1413 .remove = bfin_serial_remove,
1414 .suspend = bfin_serial_suspend,
1415 .resume = bfin_serial_resume,
1416 .driver = {
1417 .name = "bfin-uart",
Kay Sieverse169c132008-04-15 14:34:35 -07001418 .owner = THIS_MODULE,
Bryan Wu194de562007-05-06 14:50:30 -07001419 },
1420};
1421
1422static int __init bfin_serial_init(void)
1423{
1424 int ret;
1425
1426 pr_info("Serial: Blackfin serial driver\n");
1427
1428 bfin_serial_init_ports();
1429
1430 ret = uart_register_driver(&bfin_serial_reg);
1431 if (ret == 0) {
1432 ret = platform_driver_register(&bfin_serial_driver);
1433 if (ret) {
1434 pr_debug("uart register failed\n");
1435 uart_unregister_driver(&bfin_serial_reg);
1436 }
1437 }
Bryan Wu194de562007-05-06 14:50:30 -07001438 return ret;
1439}
1440
1441static void __exit bfin_serial_exit(void)
1442{
1443 platform_driver_unregister(&bfin_serial_driver);
1444 uart_unregister_driver(&bfin_serial_reg);
1445}
1446
Sonic Zhang52e15f0e2009-01-02 13:40:14 +00001447
Bryan Wu194de562007-05-06 14:50:30 -07001448module_init(bfin_serial_init);
1449module_exit(bfin_serial_exit);
1450
1451MODULE_AUTHOR("Aubrey.Li <aubrey.li@analog.com>");
1452MODULE_DESCRIPTION("Blackfin generic serial port driver");
1453MODULE_LICENSE("GPL");
1454MODULE_ALIAS_CHARDEV_MAJOR(BFIN_SERIAL_MAJOR);
Kay Sieverse169c132008-04-15 14:34:35 -07001455MODULE_ALIAS("platform:bfin-uart");