drivers/tty/serial/serial-tegra.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * serial_tegra.c
   4  *
   5  * High-speed serial driver for NVIDIA Tegra SoCs
   6  *
   7  * Copyright (c) 2012-2013, NVIDIA CORPORATION.  All rights reserved.
   8  *
   9  * Author: Laxman Dewangan <ldewangan@nvidia.com>
  10  */
  11
  12 #include <linux/clk.h>
  13 #include <linux/debugfs.h>
  14 #include <linux/delay.h>
  15 #include <linux/dmaengine.h>
  16 #include <linux/dma-mapping.h>
  17 #include <linux/dmapool.h>
  18 #include <linux/err.h>
  19 #include <linux/io.h>
  20 #include <linux/irq.h>
  21 #include <linux/module.h>
  22 #include <linux/of.h>
  23 #include <linux/of_device.h>
  24 #include <linux/pagemap.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/reset.h>
  27 #include <linux/serial.h>
  28 #include <linux/serial_8250.h>
  29 #include <linux/serial_core.h>
  30 #include <linux/serial_reg.h>
  31 #include <linux/slab.h>
  32 #include <linux/string.h>
  33 #include <linux/termios.h>
  34 #include <linux/tty.h>
  35 #include <linux/tty_flip.h>
  36
  37 #define TEGRA_UART_TYPE                         "TEGRA_UART"
  38 #define TX_EMPTY_STATUS                         (UART_LSR_TEMT | UART_LSR_THRE)
  39 #define BYTES_TO_ALIGN(x)                       ((unsigned long)(x) & 0x3)
  40
  41 #define TEGRA_UART_RX_DMA_BUFFER_SIZE           4096
  42 #define TEGRA_UART_LSR_TXFIFO_FULL              0x100
  43 #define TEGRA_UART_IER_EORD                     0x20
  44 #define TEGRA_UART_MCR_RTS_EN                   0x40
  45 #define TEGRA_UART_MCR_CTS_EN                   0x20
  46 #define TEGRA_UART_LSR_ANY                      (UART_LSR_OE | UART_LSR_BI | \
  47                                                 UART_LSR_PE | UART_LSR_FE)
  48 #define TEGRA_UART_IRDA_CSR                     0x08
  49 #define TEGRA_UART_SIR_ENABLED                  0x80
  50
  51 #define TEGRA_UART_TX_PIO                       1
  52 #define TEGRA_UART_TX_DMA                       2
  53 #define TEGRA_UART_MIN_DMA                      16
  54 #define TEGRA_UART_FIFO_SIZE                    32
  55
  56 /*
  57  * Tx fifo trigger level setting in tegra uart is in
  58  * reverse way then conventional uart.
  59  */
  60 #define TEGRA_UART_TX_TRIG_16B                  0x00
  61 #define TEGRA_UART_TX_TRIG_8B                   0x10
  62 #define TEGRA_UART_TX_TRIG_4B                   0x20
  63 #define TEGRA_UART_TX_TRIG_1B                   0x30
  64
  65 #define TEGRA_UART_MAXIMUM                      5
  66
  67 /* Default UART setting when started: 115200 no parity, stop, 8 data bits */
  68 #define TEGRA_UART_DEFAULT_BAUD                 115200
  69 #define TEGRA_UART_DEFAULT_LSR                  UART_LCR_WLEN8
  70
  71 /* Tx transfer mode */
  72 #define TEGRA_TX_PIO                            1
  73 #define TEGRA_TX_DMA                            2
  74
  75 /**
  76  * tegra_uart_chip_data: SOC specific data.
  77  *
  78  * @tx_fifo_full_status: Status flag available for checking tx fifo full.
  79  * @allow_txfifo_reset_fifo_mode: allow_tx fifo reset with fifo mode or not.
  80  *                      Tegra30 does not allow this.
  81  * @support_clk_src_div: Clock source support the clock divider.
  82  */
  83 struct tegra_uart_chip_data {
  84         bool    tx_fifo_full_status;
  85         bool    allow_txfifo_reset_fifo_mode;
  86         bool    support_clk_src_div;
  87 };
  88
  89 struct tegra_uart_port {
  90         struct uart_port                        uport;
  91         const struct tegra_uart_chip_data       *cdata;
  92
  93         struct clk                              *uart_clk;
  94         struct reset_control                    *rst;
  95         unsigned int                            current_baud;
  96
  97         /* Register shadow */
  98         unsigned long                           fcr_shadow;
  99         unsigned long                           mcr_shadow;
 100         unsigned long                           lcr_shadow;
 101         unsigned long                           ier_shadow;
 102         bool                                    rts_active;
 103
 104         int                                     tx_in_progress;
 105         unsigned int                            tx_bytes;
 106
 107         bool                                    enable_modem_interrupt;
 108
 109         bool                                    rx_timeout;
 110         int                                     rx_in_progress;
 111         int                                     symb_bit;
 112
 113         struct dma_chan                         *rx_dma_chan;
 114         struct dma_chan                         *tx_dma_chan;
 115         dma_addr_t                              rx_dma_buf_phys;
 116         dma_addr_t                              tx_dma_buf_phys;
 117         unsigned char                           *rx_dma_buf_virt;
 118         unsigned char                           *tx_dma_buf_virt;
 119         struct dma_async_tx_descriptor          *tx_dma_desc;
 120         struct dma_async_tx_descriptor          *rx_dma_desc;
 121         dma_cookie_t                            tx_cookie;
 122         dma_cookie_t                            rx_cookie;
 123         unsigned int                            tx_bytes_requested;
 124         unsigned int                            rx_bytes_requested;
 125 };
 126
 127 static void tegra_uart_start_next_tx(struct tegra_uart_port *tup);
 128 static int tegra_uart_start_rx_dma(struct tegra_uart_port *tup);
 129
 130 static inline unsigned long tegra_uart_read(struct tegra_uart_port *tup,
 131                 unsigned long reg)
 132 {
 133         return readl(tup->uport.membase + (reg << tup->uport.regshift));
 134 }
 135
 136 static inline void tegra_uart_write(struct tegra_uart_port *tup, unsigned val,
 137         unsigned long reg)
 138 {
 139         writel(val, tup->uport.membase + (reg << tup->uport.regshift));
 140 }
 141
 142 static inline struct tegra_uart_port *to_tegra_uport(struct uart_port *u)
 143 {
 144         return container_of(u, struct tegra_uart_port, uport);
 145 }
 146
 147 static unsigned int tegra_uart_get_mctrl(struct uart_port *u)
 148 {
 149         struct tegra_uart_port *tup = to_tegra_uport(u);
 150
 151         /*
 152          * RI - Ring detector is active
 153          * CD/DCD/CAR - Carrier detect is always active. For some reason
 154          *      linux has different names for carrier detect.
 155          * DSR - Data Set ready is active as the hardware doesn't support it.
 156          *      Don't know if the linux support this yet?
 157          * CTS - Clear to send. Always set to active, as the hardware handles
 158          *      CTS automatically.
 159          */
 160         if (tup->enable_modem_interrupt)
 161                 return TIOCM_RI | TIOCM_CD | TIOCM_DSR | TIOCM_CTS;
 162         return TIOCM_CTS;
 163 }
 164
 165 static void set_rts(struct tegra_uart_port *tup, bool active)
 166 {
 167         unsigned long mcr;
 168
 169         mcr = tup->mcr_shadow;
 170         if (active)
 171                 mcr |= TEGRA_UART_MCR_RTS_EN;
 172         else
 173                 mcr &= ~TEGRA_UART_MCR_RTS_EN;
 174         if (mcr != tup->mcr_shadow) {
 175                 tegra_uart_write(tup, mcr, UART_MCR);
 176                 tup->mcr_shadow = mcr;
 177         }
 178 }
 179
 180 static void set_dtr(struct tegra_uart_port *tup, bool active)
 181 {
 182         unsigned long mcr;
 183
 184         mcr = tup->mcr_shadow;
 185         if (active)
 186                 mcr |= UART_MCR_DTR;
 187         else
 188                 mcr &= ~UART_MCR_DTR;
 189         if (mcr != tup->mcr_shadow) {
 190                 tegra_uart_write(tup, mcr, UART_MCR);
 191                 tup->mcr_shadow = mcr;
 192         }
 193 }
 194
 195 static void tegra_uart_set_mctrl(struct uart_port *u, unsigned int mctrl)
 196 {
 197         struct tegra_uart_port *tup = to_tegra_uport(u);
 198         int dtr_enable;
 199
 200         tup->rts_active = !!(mctrl & TIOCM_RTS);
 201         set_rts(tup, tup->rts_active);
 202
 203         dtr_enable = !!(mctrl & TIOCM_DTR);
 204         set_dtr(tup, dtr_enable);
 205 }
 206
 207 static void tegra_uart_break_ctl(struct uart_port *u, int break_ctl)
 208 {
 209         struct tegra_uart_port *tup = to_tegra_uport(u);
 210         unsigned long lcr;
 211
 212         lcr = tup->lcr_shadow;
 213         if (break_ctl)
 214                 lcr |= UART_LCR_SBC;
 215         else
 216                 lcr &= ~UART_LCR_SBC;
 217         tegra_uart_write(tup, lcr, UART_LCR);
 218         tup->lcr_shadow = lcr;
 219 }
 220
 221 /**
 222  * tegra_uart_wait_cycle_time: Wait for N UART clock periods
 223  *
 224  * @tup:        Tegra serial port data structure.
 225  * @cycles:     Number of clock periods to wait.
 226  *
 227  * Tegra UARTs are clocked at 16X the baud/bit rate and hence the UART
 228  * clock speed is 16X the current baud rate.
 229  */
 230 static void tegra_uart_wait_cycle_time(struct tegra_uart_port *tup,
 231                                        unsigned int cycles)
 232 {
 233         if (tup->current_baud)
 234                 udelay(DIV_ROUND_UP(cycles * 1000000, tup->current_baud * 16));
 235 }
 236
 237 /* Wait for a symbol-time. */
 238 static void tegra_uart_wait_sym_time(struct tegra_uart_port *tup,
 239                 unsigned int syms)
 240 {
 241         if (tup->current_baud)
 242                 udelay(DIV_ROUND_UP(syms * tup->symb_bit * 1000000,
 243                         tup->current_baud));
 244 }
 245
 246 static void tegra_uart_fifo_reset(struct tegra_uart_port *tup, u8 fcr_bits)
 247 {
 248         unsigned long fcr = tup->fcr_shadow;
 249
 250         if (tup->cdata->allow_txfifo_reset_fifo_mode) {
 251                 fcr |= fcr_bits & (UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
 252                 tegra_uart_write(tup, fcr, UART_FCR);
 253         } else {
 254                 fcr &= ~UART_FCR_ENABLE_FIFO;
 255                 tegra_uart_write(tup, fcr, UART_FCR);
 256                 udelay(60);
 257                 fcr |= fcr_bits & (UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
 258                 tegra_uart_write(tup, fcr, UART_FCR);
 259                 fcr |= UART_FCR_ENABLE_FIFO;
 260                 tegra_uart_write(tup, fcr, UART_FCR);
 261         }
 262
 263         /* Dummy read to ensure the write is posted */
 264         tegra_uart_read(tup, UART_SCR);
 265
 266         /*
 267          * For all tegra devices (up to t210), there is a hardware issue that
 268          * requires software to wait for 32 UART clock periods for the flush
 269          * to propagate, otherwise data could be lost.
 270          */
 271         tegra_uart_wait_cycle_time(tup, 32);
 272 }
 273
 274 static int tegra_set_baudrate(struct tegra_uart_port *tup, unsigned int baud)
 275 {
 276         unsigned long rate;
 277         unsigned int divisor;
 278         unsigned long lcr;
 279         int ret;
 280
 281         if (tup->current_baud == baud)
 282                 return 0;
 283
 284         if (tup->cdata->support_clk_src_div) {
 285                 rate = baud * 16;
 286                 ret = clk_set_rate(tup->uart_clk, rate);
 287                 if (ret < 0) {
 288                         dev_err(tup->uport.dev,
 289                                 "clk_set_rate() failed for rate %lu\n", rate);
 290                         return ret;
 291                 }
 292                 divisor = 1;
 293         } else {
 294                 rate = clk_get_rate(tup->uart_clk);
 295                 divisor = DIV_ROUND_CLOSEST(rate, baud * 16);
 296         }
 297
 298         lcr = tup->lcr_shadow;
 299         lcr |= UART_LCR_DLAB;
 300         tegra_uart_write(tup, lcr, UART_LCR);
 301
 302         tegra_uart_write(tup, divisor & 0xFF, UART_TX);
 303         tegra_uart_write(tup, ((divisor >> 8) & 0xFF), UART_IER);
 304
 305         lcr &= ~UART_LCR_DLAB;
 306         tegra_uart_write(tup, lcr, UART_LCR);
 307
 308         /* Dummy read to ensure the write is posted */
 309         tegra_uart_read(tup, UART_SCR);
 310
 311         tup->current_baud = baud;
 312
 313         /* wait two character intervals at new rate */
 314         tegra_uart_wait_sym_time(tup, 2);
 315         return 0;
 316 }
 317
 318 static char tegra_uart_decode_rx_error(struct tegra_uart_port *tup,
 319                         unsigned long lsr)
 320 {
 321         char flag = TTY_NORMAL;
 322
 323         if (unlikely(lsr & TEGRA_UART_LSR_ANY)) {
 324                 if (lsr & UART_LSR_OE) {
 325                         /* Overrrun error */
 326                         flag = TTY_OVERRUN;
 327                         tup->uport.icount.overrun++;
 328                         dev_err(tup->uport.dev, "Got overrun errors\n");
 329                 } else if (lsr & UART_LSR_PE) {
 330                         /* Parity error */
 331                         flag = TTY_PARITY;
 332                         tup->uport.icount.parity++;
 333                         dev_err(tup->uport.dev, "Got Parity errors\n");
 334                 } else if (lsr & UART_LSR_FE) {
 335                         flag = TTY_FRAME;
 336                         tup->uport.icount.frame++;
 337                         dev_err(tup->uport.dev, "Got frame errors\n");
 338                 } else if (lsr & UART_LSR_BI) {
 339                         dev_err(tup->uport.dev, "Got Break\n");
 340                         tup->uport.icount.brk++;
 341                         /* If FIFO read error without any data, reset Rx FIFO */
 342                         if (!(lsr & UART_LSR_DR) && (lsr & UART_LSR_FIFOE))
 343                                 tegra_uart_fifo_reset(tup, UART_FCR_CLEAR_RCVR);
 344                 }
 345         }
 346         return flag;
 347 }
 348
 349 static int tegra_uart_request_port(struct uart_port *u)
 350 {
 351         return 0;
 352 }
 353
 354 static void tegra_uart_release_port(struct uart_port *u)
 355 {
 356         /* Nothing to do here */
 357 }
 358
 359 static void tegra_uart_fill_tx_fifo(struct tegra_uart_port *tup, int max_bytes)
 360 {
 361         struct circ_buf *xmit = &tup->uport.state->xmit;
 362         int i;
 363
 364         for (i = 0; i < max_bytes; i++) {
 365                 BUG_ON(uart_circ_empty(xmit));
 366                 if (tup->cdata->tx_fifo_full_status) {
 367                         unsigned long lsr = tegra_uart_read(tup, UART_LSR);
 368                         if ((lsr & TEGRA_UART_LSR_TXFIFO_FULL))
 369                                 break;
 370                 }
 371                 tegra_uart_write(tup, xmit->buf[xmit->tail], UART_TX);
 372                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 373                 tup->uport.icount.tx++;
 374         }
 375 }
 376
 377 static void tegra_uart_start_pio_tx(struct tegra_uart_port *tup,
 378                 unsigned int bytes)
 379 {
 380         if (bytes > TEGRA_UART_MIN_DMA)
 381                 bytes = TEGRA_UART_MIN_DMA;
 382
 383         tup->tx_in_progress = TEGRA_UART_TX_PIO;
 384         tup->tx_bytes = bytes;
 385         tup->ier_shadow |= UART_IER_THRI;
 386         tegra_uart_write(tup, tup->ier_shadow, UART_IER);
 387 }
 388
 389 static void tegra_uart_tx_dma_complete(void *args)
 390 {
 391         struct tegra_uart_port *tup = args;
 392         struct circ_buf *xmit = &tup->uport.state->xmit;
 393         struct dma_tx_state state;
 394         unsigned long flags;
 395         unsigned int count;
 396
 397         dmaengine_tx_status(tup->tx_dma_chan, tup->tx_cookie, &state);
 398         count = tup->tx_bytes_requested - state.residue;
 399         async_tx_ack(tup->tx_dma_desc);
 400         spin_lock_irqsave(&tup->uport.lock, flags);
 401         uart_xmit_advance(&tup->uport, count);
 402         tup->tx_in_progress = 0;
 403         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 404                 uart_write_wakeup(&tup->uport);
 405         tegra_uart_start_next_tx(tup);
 406         spin_unlock_irqrestore(&tup->uport.lock, flags);
 407 }
 408
 409 static int tegra_uart_start_tx_dma(struct tegra_uart_port *tup,
 410                 unsigned long count)
 411 {
 412         struct circ_buf *xmit = &tup->uport.state->xmit;
 413         dma_addr_t tx_phys_addr;
 414
 415         dma_sync_single_for_device(tup->uport.dev, tup->tx_dma_buf_phys,
 416                                 UART_XMIT_SIZE, DMA_TO_DEVICE);
 417
 418         tup->tx_bytes = count & ~(0xF);
 419         tx_phys_addr = tup->tx_dma_buf_phys + xmit->tail;
 420         tup->tx_dma_desc = dmaengine_prep_slave_single(tup->tx_dma_chan,
 421                                 tx_phys_addr, tup->tx_bytes, DMA_MEM_TO_DEV,
 422                                 DMA_PREP_INTERRUPT);
 423         if (!tup->tx_dma_desc) {
 424                 dev_err(tup->uport.dev, "Not able to get desc for Tx\n");
 425                 return -EIO;
 426         }
 427
 428         tup->tx_dma_desc->callback = tegra_uart_tx_dma_complete;
 429         tup->tx_dma_desc->callback_param = tup;
 430         tup->tx_in_progress = TEGRA_UART_TX_DMA;
 431         tup->tx_bytes_requested = tup->tx_bytes;
 432         tup->tx_cookie = dmaengine_submit(tup->tx_dma_desc);
 433         dma_async_issue_pending(tup->tx_dma_chan);
 434         return 0;
 435 }
 436
 437 static void tegra_uart_start_next_tx(struct tegra_uart_port *tup)
 438 {
 439         unsigned long tail;
 440         unsigned long count;
 441         struct circ_buf *xmit = &tup->uport.state->xmit;
 442
 443         tail = (unsigned long)&xmit->buf[xmit->tail];
 444         count = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
 445         if (!count)
 446                 return;
 447
 448         if (count < TEGRA_UART_MIN_DMA)
 449                 tegra_uart_start_pio_tx(tup, count);
 450         else if (BYTES_TO_ALIGN(tail) > 0)
 451                 tegra_uart_start_pio_tx(tup, BYTES_TO_ALIGN(tail));
 452         else
 453                 tegra_uart_start_tx_dma(tup, count);
 454 }
 455
 456 /* Called by serial core driver with u->lock taken. */
 457 static void tegra_uart_start_tx(struct uart_port *u)
 458 {
 459         struct tegra_uart_port *tup = to_tegra_uport(u);
 460         struct circ_buf *xmit = &u->state->xmit;
 461
 462         if (!uart_circ_empty(xmit) && !tup->tx_in_progress)
 463                 tegra_uart_start_next_tx(tup);
 464 }
 465
 466 static unsigned int tegra_uart_tx_empty(struct uart_port *u)
 467 {
 468         struct tegra_uart_port *tup = to_tegra_uport(u);
 469         unsigned int ret = 0;
 470         unsigned long flags;
 471
 472         spin_lock_irqsave(&u->lock, flags);
 473         if (!tup->tx_in_progress) {
 474                 unsigned long lsr = tegra_uart_read(tup, UART_LSR);
 475                 if ((lsr & TX_EMPTY_STATUS) == TX_EMPTY_STATUS)
 476                         ret = TIOCSER_TEMT;
 477         }
 478         spin_unlock_irqrestore(&u->lock, flags);
 479         return ret;
 480 }
 481
 482 static void tegra_uart_stop_tx(struct uart_port *u)
 483 {
 484         struct tegra_uart_port *tup = to_tegra_uport(u);
 485         struct dma_tx_state state;
 486         unsigned int count;
 487
 488         if (tup->tx_in_progress != TEGRA_UART_TX_DMA)
 489                 return;
 490
 491         dmaengine_terminate_all(tup->tx_dma_chan);
 492         dmaengine_tx_status(tup->tx_dma_chan, tup->tx_cookie, &state);
 493         count = tup->tx_bytes_requested - state.residue;
 494         async_tx_ack(tup->tx_dma_desc);
 495         uart_xmit_advance(&tup->uport, count);
 496         tup->tx_in_progress = 0;
 497 }
 498
 499 static void tegra_uart_handle_tx_pio(struct tegra_uart_port *tup)
 500 {
 501         struct circ_buf *xmit = &tup->uport.state->xmit;
 502
 503         tegra_uart_fill_tx_fifo(tup, tup->tx_bytes);
 504         tup->tx_in_progress = 0;
 505         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 506                 uart_write_wakeup(&tup->uport);
 507         tegra_uart_start_next_tx(tup);
 508 }
 509
 510 static void tegra_uart_handle_rx_pio(struct tegra_uart_port *tup,
 511                 struct tty_port *tty)
 512 {
 513         do {
 514                 char flag = TTY_NORMAL;
 515                 unsigned long lsr = 0;
 516                 unsigned char ch;
 517
 518                 lsr = tegra_uart_read(tup, UART_LSR);
 519                 if (!(lsr & UART_LSR_DR))
 520                         break;
 521
 522                 flag = tegra_uart_decode_rx_error(tup, lsr);
 523                 ch = (unsigned char) tegra_uart_read(tup, UART_RX);
 524                 tup->uport.icount.rx++;
 525
 526                 if (!uart_handle_sysrq_char(&tup->uport, ch) && tty)
 527                         tty_insert_flip_char(tty, ch, flag);
 528         } while (1);
 529 }
 530
 531 static void tegra_uart_copy_rx_to_tty(struct tegra_uart_port *tup,
 532                                       struct tty_port *tty,
 533                                       unsigned int count)
 534 {
 535         int copied;
 536
 537         /* If count is zero, then there is no data to be copied */
 538         if (!count)
 539                 return;
 540
 541         tup->uport.icount.rx += count;
 542         if (!tty) {
 543                 dev_err(tup->uport.dev, "No tty port\n");
 544                 return;
 545         }
 546         dma_sync_single_for_cpu(tup->uport.dev, tup->rx_dma_buf_phys,
 547                                 TEGRA_UART_RX_DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
 548         copied = tty_insert_flip_string(tty,
 549                         ((unsigned char *)(tup->rx_dma_buf_virt)), count);
 550         if (copied != count) {
 551                 WARN_ON(1);
 552                 dev_err(tup->uport.dev, "RxData copy to tty layer failed\n");
 553         }
 554         dma_sync_single_for_device(tup->uport.dev, tup->rx_dma_buf_phys,
 555                                 TEGRA_UART_RX_DMA_BUFFER_SIZE, DMA_TO_DEVICE);
 556 }
 557
 558 static void tegra_uart_rx_buffer_push(struct tegra_uart_port *tup,
 559                                       unsigned int residue)
 560 {
 561         struct tty_port *port = &tup->uport.state->port;
 562         struct tty_struct *tty = tty_port_tty_get(port);
 563         unsigned int count;
 564
 565         async_tx_ack(tup->rx_dma_desc);
 566         count = tup->rx_bytes_requested - residue;
 567
 568         /* If we are here, DMA is stopped */
 569         tegra_uart_copy_rx_to_tty(tup, port, count);
 570
 571         tegra_uart_handle_rx_pio(tup, port);
 572         if (tty) {
 573                 tty_flip_buffer_push(port);
 574                 tty_kref_put(tty);
 575         }
 576 }
 577
 578 static void tegra_uart_rx_dma_complete(void *args)
 579 {
 580         struct tegra_uart_port *tup = args;
 581         struct uart_port *u = &tup->uport;
 582         unsigned long flags;
 583         struct dma_tx_state state;
 584         enum dma_status status;
 585
 586         spin_lock_irqsave(&u->lock, flags);
 587
 588         status = dmaengine_tx_status(tup->rx_dma_chan, tup->rx_cookie, &state);
 589
 590         if (status == DMA_IN_PROGRESS) {
 591                 dev_dbg(tup->uport.dev, "RX DMA is in progress\n");
 592                 goto done;
 593         }
 594
 595         /* Deactivate flow control to stop sender */
 596         if (tup->rts_active)
 597                 set_rts(tup, false);
 598
 599         tegra_uart_rx_buffer_push(tup, 0);
 600         tegra_uart_start_rx_dma(tup);
 601
 602         /* Activate flow control to start transfer */
 603         if (tup->rts_active)
 604                 set_rts(tup, true);
 605
 606 done:
 607         spin_unlock_irqrestore(&u->lock, flags);
 608 }
 609
 610 static void tegra_uart_handle_rx_dma(struct tegra_uart_port *tup)
 611 {
 612         struct dma_tx_state state;
 613
 614         /* Deactivate flow control to stop sender */
 615         if (tup->rts_active)
 616                 set_rts(tup, false);
 617
 618         dmaengine_terminate_all(tup->rx_dma_chan);
 619         dmaengine_tx_status(tup->rx_dma_chan, tup->rx_cookie, &state);
 620         tegra_uart_rx_buffer_push(tup, state.residue);
 621         tegra_uart_start_rx_dma(tup);
 622
 623         if (tup->rts_active)
 624                 set_rts(tup, true);
 625 }
 626
 627 static int tegra_uart_start_rx_dma(struct tegra_uart_port *tup)
 628 {
 629         unsigned int count = TEGRA_UART_RX_DMA_BUFFER_SIZE;
 630
 631         tup->rx_dma_desc = dmaengine_prep_slave_single(tup->rx_dma_chan,
 632                                 tup->rx_dma_buf_phys, count, DMA_DEV_TO_MEM,
 633                                 DMA_PREP_INTERRUPT);
 634         if (!tup->rx_dma_desc) {
 635                 dev_err(tup->uport.dev, "Not able to get desc for Rx\n");
 636                 return -EIO;
 637         }
 638
 639         tup->rx_dma_desc->callback = tegra_uart_rx_dma_complete;
 640         tup->rx_dma_desc->callback_param = tup;
 641         dma_sync_single_for_device(tup->uport.dev, tup->rx_dma_buf_phys,
 642                                 count, DMA_TO_DEVICE);
 643         tup->rx_bytes_requested = count;
 644         tup->rx_cookie = dmaengine_submit(tup->rx_dma_desc);
 645         dma_async_issue_pending(tup->rx_dma_chan);
 646         return 0;
 647 }
 648
 649 static void tegra_uart_handle_modem_signal_change(struct uart_port *u)
 650 {
 651         struct tegra_uart_port *tup = to_tegra_uport(u);
 652         unsigned long msr;
 653
 654         msr = tegra_uart_read(tup, UART_MSR);
 655         if (!(msr & UART_MSR_ANY_DELTA))
 656                 return;
 657
 658         if (msr & UART_MSR_TERI)
 659                 tup->uport.icount.rng++;
 660         if (msr & UART_MSR_DDSR)
 661                 tup->uport.icount.dsr++;
 662         /* We may only get DDCD when HW init and reset */
 663         if (msr & UART_MSR_DDCD)
 664                 uart_handle_dcd_change(&tup->uport, msr & UART_MSR_DCD);
 665         /* Will start/stop_tx accordingly */
 666         if (msr & UART_MSR_DCTS)
 667                 uart_handle_cts_change(&tup->uport, msr & UART_MSR_CTS);
 668 }
 669
 670 static irqreturn_t tegra_uart_isr(int irq, void *data)
 671 {
 672         struct tegra_uart_port *tup = data;
 673         struct uart_port *u = &tup->uport;
 674         unsigned long iir;
 675         unsigned long ier;
 676         bool is_rx_int = false;
 677         unsigned long flags;
 678
 679         spin_lock_irqsave(&u->lock, flags);
 680         while (1) {
 681                 iir = tegra_uart_read(tup, UART_IIR);
 682                 if (iir & UART_IIR_NO_INT) {
 683                         if (is_rx_int) {
 684                                 tegra_uart_handle_rx_dma(tup);
 685                                 if (tup->rx_in_progress) {
 686                                         ier = tup->ier_shadow;
 687                                         ier |= (UART_IER_RLSI | UART_IER_RTOIE |
 688                                                 TEGRA_UART_IER_EORD);
 689                                         tup->ier_shadow = ier;
 690                                         tegra_uart_write(tup, ier, UART_IER);
 691                                 }
 692                         }
 693                         spin_unlock_irqrestore(&u->lock, flags);
 694                         return IRQ_HANDLED;
 695                 }
 696
 697                 switch ((iir >> 1) & 0x7) {
 698                 case 0: /* Modem signal change interrupt */
 699                         tegra_uart_handle_modem_signal_change(u);
 700                         break;
 701
 702                 case 1: /* Transmit interrupt only triggered when using PIO */
 703                         tup->ier_shadow &= ~UART_IER_THRI;
 704                         tegra_uart_write(tup, tup->ier_shadow, UART_IER);
 705                         tegra_uart_handle_tx_pio(tup);
 706                         break;
 707
 708                 case 4: /* End of data */
 709                 case 6: /* Rx timeout */
 710                 case 2: /* Receive */
 711                         if (!is_rx_int) {
 712                                 is_rx_int = true;
 713                                 /* Disable Rx interrupts */
 714                                 ier = tup->ier_shadow;
 715                                 ier |= UART_IER_RDI;
 716                                 tegra_uart_write(tup, ier, UART_IER);
 717                                 ier &= ~(UART_IER_RDI | UART_IER_RLSI |
 718                                         UART_IER_RTOIE | TEGRA_UART_IER_EORD);
 719                                 tup->ier_shadow = ier;
 720                                 tegra_uart_write(tup, ier, UART_IER);
 721                         }
 722                         break;
 723
 724                 case 3: /* Receive error */
 725                         tegra_uart_decode_rx_error(tup,
 726                                         tegra_uart_read(tup, UART_LSR));
 727                         break;
 728
 729                 case 5: /* break nothing to handle */
 730                 case 7: /* break nothing to handle */
 731                         break;
 732                 }
 733         }
 734 }
 735
 736 static void tegra_uart_stop_rx(struct uart_port *u)
 737 {
 738         struct tegra_uart_port *tup = to_tegra_uport(u);
 739         struct dma_tx_state state;
 740         unsigned long ier;
 741
 742         if (tup->rts_active)
 743                 set_rts(tup, false);
 744
 745         if (!tup->rx_in_progress)
 746                 return;
 747
 748         tegra_uart_wait_sym_time(tup, 1); /* wait a character interval */
 749
 750         ier = tup->ier_shadow;
 751         ier &= ~(UART_IER_RDI | UART_IER_RLSI | UART_IER_RTOIE |
 752                                         TEGRA_UART_IER_EORD);
 753         tup->ier_shadow = ier;
 754         tegra_uart_write(tup, ier, UART_IER);
 755         tup->rx_in_progress = 0;
 756         dmaengine_terminate_all(tup->rx_dma_chan);
 757         dmaengine_tx_status(tup->rx_dma_chan, tup->rx_cookie, &state);
 758         tegra_uart_rx_buffer_push(tup, state.residue);
 759 }
 760
 761 static void tegra_uart_hw_deinit(struct tegra_uart_port *tup)
 762 {
 763         unsigned long flags;
 764         unsigned long char_time = DIV_ROUND_UP(10000000, tup->current_baud);
 765         unsigned long fifo_empty_time = tup->uport.fifosize * char_time;
 766         unsigned long wait_time;
 767         unsigned long lsr;
 768         unsigned long msr;
 769         unsigned long mcr;
 770
 771         /* Disable interrupts */
 772         tegra_uart_write(tup, 0, UART_IER);
 773
 774         lsr = tegra_uart_read(tup, UART_LSR);
 775         if ((lsr & UART_LSR_TEMT) != UART_LSR_TEMT) {
 776                 msr = tegra_uart_read(tup, UART_MSR);
 777                 mcr = tegra_uart_read(tup, UART_MCR);
 778                 if ((mcr & TEGRA_UART_MCR_CTS_EN) && (msr & UART_MSR_CTS))
 779                         dev_err(tup->uport.dev,
 780                                 "Tx Fifo not empty, CTS disabled, waiting\n");
 781
 782                 /* Wait for Tx fifo to be empty */
 783                 while ((lsr & UART_LSR_TEMT) != UART_LSR_TEMT) {
 784                         wait_time = min(fifo_empty_time, 100lu);
 785                         udelay(wait_time);
 786                         fifo_empty_time -= wait_time;
 787                         if (!fifo_empty_time) {
 788                                 msr = tegra_uart_read(tup, UART_MSR);
 789                                 mcr = tegra_uart_read(tup, UART_MCR);
 790                                 if ((mcr & TEGRA_UART_MCR_CTS_EN) &&
 791                                         (msr & UART_MSR_CTS))
 792                                         dev_err(tup->uport.dev,
 793                                                 "Slave not ready\n");
 794                                 break;
 795                         }
 796                         lsr = tegra_uart_read(tup, UART_LSR);
 797                 }
 798         }
 799
 800         spin_lock_irqsave(&tup->uport.lock, flags);
 801         /* Reset the Rx and Tx FIFOs */
 802         tegra_uart_fifo_reset(tup, UART_FCR_CLEAR_XMIT | UART_FCR_CLEAR_RCVR);
 803         tup->current_baud = 0;
 804         spin_unlock_irqrestore(&tup->uport.lock, flags);
 805
 806         clk_disable_unprepare(tup->uart_clk);
 807 }
 808
 809 static int tegra_uart_hw_init(struct tegra_uart_port *tup)
 810 {
 811         int ret;
 812
 813         tup->fcr_shadow = 0;
 814         tup->mcr_shadow = 0;
 815         tup->lcr_shadow = 0;
 816         tup->ier_shadow = 0;
 817         tup->current_baud = 0;
 818
 819         clk_prepare_enable(tup->uart_clk);
 820
 821         /* Reset the UART controller to clear all previous status.*/
 822         reset_control_assert(tup->rst);
 823         udelay(10);
 824         reset_control_deassert(tup->rst);
 825
 826         tup->rx_in_progress = 0;
 827         tup->tx_in_progress = 0;
 828
 829         /*
 830          * Set the trigger level
 831          *
 832          * For PIO mode:
 833          *
 834          * For receive, this will interrupt the CPU after that many number of
 835          * bytes are received, for the remaining bytes the receive timeout
 836          * interrupt is received. Rx high watermark is set to 4.
 837          *
 838          * For transmit, if the trasnmit interrupt is enabled, this will
 839          * interrupt the CPU when the number of entries in the FIFO reaches the
 840          * low watermark. Tx low watermark is set to 16 bytes.
 841          *
 842          * For DMA mode:
 843          *
 844          * Set the Tx trigger to 16. This should match the DMA burst size that
 845          * programmed in the DMA registers.
 846          */
 847         tup->fcr_shadow = UART_FCR_ENABLE_FIFO;
 848         tup->fcr_shadow |= UART_FCR_R_TRIG_01;
 849         tup->fcr_shadow |= TEGRA_UART_TX_TRIG_16B;
 850         tegra_uart_write(tup, tup->fcr_shadow, UART_FCR);
 851
 852         /* Dummy read to ensure the write is posted */
 853         tegra_uart_read(tup, UART_SCR);
 854
 855         /*
 856          * For all tegra devices (up to t210), there is a hardware issue that
 857          * requires software to wait for 3 UART clock periods after enabling
 858          * the TX fifo, otherwise data could be lost.
 859          */
 860         tegra_uart_wait_cycle_time(tup, 3);
 861
 862         /*
 863          * Initialize the UART with default configuration
 864          * (115200, N, 8, 1) so that the receive DMA buffer may be
 865          * enqueued
 866          */
 867         tup->lcr_shadow = TEGRA_UART_DEFAULT_LSR;
 868         tegra_set_baudrate(tup, TEGRA_UART_DEFAULT_BAUD);
 869         tup->fcr_shadow |= UART_FCR_DMA_SELECT;
 870         tegra_uart_write(tup, tup->fcr_shadow, UART_FCR);
 871
 872         ret = tegra_uart_start_rx_dma(tup);
 873         if (ret < 0) {
 874                 dev_err(tup->uport.dev, "Not able to start Rx DMA\n");
 875                 return ret;
 876         }
 877         tup->rx_in_progress = 1;
 878
 879         /*
 880          * Enable IE_RXS for the receive status interrupts like line errros.
 881          * Enable IE_RX_TIMEOUT to get the bytes which cannot be DMA'd.
 882          *
 883          * If using DMA mode, enable EORD instead of receive interrupt which
 884          * will interrupt after the UART is done with the receive instead of
 885          * the interrupt when the FIFO "threshold" is reached.
 886          *
 887          * EORD is different interrupt than RX_TIMEOUT - RX_TIMEOUT occurs when
 888          * the DATA is sitting in the FIFO and couldn't be transferred to the
 889          * DMA as the DMA size alignment(4 bytes) is not met. EORD will be
 890          * triggered when there is a pause of the incomming data stream for 4
 891          * characters long.
 892          *
 893          * For pauses in the data which is not aligned to 4 bytes, we get
 894          * both the EORD as well as RX_TIMEOUT - SW sees RX_TIMEOUT first
 895          * then the EORD.
 896          */
 897         tup->ier_shadow = UART_IER_RLSI | UART_IER_RTOIE | TEGRA_UART_IER_EORD;
 898         tegra_uart_write(tup, tup->ier_shadow, UART_IER);
 899         return 0;
 900 }
 901
 902 static void tegra_uart_dma_channel_free(struct tegra_uart_port *tup,
 903                 bool dma_to_memory)
 904 {
 905         if (dma_to_memory) {
 906                 dmaengine_terminate_all(tup->rx_dma_chan);
 907                 dma_release_channel(tup->rx_dma_chan);
 908                 dma_free_coherent(tup->uport.dev, TEGRA_UART_RX_DMA_BUFFER_SIZE,
 909                                 tup->rx_dma_buf_virt, tup->rx_dma_buf_phys);
 910                 tup->rx_dma_chan = NULL;
 911                 tup->rx_dma_buf_phys = 0;
 912                 tup->rx_dma_buf_virt = NULL;
 913         } else {
 914                 dmaengine_terminate_all(tup->tx_dma_chan);
 915                 dma_release_channel(tup->tx_dma_chan);
 916                 dma_unmap_single(tup->uport.dev, tup->tx_dma_buf_phys,
 917                         UART_XMIT_SIZE, DMA_TO_DEVICE);
 918                 tup->tx_dma_chan = NULL;
 919                 tup->tx_dma_buf_phys = 0;
 920                 tup->tx_dma_buf_virt = NULL;
 921         }
 922 }
 923
 924 static int tegra_uart_dma_channel_allocate(struct tegra_uart_port *tup,
 925                         bool dma_to_memory)
 926 {
 927         struct dma_chan *dma_chan;
 928         unsigned char *dma_buf;
 929         dma_addr_t dma_phys;
 930         int ret;
 931         struct dma_slave_config dma_sconfig;
 932
 933         dma_chan = dma_request_slave_channel_reason(tup->uport.dev,
 934                                                 dma_to_memory ? "rx" : "tx");
 935         if (IS_ERR(dma_chan)) {
 936                 ret = PTR_ERR(dma_chan);
 937                 dev_err(tup->uport.dev,
 938                         "DMA channel alloc failed: %d\n", ret);
 939                 return ret;
 940         }
 941
 942         if (dma_to_memory) {
 943                 dma_buf = dma_alloc_coherent(tup->uport.dev,
 944                                 TEGRA_UART_RX_DMA_BUFFER_SIZE,
 945                                  &dma_phys, GFP_KERNEL);
 946                 if (!dma_buf) {
 947                         dev_err(tup->uport.dev,
 948                                 "Not able to allocate the dma buffer\n");
 949                         dma_release_channel(dma_chan);
 950                         return -ENOMEM;
 951                 }
 952                 dma_sconfig.src_addr = tup->uport.mapbase;
 953                 dma_sconfig.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
 954                 dma_sconfig.src_maxburst = 4;
 955                 tup->rx_dma_chan = dma_chan;
 956                 tup->rx_dma_buf_virt = dma_buf;
 957                 tup->rx_dma_buf_phys = dma_phys;
 958         } else {
 959                 dma_phys = dma_map_single(tup->uport.dev,
 960                         tup->uport.state->xmit.buf, UART_XMIT_SIZE,
 961                         DMA_TO_DEVICE);
 962                 if (dma_mapping_error(tup->uport.dev, dma_phys)) {
 963                         dev_err(tup->uport.dev, "dma_map_single tx failed\n");
 964                         dma_release_channel(dma_chan);
 965                         return -ENOMEM;
 966                 }
 967                 dma_buf = tup->uport.state->xmit.buf;
 968                 dma_sconfig.dst_addr = tup->uport.mapbase;
 969                 dma_sconfig.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
 970                 dma_sconfig.dst_maxburst = 16;
 971                 tup->tx_dma_chan = dma_chan;
 972                 tup->tx_dma_buf_virt = dma_buf;
 973                 tup->tx_dma_buf_phys = dma_phys;
 974         }
 975
 976         ret = dmaengine_slave_config(dma_chan, &dma_sconfig);
 977         if (ret < 0) {
 978                 dev_err(tup->uport.dev,
 979                         "Dma slave config failed, err = %d\n", ret);
 980                 tegra_uart_dma_channel_free(tup, dma_to_memory);
 981                 return ret;
 982         }
 983
 984         return 0;
 985 }
 986
 987 static int tegra_uart_startup(struct uart_port *u)
 988 {
 989         struct tegra_uart_port *tup = to_tegra_uport(u);
 990         int ret;
 991
 992         ret = tegra_uart_dma_channel_allocate(tup, false);
 993         if (ret < 0) {
 994                 dev_err(u->dev, "Tx Dma allocation failed, err = %d\n", ret);
 995                 return ret;
 996         }
 997
 998         ret = tegra_uart_dma_channel_allocate(tup, true);
 999         if (ret < 0) {
1000                 dev_err(u->dev, "Rx Dma allocation failed, err = %d\n", ret);
1001                 goto fail_rx_dma;
1002         }
1003
1004         ret = tegra_uart_hw_init(tup);
1005         if (ret < 0) {
1006                 dev_err(u->dev, "Uart HW init failed, err = %d\n", ret);
1007                 goto fail_hw_init;
1008         }
1009
1010         ret = request_irq(u->irq, tegra_uart_isr, 0,
1011                                 dev_name(u->dev), tup);
1012         if (ret < 0) {
1013                 dev_err(u->dev, "Failed to register ISR for IRQ %d\n", u->irq);
1014                 goto fail_hw_init;
1015         }
1016         return 0;
1017
1018 fail_hw_init:
1019         tegra_uart_dma_channel_free(tup, true);
1020 fail_rx_dma:
1021         tegra_uart_dma_channel_free(tup, false);
1022         return ret;
1023 }
1024
1025 /*
1026  * Flush any TX data submitted for DMA and PIO. Called when the
1027  * TX circular buffer is reset.
1028  */
1029 static void tegra_uart_flush_buffer(struct uart_port *u)
1030 {
1031         struct tegra_uart_port *tup = to_tegra_uport(u);
1032
1033         tup->tx_bytes = 0;
1034         if (tup->tx_dma_chan)
1035                 dmaengine_terminate_all(tup->tx_dma_chan);
1036 }
1037
1038 static void tegra_uart_shutdown(struct uart_port *u)
1039 {
1040         struct tegra_uart_port *tup = to_tegra_uport(u);
1041
1042         tegra_uart_hw_deinit(tup);
1043
1044         tup->rx_in_progress = 0;
1045         tup->tx_in_progress = 0;
1046
1047         tegra_uart_dma_channel_free(tup, true);
1048         tegra_uart_dma_channel_free(tup, false);
1049         free_irq(u->irq, tup);
1050 }
1051
1052 static void tegra_uart_enable_ms(struct uart_port *u)
1053 {
1054         struct tegra_uart_port *tup = to_tegra_uport(u);
1055
1056         if (tup->enable_modem_interrupt) {
1057                 tup->ier_shadow |= UART_IER_MSI;
1058                 tegra_uart_write(tup, tup->ier_shadow, UART_IER);
1059         }
1060 }
1061
1062 static void tegra_uart_set_termios(struct uart_port *u,
1063                 struct ktermios *termios, struct ktermios *oldtermios)
1064 {
1065         struct tegra_uart_port *tup = to_tegra_uport(u);
1066         unsigned int baud;
1067         unsigned long flags;
1068         unsigned int lcr;
1069         int symb_bit = 1;
1070         struct clk *parent_clk = clk_get_parent(tup->uart_clk);
1071         unsigned long parent_clk_rate = clk_get_rate(parent_clk);
1072         int max_divider = (tup->cdata->support_clk_src_div) ? 0x7FFF : 0xFFFF;
1073
1074         max_divider *= 16;
1075         spin_lock_irqsave(&u->lock, flags);
1076
1077         /* Changing configuration, it is safe to stop any rx now */
1078         if (tup->rts_active)
1079                 set_rts(tup, false);
1080
1081         /* Clear all interrupts as configuration is going to be change */
1082         tegra_uart_write(tup, tup->ier_shadow | UART_IER_RDI, UART_IER);
1083         tegra_uart_read(tup, UART_IER);
1084         tegra_uart_write(tup, 0, UART_IER);
1085         tegra_uart_read(tup, UART_IER);
1086
1087         /* Parity */
1088         lcr = tup->lcr_shadow;
1089         lcr &= ~UART_LCR_PARITY;
1090
1091         /* CMSPAR isn't supported by this driver */
1092         termios->c_cflag &= ~CMSPAR;
1093
1094         if ((termios->c_cflag & PARENB) == PARENB) {
1095                 symb_bit++;
1096                 if (termios->c_cflag & PARODD) {
1097                         lcr |= UART_LCR_PARITY;
1098                         lcr &= ~UART_LCR_EPAR;
1099                         lcr &= ~UART_LCR_SPAR;
1100                 } else {
1101                         lcr |= UART_LCR_PARITY;
1102                         lcr |= UART_LCR_EPAR;
1103                         lcr &= ~UART_LCR_SPAR;
1104                 }
1105         }
1106
1107         lcr &= ~UART_LCR_WLEN8;
1108         switch (termios->c_cflag & CSIZE) {
1109         case CS5:
1110                 lcr |= UART_LCR_WLEN5;
1111                 symb_bit += 5;
1112                 break;
1113         case CS6:
1114                 lcr |= UART_LCR_WLEN6;
1115                 symb_bit += 6;
1116                 break;
1117         case CS7:
1118                 lcr |= UART_LCR_WLEN7;
1119                 symb_bit += 7;
1120                 break;
1121         default:
1122                 lcr |= UART_LCR_WLEN8;
1123                 symb_bit += 8;
1124                 break;
1125         }
1126
1127         /* Stop bits */
1128         if (termios->c_cflag & CSTOPB) {
1129                 lcr |= UART_LCR_STOP;
1130                 symb_bit += 2;
1131         } else {
1132                 lcr &= ~UART_LCR_STOP;
1133                 symb_bit++;
1134         }
1135
1136         tegra_uart_write(tup, lcr, UART_LCR);
1137         tup->lcr_shadow = lcr;
1138         tup->symb_bit = symb_bit;
1139
1140         /* Baud rate. */
1141         baud = uart_get_baud_rate(u, termios, oldtermios,
1142                         parent_clk_rate/max_divider,
1143                         parent_clk_rate/16);
1144         spin_unlock_irqrestore(&u->lock, flags);
1145         tegra_set_baudrate(tup, baud);
1146         if (tty_termios_baud_rate(termios))
1147                 tty_termios_encode_baud_rate(termios, baud, baud);
1148         spin_lock_irqsave(&u->lock, flags);
1149
1150         /* Flow control */
1151         if (termios->c_cflag & CRTSCTS) {
1152                 tup->mcr_shadow |= TEGRA_UART_MCR_CTS_EN;
1153                 tup->mcr_shadow &= ~TEGRA_UART_MCR_RTS_EN;
1154                 tegra_uart_write(tup, tup->mcr_shadow, UART_MCR);
1155                 /* if top layer has asked to set rts active then do so here */
1156                 if (tup->rts_active)
1157                         set_rts(tup, true);
1158         } else {
1159                 tup->mcr_shadow &= ~TEGRA_UART_MCR_CTS_EN;
1160                 tup->mcr_shadow &= ~TEGRA_UART_MCR_RTS_EN;
1161                 tegra_uart_write(tup, tup->mcr_shadow, UART_MCR);
1162         }
1163
1164         /* update the port timeout based on new settings */
1165         uart_update_timeout(u, termios->c_cflag, baud);
1166
1167         /* Make sure all write has completed */
1168         tegra_uart_read(tup, UART_IER);
1169
1170         /* Reenable interrupt */
1171         tegra_uart_write(tup, tup->ier_shadow, UART_IER);
1172         tegra_uart_read(tup, UART_IER);
1173
1174         spin_unlock_irqrestore(&u->lock, flags);
1175 }
1176
1177 static const char *tegra_uart_type(struct uart_port *u)
1178 {
1179         return TEGRA_UART_TYPE;
1180 }
1181
1182 static const struct uart_ops tegra_uart_ops = {
1183         .tx_empty       = tegra_uart_tx_empty,
1184         .set_mctrl      = tegra_uart_set_mctrl,
1185         .get_mctrl      = tegra_uart_get_mctrl,
1186         .stop_tx        = tegra_uart_stop_tx,
1187         .start_tx       = tegra_uart_start_tx,
1188         .stop_rx        = tegra_uart_stop_rx,
1189         .flush_buffer   = tegra_uart_flush_buffer,
1190         .enable_ms      = tegra_uart_enable_ms,
1191         .break_ctl      = tegra_uart_break_ctl,
1192         .startup        = tegra_uart_startup,
1193         .shutdown       = tegra_uart_shutdown,
1194         .set_termios    = tegra_uart_set_termios,
1195         .type           = tegra_uart_type,
1196         .request_port   = tegra_uart_request_port,
1197         .release_port   = tegra_uart_release_port,
1198 };
1199
1200 static struct uart_driver tegra_uart_driver = {
1201         .owner          = THIS_MODULE,
1202         .driver_name    = "tegra_hsuart",
1203         .dev_name       = "ttyTHS",
1204         .cons           = NULL,
1205         .nr             = TEGRA_UART_MAXIMUM,
1206 };
1207
1208 static int tegra_uart_parse_dt(struct platform_device *pdev,
1209         struct tegra_uart_port *tup)
1210 {
1211         struct device_node *np = pdev->dev.of_node;
1212         int port;
1213
1214         port = of_alias_get_id(np, "serial");
1215         if (port < 0) {
1216                 dev_err(&pdev->dev, "failed to get alias id, errno %d\n", port);
1217                 return port;
1218         }
1219         tup->uport.line = port;
1220
1221         tup->enable_modem_interrupt = of_property_read_bool(np,
1222                                         "nvidia,enable-modem-interrupt");
1223         return 0;
1224 }
1225
1226 static struct tegra_uart_chip_data tegra20_uart_chip_data = {
1227         .tx_fifo_full_status            = false,
1228         .allow_txfifo_reset_fifo_mode   = true,
1229         .support_clk_src_div            = false,
1230 };
1231
1232 static struct tegra_uart_chip_data tegra30_uart_chip_data = {
1233         .tx_fifo_full_status            = true,
1234         .allow_txfifo_reset_fifo_mode   = false,
1235         .support_clk_src_div            = true,
1236 };
1237
1238 static const struct of_device_id tegra_uart_of_match[] = {
1239         {
1240                 .compatible     = "nvidia,tegra30-hsuart",
1241                 .data           = &tegra30_uart_chip_data,
1242         }, {
1243                 .compatible     = "nvidia,tegra20-hsuart",
1244                 .data           = &tegra20_uart_chip_data,
1245         }, {
1246         },
1247 };
1248 MODULE_DEVICE_TABLE(of, tegra_uart_of_match);
1249
1250 static int tegra_uart_probe(struct platform_device *pdev)
1251 {
1252         struct tegra_uart_port *tup;
1253         struct uart_port *u;
1254         struct resource *resource;
1255         int ret;
1256         const struct tegra_uart_chip_data *cdata;
1257         const struct of_device_id *match;
1258
1259         match = of_match_device(tegra_uart_of_match, &pdev->dev);
1260         if (!match) {
1261                 dev_err(&pdev->dev, "Error: No device match found\n");
1262                 return -ENODEV;
1263         }
1264         cdata = match->data;
1265
1266         tup = devm_kzalloc(&pdev->dev, sizeof(*tup), GFP_KERNEL);
1267         if (!tup) {
1268                 dev_err(&pdev->dev, "Failed to allocate memory for tup\n");
1269                 return -ENOMEM;
1270         }
1271
1272         ret = tegra_uart_parse_dt(pdev, tup);
1273         if (ret < 0)
1274                 return ret;
1275
1276         u = &tup->uport;
1277         u->dev = &pdev->dev;
1278         u->ops = &tegra_uart_ops;
1279         u->type = PORT_TEGRA;
1280         u->fifosize = 32;
1281         tup->cdata = cdata;
1282
1283         platform_set_drvdata(pdev, tup);
1284         resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1285         if (!resource) {
1286                 dev_err(&pdev->dev, "No IO memory resource\n");
1287                 return -ENODEV;
1288         }
1289
1290         u->mapbase = resource->start;
1291         u->membase = devm_ioremap_resource(&pdev->dev, resource);
1292         if (IS_ERR(u->membase))
1293                 return PTR_ERR(u->membase);
1294
1295         tup->uart_clk = devm_clk_get(&pdev->dev, NULL);
1296         if (IS_ERR(tup->uart_clk)) {
1297                 dev_err(&pdev->dev, "Couldn't get the clock\n");
1298                 return PTR_ERR(tup->uart_clk);
1299         }
1300
1301         tup->rst = devm_reset_control_get_exclusive(&pdev->dev, "serial");
1302         if (IS_ERR(tup->rst)) {
1303                 dev_err(&pdev->dev, "Couldn't get the reset\n");
1304                 return PTR_ERR(tup->rst);
1305         }
1306
1307         u->iotype = UPIO_MEM32;
1308         ret = platform_get_irq(pdev, 0);
1309         if (ret < 0) {
1310                 dev_err(&pdev->dev, "Couldn't get IRQ\n");
1311                 return ret;
1312         }
1313         u->irq = ret;
1314         u->regshift = 2;
1315         ret = uart_add_one_port(&tegra_uart_driver, u);
1316         if (ret < 0) {
1317                 dev_err(&pdev->dev, "Failed to add uart port, err %d\n", ret);
1318                 return ret;
1319         }
1320         return ret;
1321 }
1322
1323 static int tegra_uart_remove(struct platform_device *pdev)
1324 {
1325         struct tegra_uart_port *tup = platform_get_drvdata(pdev);
1326         struct uart_port *u = &tup->uport;
1327
1328         uart_remove_one_port(&tegra_uart_driver, u);
1329         return 0;
1330 }
1331
1332 #ifdef CONFIG_PM_SLEEP
1333 static int tegra_uart_suspend(struct device *dev)
1334 {
1335         struct tegra_uart_port *tup = dev_get_drvdata(dev);
1336         struct uart_port *u = &tup->uport;
1337
1338         return uart_suspend_port(&tegra_uart_driver, u);
1339 }
1340
1341 static int tegra_uart_resume(struct device *dev)
1342 {
1343         struct tegra_uart_port *tup = dev_get_drvdata(dev);
1344         struct uart_port *u = &tup->uport;
1345
1346         return uart_resume_port(&tegra_uart_driver, u);
1347 }
1348 #endif
1349
1350 static const struct dev_pm_ops tegra_uart_pm_ops = {
1351         SET_SYSTEM_SLEEP_PM_OPS(tegra_uart_suspend, tegra_uart_resume)
1352 };
1353
1354 static struct platform_driver tegra_uart_platform_driver = {
1355         .probe          = tegra_uart_probe,
1356         .remove         = tegra_uart_remove,
1357         .driver         = {
1358                 .name   = "serial-tegra",
1359                 .of_match_table = tegra_uart_of_match,
1360                 .pm     = &tegra_uart_pm_ops,
1361         },
1362 };
1363
1364 static int __init tegra_uart_init(void)
1365 {
1366         int ret;
1367
1368         ret = uart_register_driver(&tegra_uart_driver);
1369         if (ret < 0) {
1370                 pr_err("Could not register %s driver\n",
1371                         tegra_uart_driver.driver_name);
1372                 return ret;
1373         }
1374
1375         ret = platform_driver_register(&tegra_uart_platform_driver);
1376         if (ret < 0) {
1377                 pr_err("Uart platform driver register failed, e = %d\n", ret);
1378                 uart_unregister_driver(&tegra_uart_driver);
1379                 return ret;
1380         }
1381         return 0;
1382 }
1383
1384 static void __exit tegra_uart_exit(void)
1385 {
1386         pr_info("Unloading tegra uart driver\n");
1387         platform_driver_unregister(&tegra_uart_platform_driver);
1388         uart_unregister_driver(&tegra_uart_driver);
1389 }
1390
1391 module_init(tegra_uart_init);
1392 module_exit(tegra_uart_exit);
1393
1394 MODULE_ALIAS("platform:serial-tegra");
1395 MODULE_DESCRIPTION("High speed UART driver for tegra chipset");
1396 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
1397 MODULE_LICENSE("GPL v2");