arm: tegra: hsuart: Support for Bluetooth wakeup
[linux-2.6.git] / drivers / tty / serial / tegra_hsuart.c
1 /*
2  * drivers/serial/tegra_hsuart.c
3  *
4  * High-speed serial driver for NVIDIA Tegra SoCs
5  *
6  * Copyright (C) 2009 NVIDIA Corporation
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by the
10  * Free Software Foundation; either version 2 of the License, or (at your
11  * option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with this program; if not, write to the Free Software Foundation, Inc.,
20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21  */
22
23 /*#define DEBUG           1*/
24 /*#define VERBOSE_DEBUG   1*/
25
26 #include <linux/module.h>
27 #include <linux/serial.h>
28 #include <linux/serial_core.h>
29 #include <linux/platform_device.h>
30 #include <linux/io.h>
31 #include <linux/dma-mapping.h>
32 #include <linux/dmapool.h>
33 #include <linux/termios.h>
34 #include <linux/irq.h>
35 #include <linux/delay.h>
36 #include <linux/clk.h>
37 #include <linux/string.h>
38 #include <linux/pagemap.h>
39 #include <linux/serial_reg.h>
40 #include <linux/serial_8250.h>
41 #include <linux/debugfs.h>
42 #include <linux/slab.h>
43 #include <linux/workqueue.h>
44 #include <linux/tegra_uart.h>
45
46 #include <mach/dma.h>
47 #include <mach/clk.h>
48
49 #define TX_EMPTY_STATUS (UART_LSR_TEMT | UART_LSR_THRE)
50
51 #define BYTES_TO_ALIGN(x) ((unsigned long)(ALIGN((x), sizeof(u32))) - \
52         (unsigned long)(x))
53
54 #define UART_RX_DMA_BUFFER_SIZE    (2048*4)
55
56 #define UART_LSR_FIFOE          0x80
57 #define UART_IER_EORD           0x20
58 #define UART_MCR_RTS_EN         0x40
59 #define UART_MCR_CTS_EN         0x20
60 #define UART_LSR_ANY            (UART_LSR_OE | UART_LSR_BI | \
61                                 UART_LSR_PE | UART_LSR_FE)
62
63 #define TX_FORCE_PIO 0
64 #define RX_FORCE_PIO 0
65
66 const int dma_req_sel[] = {
67         TEGRA_DMA_REQ_SEL_UARTA,
68         TEGRA_DMA_REQ_SEL_UARTB,
69         TEGRA_DMA_REQ_SEL_UARTC,
70         TEGRA_DMA_REQ_SEL_UARTD,
71         TEGRA_DMA_REQ_SEL_UARTE,
72 };
73
74 #define TEGRA_TX_PIO                    1
75 #define TEGRA_TX_DMA                    2
76
77 #define TEGRA_UART_MIN_DMA              16
78 #define TEGRA_UART_FIFO_SIZE            8
79
80 #define TEGRA_UART_CLOSED    0
81 #define TEGRA_UART_OPENED    1
82 #define TEGRA_UART_CLOCK_OFF 2
83 #define TEGRA_UART_SUSPEND   3
84
85 /* Tx fifo trigger level setting in tegra uart is in
86  * reverse way then conventional uart */
87 #define TEGRA_UART_TX_TRIG_16B 0x00
88 #define TEGRA_UART_TX_TRIG_8B  0x10
89 #define TEGRA_UART_TX_TRIG_4B  0x20
90 #define TEGRA_UART_TX_TRIG_1B  0x30
91
92 struct tegra_uart_port {
93         struct uart_port        uport;
94         char                    port_name[32];
95
96         /* Module info */
97         unsigned long           size;
98         struct clk              *clk;
99         unsigned int            baud;
100
101         /* Register shadow */
102         unsigned char           fcr_shadow;
103         unsigned char           mcr_shadow;
104         unsigned char           lcr_shadow;
105         unsigned char           ier_shadow;
106         bool                    use_cts_control;
107         bool                    rts_active;
108
109         int                     tx_in_progress;
110         unsigned int            tx_bytes;
111
112         dma_addr_t              xmit_dma_addr;
113
114         /* TX DMA */
115         struct tegra_dma_req    tx_dma_req;
116         struct tegra_dma_channel *tx_dma;
117
118         /* RX DMA */
119         struct tegra_dma_req    rx_dma_req;
120         struct tegra_dma_channel *rx_dma;
121
122         bool                    use_rx_dma;
123         bool                    use_tx_dma;
124         int                     uart_state;
125         bool                    rx_timeout;
126         int                     rx_in_progress;
127 };
128
129 static inline u8 uart_readb(struct tegra_uart_port *t, unsigned long reg)
130 {
131         u8 val = readb(t->uport.membase + (reg << t->uport.regshift));
132         dev_vdbg(t->uport.dev, "%s: %p %03lx = %02x\n", __func__,
133                 t->uport.membase, reg << t->uport.regshift, val);
134         return val;
135 }
136
137 static inline void uart_writeb(struct tegra_uart_port *t, u8 val,
138         unsigned long reg)
139 {
140         dev_vdbg(t->uport.dev, "%s: %p %03lx %02x\n",
141                 __func__, t->uport.membase, reg << t->uport.regshift, val);
142         writeb(val, t->uport.membase + (reg << t->uport.regshift));
143 }
144
145 static inline void uart_writel(struct tegra_uart_port *t, u32 val,
146         unsigned long reg)
147 {
148         dev_vdbg(t->uport.dev, "%s: %p %03lx %08x\n",
149                 __func__, t->uport.membase, reg << t->uport.regshift, val);
150         writel(val, t->uport.membase + (reg << t->uport.regshift));
151 }
152
153 static void tegra_set_baudrate(struct tegra_uart_port *t, unsigned int baud);
154 static void tegra_set_mctrl(struct uart_port *u, unsigned int mctrl);
155 static void do_handle_rx_pio(struct tegra_uart_port *t);
156 static void do_handle_rx_dma(struct tegra_uart_port *t);
157 static void set_rts(struct tegra_uart_port *t, bool active);
158 static void set_dtr(struct tegra_uart_port *t, bool active);
159
160 static void fill_tx_fifo(struct tegra_uart_port *t, int max_bytes)
161 {
162         int i;
163         struct circ_buf *xmit = &t->uport.state->xmit;
164
165         for (i = 0; i < max_bytes; i++) {
166                 BUG_ON(uart_circ_empty(xmit));
167                 uart_writeb(t, xmit->buf[xmit->tail], UART_TX);
168                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
169                 t->uport.icount.tx++;
170         }
171 }
172
173 static void tegra_start_pio_tx(struct tegra_uart_port *t, unsigned int bytes)
174 {
175         if (bytes > TEGRA_UART_FIFO_SIZE)
176                 bytes = TEGRA_UART_FIFO_SIZE;
177
178         t->fcr_shadow &= ~UART_FCR_T_TRIG_11;
179         t->fcr_shadow |= TEGRA_UART_TX_TRIG_8B;
180         uart_writeb(t, t->fcr_shadow, UART_FCR);
181         t->tx_in_progress = TEGRA_TX_PIO;
182         t->tx_bytes = bytes;
183         t->ier_shadow |= UART_IER_THRI;
184         uart_writeb(t, t->ier_shadow, UART_IER);
185 }
186
187 static void tegra_start_dma_tx(struct tegra_uart_port *t, unsigned long bytes)
188 {
189         struct circ_buf *xmit;
190         xmit = &t->uport.state->xmit;
191
192         dma_sync_single_for_device(t->uport.dev, t->xmit_dma_addr,
193                 UART_XMIT_SIZE, DMA_TO_DEVICE);
194
195         t->fcr_shadow &= ~UART_FCR_T_TRIG_11;
196         t->fcr_shadow |= TEGRA_UART_TX_TRIG_4B;
197         uart_writeb(t, t->fcr_shadow, UART_FCR);
198
199         t->tx_bytes = bytes & ~(sizeof(u32)-1);
200         t->tx_dma_req.source_addr = t->xmit_dma_addr + xmit->tail;
201         t->tx_dma_req.size = t->tx_bytes;
202
203         t->tx_in_progress = TEGRA_TX_DMA;
204
205         tegra_dma_enqueue_req(t->tx_dma, &t->tx_dma_req);
206 }
207
208 /* Called with u->lock taken */
209 static void tegra_start_next_tx(struct tegra_uart_port *t)
210 {
211         unsigned long tail;
212         unsigned long count;
213
214         struct circ_buf *xmit;
215
216         xmit = &t->uport.state->xmit;
217         tail = (unsigned long)&xmit->buf[xmit->tail];
218         count = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
219
220
221         dev_vdbg(t->uport.dev, "+%s %lu %d\n", __func__, count,
222                 t->tx_in_progress);
223
224         if (count == 0)
225                 goto out;
226
227         if (!t->use_tx_dma || count < TEGRA_UART_MIN_DMA)
228                 tegra_start_pio_tx(t, count);
229         else if (BYTES_TO_ALIGN(tail) > 0)
230                 tegra_start_pio_tx(t, BYTES_TO_ALIGN(tail));
231         else
232                 tegra_start_dma_tx(t, count);
233
234 out:
235         dev_vdbg(t->uport.dev, "-%s", __func__);
236 }
237
238 /* Called by serial core driver with u->lock taken. */
239 static void tegra_start_tx(struct uart_port *u)
240 {
241         struct tegra_uart_port *t;
242         struct circ_buf *xmit;
243
244         t = container_of(u, struct tegra_uart_port, uport);
245         xmit = &u->state->xmit;
246
247         if (!uart_circ_empty(xmit) && !t->tx_in_progress)
248                 tegra_start_next_tx(t);
249 }
250
251 static int tegra_start_dma_rx(struct tegra_uart_port *t)
252 {
253         wmb();
254         if (tegra_dma_enqueue_req(t->rx_dma, &t->rx_dma_req)) {
255                 dev_err(t->uport.dev, "Could not enqueue Rx DMA req\n");
256                 return -EINVAL;
257         }
258         return 0;
259 }
260
261 static void tegra_rx_dma_threshold_callback(struct tegra_dma_req *req)
262 {
263         struct tegra_uart_port *t = req->dev;
264         struct uart_port *u = &t->uport;
265         unsigned long flags;
266
267         spin_lock_irqsave(&u->lock, flags);
268
269         do_handle_rx_dma(t);
270
271         spin_unlock_irqrestore(&u->lock, flags);
272 }
273
274 /* It is expected that the callers take the UART lock when this API is called.
275  *
276  * There are 2 contexts when this function is called:
277  *
278  * 1. DMA ISR - DMA ISR triggers the threshold complete calback, which calls the
279  * dequue API which in-turn calls this callback. UART lock is taken during
280  * the call to the threshold callback.
281  *
282  * 2. UART ISR - UART calls the dequue API which in-turn will call this API.
283  * In this case, UART ISR takes the UART lock.
284  * */
285 static void tegra_rx_dma_complete_callback(struct tegra_dma_req *req)
286 {
287         struct tegra_uart_port *t = req->dev;
288         struct uart_port *u = &t->uport;
289         struct tty_struct *tty = u->state->port.tty;
290
291         /* If we are here, DMA is stopped */
292
293         dev_dbg(t->uport.dev, "%s: %d %d\n", __func__, req->bytes_transferred,
294                 req->status);
295         if (req->bytes_transferred) {
296                 t->uport.icount.rx += req->bytes_transferred;
297                 tty_insert_flip_string(tty,
298                         ((unsigned char *)(req->virt_addr)),
299                         req->bytes_transferred);
300         }
301
302         do_handle_rx_pio(t);
303
304         /* Push the read data later in caller place. */
305         if (req->status == -TEGRA_DMA_REQ_ERROR_ABORTED)
306                 return;
307
308         spin_unlock(&u->lock);
309         tty_flip_buffer_push(u->state->port.tty);
310         spin_lock(&u->lock);
311 }
312
313 /* Lock already taken */
314 static void do_handle_rx_dma(struct tegra_uart_port *t)
315 {
316         struct uart_port *u = &t->uport;
317         if (t->rts_active)
318                 set_rts(t, false);
319         tegra_dma_dequeue(t->rx_dma);
320         tty_flip_buffer_push(u->state->port.tty);
321         /* enqueue the request again */
322         tegra_start_dma_rx(t);
323         if (t->rts_active)
324                 set_rts(t, true);
325 }
326
327 /* Wait for a symbol-time. */
328 static void wait_sym_time(struct tegra_uart_port *t, unsigned int syms)
329 {
330
331         /* Definitely have a start bit. */
332         unsigned int bits = 1;
333         switch (t->lcr_shadow & 3) {
334         case UART_LCR_WLEN5:
335                 bits += 5;
336                 break;
337         case UART_LCR_WLEN6:
338                 bits += 6;
339                 break;
340         case UART_LCR_WLEN7:
341                 bits += 7;
342                 break;
343         default:
344                 bits += 8;
345                 break;
346         }
347
348         /* Technically 5 bits gets 1.5 bits of stop... */
349         if (t->lcr_shadow & UART_LCR_STOP) {
350                 bits += 2;
351         } else {
352                 bits++;
353         }
354
355         if (t->lcr_shadow & UART_LCR_PARITY)
356                 bits++;
357
358         if (likely(t->baud))
359                 udelay(DIV_ROUND_UP(syms * bits * 1000000, t->baud));
360 }
361
362 /* Flush desired FIFO. */
363 static void tegra_fifo_reset(struct tegra_uart_port *t, u8 fcr_bits)
364 {
365         unsigned char fcr = t->fcr_shadow;
366         fcr |= fcr_bits & (UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
367         uart_writeb(t, fcr, UART_FCR);
368         uart_readb(t, UART_SCR); /* Dummy read to ensure the write is posted */
369         wait_sym_time(t, 1); /* Wait for the flush to propagate. */
370 }
371
372 static char do_decode_rx_error(struct tegra_uart_port *t, u8 lsr)
373 {
374         char flag = TTY_NORMAL;
375
376         if (unlikely(lsr & UART_LSR_ANY)) {
377                 if (lsr & UART_LSR_OE) {
378                         /* Overrrun error  */
379                         flag |= TTY_OVERRUN;
380                         t->uport.icount.overrun++;
381                         dev_err(t->uport.dev, "Got overrun errors\n");
382                 } else if (lsr & UART_LSR_PE) {
383                         /* Parity error */
384                         flag |= TTY_PARITY;
385                         t->uport.icount.parity++;
386                         dev_err(t->uport.dev, "Got Parity errors\n");
387                 } else if (lsr & UART_LSR_FE) {
388                         flag |= TTY_FRAME;
389                         t->uport.icount.frame++;
390                         dev_err(t->uport.dev, "Got frame errors\n");
391                 } else if (lsr & UART_LSR_BI) {
392                         dev_err(t->uport.dev, "Got Break\n");
393                         t->uport.icount.brk++;
394                         /* If FIFO read error without any data, reset Rx FIFO */
395                         if (!(lsr & UART_LSR_DR) && (lsr & UART_LSR_FIFOE))
396                                 tegra_fifo_reset(t, UART_FCR_CLEAR_RCVR);
397                 }
398         }
399         return flag;
400 }
401
402 static void do_handle_rx_pio(struct tegra_uart_port *t)
403 {
404         int count = 0;
405         do {
406                 char flag = TTY_NORMAL;
407                 unsigned char lsr = 0;
408                 unsigned char ch;
409
410
411                 lsr = uart_readb(t, UART_LSR);
412                 if (!(lsr & UART_LSR_DR))
413                         break;
414
415                 flag =  do_decode_rx_error(t, lsr);
416                 ch = uart_readb(t, UART_RX);
417                 t->uport.icount.rx++;
418                 count++;
419
420                 if (!uart_handle_sysrq_char(&t->uport, c))
421                         uart_insert_char(&t->uport, lsr, UART_LSR_OE, ch, flag);
422         } while (1);
423
424         dev_dbg(t->uport.dev, "PIO received %d bytes\n", count);
425
426         return;
427 }
428
429 static void do_handle_modem_signal(struct uart_port *u)
430 {
431         unsigned char msr;
432         struct tegra_uart_port *t;
433
434         t = container_of(u, struct tegra_uart_port, uport);
435         msr = uart_readb(t, UART_MSR);
436         if (msr & UART_MSR_CTS)
437                 dev_dbg(u->dev, "CTS triggered\n");
438         if (msr & UART_MSR_DSR)
439                 dev_dbg(u->dev, "DSR enabled\n");
440         if (msr & UART_MSR_DCD)
441                 dev_dbg(u->dev, "CD enabled\n");
442         if (msr & UART_MSR_RI)
443                 dev_dbg(u->dev, "RI enabled\n");
444         return;
445 }
446
447 static void do_handle_tx_pio(struct tegra_uart_port *t)
448 {
449         struct circ_buf *xmit = &t->uport.state->xmit;
450
451         fill_tx_fifo(t, t->tx_bytes);
452
453         t->tx_in_progress = 0;
454
455         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
456                 uart_write_wakeup(&t->uport);
457
458         tegra_start_next_tx(t);
459         return;
460 }
461
462 static void tegra_tx_dma_complete_callback(struct tegra_dma_req *req)
463 {
464         struct tegra_uart_port *t = req->dev;
465         struct circ_buf *xmit = &t->uport.state->xmit;
466         int count = req->bytes_transferred;
467         unsigned long flags;
468
469         dev_vdbg(t->uport.dev, "%s: %d\n", __func__, count);
470
471         spin_lock_irqsave(&t->uport.lock, flags);
472         xmit->tail = (xmit->tail + count) & (UART_XMIT_SIZE - 1);
473         t->tx_in_progress = 0;
474
475         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
476                 uart_write_wakeup(&t->uport);
477
478         if (req->status != -TEGRA_DMA_REQ_ERROR_ABORTED)
479                 tegra_start_next_tx(t);
480
481         spin_unlock_irqrestore(&t->uport.lock, flags);
482 }
483
484 static irqreturn_t tegra_uart_isr(int irq, void *data)
485 {
486         struct tegra_uart_port *t = data;
487         struct uart_port *u = &t->uport;
488         unsigned char iir;
489         unsigned char ier;
490         bool is_rx_int = false;
491         unsigned long flags;
492
493         spin_lock_irqsave(&u->lock, flags);
494         t  = container_of(u, struct tegra_uart_port, uport);
495         while (1) {
496                 iir = uart_readb(t, UART_IIR);
497                 if (iir & UART_IIR_NO_INT) {
498                         if (likely(t->use_rx_dma) && is_rx_int) {
499                                 do_handle_rx_dma(t);
500
501                                 if (t->rx_in_progress) {
502                                         ier = t->ier_shadow;
503                                         ier |= (UART_IER_RLSI | UART_IER_RTOIE | UART_IER_EORD);
504                                         t->ier_shadow = ier;
505                                         uart_writeb(t, ier, UART_IER);
506                                 }
507                         }
508                         spin_unlock_irqrestore(&u->lock, flags);
509                         return IRQ_HANDLED;
510                 }
511
512                 dev_dbg(u->dev, "tegra_uart_isr iir = 0x%x (%d)\n", iir,
513                         (iir >> 1) & 0x7);
514                 switch ((iir >> 1) & 0x7) {
515                 case 0: /* Modem signal change interrupt */
516                         do_handle_modem_signal(u);
517                         break;
518                 case 1: /* Transmit interrupt only triggered when using PIO */
519                         t->ier_shadow &= ~UART_IER_THRI;
520                         uart_writeb(t, t->ier_shadow, UART_IER);
521                         do_handle_tx_pio(t);
522                         break;
523                 case 4: /* End of data */
524                 case 6: /* Rx timeout */
525                 case 2: /* Receive */
526                         if (likely(t->use_rx_dma)) {
527                                 if (!is_rx_int) {
528                                         is_rx_int = true;
529                                         /* Disable interrups */
530                                         ier = t->ier_shadow;
531                                         ier |= UART_IER_RDI;
532                                         uart_writeb(t, ier, UART_IER);
533                                         ier &= ~(UART_IER_RDI | UART_IER_RLSI | UART_IER_RTOIE | UART_IER_EORD);
534                                         t->ier_shadow = ier;
535                                         uart_writeb(t, ier, UART_IER);
536                                 }
537                         } else {
538                                 do_handle_rx_pio(t);
539
540                                 spin_unlock_irqrestore(&u->lock, flags);
541                                 tty_flip_buffer_push(u->state->port.tty);
542                                 spin_lock_irqsave(&u->lock, flags);
543                         }
544                         break;
545                 case 3: /* Receive error */
546                         /* FIXME how to handle this? Why do we get here */
547                         do_decode_rx_error(t, uart_readb(t, UART_LSR));
548                         break;
549                 case 5: /* break nothing to handle */
550                 case 7: /* break nothing to handle */
551                         break;
552                 }
553         }
554 }
555
556 static void tegra_stop_rx(struct uart_port *u)
557 {
558         struct tegra_uart_port *t;
559         unsigned char ier;
560
561         t = container_of(u, struct tegra_uart_port, uport);
562
563         if (t->rts_active)
564                 set_rts(t, false);
565
566         if (t->rx_in_progress) {
567                 wait_sym_time(t, 1); /* wait a character interval */
568
569                 ier = t->ier_shadow;
570                 ier &= ~(UART_IER_RDI | UART_IER_RLSI | UART_IER_RTOIE | UART_IER_EORD);
571                 t->ier_shadow = ier;
572                 uart_writeb(t, ier, UART_IER);
573                 t->rx_in_progress = 0;
574
575                 if (t->use_rx_dma && t->rx_dma)
576                         tegra_dma_dequeue(t->rx_dma);
577                 else
578                         do_handle_rx_pio(t);
579
580                 tty_flip_buffer_push(u->state->port.tty);
581         }
582
583         return;
584 }
585
586 static void tegra_uart_hw_deinit(struct tegra_uart_port *t)
587 {
588         unsigned long flags;
589
590         /* Disable interrupts */
591         uart_writeb(t, 0, UART_IER);
592
593         while ((uart_readb(t, UART_LSR) & UART_LSR_TEMT) != UART_LSR_TEMT);
594                 udelay(200);
595
596         spin_lock_irqsave(&t->uport.lock, flags);
597
598         /* Reset the Rx and Tx FIFOs */
599         tegra_fifo_reset(t, UART_FCR_CLEAR_XMIT | UART_FCR_CLEAR_RCVR);
600
601         clk_disable(t->clk);
602         t->baud = 0;
603         t->uart_state = TEGRA_UART_CLOSED;
604
605         spin_unlock_irqrestore(&t->uport.lock, flags);
606 }
607
608 static void tegra_uart_free_rx_dma(struct tegra_uart_port *t)
609 {
610         if (!t->use_rx_dma)
611                return;
612
613         tegra_dma_free_channel(t->rx_dma);
614         t->rx_dma = NULL;
615
616         if (likely(t->rx_dma_req.dest_addr))
617                 dma_free_coherent(t->uport.dev, t->rx_dma_req.size,
618                         t->rx_dma_req.virt_addr, t->rx_dma_req.dest_addr);
619         t->rx_dma_req.dest_addr = 0;
620         t->rx_dma_req.virt_addr = NULL;
621
622         t->use_rx_dma = false;
623 }
624
625 static int tegra_uart_hw_init(struct tegra_uart_port *t)
626 {
627         unsigned char ier;
628
629         dev_vdbg(t->uport.dev, "+tegra_uart_hw_init\n");
630
631         t->fcr_shadow = 0;
632         t->mcr_shadow = 0;
633         t->lcr_shadow = 0;
634         t->ier_shadow = 0;
635         t->baud = 0;
636
637         clk_enable(t->clk);
638
639         /* Reset the UART controller to clear all previous status.*/
640         tegra_periph_reset_assert(t->clk);
641         udelay(100);
642         tegra_periph_reset_deassert(t->clk);
643         udelay(100);
644
645         t->rx_in_progress = 0;
646
647         /* Set the trigger level
648          *
649          * For PIO mode:
650          *
651          * For receive, this will interrupt the CPU after that many number of
652          * bytes are received, for the remaining bytes the receive timeout
653          * interrupt is received.
654          *
655          *  Rx high watermark is set to 4.
656          *
657          * For transmit, if the trasnmit interrupt is enabled, this will
658          * interrupt the CPU when the number of entries in the FIFO reaches the
659          * low watermark.
660          *
661          *  Tx low watermark is set to 8.
662          *
663          *  For DMA mode:
664          *
665          *  Set the Tx trigger to 4. This should match the DMA burst size that
666          *  programmed in the DMA registers.
667          * */
668         t->fcr_shadow = UART_FCR_ENABLE_FIFO;
669         t->fcr_shadow |= UART_FCR_R_TRIG_01;
670         t->fcr_shadow |= TEGRA_UART_TX_TRIG_8B;
671         uart_writeb(t, t->fcr_shadow, UART_FCR);
672
673         if (t->use_rx_dma) {
674                 /* initialize the UART for a simple default configuration
675                   * so that the receive DMA buffer may be enqueued */
676                 t->lcr_shadow = 3;  /* no parity, stop, 8 data bits */
677                 tegra_set_baudrate(t, 115200);
678                 t->fcr_shadow |= UART_FCR_DMA_SELECT;
679                 uart_writeb(t, t->fcr_shadow, UART_FCR);
680                 if (tegra_start_dma_rx(t)) {
681                         dev_err(t->uport.dev, "Rx DMA enqueue failed\n");
682                         tegra_uart_free_rx_dma(t);
683                         t->fcr_shadow &= ~UART_FCR_DMA_SELECT;
684                         uart_writeb(t, t->fcr_shadow, UART_FCR);
685                 }
686         }
687         else
688                 uart_writeb(t, t->fcr_shadow, UART_FCR);
689
690         t->rx_in_progress = 1;
691
692         /*
693          *  Enable IE_RXS for the receive status interrupts like line errros.
694          *  Enable IE_RX_TIMEOUT to get the bytes which cannot be DMA'd.
695          *
696          *  If using DMA mode, enable EORD instead of receive interrupt which
697          *  will interrupt after the UART is done with the receive instead of
698          *  the interrupt when the FIFO "threshold" is reached.
699          *
700          *  EORD is different interrupt than RX_TIMEOUT - RX_TIMEOUT occurs when
701          *  the DATA is sitting in the FIFO and couldn't be transferred to the
702          *  DMA as the DMA size alignment(4 bytes) is not met. EORD will be
703          *  triggered when there is a pause of the incomming data stream for 4
704          *  characters long.
705          *
706          *  For pauses in the data which is not aligned to 4 bytes, we get
707          *  both the EORD as well as RX_TIMEOUT - SW sees RX_TIMEOUT first
708          *  then the EORD.
709          *
710          *  Don't get confused, believe in the magic of nvidia hw...:-)
711          */
712         ier = 0;
713         ier |= UART_IER_RLSI | UART_IER_RTOIE;
714         if (t->use_rx_dma)
715                 ier |= UART_IER_EORD;
716         else
717                 ier |= UART_IER_RDI;
718         t->ier_shadow = ier;
719         uart_writeb(t, ier, UART_IER);
720
721         t->uart_state = TEGRA_UART_OPENED;
722         dev_vdbg(t->uport.dev, "-tegra_uart_hw_init\n");
723         return 0;
724 }
725
726 static int tegra_uart_init_rx_dma(struct tegra_uart_port *t)
727 {
728         dma_addr_t rx_dma_phys;
729         void *rx_dma_virt;
730
731         t->rx_dma = tegra_dma_allocate_channel(TEGRA_DMA_MODE_CONTINUOUS);
732         if (!t->rx_dma) {
733                 dev_err(t->uport.dev, "%s: failed to allocate RX DMA.\n", __func__);
734                 return -ENODEV;
735         }
736
737         t->rx_dma_req.size = UART_RX_DMA_BUFFER_SIZE;
738         rx_dma_virt = dma_alloc_coherent(t->uport.dev,
739                 t->rx_dma_req.size, &rx_dma_phys, GFP_KERNEL);
740         if (!rx_dma_virt) {
741                 dev_err(t->uport.dev, "DMA buffers allocate failed\n");
742                 goto fail;
743         }
744         t->rx_dma_req.dest_addr = rx_dma_phys;
745         t->rx_dma_req.virt_addr = rx_dma_virt;
746
747         t->rx_dma_req.source_addr = (unsigned long)t->uport.mapbase;
748         t->rx_dma_req.source_wrap = 4;
749         t->rx_dma_req.dest_wrap = 0;
750         t->rx_dma_req.to_memory = 1;
751         t->rx_dma_req.source_bus_width = 8;
752         t->rx_dma_req.dest_bus_width = 32;
753         t->rx_dma_req.req_sel = dma_req_sel[t->uport.line];
754         t->rx_dma_req.complete = tegra_rx_dma_complete_callback;
755         t->rx_dma_req.threshold = tegra_rx_dma_threshold_callback;
756         t->rx_dma_req.dev = t;
757
758         return 0;
759 fail:
760         tegra_uart_free_rx_dma(t);
761         return -ENODEV;
762 }
763
764 static int tegra_startup(struct uart_port *u)
765 {
766         struct tegra_uart_port *t = container_of(u,
767                 struct tegra_uart_port, uport);
768         int ret = 0;
769
770         t = container_of(u, struct tegra_uart_port, uport);
771         sprintf(t->port_name, "tegra_uart_%d", u->line);
772
773         t->use_tx_dma = false;
774         if (!TX_FORCE_PIO) {
775                 t->tx_dma = tegra_dma_allocate_channel(TEGRA_DMA_MODE_ONESHOT);
776                 if (t->tx_dma)
777                         t->use_tx_dma = true;
778                 else
779                         pr_err("%s: failed to allocate TX DMA.\n", __func__);
780         }
781         if (t->use_tx_dma) {
782                 t->tx_dma_req.instance = u->line;
783                 t->tx_dma_req.complete = tegra_tx_dma_complete_callback;
784                 t->tx_dma_req.to_memory = 0;
785
786                 t->tx_dma_req.dest_addr = (unsigned long)t->uport.mapbase;
787                 t->tx_dma_req.dest_wrap = 4;
788                 t->tx_dma_req.source_wrap = 0;
789                 t->tx_dma_req.source_bus_width = 32;
790                 t->tx_dma_req.dest_bus_width = 8;
791                 t->tx_dma_req.req_sel = dma_req_sel[t->uport.line];
792                 t->tx_dma_req.dev = t;
793                 t->tx_dma_req.size = 0;
794                 t->xmit_dma_addr = dma_map_single(t->uport.dev,
795                         t->uport.state->xmit.buf, UART_XMIT_SIZE,
796                         DMA_TO_DEVICE);
797         }
798         t->tx_in_progress = 0;
799
800         t->use_rx_dma = false;
801         if (!RX_FORCE_PIO) {
802                 if (!tegra_uart_init_rx_dma(t))
803                         t->use_rx_dma = true;
804         }
805
806         ret = tegra_uart_hw_init(t);
807         if (ret)
808                 goto fail;
809
810         dev_dbg(u->dev, "Requesting IRQ %d\n", u->irq);
811         msleep(1);
812
813         ret = request_irq(u->irq, tegra_uart_isr, IRQF_DISABLED,
814                 t->port_name, t);
815         if (ret) {
816                 dev_err(u->dev, "Failed to register ISR for IRQ %d\n", u->irq);
817                 goto fail;
818         }
819         dev_dbg(u->dev,"Started UART port %d\n", u->line);
820
821         return 0;
822 fail:
823         dev_err(u->dev, "Tegra UART startup failed\n");
824         return ret;
825 }
826
827 static void tegra_shutdown(struct uart_port *u)
828 {
829         struct tegra_uart_port *t;
830
831         t = container_of(u, struct tegra_uart_port, uport);
832         dev_vdbg(u->dev, "+tegra_shutdown\n");
833
834         tegra_uart_hw_deinit(t);
835
836         t->rx_in_progress = 0;
837         t->tx_in_progress = 0;
838
839         tegra_uart_free_rx_dma(t);
840         if (t->use_tx_dma) {
841                 tegra_dma_free_channel(t->tx_dma);
842                 t->tx_dma = NULL;
843                 t->use_tx_dma = false;
844                 dma_unmap_single(t->uport.dev, t->xmit_dma_addr, UART_XMIT_SIZE,
845                                 DMA_TO_DEVICE);
846                 t->xmit_dma_addr = 0;
847         }
848
849         free_irq(u->irq, t);
850         dev_vdbg(u->dev, "-tegra_shutdown\n");
851 }
852
853 static unsigned int tegra_get_mctrl(struct uart_port *u)
854 {
855         /* RI - Ring detector is active
856          * CD/DCD/CAR - Carrier detect is always active. For some reason
857          *                        linux has different names for carrier detect.
858          * DSR - Data Set ready is active as the hardware doesn't support it.
859          *         Don't know if the linux support this yet?
860          * CTS - Clear to send. Always set to active, as the hardware handles
861          *         CTS automatically.
862          * */
863         return TIOCM_RI | TIOCM_CD | TIOCM_DSR | TIOCM_CTS;
864 }
865
866 static void set_rts(struct tegra_uart_port *t, bool active)
867 {
868         unsigned char mcr;
869         mcr = t->mcr_shadow;
870         if (active)
871                 mcr |= UART_MCR_RTS;
872         else
873                 mcr &= ~UART_MCR_RTS;
874         if (mcr != t->mcr_shadow) {
875                 uart_writeb(t, mcr, UART_MCR);
876                 t->mcr_shadow = mcr;
877         }
878         return;
879 }
880
881 static void set_dtr(struct tegra_uart_port *t, bool active)
882 {
883         unsigned char mcr;
884         mcr = t->mcr_shadow;
885         if (active)
886                 mcr |= UART_MCR_DTR;
887         else
888                 mcr &= ~UART_MCR_DTR;
889         if (mcr != t->mcr_shadow) {
890                 uart_writeb(t, mcr, UART_MCR);
891                 t->mcr_shadow = mcr;
892         }
893         return;
894 }
895
896 static void tegra_set_mctrl(struct uart_port *u, unsigned int mctrl)
897 {
898         unsigned char mcr;
899         struct tegra_uart_port *t;
900
901         dev_dbg(u->dev, "tegra_set_mctrl called with %d\n", mctrl);
902         t = container_of(u, struct tegra_uart_port, uport);
903
904         mcr = t->mcr_shadow;
905         if (mctrl & TIOCM_RTS) {
906                 t->rts_active = true;
907                 set_rts(t, true);
908         } else {
909                 t->rts_active = false;
910                 set_rts(t, false);
911         }
912
913         if (mctrl & TIOCM_DTR)
914                 set_dtr(t, true);
915         else
916                 set_dtr(t, false);
917         return;
918 }
919
920 static void tegra_break_ctl(struct uart_port *u, int break_ctl)
921 {
922         struct tegra_uart_port *t;
923         unsigned char lcr;
924
925         t = container_of(u, struct tegra_uart_port, uport);
926         lcr = t->lcr_shadow;
927         if (break_ctl)
928                 lcr |= UART_LCR_SBC;
929         else
930                 lcr &= ~UART_LCR_SBC;
931         uart_writeb(t, lcr, UART_LCR);
932         t->lcr_shadow = lcr;
933 }
934
935 static int tegra_request_port(struct uart_port *u)
936 {
937         return 0;
938 }
939
940 static void tegra_release_port(struct uart_port *u)
941 {
942
943 }
944
945 static unsigned int tegra_tx_empty(struct uart_port *u)
946 {
947         struct tegra_uart_port *t;
948         unsigned int ret = 0;
949         unsigned long flags;
950         unsigned char lsr;
951
952         t = container_of(u, struct tegra_uart_port, uport);
953         dev_vdbg(u->dev, "+tegra_tx_empty\n");
954
955         spin_lock_irqsave(&u->lock, flags);
956         if (!t->tx_in_progress) {
957                 lsr = uart_readb(t, UART_LSR);
958                 if ((lsr & TX_EMPTY_STATUS) == TX_EMPTY_STATUS)
959                         ret = TIOCSER_TEMT;
960         }
961         spin_unlock_irqrestore(&u->lock, flags);
962
963         dev_vdbg(u->dev, "-tegra_tx_empty\n");
964         return ret;
965 }
966
967 static void tegra_stop_tx(struct uart_port *u)
968 {
969         struct tegra_uart_port *t;
970
971         t = container_of(u, struct tegra_uart_port, uport);
972
973         if (t->use_tx_dma)
974                 tegra_dma_dequeue_req(t->tx_dma, &t->tx_dma_req);
975
976         return;
977 }
978
979 static void tegra_enable_ms(struct uart_port *u)
980 {
981 }
982
983 #define UART_CLOCK_ACCURACY 5
984
985 static void tegra_set_baudrate(struct tegra_uart_port *t, unsigned int baud)
986 {
987         unsigned long rate;
988         unsigned int divisor;
989         unsigned char lcr;
990
991         if (t->baud == baud)
992                 return;
993
994         rate = clk_get_rate(t->clk);
995
996         divisor = rate;
997         do_div(divisor, 16);
998         divisor += baud/2;
999         do_div(divisor, baud);
1000
1001         lcr = t->lcr_shadow;
1002         lcr |= UART_LCR_DLAB;
1003         uart_writeb(t, lcr, UART_LCR);
1004
1005         uart_writel(t, divisor & 0xFF, UART_TX);
1006         uart_writel(t, ((divisor >> 8) & 0xFF), UART_IER);
1007
1008         lcr &= ~UART_LCR_DLAB;
1009         uart_writeb(t, lcr, UART_LCR);
1010         uart_readb(t, UART_SCR); /* Dummy read to ensure the write is posted */
1011
1012         t->baud = baud;
1013         wait_sym_time(t, 2); /* wait two character intervals at new rate */
1014         dev_dbg(t->uport.dev, "Baud %u clock freq %lu and divisor of %u\n",
1015                 baud, rate, divisor);
1016 }
1017
1018 static void tegra_set_termios(struct uart_port *u, struct ktermios *termios,
1019                                            struct ktermios *oldtermios)
1020 {
1021         struct tegra_uart_port *t;
1022         unsigned int baud;
1023         unsigned long flags;
1024         unsigned int lcr;
1025         unsigned int c_cflag = termios->c_cflag;
1026         unsigned char mcr;
1027
1028         t = container_of(u, struct tegra_uart_port, uport);
1029         dev_vdbg(t->uport.dev, "+tegra_set_termios\n");
1030
1031         spin_lock_irqsave(&u->lock, flags);
1032
1033         /* Changing configuration, it is safe to stop any rx now */
1034         if (t->rts_active)
1035                 set_rts(t, false);
1036
1037         /* Parity */
1038         lcr = t->lcr_shadow;
1039         lcr &= ~UART_LCR_PARITY;
1040         if (PARENB == (c_cflag & PARENB)) {
1041                 if (CMSPAR == (c_cflag & CMSPAR)) {
1042                         /* FIXME What is space parity? */
1043                         /* data |= SPACE_PARITY; */
1044                 } else if (c_cflag & PARODD) {
1045                         lcr |= UART_LCR_PARITY;
1046                         lcr &= ~UART_LCR_EPAR;
1047                         lcr &= ~UART_LCR_SPAR;
1048                 } else {
1049                         lcr |= UART_LCR_PARITY;
1050                         lcr |= UART_LCR_EPAR;
1051                         lcr &= ~UART_LCR_SPAR;
1052                 }
1053         }
1054
1055         lcr &= ~UART_LCR_WLEN8;
1056         switch (c_cflag & CSIZE) {
1057         case CS5:
1058                 lcr |= UART_LCR_WLEN5;
1059                 break;
1060         case CS6:
1061                 lcr |= UART_LCR_WLEN6;
1062                 break;
1063         case CS7:
1064                 lcr |= UART_LCR_WLEN7;
1065                 break;
1066         default:
1067                 lcr |= UART_LCR_WLEN8;
1068                 break;
1069         }
1070
1071         /* Stop bits */
1072         if (termios->c_cflag & CSTOPB)
1073                 lcr |= UART_LCR_STOP;
1074         else
1075                 lcr &= ~UART_LCR_STOP;
1076
1077         uart_writeb(t, lcr, UART_LCR);
1078         t->lcr_shadow = lcr;
1079
1080         /* Baud rate. */
1081         baud = uart_get_baud_rate(u, termios, oldtermios, 200, 4000000);
1082         tegra_set_baudrate(t, baud);
1083
1084         /* Flow control */
1085         if (termios->c_cflag & CRTSCTS) {
1086                 mcr = t->mcr_shadow;
1087                 mcr |= UART_MCR_CTS_EN;
1088                 mcr &= ~UART_MCR_RTS_EN;
1089                 t->mcr_shadow = mcr;
1090                 uart_writeb(t, mcr, UART_MCR);
1091                 t->use_cts_control = true;
1092                 /* if top layer has asked to set rts active then do so here */
1093                 if (t->rts_active)
1094                         set_rts(t, true);
1095         } else {
1096                 mcr = t->mcr_shadow;
1097                 mcr &= ~UART_MCR_CTS_EN;
1098                 mcr &= ~UART_MCR_RTS_EN;
1099                 t->mcr_shadow = mcr;
1100                 uart_writeb(t, mcr, UART_MCR);
1101                 t->use_cts_control = false;
1102         }
1103
1104         /* update the port timeout based on new settings */
1105         uart_update_timeout(u, termios->c_cflag, baud);
1106
1107         spin_unlock_irqrestore(&u->lock, flags);
1108         dev_vdbg(t->uport.dev, "-tegra_set_termios\n");
1109         return;
1110 }
1111
1112 /*
1113  * Flush any TX data submitted for DMA. Called when the TX circular
1114  * buffer is reset.
1115  */
1116 static void tegra_flush_buffer(struct uart_port *u)
1117 {
1118         struct tegra_uart_port *t;
1119
1120         dev_vdbg(u->dev, "%s called", __func__);
1121
1122         t = container_of(u, struct tegra_uart_port, uport);
1123
1124         if (t->use_tx_dma) {
1125                 tegra_dma_dequeue_req(t->tx_dma, &t->tx_dma_req);
1126                 t->tx_dma_req.size = 0;
1127         }
1128         return;
1129 }
1130
1131
1132 static void tegra_pm(struct uart_port *u, unsigned int state,
1133         unsigned int oldstate)
1134 {
1135
1136 }
1137
1138 static const char *tegra_type(struct uart_port *u)
1139 {
1140         return 0;
1141 }
1142
1143 static struct uart_ops tegra_uart_ops = {
1144         .tx_empty       = tegra_tx_empty,
1145         .set_mctrl      = tegra_set_mctrl,
1146         .get_mctrl      = tegra_get_mctrl,
1147         .stop_tx        = tegra_stop_tx,
1148         .start_tx       = tegra_start_tx,
1149         .stop_rx        = tegra_stop_rx,
1150         .flush_buffer   = tegra_flush_buffer,
1151         .enable_ms      = tegra_enable_ms,
1152         .break_ctl      = tegra_break_ctl,
1153         .startup        = tegra_startup,
1154         .shutdown       = tegra_shutdown,
1155         .set_termios    = tegra_set_termios,
1156         .pm             = tegra_pm,
1157         .type           = tegra_type,
1158         .request_port   = tegra_request_port,
1159         .release_port   = tegra_release_port,
1160 };
1161
1162 static int tegra_uart_probe(struct platform_device *pdev);
1163 static int __devexit tegra_uart_remove(struct platform_device *pdev);
1164 static int tegra_uart_suspend(struct platform_device *pdev, pm_message_t state);
1165 static int tegra_uart_resume(struct platform_device *pdev);
1166
1167 static struct platform_driver tegra_uart_platform_driver = {
1168         .remove         = tegra_uart_remove,
1169         .probe          = tegra_uart_probe,
1170         .suspend        = tegra_uart_suspend,
1171         .resume         = tegra_uart_resume,
1172         .driver         = {
1173                 .name   = "tegra_uart"
1174         }
1175 };
1176
1177 static struct uart_driver tegra_uart_driver =
1178 {
1179         .owner          = THIS_MODULE,
1180         .driver_name    = "tegra_uart",
1181         .dev_name       = "ttyHS",
1182         .cons           = 0,
1183         .nr             = 5,
1184 };
1185
1186 static int tegra_uart_suspend(struct platform_device *pdev, pm_message_t state)
1187 {
1188         struct tegra_uart_port *t = platform_get_drvdata(pdev);
1189         struct uart_port *u;
1190
1191         if (pdev->id < 0 || pdev->id > tegra_uart_driver.nr)
1192                 pr_err("Invalid Uart instance (%d)\n", pdev->id);
1193
1194         u = &t->uport;
1195         dev_dbg(t->uport.dev, "tegra_uart_suspend called\n");
1196
1197         /* enable clock before calling suspend so that controller
1198            register can be accessible */
1199         if (t->uart_state == TEGRA_UART_CLOCK_OFF) {
1200                 clk_enable(t->clk);
1201                 t->uart_state = TEGRA_UART_OPENED;
1202         }
1203
1204         uart_suspend_port(&tegra_uart_driver, u);
1205         t->uart_state = TEGRA_UART_SUSPEND;
1206
1207         return 0;
1208 }
1209
1210 static int tegra_uart_resume(struct platform_device *pdev)
1211 {
1212         struct tegra_uart_port *t = platform_get_drvdata(pdev);
1213         struct uart_port *u;
1214
1215         if (pdev->id < 0 || pdev->id > tegra_uart_driver.nr)
1216                 pr_err("Invalid Uart instance (%d)\n", pdev->id);
1217
1218         u = &t->uport;
1219         dev_dbg(t->uport.dev, "tegra_uart_resume called\n");
1220
1221         if (t->uart_state == TEGRA_UART_SUSPEND) {
1222                 uart_resume_port(&tegra_uart_driver, u);
1223         }
1224         return 0;
1225 }
1226
1227
1228
1229 static int __devexit tegra_uart_remove(struct platform_device *pdev)
1230 {
1231         struct tegra_uart_port *t = platform_get_drvdata(pdev);
1232         struct uart_port *u;
1233
1234         if (pdev->id < 0 || pdev->id > tegra_uart_driver.nr)
1235                 pr_err("Invalid Uart instance (%d)\n", pdev->id);
1236
1237         u = &t->uport;
1238         uart_remove_one_port(&tegra_uart_driver, u);
1239
1240         platform_set_drvdata(pdev, NULL);
1241
1242         pr_info("Unregistered UART port %s%d\n",
1243                 tegra_uart_driver.dev_name, u->line);
1244         kfree(t);
1245         return 0;
1246 }
1247
1248 static int tegra_uart_probe(struct platform_device *pdev)
1249 {
1250         struct tegra_uart_port *t;
1251         struct uart_port *u;
1252         struct resource *resource;
1253         int ret;
1254         char name[64];
1255         if (pdev->id < 0 || pdev->id > tegra_uart_driver.nr) {
1256                 pr_err("Invalid Uart instance (%d)\n", pdev->id);
1257                 return -ENODEV;
1258         }
1259
1260         t = kzalloc(sizeof(struct tegra_uart_port), GFP_KERNEL);
1261         if (!t) {
1262                 pr_err("%s: Failed to allocate memory\n", __func__);
1263                 return -ENOMEM;
1264         }
1265         u = &t->uport;
1266         u->dev = &pdev->dev;
1267         platform_set_drvdata(pdev, u);
1268         u->line = pdev->id;
1269         u->ops = &tegra_uart_ops;
1270         u->type = ~PORT_UNKNOWN;
1271         u->fifosize = 32;
1272
1273         resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1274         if (unlikely(!resource))
1275                 return -ENXIO;
1276
1277         u->mapbase = resource->start;
1278         u->membase = IO_ADDRESS(u->mapbase);
1279         if (unlikely(!u->membase))
1280                 return -ENOMEM;
1281
1282         u->irq = platform_get_irq(pdev, 0);
1283         if (unlikely(u->irq < 0))
1284                 return -ENXIO;
1285
1286         u->regshift = 2;
1287
1288         t->clk = clk_get(&pdev->dev, NULL);
1289         if (!t->clk) {
1290                 dev_err(&pdev->dev, "Couldn't get the clock\n");
1291                 goto fail;
1292         }
1293
1294         ret = uart_add_one_port(&tegra_uart_driver, u);
1295         if (ret) {
1296                 pr_err("%s: Failed(%d) to add uart port %s%d\n",
1297                         __func__, ret, tegra_uart_driver.dev_name, u->line);
1298                 kfree(t);
1299                 platform_set_drvdata(pdev, NULL);
1300                 return ret;
1301         }
1302
1303         snprintf(name, sizeof(name), "tegra_hsuart_%d", u->line);
1304         pr_info("Registered UART port %s%d\n",
1305                 tegra_uart_driver.dev_name, u->line);
1306         t->uart_state = TEGRA_UART_CLOSED;
1307         return ret;
1308 fail:
1309         kfree(t);
1310         return -ENODEV;
1311 }
1312
1313 /* Switch off the clock of the uart controller. */
1314 void tegra_uart_request_clock_off(struct uart_port *uport)
1315 {
1316         unsigned long flags;
1317         struct tegra_uart_port *t;
1318
1319         if (IS_ERR_OR_NULL(uport))
1320                 BUG();
1321
1322         dev_vdbg(uport->dev, "tegra_uart_request_clock_off");
1323
1324         t = container_of(uport, struct tegra_uart_port, uport);
1325         spin_lock_irqsave(&uport->lock, flags);
1326         if (t->uart_state == TEGRA_UART_OPENED) {
1327                 clk_disable(t->clk);
1328                 t->uart_state = TEGRA_UART_CLOCK_OFF;
1329         }
1330         spin_unlock_irqrestore(&uport->lock, flags);
1331         return;
1332 }
1333
1334 /* Switch on the clock of the uart controller */
1335 void tegra_uart_request_clock_on(struct uart_port *uport)
1336 {
1337         unsigned long flags;
1338         struct tegra_uart_port *t;
1339
1340         if (IS_ERR_OR_NULL(uport))
1341                 BUG();
1342
1343         t = container_of(uport, struct tegra_uart_port, uport);
1344         spin_lock_irqsave(&uport->lock, flags);
1345         if (t->uart_state == TEGRA_UART_CLOCK_OFF) {
1346                 clk_enable(t->clk);
1347                 t->uart_state = TEGRA_UART_OPENED;
1348         }
1349         spin_unlock_irqrestore(&uport->lock, flags);
1350         return;
1351 }
1352
1353 /* Set the modem control signals state of uart controller. */
1354 void tegra_uart_set_mctrl(struct uart_port *uport, unsigned int mctrl)
1355 {
1356         unsigned long flags;
1357         struct tegra_uart_port *t;
1358
1359         t = container_of(uport, struct tegra_uart_port, uport);
1360         spin_lock_irqsave(&uport->lock, flags);
1361         if (mctrl & TIOCM_RTS) {
1362                 t->rts_active = true;
1363                 set_rts(t, true);
1364         } else {
1365                 t->rts_active = false;
1366                 set_rts(t, false);
1367         }
1368
1369         if (mctrl & TIOCM_DTR)
1370                 set_dtr(t, true);
1371         else
1372                 set_dtr(t, false);
1373         spin_unlock_irqrestore(&uport->lock, flags);
1374         return;
1375 }
1376
1377 /* Return the status of the transmit fifo whether empty or not.
1378  * Return 0 if tx fifo is not empty.
1379  * Return TIOCSER_TEMT if tx fifo is empty.
1380  */
1381 int tegra_uart_is_tx_empty(struct uart_port *uport)
1382 {
1383         return tegra_tx_empty(uport);
1384 }
1385
1386 static int __init tegra_uart_init(void)
1387 {
1388         int ret;
1389
1390         ret = uart_register_driver(&tegra_uart_driver);
1391         if (unlikely(ret)) {
1392                 pr_err("Could not register %s driver\n",
1393                         tegra_uart_driver.driver_name);
1394                 return ret;
1395         }
1396
1397         ret = platform_driver_register(&tegra_uart_platform_driver);
1398         if (unlikely(ret)) {
1399                 pr_err("Could not register the UART platfrom "
1400                         "driver\n");
1401                 uart_unregister_driver(&tegra_uart_driver);
1402                 return ret;
1403         }
1404
1405         pr_info("Initialized tegra uart driver\n");
1406         return 0;
1407 }
1408
1409 static void __exit tegra_uart_exit(void)
1410 {
1411         pr_info("Unloading tegra uart driver\n");
1412         platform_driver_unregister(&tegra_uart_platform_driver);
1413         uart_unregister_driver(&tegra_uart_driver);
1414 }
1415
1416 module_init(tegra_uart_init);
1417 module_exit(tegra_uart_exit);
1418 MODULE_DESCRIPTION("High speed UART driver for tegra chipset");