Change hardware flow control from poll to interrupt driven
[linux-2.6.git] / drivers / serial / bfin_5xx.c
1 /*
2  * Blackfin On-Chip Serial Driver
3  *
4  * Copyright 2006-2008 Analog Devices Inc.
5  *
6  * Enter bugs at http://blackfin.uclinux.org/
7  *
8  * Licensed under the GPL-2 or later.
9  */
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
25 #if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
26         defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
27 #include <linux/kgdb.h>
28 #include <asm/irq_regs.h>
29 #endif
30
31 #include <asm/gpio.h>
32 #include <mach/bfin_serial_5xx.h>
33
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
41 /* UART name and device definitions */
42 #define BFIN_SERIAL_NAME        "ttyBF"
43 #define BFIN_SERIAL_MAJOR       204
44 #define BFIN_SERIAL_MINOR       64
45
46 static struct bfin_serial_port bfin_serial_ports[BFIN_UART_NR_PORTS];
47 static int nr_active_ports = ARRAY_SIZE(bfin_serial_resource);
48
49 #if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
50         defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
51
52 # ifndef CONFIG_SERIAL_BFIN_PIO
53 #  error KGDB only support UART in PIO mode.
54 # endif
55
56 static int kgdboc_port_line;
57 static int kgdboc_break_enabled;
58 #endif
59 /*
60  * Setup for console. Argument comes from the menuconfig
61  */
62 #define DMA_RX_XCOUNT           512
63 #define DMA_RX_YCOUNT           (PAGE_SIZE / DMA_RX_XCOUNT)
64
65 #define DMA_RX_FLUSH_JIFFIES    (HZ / 50)
66
67 #ifdef CONFIG_SERIAL_BFIN_DMA
68 static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart);
69 #else
70 static void bfin_serial_tx_chars(struct bfin_serial_port *uart);
71 #endif
72
73 static void bfin_serial_reset_irda(struct uart_port *port);
74
75 /*
76  * interrupts are disabled on entry
77  */
78 static void bfin_serial_stop_tx(struct uart_port *port)
79 {
80         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
81 #ifdef CONFIG_SERIAL_BFIN_DMA
82         struct circ_buf *xmit = &uart->port.info->xmit;
83 #endif
84
85         while (!(UART_GET_LSR(uart) & TEMT))
86                 cpu_relax();
87
88 #ifdef CONFIG_SERIAL_BFIN_DMA
89         disable_dma(uart->tx_dma_channel);
90         xmit->tail = (xmit->tail + uart->tx_count) & (UART_XMIT_SIZE - 1);
91         uart->port.icount.tx += uart->tx_count;
92         uart->tx_count = 0;
93         uart->tx_done = 1;
94 #else
95 #ifdef CONFIG_BF54x
96         /* Clear TFI bit */
97         UART_PUT_LSR(uart, TFI);
98 #endif
99         UART_CLEAR_IER(uart, ETBEI);
100 #endif
101 }
102
103 /*
104  * port is locked and interrupts are disabled
105  */
106 static void bfin_serial_start_tx(struct uart_port *port)
107 {
108         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
109         struct tty_struct *tty = uart->port.info->port.tty;
110
111         /*
112          * To avoid losting RX interrupt, we reset IR function
113          * before sending data.
114          */
115         if (tty->termios->c_line == N_IRDA)
116                 bfin_serial_reset_irda(port);
117
118 #ifdef CONFIG_SERIAL_BFIN_DMA
119         if (uart->tx_done)
120                 bfin_serial_dma_tx_chars(uart);
121 #else
122         UART_SET_IER(uart, ETBEI);
123         bfin_serial_tx_chars(uart);
124 #endif
125 }
126
127 /*
128  * Interrupts are enabled
129  */
130 static void bfin_serial_stop_rx(struct uart_port *port)
131 {
132         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
133
134         UART_CLEAR_IER(uart, ERBFI);
135 }
136
137 /*
138  * Set the modem control timer to fire immediately.
139  */
140 static void bfin_serial_enable_ms(struct uart_port *port)
141 {
142 }
143
144
145 #if ANOMALY_05000363 && defined(CONFIG_SERIAL_BFIN_PIO)
146 # define UART_GET_ANOMALY_THRESHOLD(uart)    ((uart)->anomaly_threshold)
147 # define UART_SET_ANOMALY_THRESHOLD(uart, v) ((uart)->anomaly_threshold = (v))
148 #else
149 # define UART_GET_ANOMALY_THRESHOLD(uart)    0
150 # define UART_SET_ANOMALY_THRESHOLD(uart, v)
151 #endif
152
153 #ifdef CONFIG_SERIAL_BFIN_PIO
154 static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
155 {
156         struct tty_struct *tty = NULL;
157         unsigned int status, ch, flg;
158         static struct timeval anomaly_start = { .tv_sec = 0 };
159
160         status = UART_GET_LSR(uart);
161         UART_CLEAR_LSR(uart);
162
163         ch = UART_GET_CHAR(uart);
164         uart->port.icount.rx++;
165
166 #if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
167         defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
168         if (kgdb_connected && kgdboc_port_line == uart->port.line)
169                 if (ch == 0x3) {/* Ctrl + C */
170                         kgdb_breakpoint();
171                         return;
172                 }
173
174         if (!uart->port.info || !uart->port.info->port.tty)
175                 return;
176 #endif
177         tty = uart->port.info->port.tty;
178
179         if (ANOMALY_05000363) {
180                 /* The BF533 (and BF561) family of processors have a nice anomaly
181                  * where they continuously generate characters for a "single" break.
182                  * We have to basically ignore this flood until the "next" valid
183                  * character comes across.  Due to the nature of the flood, it is
184                  * not possible to reliably catch bytes that are sent too quickly
185                  * after this break.  So application code talking to the Blackfin
186                  * which sends a break signal must allow at least 1.5 character
187                  * times after the end of the break for things to stabilize.  This
188                  * timeout was picked as it must absolutely be larger than 1
189                  * character time +/- some percent.  So 1.5 sounds good.  All other
190                  * Blackfin families operate properly.  Woo.
191                  */
192                 if (anomaly_start.tv_sec) {
193                         struct timeval curr;
194                         suseconds_t usecs;
195
196                         if ((~ch & (~ch + 1)) & 0xff)
197                                 goto known_good_char;
198
199                         do_gettimeofday(&curr);
200                         if (curr.tv_sec - anomaly_start.tv_sec > 1)
201                                 goto known_good_char;
202
203                         usecs = 0;
204                         if (curr.tv_sec != anomaly_start.tv_sec)
205                                 usecs += USEC_PER_SEC;
206                         usecs += curr.tv_usec - anomaly_start.tv_usec;
207
208                         if (usecs > UART_GET_ANOMALY_THRESHOLD(uart))
209                                 goto known_good_char;
210
211                         if (ch)
212                                 anomaly_start.tv_sec = 0;
213                         else
214                                 anomaly_start = curr;
215
216                         return;
217
218  known_good_char:
219                         status &= ~BI;
220                         anomaly_start.tv_sec = 0;
221                 }
222         }
223
224         if (status & BI) {
225                 if (ANOMALY_05000363)
226                         if (bfin_revid() < 5)
227                                 do_gettimeofday(&anomaly_start);
228                 uart->port.icount.brk++;
229                 if (uart_handle_break(&uart->port))
230                         goto ignore_char;
231                 status &= ~(PE | FE);
232         }
233         if (status & PE)
234                 uart->port.icount.parity++;
235         if (status & OE)
236                 uart->port.icount.overrun++;
237         if (status & FE)
238                 uart->port.icount.frame++;
239
240         status &= uart->port.read_status_mask;
241
242         if (status & BI)
243                 flg = TTY_BREAK;
244         else if (status & PE)
245                 flg = TTY_PARITY;
246         else if (status & FE)
247                 flg = TTY_FRAME;
248         else
249                 flg = TTY_NORMAL;
250
251         if (uart_handle_sysrq_char(&uart->port, ch))
252                 goto ignore_char;
253
254         uart_insert_char(&uart->port, status, OE, ch, flg);
255
256  ignore_char:
257         tty_flip_buffer_push(tty);
258 }
259
260 static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
261 {
262         struct circ_buf *xmit = &uart->port.info->xmit;
263
264         if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
265 #ifdef CONFIG_BF54x
266                 /* Clear TFI bit */
267                 UART_PUT_LSR(uart, TFI);
268 #endif
269                 UART_CLEAR_IER(uart, ETBEI);
270                 return;
271         }
272
273         if (uart->port.x_char) {
274                 UART_PUT_CHAR(uart, uart->port.x_char);
275                 uart->port.icount.tx++;
276                 uart->port.x_char = 0;
277         }
278
279         while ((UART_GET_LSR(uart) & THRE) && xmit->tail != xmit->head) {
280                 UART_PUT_CHAR(uart, xmit->buf[xmit->tail]);
281                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
282                 uart->port.icount.tx++;
283                 SSYNC();
284         }
285
286         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
287                 uart_write_wakeup(&uart->port);
288 }
289
290 static irqreturn_t bfin_serial_rx_int(int irq, void *dev_id)
291 {
292         struct bfin_serial_port *uart = dev_id;
293
294         spin_lock(&uart->port.lock);
295         while (UART_GET_LSR(uart) & DR)
296                 bfin_serial_rx_chars(uart);
297         spin_unlock(&uart->port.lock);
298
299         return IRQ_HANDLED;
300 }
301
302 static irqreturn_t bfin_serial_tx_int(int irq, void *dev_id)
303 {
304         struct bfin_serial_port *uart = dev_id;
305
306         spin_lock(&uart->port.lock);
307         if (UART_GET_LSR(uart) & THRE)
308                 bfin_serial_tx_chars(uart);
309         spin_unlock(&uart->port.lock);
310
311         return IRQ_HANDLED;
312 }
313 #endif
314
315 #ifdef CONFIG_SERIAL_BFIN_DMA
316 static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
317 {
318         struct circ_buf *xmit = &uart->port.info->xmit;
319
320         uart->tx_done = 0;
321
322         if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
323                 uart->tx_count = 0;
324                 uart->tx_done = 1;
325                 return;
326         }
327
328         if (uart->port.x_char) {
329                 UART_PUT_CHAR(uart, uart->port.x_char);
330                 uart->port.icount.tx++;
331                 uart->port.x_char = 0;
332         }
333
334         uart->tx_count = CIRC_CNT(xmit->head, xmit->tail, UART_XMIT_SIZE);
335         if (uart->tx_count > (UART_XMIT_SIZE - xmit->tail))
336                 uart->tx_count = UART_XMIT_SIZE - xmit->tail;
337         blackfin_dcache_flush_range((unsigned long)(xmit->buf+xmit->tail),
338                                         (unsigned long)(xmit->buf+xmit->tail+uart->tx_count));
339         set_dma_config(uart->tx_dma_channel,
340                 set_bfin_dma_config(DIR_READ, DMA_FLOW_STOP,
341                         INTR_ON_BUF,
342                         DIMENSION_LINEAR,
343                         DATA_SIZE_8,
344                         DMA_SYNC_RESTART));
345         set_dma_start_addr(uart->tx_dma_channel, (unsigned long)(xmit->buf+xmit->tail));
346         set_dma_x_count(uart->tx_dma_channel, uart->tx_count);
347         set_dma_x_modify(uart->tx_dma_channel, 1);
348         enable_dma(uart->tx_dma_channel);
349
350         UART_SET_IER(uart, ETBEI);
351 }
352
353 static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart)
354 {
355         struct tty_struct *tty = uart->port.info->port.tty;
356         int i, flg, status;
357
358         status = UART_GET_LSR(uart);
359         UART_CLEAR_LSR(uart);
360
361         uart->port.icount.rx +=
362                 CIRC_CNT(uart->rx_dma_buf.head, uart->rx_dma_buf.tail,
363                 UART_XMIT_SIZE);
364
365         if (status & BI) {
366                 uart->port.icount.brk++;
367                 if (uart_handle_break(&uart->port))
368                         goto dma_ignore_char;
369                 status &= ~(PE | FE);
370         }
371         if (status & PE)
372                 uart->port.icount.parity++;
373         if (status & OE)
374                 uart->port.icount.overrun++;
375         if (status & FE)
376                 uart->port.icount.frame++;
377
378         status &= uart->port.read_status_mask;
379
380         if (status & BI)
381                 flg = TTY_BREAK;
382         else if (status & PE)
383                 flg = TTY_PARITY;
384         else if (status & FE)
385                 flg = TTY_FRAME;
386         else
387                 flg = TTY_NORMAL;
388
389         for (i = uart->rx_dma_buf.tail; ; i++) {
390                 if (i >= UART_XMIT_SIZE)
391                         i = 0;
392                 if (i == uart->rx_dma_buf.head)
393                         break;
394                 if (!uart_handle_sysrq_char(&uart->port, uart->rx_dma_buf.buf[i]))
395                         uart_insert_char(&uart->port, status, OE,
396                                 uart->rx_dma_buf.buf[i], flg);
397         }
398
399  dma_ignore_char:
400         tty_flip_buffer_push(tty);
401 }
402
403 void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
404 {
405         int x_pos, pos;
406         unsigned long flags;
407
408         spin_lock_irqsave(&uart->port.lock, flags);
409
410         uart->rx_dma_nrows = get_dma_curr_ycount(uart->rx_dma_channel);
411         x_pos = get_dma_curr_xcount(uart->rx_dma_channel);
412         uart->rx_dma_nrows = DMA_RX_YCOUNT - uart->rx_dma_nrows;
413         if (uart->rx_dma_nrows == DMA_RX_YCOUNT)
414                 uart->rx_dma_nrows = 0;
415         x_pos = DMA_RX_XCOUNT - x_pos;
416         if (x_pos == DMA_RX_XCOUNT)
417                 x_pos = 0;
418
419         pos = uart->rx_dma_nrows * DMA_RX_XCOUNT + x_pos;
420         if (pos != uart->rx_dma_buf.tail) {
421                 uart->rx_dma_buf.head = pos;
422                 bfin_serial_dma_rx_chars(uart);
423                 uart->rx_dma_buf.tail = uart->rx_dma_buf.head;
424         }
425
426         spin_unlock_irqrestore(&uart->port.lock, flags);
427
428         mod_timer(&(uart->rx_dma_timer), jiffies + DMA_RX_FLUSH_JIFFIES);
429 }
430
431 static irqreturn_t bfin_serial_dma_tx_int(int irq, void *dev_id)
432 {
433         struct bfin_serial_port *uart = dev_id;
434         struct circ_buf *xmit = &uart->port.info->xmit;
435
436         spin_lock(&uart->port.lock);
437         if (!(get_dma_curr_irqstat(uart->tx_dma_channel)&DMA_RUN)) {
438                 disable_dma(uart->tx_dma_channel);
439                 clear_dma_irqstat(uart->tx_dma_channel);
440                 UART_CLEAR_IER(uart, ETBEI);
441                 xmit->tail = (xmit->tail + uart->tx_count) & (UART_XMIT_SIZE - 1);
442                 uart->port.icount.tx += uart->tx_count;
443
444                 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
445                         uart_write_wakeup(&uart->port);
446
447                 bfin_serial_dma_tx_chars(uart);
448         }
449
450         spin_unlock(&uart->port.lock);
451         return IRQ_HANDLED;
452 }
453
454 static irqreturn_t bfin_serial_dma_rx_int(int irq, void *dev_id)
455 {
456         struct bfin_serial_port *uart = dev_id;
457         unsigned short irqstat;
458
459         spin_lock(&uart->port.lock);
460         irqstat = get_dma_curr_irqstat(uart->rx_dma_channel);
461         clear_dma_irqstat(uart->rx_dma_channel);
462         bfin_serial_dma_rx_chars(uart);
463         spin_unlock(&uart->port.lock);
464
465         return IRQ_HANDLED;
466 }
467 #endif
468
469 /*
470  * Return TIOCSER_TEMT when transmitter is not busy.
471  */
472 static unsigned int bfin_serial_tx_empty(struct uart_port *port)
473 {
474         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
475         unsigned short lsr;
476
477         lsr = UART_GET_LSR(uart);
478         if (lsr & TEMT)
479                 return TIOCSER_TEMT;
480         else
481                 return 0;
482 }
483
484 static unsigned int bfin_serial_get_mctrl(struct uart_port *port)
485 {
486 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
487         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
488         if (uart->cts_pin < 0)
489                 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
490
491         if (UART_GET_CTS(uart))
492                 return TIOCM_DSR | TIOCM_CAR;
493         else
494 #endif
495                 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
496 }
497
498 static void bfin_serial_set_mctrl(struct uart_port *port, unsigned int mctrl)
499 {
500 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
501         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
502         if (uart->rts_pin < 0)
503                 return;
504
505         if (mctrl & TIOCM_RTS)
506                 UART_CLEAR_RTS(uart);
507         else
508                 UART_SET_RTS(uart);
509 #endif
510 }
511
512 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
513 /*
514  * Handle any change of modem status signal.
515  */
516 static irqreturn_t bfin_serial_mctrl_cts_int(int irq, void *dev_id)
517 {
518         struct bfin_serial_port *uart = dev_id;
519         unsigned int status;
520
521         status = bfin_serial_get_mctrl(&uart->port);
522         uart_handle_cts_change(&uart->port, status & TIOCM_CTS);
523
524         return IRQ_HANDLED;
525 }
526 #endif
527
528 /*
529  * Interrupts are always disabled.
530  */
531 static void bfin_serial_break_ctl(struct uart_port *port, int break_state)
532 {
533         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
534         u16 lcr = UART_GET_LCR(uart);
535         if (break_state)
536                 lcr |= SB;
537         else
538                 lcr &= ~SB;
539         UART_PUT_LCR(uart, lcr);
540         SSYNC();
541 }
542
543 static int bfin_serial_startup(struct uart_port *port)
544 {
545         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
546
547 #ifdef CONFIG_SERIAL_BFIN_DMA
548         dma_addr_t dma_handle;
549
550         if (request_dma(uart->rx_dma_channel, "BFIN_UART_RX") < 0) {
551                 printk(KERN_NOTICE "Unable to attach Blackfin UART RX DMA channel\n");
552                 return -EBUSY;
553         }
554
555         if (request_dma(uart->tx_dma_channel, "BFIN_UART_TX") < 0) {
556                 printk(KERN_NOTICE "Unable to attach Blackfin UART TX DMA channel\n");
557                 free_dma(uart->rx_dma_channel);
558                 return -EBUSY;
559         }
560
561         set_dma_callback(uart->rx_dma_channel, bfin_serial_dma_rx_int, uart);
562         set_dma_callback(uart->tx_dma_channel, bfin_serial_dma_tx_int, uart);
563
564         uart->rx_dma_buf.buf = (unsigned char *)dma_alloc_coherent(NULL, PAGE_SIZE, &dma_handle, GFP_DMA);
565         uart->rx_dma_buf.head = 0;
566         uart->rx_dma_buf.tail = 0;
567         uart->rx_dma_nrows = 0;
568
569         set_dma_config(uart->rx_dma_channel,
570                 set_bfin_dma_config(DIR_WRITE, DMA_FLOW_AUTO,
571                                 INTR_ON_ROW, DIMENSION_2D,
572                                 DATA_SIZE_8,
573                                 DMA_SYNC_RESTART));
574         set_dma_x_count(uart->rx_dma_channel, DMA_RX_XCOUNT);
575         set_dma_x_modify(uart->rx_dma_channel, 1);
576         set_dma_y_count(uart->rx_dma_channel, DMA_RX_YCOUNT);
577         set_dma_y_modify(uart->rx_dma_channel, 1);
578         set_dma_start_addr(uart->rx_dma_channel, (unsigned long)uart->rx_dma_buf.buf);
579         enable_dma(uart->rx_dma_channel);
580
581         uart->rx_dma_timer.data = (unsigned long)(uart);
582         uart->rx_dma_timer.function = (void *)bfin_serial_rx_dma_timeout;
583         uart->rx_dma_timer.expires = jiffies + DMA_RX_FLUSH_JIFFIES;
584         add_timer(&(uart->rx_dma_timer));
585 #else
586 # if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
587         defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
588         if (kgdboc_port_line == uart->port.line && kgdboc_break_enabled)
589                 kgdboc_break_enabled = 0;
590         else {
591 # endif
592         if (request_irq(uart->port.irq, bfin_serial_rx_int, IRQF_DISABLED,
593              "BFIN_UART_RX", uart)) {
594                 printk(KERN_NOTICE "Unable to attach BlackFin UART RX interrupt\n");
595                 return -EBUSY;
596         }
597
598         if (request_irq
599             (uart->port.irq+1, bfin_serial_tx_int, IRQF_DISABLED,
600              "BFIN_UART_TX", uart)) {
601                 printk(KERN_NOTICE "Unable to attach BlackFin UART TX interrupt\n");
602                 free_irq(uart->port.irq, uart);
603                 return -EBUSY;
604         }
605
606 # ifdef CONFIG_BF54x
607         {
608                 unsigned uart_dma_ch_rx, uart_dma_ch_tx;
609
610                 switch (uart->port.irq) {
611                 case IRQ_UART3_RX:
612                         uart_dma_ch_rx = CH_UART3_RX;
613                         uart_dma_ch_tx = CH_UART3_TX;
614                         break;
615                 case IRQ_UART2_RX:
616                         uart_dma_ch_rx = CH_UART2_RX;
617                         uart_dma_ch_tx = CH_UART2_TX;
618                         break;
619                 default:
620                         uart_dma_ch_rx = uart_dma_ch_tx = 0;
621                         break;
622                 };
623
624                 if (uart_dma_ch_rx &&
625                         request_dma(uart_dma_ch_rx, "BFIN_UART_RX") < 0) {
626                         printk(KERN_NOTICE"Fail to attach UART interrupt\n");
627                         free_irq(uart->port.irq, uart);
628                         free_irq(uart->port.irq + 1, uart);
629                         return -EBUSY;
630                 }
631                 if (uart_dma_ch_tx &&
632                         request_dma(uart_dma_ch_tx, "BFIN_UART_TX") < 0) {
633                         printk(KERN_NOTICE "Fail to attach UART interrupt\n");
634                         free_dma(uart_dma_ch_rx);
635                         free_irq(uart->port.irq, uart);
636                         free_irq(uart->port.irq + 1, uart);
637                         return -EBUSY;
638                 }
639         }
640 # endif
641 # if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
642         defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
643         }
644 # endif
645 #endif
646
647 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
648         if (uart->cts_pin >= 0) {
649                 if (request_irq(gpio_to_irq(uart->cts_pin),
650                         bfin_serial_mctrl_cts_int,
651                         IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
652                         IRQF_DISABLED, "BFIN_UART_CTS", uart)) {
653                         uart->cts_pin = -1;
654                         pr_info("Unable to attach BlackFin UART CTS interrupt.\
655                                  So, disable it.\n");
656                 }
657         }
658         if (uart->rts_pin >= 0) {
659                 gpio_request(uart->rts_pin, DRIVER_NAME);
660                 gpio_direction_output(uart->rts_pin, 0);
661         }
662 #endif
663         UART_SET_IER(uart, ERBFI);
664         return 0;
665 }
666
667 static void bfin_serial_shutdown(struct uart_port *port)
668 {
669         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
670
671 #ifdef CONFIG_SERIAL_BFIN_DMA
672         disable_dma(uart->tx_dma_channel);
673         free_dma(uart->tx_dma_channel);
674         disable_dma(uart->rx_dma_channel);
675         free_dma(uart->rx_dma_channel);
676         del_timer(&(uart->rx_dma_timer));
677         dma_free_coherent(NULL, PAGE_SIZE, uart->rx_dma_buf.buf, 0);
678 #else
679 #ifdef CONFIG_BF54x
680         switch (uart->port.irq) {
681         case IRQ_UART3_RX:
682                 free_dma(CH_UART3_RX);
683                 free_dma(CH_UART3_TX);
684                 break;
685         case IRQ_UART2_RX:
686                 free_dma(CH_UART2_RX);
687                 free_dma(CH_UART2_TX);
688                 break;
689         default:
690                 break;
691         };
692 #endif
693         free_irq(uart->port.irq, uart);
694         free_irq(uart->port.irq+1, uart);
695 #endif
696
697 # ifdef CONFIG_SERIAL_BFIN_CTSRTS
698         if (uart->cts_pin >= 0)
699                 free_irq(gpio_to_irq(uart->cts_pin), uart);
700         if (uart->rts_pin >= 0)
701                 gpio_free(uart->rts_pin);
702 # endif
703 }
704
705 static void
706 bfin_serial_set_termios(struct uart_port *port, struct ktermios *termios,
707                    struct ktermios *old)
708 {
709         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
710         unsigned long flags;
711         unsigned int baud, quot;
712         unsigned short val, ier, lcr = 0;
713
714         switch (termios->c_cflag & CSIZE) {
715         case CS8:
716                 lcr = WLS(8);
717                 break;
718         case CS7:
719                 lcr = WLS(7);
720                 break;
721         case CS6:
722                 lcr = WLS(6);
723                 break;
724         case CS5:
725                 lcr = WLS(5);
726                 break;
727         default:
728                 printk(KERN_ERR "%s: word lengh not supported\n",
729                         __func__);
730         }
731
732         if (termios->c_cflag & CSTOPB)
733                 lcr |= STB;
734         if (termios->c_cflag & PARENB)
735                 lcr |= PEN;
736         if (!(termios->c_cflag & PARODD))
737                 lcr |= EPS;
738         if (termios->c_cflag & CMSPAR)
739                 lcr |= STP;
740
741         port->read_status_mask = OE;
742         if (termios->c_iflag & INPCK)
743                 port->read_status_mask |= (FE | PE);
744         if (termios->c_iflag & (BRKINT | PARMRK))
745                 port->read_status_mask |= BI;
746
747         /*
748          * Characters to ignore
749          */
750         port->ignore_status_mask = 0;
751         if (termios->c_iflag & IGNPAR)
752                 port->ignore_status_mask |= FE | PE;
753         if (termios->c_iflag & IGNBRK) {
754                 port->ignore_status_mask |= BI;
755                 /*
756                  * If we're ignoring parity and break indicators,
757                  * ignore overruns too (for real raw support).
758                  */
759                 if (termios->c_iflag & IGNPAR)
760                         port->ignore_status_mask |= OE;
761         }
762
763         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
764         quot = uart_get_divisor(port, baud) - ANOMALY_05000230;
765         spin_lock_irqsave(&uart->port.lock, flags);
766
767         UART_SET_ANOMALY_THRESHOLD(uart, USEC_PER_SEC / baud * 15);
768
769         /* Disable UART */
770         ier = UART_GET_IER(uart);
771         UART_DISABLE_INTS(uart);
772
773         /* Set DLAB in LCR to Access DLL and DLH */
774         UART_SET_DLAB(uart);
775
776         UART_PUT_DLL(uart, quot & 0xFF);
777         UART_PUT_DLH(uart, (quot >> 8) & 0xFF);
778         SSYNC();
779
780         /* Clear DLAB in LCR to Access THR RBR IER */
781         UART_CLEAR_DLAB(uart);
782
783         UART_PUT_LCR(uart, lcr);
784
785         /* Enable UART */
786         UART_ENABLE_INTS(uart, ier);
787
788         val = UART_GET_GCTL(uart);
789         val |= UCEN;
790         UART_PUT_GCTL(uart, val);
791
792         /* Port speed changed, update the per-port timeout. */
793         uart_update_timeout(port, termios->c_cflag, baud);
794
795         spin_unlock_irqrestore(&uart->port.lock, flags);
796 }
797
798 static const char *bfin_serial_type(struct uart_port *port)
799 {
800         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
801
802         return uart->port.type == PORT_BFIN ? "BFIN-UART" : NULL;
803 }
804
805 /*
806  * Release the memory region(s) being used by 'port'.
807  */
808 static void bfin_serial_release_port(struct uart_port *port)
809 {
810 }
811
812 /*
813  * Request the memory region(s) being used by 'port'.
814  */
815 static int bfin_serial_request_port(struct uart_port *port)
816 {
817         return 0;
818 }
819
820 /*
821  * Configure/autoconfigure the port.
822  */
823 static void bfin_serial_config_port(struct uart_port *port, int flags)
824 {
825         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
826
827         if (flags & UART_CONFIG_TYPE &&
828             bfin_serial_request_port(&uart->port) == 0)
829                 uart->port.type = PORT_BFIN;
830 }
831
832 /*
833  * Verify the new serial_struct (for TIOCSSERIAL).
834  * The only change we allow are to the flags and type, and
835  * even then only between PORT_BFIN and PORT_UNKNOWN
836  */
837 static int
838 bfin_serial_verify_port(struct uart_port *port, struct serial_struct *ser)
839 {
840         return 0;
841 }
842
843 /*
844  * Enable the IrDA function if tty->ldisc.num is N_IRDA.
845  * In other cases, disable IrDA function.
846  */
847 static void bfin_serial_set_ldisc(struct uart_port *port)
848 {
849         int line = port->line;
850         unsigned short val;
851
852         if (line >= port->info->port.tty->driver->num)
853                 return;
854
855         switch (port->info->port.tty->termios->c_line) {
856         case N_IRDA:
857                 val = UART_GET_GCTL(&bfin_serial_ports[line]);
858                 val |= (IREN | RPOLC);
859                 UART_PUT_GCTL(&bfin_serial_ports[line], val);
860                 break;
861         default:
862                 val = UART_GET_GCTL(&bfin_serial_ports[line]);
863                 val &= ~(IREN | RPOLC);
864                 UART_PUT_GCTL(&bfin_serial_ports[line], val);
865         }
866 }
867
868 static void bfin_serial_reset_irda(struct uart_port *port)
869 {
870         int line = port->line;
871         unsigned short val;
872
873         val = UART_GET_GCTL(&bfin_serial_ports[line]);
874         val &= ~(IREN | RPOLC);
875         UART_PUT_GCTL(&bfin_serial_ports[line], val);
876         SSYNC();
877         val |= (IREN | RPOLC);
878         UART_PUT_GCTL(&bfin_serial_ports[line], val);
879         SSYNC();
880 }
881
882 #ifdef CONFIG_CONSOLE_POLL
883 static void bfin_serial_poll_put_char(struct uart_port *port, unsigned char chr)
884 {
885         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
886
887         while (!(UART_GET_LSR(uart) & THRE))
888                 cpu_relax();
889
890         UART_CLEAR_DLAB(uart);
891         UART_PUT_CHAR(uart, (unsigned char)chr);
892 }
893
894 static int bfin_serial_poll_get_char(struct uart_port *port)
895 {
896         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
897         unsigned char chr;
898
899         while (!(UART_GET_LSR(uart) & DR))
900                 cpu_relax();
901
902         UART_CLEAR_DLAB(uart);
903         chr = UART_GET_CHAR(uart);
904
905         return chr;
906 }
907 #endif
908
909 #if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
910         defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
911 static void bfin_kgdboc_port_shutdown(struct uart_port *port)
912 {
913         if (kgdboc_break_enabled) {
914                 kgdboc_break_enabled = 0;
915                 bfin_serial_shutdown(port);
916         }
917 }
918
919 static int bfin_kgdboc_port_startup(struct uart_port *port)
920 {
921         kgdboc_port_line = port->line;
922         kgdboc_break_enabled = !bfin_serial_startup(port);
923         return 0;
924 }
925 #endif
926
927 static struct uart_ops bfin_serial_pops = {
928         .tx_empty       = bfin_serial_tx_empty,
929         .set_mctrl      = bfin_serial_set_mctrl,
930         .get_mctrl      = bfin_serial_get_mctrl,
931         .stop_tx        = bfin_serial_stop_tx,
932         .start_tx       = bfin_serial_start_tx,
933         .stop_rx        = bfin_serial_stop_rx,
934         .enable_ms      = bfin_serial_enable_ms,
935         .break_ctl      = bfin_serial_break_ctl,
936         .startup        = bfin_serial_startup,
937         .shutdown       = bfin_serial_shutdown,
938         .set_termios    = bfin_serial_set_termios,
939         .set_ldisc      = bfin_serial_set_ldisc,
940         .type           = bfin_serial_type,
941         .release_port   = bfin_serial_release_port,
942         .request_port   = bfin_serial_request_port,
943         .config_port    = bfin_serial_config_port,
944         .verify_port    = bfin_serial_verify_port,
945 #if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
946         defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
947         .kgdboc_port_startup    = bfin_kgdboc_port_startup,
948         .kgdboc_port_shutdown   = bfin_kgdboc_port_shutdown,
949 #endif
950 #ifdef CONFIG_CONSOLE_POLL
951         .poll_put_char  = bfin_serial_poll_put_char,
952         .poll_get_char  = bfin_serial_poll_get_char,
953 #endif
954 };
955
956 static void __init bfin_serial_hw_init(void)
957 {
958 #ifdef CONFIG_SERIAL_BFIN_UART0
959         peripheral_request(P_UART0_TX, DRIVER_NAME);
960         peripheral_request(P_UART0_RX, DRIVER_NAME);
961 #endif
962
963 #ifdef CONFIG_SERIAL_BFIN_UART1
964         peripheral_request(P_UART1_TX, DRIVER_NAME);
965         peripheral_request(P_UART1_RX, DRIVER_NAME);
966
967 # if defined(CONFIG_BFIN_UART1_CTSRTS) && defined(CONFIG_BF54x)
968         peripheral_request(P_UART1_RTS, DRIVER_NAME);
969         peripheral_request(P_UART1_CTS, DRIVER_NAME);
970 # endif
971 #endif
972
973 #ifdef CONFIG_SERIAL_BFIN_UART2
974         peripheral_request(P_UART2_TX, DRIVER_NAME);
975         peripheral_request(P_UART2_RX, DRIVER_NAME);
976 #endif
977
978 #ifdef CONFIG_SERIAL_BFIN_UART3
979         peripheral_request(P_UART3_TX, DRIVER_NAME);
980         peripheral_request(P_UART3_RX, DRIVER_NAME);
981
982 # if defined(CONFIG_BFIN_UART3_CTSRTS) && defined(CONFIG_BF54x)
983         peripheral_request(P_UART3_RTS, DRIVER_NAME);
984         peripheral_request(P_UART3_CTS, DRIVER_NAME);
985 # endif
986 #endif
987 }
988
989 static void __init bfin_serial_init_ports(void)
990 {
991         static int first = 1;
992         int i;
993
994         if (!first)
995                 return;
996         first = 0;
997
998         bfin_serial_hw_init();
999
1000         for (i = 0; i < nr_active_ports; i++) {
1001                 bfin_serial_ports[i].port.uartclk   = get_sclk();
1002                 bfin_serial_ports[i].port.fifosize  = BFIN_UART_TX_FIFO_SIZE;
1003                 bfin_serial_ports[i].port.ops       = &bfin_serial_pops;
1004                 bfin_serial_ports[i].port.line      = i;
1005                 bfin_serial_ports[i].port.iotype    = UPIO_MEM;
1006                 bfin_serial_ports[i].port.membase   =
1007                         (void __iomem *)bfin_serial_resource[i].uart_base_addr;
1008                 bfin_serial_ports[i].port.mapbase   =
1009                         bfin_serial_resource[i].uart_base_addr;
1010                 bfin_serial_ports[i].port.irq       =
1011                         bfin_serial_resource[i].uart_irq;
1012                 bfin_serial_ports[i].port.flags     = UPF_BOOT_AUTOCONF;
1013 #ifdef CONFIG_SERIAL_BFIN_DMA
1014                 bfin_serial_ports[i].tx_done        = 1;
1015                 bfin_serial_ports[i].tx_count       = 0;
1016                 bfin_serial_ports[i].tx_dma_channel =
1017                         bfin_serial_resource[i].uart_tx_dma_channel;
1018                 bfin_serial_ports[i].rx_dma_channel =
1019                         bfin_serial_resource[i].uart_rx_dma_channel;
1020                 init_timer(&(bfin_serial_ports[i].rx_dma_timer));
1021 #endif
1022 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
1023                 bfin_serial_ports[i].cts_pin        =
1024                         bfin_serial_resource[i].uart_cts_pin;
1025                 bfin_serial_ports[i].rts_pin        =
1026                         bfin_serial_resource[i].uart_rts_pin;
1027 #endif
1028         }
1029 }
1030
1031 #if defined(CONFIG_SERIAL_BFIN_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
1032 /*
1033  * If the port was already initialised (eg, by a boot loader),
1034  * try to determine the current setup.
1035  */
1036 static void __init
1037 bfin_serial_console_get_options(struct bfin_serial_port *uart, int *baud,
1038                            int *parity, int *bits)
1039 {
1040         unsigned short status;
1041
1042         status = UART_GET_IER(uart) & (ERBFI | ETBEI);
1043         if (status == (ERBFI | ETBEI)) {
1044                 /* ok, the port was enabled */
1045                 u16 lcr, dlh, dll;
1046
1047                 lcr = UART_GET_LCR(uart);
1048
1049                 *parity = 'n';
1050                 if (lcr & PEN) {
1051                         if (lcr & EPS)
1052                                 *parity = 'e';
1053                         else
1054                                 *parity = 'o';
1055                 }
1056                 switch (lcr & 0x03) {
1057                         case 0: *bits = 5; break;
1058                         case 1: *bits = 6; break;
1059                         case 2: *bits = 7; break;
1060                         case 3: *bits = 8; break;
1061                 }
1062                 /* Set DLAB in LCR to Access DLL and DLH */
1063                 UART_SET_DLAB(uart);
1064
1065                 dll = UART_GET_DLL(uart);
1066                 dlh = UART_GET_DLH(uart);
1067
1068                 /* Clear DLAB in LCR to Access THR RBR IER */
1069                 UART_CLEAR_DLAB(uart);
1070
1071                 *baud = get_sclk() / (16*(dll | dlh << 8));
1072         }
1073         pr_debug("%s:baud = %d, parity = %c, bits= %d\n", __func__, *baud, *parity, *bits);
1074 }
1075
1076 static struct uart_driver bfin_serial_reg;
1077
1078 static int __init
1079 bfin_serial_console_setup(struct console *co, char *options)
1080 {
1081         struct bfin_serial_port *uart;
1082         int baud = 57600;
1083         int bits = 8;
1084         int parity = 'n';
1085 # ifdef CONFIG_SERIAL_BFIN_CTSRTS
1086         int flow = 'r';
1087 # else
1088         int flow = 'n';
1089 # endif
1090
1091         /*
1092          * Check whether an invalid uart number has been specified, and
1093          * if so, search for the first available port that does have
1094          * console support.
1095          */
1096         if (co->index == -1 || co->index >= nr_active_ports)
1097                 co->index = 0;
1098         uart = &bfin_serial_ports[co->index];
1099
1100         if (options)
1101                 uart_parse_options(options, &baud, &parity, &bits, &flow);
1102         else
1103                 bfin_serial_console_get_options(uart, &baud, &parity, &bits);
1104
1105         return uart_set_options(&uart->port, co, baud, parity, bits, flow);
1106 }
1107 #endif /* defined (CONFIG_SERIAL_BFIN_CONSOLE) ||
1108                                  defined (CONFIG_EARLY_PRINTK) */
1109
1110 #ifdef CONFIG_SERIAL_BFIN_CONSOLE
1111 static void bfin_serial_console_putchar(struct uart_port *port, int ch)
1112 {
1113         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
1114         while (!(UART_GET_LSR(uart) & THRE))
1115                 barrier();
1116         UART_PUT_CHAR(uart, ch);
1117         SSYNC();
1118 }
1119
1120 /*
1121  * Interrupts are disabled on entering
1122  */
1123 static void
1124 bfin_serial_console_write(struct console *co, const char *s, unsigned int count)
1125 {
1126         struct bfin_serial_port *uart = &bfin_serial_ports[co->index];
1127         unsigned long flags;
1128
1129         spin_lock_irqsave(&uart->port.lock, flags);
1130         uart_console_write(&uart->port, s, count, bfin_serial_console_putchar);
1131         spin_unlock_irqrestore(&uart->port.lock, flags);
1132
1133 }
1134
1135 static struct console bfin_serial_console = {
1136         .name           = BFIN_SERIAL_NAME,
1137         .write          = bfin_serial_console_write,
1138         .device         = uart_console_device,
1139         .setup          = bfin_serial_console_setup,
1140         .flags          = CON_PRINTBUFFER,
1141         .index          = -1,
1142         .data           = &bfin_serial_reg,
1143 };
1144
1145 static int __init bfin_serial_rs_console_init(void)
1146 {
1147         bfin_serial_init_ports();
1148         register_console(&bfin_serial_console);
1149
1150         return 0;
1151 }
1152 console_initcall(bfin_serial_rs_console_init);
1153
1154 #define BFIN_SERIAL_CONSOLE     &bfin_serial_console
1155 #else
1156 #define BFIN_SERIAL_CONSOLE     NULL
1157 #endif /* CONFIG_SERIAL_BFIN_CONSOLE */
1158
1159
1160 #ifdef CONFIG_EARLY_PRINTK
1161 static __init void early_serial_putc(struct uart_port *port, int ch)
1162 {
1163         unsigned timeout = 0xffff;
1164         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
1165
1166         while ((!(UART_GET_LSR(uart) & THRE)) && --timeout)
1167                 cpu_relax();
1168         UART_PUT_CHAR(uart, ch);
1169 }
1170
1171 static __init void early_serial_write(struct console *con, const char *s,
1172                                         unsigned int n)
1173 {
1174         struct bfin_serial_port *uart = &bfin_serial_ports[con->index];
1175         unsigned int i;
1176
1177         for (i = 0; i < n; i++, s++) {
1178                 if (*s == '\n')
1179                         early_serial_putc(&uart->port, '\r');
1180                 early_serial_putc(&uart->port, *s);
1181         }
1182 }
1183
1184 static struct __initdata console bfin_early_serial_console = {
1185         .name = "early_BFuart",
1186         .write = early_serial_write,
1187         .device = uart_console_device,
1188         .flags = CON_PRINTBUFFER,
1189         .setup = bfin_serial_console_setup,
1190         .index = -1,
1191         .data  = &bfin_serial_reg,
1192 };
1193
1194 struct console __init *bfin_earlyserial_init(unsigned int port,
1195                                                 unsigned int cflag)
1196 {
1197         struct bfin_serial_port *uart;
1198         struct ktermios t;
1199
1200         if (port == -1 || port >= nr_active_ports)
1201                 port = 0;
1202         bfin_serial_init_ports();
1203         bfin_early_serial_console.index = port;
1204         uart = &bfin_serial_ports[port];
1205         t.c_cflag = cflag;
1206         t.c_iflag = 0;
1207         t.c_oflag = 0;
1208         t.c_lflag = ICANON;
1209         t.c_line = port;
1210         bfin_serial_set_termios(&uart->port, &t, &t);
1211         return &bfin_early_serial_console;
1212 }
1213
1214 #endif /* CONFIG_EARLY_PRINTK */
1215
1216 static struct uart_driver bfin_serial_reg = {
1217         .owner                  = THIS_MODULE,
1218         .driver_name            = "bfin-uart",
1219         .dev_name               = BFIN_SERIAL_NAME,
1220         .major                  = BFIN_SERIAL_MAJOR,
1221         .minor                  = BFIN_SERIAL_MINOR,
1222         .nr                     = BFIN_UART_NR_PORTS,
1223         .cons                   = BFIN_SERIAL_CONSOLE,
1224 };
1225
1226 static int bfin_serial_suspend(struct platform_device *dev, pm_message_t state)
1227 {
1228         int i;
1229
1230         for (i = 0; i < nr_active_ports; i++) {
1231                 if (bfin_serial_ports[i].port.dev != &dev->dev)
1232                         continue;
1233                 uart_suspend_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
1234         }
1235
1236         return 0;
1237 }
1238
1239 static int bfin_serial_resume(struct platform_device *dev)
1240 {
1241         int i;
1242
1243         for (i = 0; i < nr_active_ports; i++) {
1244                 if (bfin_serial_ports[i].port.dev != &dev->dev)
1245                         continue;
1246                 uart_resume_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
1247         }
1248
1249         return 0;
1250 }
1251
1252 static int bfin_serial_probe(struct platform_device *dev)
1253 {
1254         struct resource *res = dev->resource;
1255         int i;
1256
1257         for (i = 0; i < dev->num_resources; i++, res++)
1258                 if (res->flags & IORESOURCE_MEM)
1259                         break;
1260
1261         if (i < dev->num_resources) {
1262                 for (i = 0; i < nr_active_ports; i++, res++) {
1263                         if (bfin_serial_ports[i].port.mapbase != res->start)
1264                                 continue;
1265                         bfin_serial_ports[i].port.dev = &dev->dev;
1266                         uart_add_one_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
1267                 }
1268         }
1269
1270         return 0;
1271 }
1272
1273 static int bfin_serial_remove(struct platform_device *dev)
1274 {
1275         int i;
1276
1277         for (i = 0; i < nr_active_ports; i++) {
1278                 if (bfin_serial_ports[i].port.dev != &dev->dev)
1279                         continue;
1280                 uart_remove_one_port(&bfin_serial_reg, &bfin_serial_ports[i].port);
1281                 bfin_serial_ports[i].port.dev = NULL;
1282 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
1283                 gpio_free(bfin_serial_ports[i].cts_pin);
1284                 gpio_free(bfin_serial_ports[i].rts_pin);
1285 #endif
1286         }
1287
1288         return 0;
1289 }
1290
1291 static struct platform_driver bfin_serial_driver = {
1292         .probe          = bfin_serial_probe,
1293         .remove         = bfin_serial_remove,
1294         .suspend        = bfin_serial_suspend,
1295         .resume         = bfin_serial_resume,
1296         .driver         = {
1297                 .name   = "bfin-uart",
1298                 .owner  = THIS_MODULE,
1299         },
1300 };
1301
1302 static int __init bfin_serial_init(void)
1303 {
1304         int ret;
1305
1306         pr_info("Serial: Blackfin serial driver\n");
1307
1308         bfin_serial_init_ports();
1309
1310         ret = uart_register_driver(&bfin_serial_reg);
1311         if (ret == 0) {
1312                 ret = platform_driver_register(&bfin_serial_driver);
1313                 if (ret) {
1314                         pr_debug("uart register failed\n");
1315                         uart_unregister_driver(&bfin_serial_reg);
1316                 }
1317         }
1318         return ret;
1319 }
1320
1321 static void __exit bfin_serial_exit(void)
1322 {
1323         platform_driver_unregister(&bfin_serial_driver);
1324         uart_unregister_driver(&bfin_serial_reg);
1325 }
1326
1327
1328 module_init(bfin_serial_init);
1329 module_exit(bfin_serial_exit);
1330
1331 MODULE_AUTHOR("Aubrey.Li <aubrey.li@analog.com>");
1332 MODULE_DESCRIPTION("Blackfin generic serial port driver");
1333 MODULE_LICENSE("GPL");
1334 MODULE_ALIAS_CHARDEV_MAJOR(BFIN_SERIAL_MAJOR);
1335 MODULE_ALIAS("platform:bfin-uart");