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