drivers/tty/serial/msm_serial.c

   1 /*
   2  * Driver for msm7k serial device and console
   3  *
   4  * Copyright (C) 2007 Google, Inc.
   5  * Author: Robert Love <rlove@google.com>
   6  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
   7  *
   8  * This software is licensed under the terms of the GNU General Public
   9  * License version 2, as published by the Free Software Foundation, and
  10  * may be copied, distributed, and modified under those terms.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  */
  17
  18 #if defined(CONFIG_SERIAL_MSM_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  19 # define SUPPORT_SYSRQ
  20 #endif
  21
  22 #include <linux/atomic.h>
  23 #include <linux/dma-mapping.h>
  24 #include <linux/dmaengine.h>
  25 #include <linux/hrtimer.h>
  26 #include <linux/module.h>
  27 #include <linux/io.h>
  28 #include <linux/ioport.h>
  29 #include <linux/irq.h>
  30 #include <linux/init.h>
  31 #include <linux/console.h>
  32 #include <linux/tty.h>
  33 #include <linux/tty_flip.h>
  34 #include <linux/serial_core.h>
  35 #include <linux/serial.h>
  36 #include <linux/slab.h>
  37 #include <linux/clk.h>
  38 #include <linux/platform_device.h>
  39 #include <linux/delay.h>
  40 #include <linux/of.h>
  41 #include <linux/of_device.h>
  42
  43 #include "msm_serial.h"
  44
  45 #define UARTDM_BURST_SIZE       16   /* in bytes */
  46 #define UARTDM_TX_AIGN(x)       ((x) & ~0x3) /* valid for > 1p3 */
  47 #define UARTDM_TX_MAX           256   /* in bytes, valid for <= 1p3 */
  48 #define UARTDM_RX_SIZE          (UART_XMIT_SIZE / 4)
  49
  50 enum {
  51         UARTDM_1P1 = 1,
  52         UARTDM_1P2,
  53         UARTDM_1P3,
  54         UARTDM_1P4,
  55 };
  56
  57 struct msm_dma {
  58         struct dma_chan         *chan;
  59         enum dma_data_direction dir;
  60         dma_addr_t              phys;
  61         unsigned char           *virt;
  62         dma_cookie_t            cookie;
  63         u32                     enable_bit;
  64         unsigned int            count;
  65         struct dma_async_tx_descriptor  *desc;
  66 };
  67
  68 struct msm_port {
  69         struct uart_port        uart;
  70         char                    name[16];
  71         struct clk              *clk;
  72         struct clk              *pclk;
  73         unsigned int            imr;
  74         int                     is_uartdm;
  75         unsigned int            old_snap_state;
  76         bool                    break_detected;
  77         struct msm_dma          tx_dma;
  78         struct msm_dma          rx_dma;
  79         unsigned int            last_baud;
  80 };
  81
  82 static void msm_handle_tx(struct uart_port *port);
  83 static void msm_start_rx_dma(struct msm_port *msm_port);
  84
  85 void msm_stop_dma(struct uart_port *port, struct msm_dma *dma)
  86 {
  87         struct device *dev = port->dev;
  88         unsigned int mapped;
  89         u32 val;
  90
  91         mapped = dma->count;
  92         dma->count = 0;
  93
  94         dmaengine_terminate_all(dma->chan);
  95
  96         /*
  97          * DMA Stall happens if enqueue and flush command happens concurrently.
  98          * For example before changing the baud rate/protocol configuration and
  99          * sending flush command to ADM, disable the channel of UARTDM.
 100          * Note: should not reset the receiver here immediately as it is not
 101          * suggested to do disable/reset or reset/disable at the same time.
 102          */
 103         val = msm_read(port, UARTDM_DMEN);
 104         val &= ~dma->enable_bit;
 105         msm_write(port, val, UARTDM_DMEN);
 106
 107         if (mapped)
 108                 dma_unmap_single(dev, dma->phys, mapped, dma->dir);
 109 }
 110
 111 static void msm_release_dma(struct msm_port *msm_port)
 112 {
 113         struct msm_dma *dma;
 114
 115         dma = &msm_port->tx_dma;
 116         if (dma->chan) {
 117                 msm_stop_dma(&msm_port->uart, dma);
 118                 dma_release_channel(dma->chan);
 119         }
 120
 121         memset(dma, 0, sizeof(*dma));
 122
 123         dma = &msm_port->rx_dma;
 124         if (dma->chan) {
 125                 msm_stop_dma(&msm_port->uart, dma);
 126                 dma_release_channel(dma->chan);
 127                 kfree(dma->virt);
 128         }
 129
 130         memset(dma, 0, sizeof(*dma));
 131 }
 132
 133 static void msm_request_tx_dma(struct msm_port *msm_port, resource_size_t base)
 134 {
 135         struct device *dev = msm_port->uart.dev;
 136         struct dma_slave_config conf;
 137         struct msm_dma *dma;
 138         u32 crci = 0;
 139         int ret;
 140
 141         dma = &msm_port->tx_dma;
 142
 143         /* allocate DMA resources, if available */
 144         dma->chan = dma_request_slave_channel_reason(dev, "tx");
 145         if (IS_ERR(dma->chan))
 146                 goto no_tx;
 147
 148         of_property_read_u32(dev->of_node, "qcom,tx-crci", &crci);
 149
 150         memset(&conf, 0, sizeof(conf));
 151         conf.direction = DMA_MEM_TO_DEV;
 152         conf.device_fc = true;
 153         conf.dst_addr = base + UARTDM_TF;
 154         conf.dst_maxburst = UARTDM_BURST_SIZE;
 155         conf.slave_id = crci;
 156
 157         ret = dmaengine_slave_config(dma->chan, &conf);
 158         if (ret)
 159                 goto rel_tx;
 160
 161         dma->dir = DMA_TO_DEVICE;
 162
 163         if (msm_port->is_uartdm < UARTDM_1P4)
 164                 dma->enable_bit = UARTDM_DMEN_TX_DM_ENABLE;
 165         else
 166                 dma->enable_bit = UARTDM_DMEN_TX_BAM_ENABLE;
 167
 168         return;
 169
 170 rel_tx:
 171         dma_release_channel(dma->chan);
 172 no_tx:
 173         memset(dma, 0, sizeof(*dma));
 174 }
 175
 176 static void msm_request_rx_dma(struct msm_port *msm_port, resource_size_t base)
 177 {
 178         struct device *dev = msm_port->uart.dev;
 179         struct dma_slave_config conf;
 180         struct msm_dma *dma;
 181         u32 crci = 0;
 182         int ret;
 183
 184         dma = &msm_port->rx_dma;
 185
 186         /* allocate DMA resources, if available */
 187         dma->chan = dma_request_slave_channel_reason(dev, "rx");
 188         if (IS_ERR(dma->chan))
 189                 goto no_rx;
 190
 191         of_property_read_u32(dev->of_node, "qcom,rx-crci", &crci);
 192
 193         dma->virt = kzalloc(UARTDM_RX_SIZE, GFP_KERNEL);
 194         if (!dma->virt)
 195                 goto rel_rx;
 196
 197         memset(&conf, 0, sizeof(conf));
 198         conf.direction = DMA_DEV_TO_MEM;
 199         conf.device_fc = true;
 200         conf.src_addr = base + UARTDM_RF;
 201         conf.src_maxburst = UARTDM_BURST_SIZE;
 202         conf.slave_id = crci;
 203
 204         ret = dmaengine_slave_config(dma->chan, &conf);
 205         if (ret)
 206                 goto err;
 207
 208         dma->dir = DMA_FROM_DEVICE;
 209
 210         if (msm_port->is_uartdm < UARTDM_1P4)
 211                 dma->enable_bit = UARTDM_DMEN_RX_DM_ENABLE;
 212         else
 213                 dma->enable_bit = UARTDM_DMEN_RX_BAM_ENABLE;
 214
 215         return;
 216 err:
 217         kfree(dma->virt);
 218 rel_rx:
 219         dma_release_channel(dma->chan);
 220 no_rx:
 221         memset(dma, 0, sizeof(*dma));
 222 }
 223
 224 static inline void msm_wait_for_xmitr(struct uart_port *port)
 225 {
 226         while (!(msm_read(port, UART_SR) & UART_SR_TX_EMPTY)) {
 227                 if (msm_read(port, UART_ISR) & UART_ISR_TX_READY)
 228                         break;
 229                 udelay(1);
 230         }
 231         msm_write(port, UART_CR_CMD_RESET_TX_READY, UART_CR);
 232 }
 233
 234 static void msm_stop_tx(struct uart_port *port)
 235 {
 236         struct msm_port *msm_port = UART_TO_MSM(port);
 237
 238         msm_port->imr &= ~UART_IMR_TXLEV;
 239         msm_write(port, msm_port->imr, UART_IMR);
 240 }
 241
 242 static void msm_start_tx(struct uart_port *port)
 243 {
 244         struct msm_port *msm_port = UART_TO_MSM(port);
 245         struct msm_dma *dma = &msm_port->tx_dma;
 246
 247         /* Already started in DMA mode */
 248         if (dma->count)
 249                 return;
 250
 251         msm_port->imr |= UART_IMR_TXLEV;
 252         msm_write(port, msm_port->imr, UART_IMR);
 253 }
 254
 255 static void msm_reset_dm_count(struct uart_port *port, int count)
 256 {
 257         msm_wait_for_xmitr(port);
 258         msm_write(port, count, UARTDM_NCF_TX);
 259         msm_read(port, UARTDM_NCF_TX);
 260 }
 261
 262 static void msm_complete_tx_dma(void *args)
 263 {
 264         struct msm_port *msm_port = args;
 265         struct uart_port *port = &msm_port->uart;
 266         struct circ_buf *xmit = &port->state->xmit;
 267         struct msm_dma *dma = &msm_port->tx_dma;
 268         struct dma_tx_state state;
 269         enum dma_status status;
 270         unsigned long flags;
 271         unsigned int count;
 272         u32 val;
 273
 274         spin_lock_irqsave(&port->lock, flags);
 275
 276         /* Already stopped */
 277         if (!dma->count)
 278                 goto done;
 279
 280         status = dmaengine_tx_status(dma->chan, dma->cookie, &state);
 281
 282         dma_unmap_single(port->dev, dma->phys, dma->count, dma->dir);
 283
 284         val = msm_read(port, UARTDM_DMEN);
 285         val &= ~dma->enable_bit;
 286         msm_write(port, val, UARTDM_DMEN);
 287
 288         if (msm_port->is_uartdm > UARTDM_1P3) {
 289                 msm_write(port, UART_CR_CMD_RESET_TX, UART_CR);
 290                 msm_write(port, UART_CR_TX_ENABLE, UART_CR);
 291         }
 292
 293         count = dma->count - state.residue;
 294         port->icount.tx += count;
 295         dma->count = 0;
 296
 297         xmit->tail += count;
 298         xmit->tail &= UART_XMIT_SIZE - 1;
 299
 300         /* Restore "Tx FIFO below watermark" interrupt */
 301         msm_port->imr |= UART_IMR_TXLEV;
 302         msm_write(port, msm_port->imr, UART_IMR);
 303
 304         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 305                 uart_write_wakeup(port);
 306
 307         msm_handle_tx(port);
 308 done:
 309         spin_unlock_irqrestore(&port->lock, flags);
 310 }
 311
 312 static int msm_handle_tx_dma(struct msm_port *msm_port, unsigned int count)
 313 {
 314         struct circ_buf *xmit = &msm_port->uart.state->xmit;
 315         struct uart_port *port = &msm_port->uart;
 316         struct msm_dma *dma = &msm_port->tx_dma;
 317         void *cpu_addr;
 318         int ret;
 319         u32 val;
 320
 321         cpu_addr = &xmit->buf[xmit->tail];
 322
 323         dma->phys = dma_map_single(port->dev, cpu_addr, count, dma->dir);
 324         ret = dma_mapping_error(port->dev, dma->phys);
 325         if (ret)
 326                 return ret;
 327
 328         dma->desc = dmaengine_prep_slave_single(dma->chan, dma->phys,
 329                                                 count, DMA_MEM_TO_DEV,
 330                                                 DMA_PREP_INTERRUPT |
 331                                                 DMA_PREP_FENCE);
 332         if (!dma->desc) {
 333                 ret = -EIO;
 334                 goto unmap;
 335         }
 336
 337         dma->desc->callback = msm_complete_tx_dma;
 338         dma->desc->callback_param = msm_port;
 339
 340         dma->cookie = dmaengine_submit(dma->desc);
 341         ret = dma_submit_error(dma->cookie);
 342         if (ret)
 343                 goto unmap;
 344
 345         /*
 346          * Using DMA complete for Tx FIFO reload, no need for
 347          * "Tx FIFO below watermark" one, disable it
 348          */
 349         msm_port->imr &= ~UART_IMR_TXLEV;
 350         msm_write(port, msm_port->imr, UART_IMR);
 351
 352         dma->count = count;
 353
 354         val = msm_read(port, UARTDM_DMEN);
 355         val |= dma->enable_bit;
 356
 357         if (msm_port->is_uartdm < UARTDM_1P4)
 358                 msm_write(port, val, UARTDM_DMEN);
 359
 360         msm_reset_dm_count(port, count);
 361
 362         if (msm_port->is_uartdm > UARTDM_1P3)
 363                 msm_write(port, val, UARTDM_DMEN);
 364
 365         dma_async_issue_pending(dma->chan);
 366         return 0;
 367 unmap:
 368         dma_unmap_single(port->dev, dma->phys, count, dma->dir);
 369         return ret;
 370 }
 371
 372 static void msm_complete_rx_dma(void *args)
 373 {
 374         struct msm_port *msm_port = args;
 375         struct uart_port *port = &msm_port->uart;
 376         struct tty_port *tport = &port->state->port;
 377         struct msm_dma *dma = &msm_port->rx_dma;
 378         int count = 0, i, sysrq;
 379         unsigned long flags;
 380         u32 val;
 381
 382         spin_lock_irqsave(&port->lock, flags);
 383
 384         /* Already stopped */
 385         if (!dma->count)
 386                 goto done;
 387
 388         val = msm_read(port, UARTDM_DMEN);
 389         val &= ~dma->enable_bit;
 390         msm_write(port, val, UARTDM_DMEN);
 391
 392         /* Restore interrupts */
 393         msm_port->imr |= UART_IMR_RXLEV | UART_IMR_RXSTALE;
 394         msm_write(port, msm_port->imr, UART_IMR);
 395
 396         if (msm_read(port, UART_SR) & UART_SR_OVERRUN) {
 397                 port->icount.overrun++;
 398                 tty_insert_flip_char(tport, 0, TTY_OVERRUN);
 399                 msm_write(port, UART_CR_CMD_RESET_ERR, UART_CR);
 400         }
 401
 402         count = msm_read(port, UARTDM_RX_TOTAL_SNAP);
 403
 404         port->icount.rx += count;
 405
 406         dma->count = 0;
 407
 408         dma_unmap_single(port->dev, dma->phys, UARTDM_RX_SIZE, dma->dir);
 409
 410         for (i = 0; i < count; i++) {
 411                 char flag = TTY_NORMAL;
 412
 413                 if (msm_port->break_detected && dma->virt[i] == 0) {
 414                         port->icount.brk++;
 415                         flag = TTY_BREAK;
 416                         msm_port->break_detected = false;
 417                         if (uart_handle_break(port))
 418                                 continue;
 419                 }
 420
 421                 if (!(port->read_status_mask & UART_SR_RX_BREAK))
 422                         flag = TTY_NORMAL;
 423
 424                 spin_unlock_irqrestore(&port->lock, flags);
 425                 sysrq = uart_handle_sysrq_char(port, dma->virt[i]);
 426                 spin_lock_irqsave(&port->lock, flags);
 427                 if (!sysrq)
 428                         tty_insert_flip_char(tport, dma->virt[i], flag);
 429         }
 430
 431         msm_start_rx_dma(msm_port);
 432 done:
 433         spin_unlock_irqrestore(&port->lock, flags);
 434
 435         if (count)
 436                 tty_flip_buffer_push(tport);
 437 }
 438
 439 static void msm_start_rx_dma(struct msm_port *msm_port)
 440 {
 441         struct msm_dma *dma = &msm_port->rx_dma;
 442         struct uart_port *uart = &msm_port->uart;
 443         u32 val;
 444         int ret;
 445
 446         if (!dma->chan)
 447                 return;
 448
 449         dma->phys = dma_map_single(uart->dev, dma->virt,
 450                                    UARTDM_RX_SIZE, dma->dir);
 451         ret = dma_mapping_error(uart->dev, dma->phys);
 452         if (ret)
 453                 return;
 454
 455         dma->desc = dmaengine_prep_slave_single(dma->chan, dma->phys,
 456                                                 UARTDM_RX_SIZE, DMA_DEV_TO_MEM,
 457                                                 DMA_PREP_INTERRUPT);
 458         if (!dma->desc)
 459                 goto unmap;
 460
 461         dma->desc->callback = msm_complete_rx_dma;
 462         dma->desc->callback_param = msm_port;
 463
 464         dma->cookie = dmaengine_submit(dma->desc);
 465         ret = dma_submit_error(dma->cookie);
 466         if (ret)
 467                 goto unmap;
 468         /*
 469          * Using DMA for FIFO off-load, no need for "Rx FIFO over
 470          * watermark" or "stale" interrupts, disable them
 471          */
 472         msm_port->imr &= ~(UART_IMR_RXLEV | UART_IMR_RXSTALE);
 473
 474         /*
 475          * Well, when DMA is ADM3 engine(implied by <= UARTDM v1.3),
 476          * we need RXSTALE to flush input DMA fifo to memory
 477          */
 478         if (msm_port->is_uartdm < UARTDM_1P4)
 479                 msm_port->imr |= UART_IMR_RXSTALE;
 480
 481         msm_write(uart, msm_port->imr, UART_IMR);
 482
 483         dma->count = UARTDM_RX_SIZE;
 484
 485         dma_async_issue_pending(dma->chan);
 486
 487         msm_write(uart, UART_CR_CMD_RESET_STALE_INT, UART_CR);
 488         msm_write(uart, UART_CR_CMD_STALE_EVENT_ENABLE, UART_CR);
 489
 490         val = msm_read(uart, UARTDM_DMEN);
 491         val |= dma->enable_bit;
 492
 493         if (msm_port->is_uartdm < UARTDM_1P4)
 494                 msm_write(uart, val, UARTDM_DMEN);
 495
 496         msm_write(uart, UARTDM_RX_SIZE, UARTDM_DMRX);
 497
 498         if (msm_port->is_uartdm > UARTDM_1P3)
 499                 msm_write(uart, val, UARTDM_DMEN);
 500
 501         return;
 502 unmap:
 503         dma_unmap_single(uart->dev, dma->phys, UARTDM_RX_SIZE, dma->dir);
 504 }
 505
 506 static void msm_stop_rx(struct uart_port *port)
 507 {
 508         struct msm_port *msm_port = UART_TO_MSM(port);
 509         struct msm_dma *dma = &msm_port->rx_dma;
 510
 511         msm_port->imr &= ~(UART_IMR_RXLEV | UART_IMR_RXSTALE);
 512         msm_write(port, msm_port->imr, UART_IMR);
 513
 514         if (dma->chan)
 515                 msm_stop_dma(port, dma);
 516 }
 517
 518 static void msm_enable_ms(struct uart_port *port)
 519 {
 520         struct msm_port *msm_port = UART_TO_MSM(port);
 521
 522         msm_port->imr |= UART_IMR_DELTA_CTS;
 523         msm_write(port, msm_port->imr, UART_IMR);
 524 }
 525
 526 static void msm_handle_rx_dm(struct uart_port *port, unsigned int misr)
 527 {
 528         struct tty_port *tport = &port->state->port;
 529         unsigned int sr;
 530         int count = 0;
 531         struct msm_port *msm_port = UART_TO_MSM(port);
 532
 533         if ((msm_read(port, UART_SR) & UART_SR_OVERRUN)) {
 534                 port->icount.overrun++;
 535                 tty_insert_flip_char(tport, 0, TTY_OVERRUN);
 536                 msm_write(port, UART_CR_CMD_RESET_ERR, UART_CR);
 537         }
 538
 539         if (misr & UART_IMR_RXSTALE) {
 540                 count = msm_read(port, UARTDM_RX_TOTAL_SNAP) -
 541                         msm_port->old_snap_state;
 542                 msm_port->old_snap_state = 0;
 543         } else {
 544                 count = 4 * (msm_read(port, UART_RFWR));
 545                 msm_port->old_snap_state += count;
 546         }
 547
 548         /* TODO: Precise error reporting */
 549
 550         port->icount.rx += count;
 551
 552         while (count > 0) {
 553                 unsigned char buf[4];
 554                 int sysrq, r_count, i;
 555
 556                 sr = msm_read(port, UART_SR);
 557                 if ((sr & UART_SR_RX_READY) == 0) {
 558                         msm_port->old_snap_state -= count;
 559                         break;
 560                 }
 561
 562                 ioread32_rep(port->membase + UARTDM_RF, buf, 1);
 563                 r_count = min_t(int, count, sizeof(buf));
 564
 565                 for (i = 0; i < r_count; i++) {
 566                         char flag = TTY_NORMAL;
 567
 568                         if (msm_port->break_detected && buf[i] == 0) {
 569                                 port->icount.brk++;
 570                                 flag = TTY_BREAK;
 571                                 msm_port->break_detected = false;
 572                                 if (uart_handle_break(port))
 573                                         continue;
 574                         }
 575
 576                         if (!(port->read_status_mask & UART_SR_RX_BREAK))
 577                                 flag = TTY_NORMAL;
 578
 579                         spin_unlock(&port->lock);
 580                         sysrq = uart_handle_sysrq_char(port, buf[i]);
 581                         spin_lock(&port->lock);
 582                         if (!sysrq)
 583                                 tty_insert_flip_char(tport, buf[i], flag);
 584                 }
 585                 count -= r_count;
 586         }
 587
 588         spin_unlock(&port->lock);
 589         tty_flip_buffer_push(tport);
 590         spin_lock(&port->lock);
 591
 592         if (misr & (UART_IMR_RXSTALE))
 593                 msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);
 594         msm_write(port, 0xFFFFFF, UARTDM_DMRX);
 595         msm_write(port, UART_CR_CMD_STALE_EVENT_ENABLE, UART_CR);
 596
 597         /* Try to use DMA */
 598         msm_start_rx_dma(msm_port);
 599 }
 600
 601 static void msm_handle_rx(struct uart_port *port)
 602 {
 603         struct tty_port *tport = &port->state->port;
 604         unsigned int sr;
 605
 606         /*
 607          * Handle overrun. My understanding of the hardware is that overrun
 608          * is not tied to the RX buffer, so we handle the case out of band.
 609          */
 610         if ((msm_read(port, UART_SR) & UART_SR_OVERRUN)) {
 611                 port->icount.overrun++;
 612                 tty_insert_flip_char(tport, 0, TTY_OVERRUN);
 613                 msm_write(port, UART_CR_CMD_RESET_ERR, UART_CR);
 614         }
 615
 616         /* and now the main RX loop */
 617         while ((sr = msm_read(port, UART_SR)) & UART_SR_RX_READY) {
 618                 unsigned int c;
 619                 char flag = TTY_NORMAL;
 620                 int sysrq;
 621
 622                 c = msm_read(port, UART_RF);
 623
 624                 if (sr & UART_SR_RX_BREAK) {
 625                         port->icount.brk++;
 626                         if (uart_handle_break(port))
 627                                 continue;
 628                 } else if (sr & UART_SR_PAR_FRAME_ERR) {
 629                         port->icount.frame++;
 630                 } else {
 631                         port->icount.rx++;
 632                 }
 633
 634                 /* Mask conditions we're ignorning. */
 635                 sr &= port->read_status_mask;
 636
 637                 if (sr & UART_SR_RX_BREAK)
 638                         flag = TTY_BREAK;
 639                 else if (sr & UART_SR_PAR_FRAME_ERR)
 640                         flag = TTY_FRAME;
 641
 642                 spin_unlock(&port->lock);
 643                 sysrq = uart_handle_sysrq_char(port, c);
 644                 spin_lock(&port->lock);
 645                 if (!sysrq)
 646                         tty_insert_flip_char(tport, c, flag);
 647         }
 648
 649         spin_unlock(&port->lock);
 650         tty_flip_buffer_push(tport);
 651         spin_lock(&port->lock);
 652 }
 653
 654 static void msm_handle_tx_pio(struct uart_port *port, unsigned int tx_count)
 655 {
 656         struct circ_buf *xmit = &port->state->xmit;
 657         struct msm_port *msm_port = UART_TO_MSM(port);
 658         unsigned int num_chars;
 659         unsigned int tf_pointer = 0;
 660         void __iomem *tf;
 661
 662         if (msm_port->is_uartdm)
 663                 tf = port->membase + UARTDM_TF;
 664         else
 665                 tf = port->membase + UART_TF;
 666
 667         if (tx_count && msm_port->is_uartdm)
 668                 msm_reset_dm_count(port, tx_count);
 669
 670         while (tf_pointer < tx_count) {
 671                 int i;
 672                 char buf[4] = { 0 };
 673
 674                 if (!(msm_read(port, UART_SR) & UART_SR_TX_READY))
 675                         break;
 676
 677                 if (msm_port->is_uartdm)
 678                         num_chars = min(tx_count - tf_pointer,
 679                                         (unsigned int)sizeof(buf));
 680                 else
 681                         num_chars = 1;
 682
 683                 for (i = 0; i < num_chars; i++) {
 684                         buf[i] = xmit->buf[xmit->tail + i];
 685                         port->icount.tx++;
 686                 }
 687
 688                 iowrite32_rep(tf, buf, 1);
 689                 xmit->tail = (xmit->tail + num_chars) & (UART_XMIT_SIZE - 1);
 690                 tf_pointer += num_chars;
 691         }
 692
 693         /* disable tx interrupts if nothing more to send */
 694         if (uart_circ_empty(xmit))
 695                 msm_stop_tx(port);
 696
 697         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 698                 uart_write_wakeup(port);
 699 }
 700
 701 static void msm_handle_tx(struct uart_port *port)
 702 {
 703         struct msm_port *msm_port = UART_TO_MSM(port);
 704         struct circ_buf *xmit = &msm_port->uart.state->xmit;
 705         struct msm_dma *dma = &msm_port->tx_dma;
 706         unsigned int pio_count, dma_count, dma_min;
 707         void __iomem *tf;
 708         int err = 0;
 709
 710         if (port->x_char) {
 711                 if (msm_port->is_uartdm)
 712                         tf = port->membase + UARTDM_TF;
 713                 else
 714                         tf = port->membase + UART_TF;
 715
 716                 if (msm_port->is_uartdm)
 717                         msm_reset_dm_count(port, 1);
 718
 719                 iowrite8_rep(tf, &port->x_char, 1);
 720                 port->icount.tx++;
 721                 port->x_char = 0;
 722                 return;
 723         }
 724
 725         if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
 726                 msm_stop_tx(port);
 727                 return;
 728         }
 729
 730         pio_count = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
 731         dma_count = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
 732
 733         dma_min = 1;    /* Always DMA */
 734         if (msm_port->is_uartdm > UARTDM_1P3) {
 735                 dma_count = UARTDM_TX_AIGN(dma_count);
 736                 dma_min = UARTDM_BURST_SIZE;
 737         } else {
 738                 if (dma_count > UARTDM_TX_MAX)
 739                         dma_count = UARTDM_TX_MAX;
 740         }
 741
 742         if (pio_count > port->fifosize)
 743                 pio_count = port->fifosize;
 744
 745         if (!dma->chan || dma_count < dma_min)
 746                 msm_handle_tx_pio(port, pio_count);
 747         else
 748                 err = msm_handle_tx_dma(msm_port, dma_count);
 749
 750         if (err)        /* fall back to PIO mode */
 751                 msm_handle_tx_pio(port, pio_count);
 752 }
 753
 754 static void msm_handle_delta_cts(struct uart_port *port)
 755 {
 756         msm_write(port, UART_CR_CMD_RESET_CTS, UART_CR);
 757         port->icount.cts++;
 758         wake_up_interruptible(&port->state->port.delta_msr_wait);
 759 }
 760
 761 static irqreturn_t msm_uart_irq(int irq, void *dev_id)
 762 {
 763         struct uart_port *port = dev_id;
 764         struct msm_port *msm_port = UART_TO_MSM(port);
 765         struct msm_dma *dma = &msm_port->rx_dma;
 766         unsigned long flags;
 767         unsigned int misr;
 768         u32 val;
 769
 770         spin_lock_irqsave(&port->lock, flags);
 771         misr = msm_read(port, UART_MISR);
 772         msm_write(port, 0, UART_IMR); /* disable interrupt */
 773
 774         if (misr & UART_IMR_RXBREAK_START) {
 775                 msm_port->break_detected = true;
 776                 msm_write(port, UART_CR_CMD_RESET_RXBREAK_START, UART_CR);
 777         }
 778
 779         if (misr & (UART_IMR_RXLEV | UART_IMR_RXSTALE)) {
 780                 if (dma->count) {
 781                         val = UART_CR_CMD_STALE_EVENT_DISABLE;
 782                         msm_write(port, val, UART_CR);
 783                         val = UART_CR_CMD_RESET_STALE_INT;
 784                         msm_write(port, val, UART_CR);
 785                         /*
 786                          * Flush DMA input fifo to memory, this will also
 787                          * trigger DMA RX completion
 788                          */
 789                         dmaengine_terminate_all(dma->chan);
 790                 } else if (msm_port->is_uartdm) {
 791                         msm_handle_rx_dm(port, misr);
 792                 } else {
 793                         msm_handle_rx(port);
 794                 }
 795         }
 796         if (misr & UART_IMR_TXLEV)
 797                 msm_handle_tx(port);
 798         if (misr & UART_IMR_DELTA_CTS)
 799                 msm_handle_delta_cts(port);
 800
 801         msm_write(port, msm_port->imr, UART_IMR); /* restore interrupt */
 802         spin_unlock_irqrestore(&port->lock, flags);
 803
 804         return IRQ_HANDLED;
 805 }
 806
 807 static unsigned int msm_tx_empty(struct uart_port *port)
 808 {
 809         return (msm_read(port, UART_SR) & UART_SR_TX_EMPTY) ? TIOCSER_TEMT : 0;
 810 }
 811
 812 static unsigned int msm_get_mctrl(struct uart_port *port)
 813 {
 814         return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR | TIOCM_RTS;
 815 }
 816
 817 static void msm_reset(struct uart_port *port)
 818 {
 819         struct msm_port *msm_port = UART_TO_MSM(port);
 820
 821         /* reset everything */
 822         msm_write(port, UART_CR_CMD_RESET_RX, UART_CR);
 823         msm_write(port, UART_CR_CMD_RESET_TX, UART_CR);
 824         msm_write(port, UART_CR_CMD_RESET_ERR, UART_CR);
 825         msm_write(port, UART_CR_CMD_RESET_BREAK_INT, UART_CR);
 826         msm_write(port, UART_CR_CMD_RESET_CTS, UART_CR);
 827         msm_write(port, UART_CR_CMD_SET_RFR, UART_CR);
 828
 829         /* Disable DM modes */
 830         if (msm_port->is_uartdm)
 831                 msm_write(port, 0, UARTDM_DMEN);
 832 }
 833
 834 static void msm_set_mctrl(struct uart_port *port, unsigned int mctrl)
 835 {
 836         unsigned int mr;
 837
 838         mr = msm_read(port, UART_MR1);
 839
 840         if (!(mctrl & TIOCM_RTS)) {
 841                 mr &= ~UART_MR1_RX_RDY_CTL;
 842                 msm_write(port, mr, UART_MR1);
 843                 msm_write(port, UART_CR_CMD_RESET_RFR, UART_CR);
 844         } else {
 845                 mr |= UART_MR1_RX_RDY_CTL;
 846                 msm_write(port, mr, UART_MR1);
 847         }
 848 }
 849
 850 static void msm_break_ctl(struct uart_port *port, int break_ctl)
 851 {
 852         if (break_ctl)
 853                 msm_write(port, UART_CR_CMD_START_BREAK, UART_CR);
 854         else
 855                 msm_write(port, UART_CR_CMD_STOP_BREAK, UART_CR);
 856 }
 857
 858 struct msm_baud_map {
 859         u16     divisor;
 860         u8      code;
 861         u8      rxstale;
 862 };
 863
 864 static const struct msm_baud_map *
 865 msm_find_best_baud(struct uart_port *port, unsigned int baud)
 866 {
 867         unsigned int i, divisor;
 868         const struct msm_baud_map *entry;
 869         static const struct msm_baud_map table[] = {
 870                 { 1536, 0x00,  1 },
 871                 {  768, 0x11,  1 },
 872                 {  384, 0x22,  1 },
 873                 {  192, 0x33,  1 },
 874                 {   96, 0x44,  1 },
 875                 {   48, 0x55,  1 },
 876                 {   32, 0x66,  1 },
 877                 {   24, 0x77,  1 },
 878                 {   16, 0x88,  1 },
 879                 {   12, 0x99,  6 },
 880                 {    8, 0xaa,  6 },
 881                 {    6, 0xbb,  6 },
 882                 {    4, 0xcc,  6 },
 883                 {    3, 0xdd,  8 },
 884                 {    2, 0xee, 16 },
 885                 {    1, 0xff, 31 },
 886                 {    0, 0xff, 31 },
 887         };
 888
 889         divisor = uart_get_divisor(port, baud);
 890
 891         for (i = 0, entry = table; i < ARRAY_SIZE(table); i++, entry++)
 892                 if (entry->divisor <= divisor)
 893                         break;
 894
 895         return entry; /* Default to smallest divider */
 896 }
 897
 898 static int msm_set_baud_rate(struct uart_port *port, unsigned int baud,
 899                              unsigned long *saved_flags)
 900 {
 901         unsigned int rxstale, watermark, mask;
 902         struct msm_port *msm_port = UART_TO_MSM(port);
 903         const struct msm_baud_map *entry;
 904         unsigned long flags;
 905
 906         entry = msm_find_best_baud(port, baud);
 907
 908         msm_write(port, entry->code, UART_CSR);
 909
 910         if (baud > 460800)
 911                 port->uartclk = baud * 16;
 912
 913         flags = *saved_flags;
 914         spin_unlock_irqrestore(&port->lock, flags);
 915
 916         clk_set_rate(msm_port->clk, port->uartclk);
 917
 918         spin_lock_irqsave(&port->lock, flags);
 919         *saved_flags = flags;
 920
 921         /* RX stale watermark */
 922         rxstale = entry->rxstale;
 923         watermark = UART_IPR_STALE_LSB & rxstale;
 924         if (msm_port->is_uartdm) {
 925                 mask = UART_DM_IPR_STALE_TIMEOUT_MSB;
 926         } else {
 927                 watermark |= UART_IPR_RXSTALE_LAST;
 928                 mask = UART_IPR_STALE_TIMEOUT_MSB;
 929         }
 930
 931         watermark |= mask & (rxstale << 2);
 932
 933         msm_write(port, watermark, UART_IPR);
 934
 935         /* set RX watermark */
 936         watermark = (port->fifosize * 3) / 4;
 937         msm_write(port, watermark, UART_RFWR);
 938
 939         /* set TX watermark */
 940         msm_write(port, 10, UART_TFWR);
 941
 942         msm_write(port, UART_CR_CMD_PROTECTION_EN, UART_CR);
 943         msm_reset(port);
 944
 945         /* Enable RX and TX */
 946         msm_write(port, UART_CR_TX_ENABLE | UART_CR_RX_ENABLE, UART_CR);
 947
 948         /* turn on RX and CTS interrupts */
 949         msm_port->imr = UART_IMR_RXLEV | UART_IMR_RXSTALE |
 950                         UART_IMR_CURRENT_CTS | UART_IMR_RXBREAK_START;
 951
 952         msm_write(port, msm_port->imr, UART_IMR);
 953
 954         if (msm_port->is_uartdm) {
 955                 msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);
 956                 msm_write(port, 0xFFFFFF, UARTDM_DMRX);
 957                 msm_write(port, UART_CR_CMD_STALE_EVENT_ENABLE, UART_CR);
 958         }
 959
 960         return baud;
 961 }
 962
 963 static void msm_init_clock(struct uart_port *port)
 964 {
 965         struct msm_port *msm_port = UART_TO_MSM(port);
 966
 967         clk_prepare_enable(msm_port->clk);
 968         clk_prepare_enable(msm_port->pclk);
 969         msm_serial_set_mnd_regs(port);
 970 }
 971
 972 static int msm_startup(struct uart_port *port)
 973 {
 974         struct msm_port *msm_port = UART_TO_MSM(port);
 975         unsigned int data, rfr_level, mask;
 976         int ret;
 977
 978         snprintf(msm_port->name, sizeof(msm_port->name),
 979                  "msm_serial%d", port->line);
 980
 981         ret = request_irq(port->irq, msm_uart_irq, IRQF_TRIGGER_HIGH,
 982                           msm_port->name, port);
 983         if (unlikely(ret))
 984                 return ret;
 985
 986         msm_init_clock(port);
 987
 988         if (likely(port->fifosize > 12))
 989                 rfr_level = port->fifosize - 12;
 990         else
 991                 rfr_level = port->fifosize;
 992
 993         /* set automatic RFR level */
 994         data = msm_read(port, UART_MR1);
 995
 996         if (msm_port->is_uartdm)
 997                 mask = UART_DM_MR1_AUTO_RFR_LEVEL1;
 998         else
 999                 mask = UART_MR1_AUTO_RFR_LEVEL1;
1000
1001         data &= ~mask;
1002         data &= ~UART_MR1_AUTO_RFR_LEVEL0;
1003         data |= mask & (rfr_level << 2);
1004         data |= UART_MR1_AUTO_RFR_LEVEL0 & rfr_level;
1005         msm_write(port, data, UART_MR1);
1006
1007         if (msm_port->is_uartdm) {
1008                 msm_request_tx_dma(msm_port, msm_port->uart.mapbase);
1009                 msm_request_rx_dma(msm_port, msm_port->uart.mapbase);
1010         }
1011
1012         return 0;
1013 }
1014
1015 static void msm_shutdown(struct uart_port *port)
1016 {
1017         struct msm_port *msm_port = UART_TO_MSM(port);
1018
1019         msm_port->imr = 0;
1020         msm_write(port, 0, UART_IMR); /* disable interrupts */
1021
1022         if (msm_port->is_uartdm)
1023                 msm_release_dma(msm_port);
1024
1025         clk_disable_unprepare(msm_port->clk);
1026
1027         free_irq(port->irq, port);
1028 }
1029
1030 static void msm_set_termios(struct uart_port *port, struct ktermios *termios,
1031                             struct ktermios *old)
1032 {
1033         struct msm_port *msm_port = UART_TO_MSM(port);
1034         struct msm_dma *dma = &msm_port->rx_dma;
1035         unsigned long flags;
1036         unsigned int baud, mr;
1037
1038         spin_lock_irqsave(&port->lock, flags);
1039
1040         if (dma->chan) /* Terminate if any */
1041                 msm_stop_dma(port, dma);
1042
1043         /* calculate and set baud rate, if changed from last request */
1044         baud = uart_get_baud_rate(port, termios, old, 300, 4000000);
1045         if (baud != msm_port->last_baud) {
1046                 msm_port->last_baud = baud;
1047
1048                 baud = msm_set_baud_rate(port, baud, &flags);
1049                 if (tty_termios_baud_rate(termios))
1050                         tty_termios_encode_baud_rate(termios, baud, baud);
1051                 uart_update_timeout(port, termios->c_cflag, baud);
1052         }
1053
1054         /* calculate parity */
1055         mr = msm_read(port, UART_MR2);
1056         mr &= ~UART_MR2_PARITY_MODE;
1057         if (termios->c_cflag & PARENB) {
1058                 if (termios->c_cflag & PARODD)
1059                         mr |= UART_MR2_PARITY_MODE_ODD;
1060                 else if (termios->c_cflag & CMSPAR)
1061                         mr |= UART_MR2_PARITY_MODE_SPACE;
1062                 else
1063                         mr |= UART_MR2_PARITY_MODE_EVEN;
1064         }
1065
1066         /* calculate bits per char */
1067         mr &= ~UART_MR2_BITS_PER_CHAR;
1068         switch (termios->c_cflag & CSIZE) {
1069         case CS5:
1070                 mr |= UART_MR2_BITS_PER_CHAR_5;
1071                 break;
1072         case CS6:
1073                 mr |= UART_MR2_BITS_PER_CHAR_6;
1074                 break;
1075         case CS7:
1076                 mr |= UART_MR2_BITS_PER_CHAR_7;
1077                 break;
1078         case CS8:
1079         default:
1080                 mr |= UART_MR2_BITS_PER_CHAR_8;
1081                 break;
1082         }
1083
1084         /* calculate stop bits */
1085         mr &= ~(UART_MR2_STOP_BIT_LEN_ONE | UART_MR2_STOP_BIT_LEN_TWO);
1086         if (termios->c_cflag & CSTOPB)
1087                 mr |= UART_MR2_STOP_BIT_LEN_TWO;
1088         else
1089                 mr |= UART_MR2_STOP_BIT_LEN_ONE;
1090
1091         /* set parity, bits per char, and stop bit */
1092         msm_write(port, mr, UART_MR2);
1093
1094         /* calculate and set hardware flow control */
1095         mr = msm_read(port, UART_MR1);
1096         mr &= ~(UART_MR1_CTS_CTL | UART_MR1_RX_RDY_CTL);
1097         if (termios->c_cflag & CRTSCTS) {
1098                 mr |= UART_MR1_CTS_CTL;
1099                 mr |= UART_MR1_RX_RDY_CTL;
1100         }
1101         msm_write(port, mr, UART_MR1);
1102
1103         /* Configure status bits to ignore based on termio flags. */
1104         port->read_status_mask = 0;
1105         if (termios->c_iflag & INPCK)
1106                 port->read_status_mask |= UART_SR_PAR_FRAME_ERR;
1107         if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
1108                 port->read_status_mask |= UART_SR_RX_BREAK;
1109
1110         /* Try to use DMA */
1111         msm_start_rx_dma(msm_port);
1112
1113         spin_unlock_irqrestore(&port->lock, flags);
1114 }
1115
1116 static const char *msm_type(struct uart_port *port)
1117 {
1118         return "MSM";
1119 }
1120
1121 static void msm_release_port(struct uart_port *port)
1122 {
1123         struct platform_device *pdev = to_platform_device(port->dev);
1124         struct resource *uart_resource;
1125         resource_size_t size;
1126
1127         uart_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1128         if (unlikely(!uart_resource))
1129                 return;
1130         size = resource_size(uart_resource);
1131
1132         release_mem_region(port->mapbase, size);
1133         iounmap(port->membase);
1134         port->membase = NULL;
1135 }
1136
1137 static int msm_request_port(struct uart_port *port)
1138 {
1139         struct platform_device *pdev = to_platform_device(port->dev);
1140         struct resource *uart_resource;
1141         resource_size_t size;
1142         int ret;
1143
1144         uart_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1145         if (unlikely(!uart_resource))
1146                 return -ENXIO;
1147
1148         size = resource_size(uart_resource);
1149
1150         if (!request_mem_region(port->mapbase, size, "msm_serial"))
1151                 return -EBUSY;
1152
1153         port->membase = ioremap(port->mapbase, size);
1154         if (!port->membase) {
1155                 ret = -EBUSY;
1156                 goto fail_release_port;
1157         }
1158
1159         return 0;
1160
1161 fail_release_port:
1162         release_mem_region(port->mapbase, size);
1163         return ret;
1164 }
1165
1166 static void msm_config_port(struct uart_port *port, int flags)
1167 {
1168         int ret;
1169
1170         if (flags & UART_CONFIG_TYPE) {
1171                 port->type = PORT_MSM;
1172                 ret = msm_request_port(port);
1173                 if (ret)
1174                         return;
1175         }
1176 }
1177
1178 static int msm_verify_port(struct uart_port *port, struct serial_struct *ser)
1179 {
1180         if (unlikely(ser->type != PORT_UNKNOWN && ser->type != PORT_MSM))
1181                 return -EINVAL;
1182         if (unlikely(port->irq != ser->irq))
1183                 return -EINVAL;
1184         return 0;
1185 }
1186
1187 static void msm_power(struct uart_port *port, unsigned int state,
1188                       unsigned int oldstate)
1189 {
1190         struct msm_port *msm_port = UART_TO_MSM(port);
1191
1192         switch (state) {
1193         case 0:
1194                 clk_prepare_enable(msm_port->clk);
1195                 clk_prepare_enable(msm_port->pclk);
1196                 break;
1197         case 3:
1198                 clk_disable_unprepare(msm_port->clk);
1199                 clk_disable_unprepare(msm_port->pclk);
1200                 break;
1201         default:
1202                 pr_err("msm_serial: Unknown PM state %d\n", state);
1203         }
1204 }
1205
1206 #ifdef CONFIG_CONSOLE_POLL
1207 static int msm_poll_get_char_single(struct uart_port *port)
1208 {
1209         struct msm_port *msm_port = UART_TO_MSM(port);
1210         unsigned int rf_reg = msm_port->is_uartdm ? UARTDM_RF : UART_RF;
1211
1212         if (!(msm_read(port, UART_SR) & UART_SR_RX_READY))
1213                 return NO_POLL_CHAR;
1214
1215         return msm_read(port, rf_reg) & 0xff;
1216 }
1217
1218 static int msm_poll_get_char_dm(struct uart_port *port)
1219 {
1220         int c;
1221         static u32 slop;
1222         static int count;
1223         unsigned char *sp = (unsigned char *)&slop;
1224
1225         /* Check if a previous read had more than one char */
1226         if (count) {
1227                 c = sp[sizeof(slop) - count];
1228                 count--;
1229         /* Or if FIFO is empty */
1230         } else if (!(msm_read(port, UART_SR) & UART_SR_RX_READY)) {
1231                 /*
1232                  * If RX packing buffer has less than a word, force stale to
1233                  * push contents into RX FIFO
1234                  */
1235                 count = msm_read(port, UARTDM_RXFS);
1236                 count = (count >> UARTDM_RXFS_BUF_SHIFT) & UARTDM_RXFS_BUF_MASK;
1237                 if (count) {
1238                         msm_write(port, UART_CR_CMD_FORCE_STALE, UART_CR);
1239                         slop = msm_read(port, UARTDM_RF);
1240                         c = sp[0];
1241                         count--;
1242                         msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);
1243                         msm_write(port, 0xFFFFFF, UARTDM_DMRX);
1244                         msm_write(port, UART_CR_CMD_STALE_EVENT_ENABLE,
1245                                   UART_CR);
1246                 } else {
1247                         c = NO_POLL_CHAR;
1248                 }
1249         /* FIFO has a word */
1250         } else {
1251                 slop = msm_read(port, UARTDM_RF);
1252                 c = sp[0];
1253                 count = sizeof(slop) - 1;
1254         }
1255
1256         return c;
1257 }
1258
1259 static int msm_poll_get_char(struct uart_port *port)
1260 {
1261         u32 imr;
1262         int c;
1263         struct msm_port *msm_port = UART_TO_MSM(port);
1264
1265         /* Disable all interrupts */
1266         imr = msm_read(port, UART_IMR);
1267         msm_write(port, 0, UART_IMR);
1268
1269         if (msm_port->is_uartdm)
1270                 c = msm_poll_get_char_dm(port);
1271         else
1272                 c = msm_poll_get_char_single(port);
1273
1274         /* Enable interrupts */
1275         msm_write(port, imr, UART_IMR);
1276
1277         return c;
1278 }
1279
1280 static void msm_poll_put_char(struct uart_port *port, unsigned char c)
1281 {
1282         u32 imr;
1283         struct msm_port *msm_port = UART_TO_MSM(port);
1284
1285         /* Disable all interrupts */
1286         imr = msm_read(port, UART_IMR);
1287         msm_write(port, 0, UART_IMR);
1288
1289         if (msm_port->is_uartdm)
1290                 msm_reset_dm_count(port, 1);
1291
1292         /* Wait until FIFO is empty */
1293         while (!(msm_read(port, UART_SR) & UART_SR_TX_READY))
1294                 cpu_relax();
1295
1296         /* Write a character */
1297         msm_write(port, c, msm_port->is_uartdm ? UARTDM_TF : UART_TF);
1298
1299         /* Wait until FIFO is empty */
1300         while (!(msm_read(port, UART_SR) & UART_SR_TX_READY))
1301                 cpu_relax();
1302
1303         /* Enable interrupts */
1304         msm_write(port, imr, UART_IMR);
1305 }
1306 #endif
1307
1308 static struct uart_ops msm_uart_pops = {
1309         .tx_empty = msm_tx_empty,
1310         .set_mctrl = msm_set_mctrl,
1311         .get_mctrl = msm_get_mctrl,
1312         .stop_tx = msm_stop_tx,
1313         .start_tx = msm_start_tx,
1314         .stop_rx = msm_stop_rx,
1315         .enable_ms = msm_enable_ms,
1316         .break_ctl = msm_break_ctl,
1317         .startup = msm_startup,
1318         .shutdown = msm_shutdown,
1319         .set_termios = msm_set_termios,
1320         .type = msm_type,
1321         .release_port = msm_release_port,
1322         .request_port = msm_request_port,
1323         .config_port = msm_config_port,
1324         .verify_port = msm_verify_port,
1325         .pm = msm_power,
1326 #ifdef CONFIG_CONSOLE_POLL
1327         .poll_get_char  = msm_poll_get_char,
1328         .poll_put_char  = msm_poll_put_char,
1329 #endif
1330 };
1331
1332 static struct msm_port msm_uart_ports[] = {
1333         {
1334                 .uart = {
1335                         .iotype = UPIO_MEM,
1336                         .ops = &msm_uart_pops,
1337                         .flags = UPF_BOOT_AUTOCONF,
1338                         .fifosize = 64,
1339                         .line = 0,
1340                 },
1341         },
1342         {
1343                 .uart = {
1344                         .iotype = UPIO_MEM,
1345                         .ops = &msm_uart_pops,
1346                         .flags = UPF_BOOT_AUTOCONF,
1347                         .fifosize = 64,
1348                         .line = 1,
1349                 },
1350         },
1351         {
1352                 .uart = {
1353                         .iotype = UPIO_MEM,
1354                         .ops = &msm_uart_pops,
1355                         .flags = UPF_BOOT_AUTOCONF,
1356                         .fifosize = 64,
1357                         .line = 2,
1358                 },
1359         },
1360 };
1361
1362 #define UART_NR ARRAY_SIZE(msm_uart_ports)
1363
1364 static inline struct uart_port *msm_get_port_from_line(unsigned int line)
1365 {
1366         return &msm_uart_ports[line].uart;
1367 }
1368
1369 #ifdef CONFIG_SERIAL_MSM_CONSOLE
1370 static void __msm_console_write(struct uart_port *port, const char *s,
1371                                 unsigned int count, bool is_uartdm)
1372 {
1373         int i;
1374         int num_newlines = 0;
1375         bool replaced = false;
1376         void __iomem *tf;
1377
1378         if (is_uartdm)
1379                 tf = port->membase + UARTDM_TF;
1380         else
1381                 tf = port->membase + UART_TF;
1382
1383         /* Account for newlines that will get a carriage return added */
1384         for (i = 0; i < count; i++)
1385                 if (s[i] == '\n')
1386                         num_newlines++;
1387         count += num_newlines;
1388
1389         spin_lock(&port->lock);
1390         if (is_uartdm)
1391                 msm_reset_dm_count(port, count);
1392
1393         i = 0;
1394         while (i < count) {
1395                 int j;
1396                 unsigned int num_chars;
1397                 char buf[4] = { 0 };
1398
1399                 if (is_uartdm)
1400                         num_chars = min(count - i, (unsigned int)sizeof(buf));
1401                 else
1402                         num_chars = 1;
1403
1404                 for (j = 0; j < num_chars; j++) {
1405                         char c = *s;
1406
1407                         if (c == '\n' && !replaced) {
1408                                 buf[j] = '\r';
1409                                 j++;
1410                                 replaced = true;
1411                         }
1412                         if (j < num_chars) {
1413                                 buf[j] = c;
1414                                 s++;
1415                                 replaced = false;
1416                         }
1417                 }
1418
1419                 while (!(msm_read(port, UART_SR) & UART_SR_TX_READY))
1420                         cpu_relax();
1421
1422                 iowrite32_rep(tf, buf, 1);
1423                 i += num_chars;
1424         }
1425         spin_unlock(&port->lock);
1426 }
1427
1428 static void msm_console_write(struct console *co, const char *s,
1429                               unsigned int count)
1430 {
1431         struct uart_port *port;
1432         struct msm_port *msm_port;
1433
1434         BUG_ON(co->index < 0 || co->index >= UART_NR);
1435
1436         port = msm_get_port_from_line(co->index);
1437         msm_port = UART_TO_MSM(port);
1438
1439         __msm_console_write(port, s, count, msm_port->is_uartdm);
1440 }
1441
1442 static int __init msm_console_setup(struct console *co, char *options)
1443 {
1444         struct uart_port *port;
1445         int baud = 115200;
1446         int bits = 8;
1447         int parity = 'n';
1448         int flow = 'n';
1449
1450         if (unlikely(co->index >= UART_NR || co->index < 0))
1451                 return -ENXIO;
1452
1453         port = msm_get_port_from_line(co->index);
1454
1455         if (unlikely(!port->membase))
1456                 return -ENXIO;
1457
1458         msm_init_clock(port);
1459
1460         if (options)
1461                 uart_parse_options(options, &baud, &parity, &bits, &flow);
1462
1463         pr_info("msm_serial: console setup on port #%d\n", port->line);
1464
1465         return uart_set_options(port, co, baud, parity, bits, flow);
1466 }
1467
1468 static void
1469 msm_serial_early_write(struct console *con, const char *s, unsigned n)
1470 {
1471         struct earlycon_device *dev = con->data;
1472
1473         __msm_console_write(&dev->port, s, n, false);
1474 }
1475
1476 static int __init
1477 msm_serial_early_console_setup(struct earlycon_device *device, const char *opt)
1478 {
1479         if (!device->port.membase)
1480                 return -ENODEV;
1481
1482         device->con->write = msm_serial_early_write;
1483         return 0;
1484 }
1485 EARLYCON_DECLARE(msm_serial, msm_serial_early_console_setup);
1486 OF_EARLYCON_DECLARE(msm_serial, "qcom,msm-uart",
1487                     msm_serial_early_console_setup);
1488
1489 static void
1490 msm_serial_early_write_dm(struct console *con, const char *s, unsigned n)
1491 {
1492         struct earlycon_device *dev = con->data;
1493
1494         __msm_console_write(&dev->port, s, n, true);
1495 }
1496
1497 static int __init
1498 msm_serial_early_console_setup_dm(struct earlycon_device *device,
1499                                   const char *opt)
1500 {
1501         if (!device->port.membase)
1502                 return -ENODEV;
1503
1504         device->con->write = msm_serial_early_write_dm;
1505         return 0;
1506 }
1507 EARLYCON_DECLARE(msm_serial_dm, msm_serial_early_console_setup_dm);
1508 OF_EARLYCON_DECLARE(msm_serial_dm, "qcom,msm-uartdm",
1509                     msm_serial_early_console_setup_dm);
1510
1511 static struct uart_driver msm_uart_driver;
1512
1513 static struct console msm_console = {
1514         .name = "ttyMSM",
1515         .write = msm_console_write,
1516         .device = uart_console_device,
1517         .setup = msm_console_setup,
1518         .flags = CON_PRINTBUFFER,
1519         .index = -1,
1520         .data = &msm_uart_driver,
1521 };
1522
1523 #define MSM_CONSOLE     (&msm_console)
1524
1525 #else
1526 #define MSM_CONSOLE     NULL
1527 #endif
1528
1529 static struct uart_driver msm_uart_driver = {
1530         .owner = THIS_MODULE,
1531         .driver_name = "msm_serial",
1532         .dev_name = "ttyMSM",
1533         .nr = UART_NR,
1534         .cons = MSM_CONSOLE,
1535 };
1536
1537 static atomic_t msm_uart_next_id = ATOMIC_INIT(0);
1538
1539 static const struct of_device_id msm_uartdm_table[] = {
1540         { .compatible = "qcom,msm-uartdm-v1.1", .data = (void *)UARTDM_1P1 },
1541         { .compatible = "qcom,msm-uartdm-v1.2", .data = (void *)UARTDM_1P2 },
1542         { .compatible = "qcom,msm-uartdm-v1.3", .data = (void *)UARTDM_1P3 },
1543         { .compatible = "qcom,msm-uartdm-v1.4", .data = (void *)UARTDM_1P4 },
1544         { }
1545 };
1546
1547 static int msm_serial_probe(struct platform_device *pdev)
1548 {
1549         struct msm_port *msm_port;
1550         struct resource *resource;
1551         struct uart_port *port;
1552         const struct of_device_id *id;
1553         int irq, line;
1554
1555         if (pdev->dev.of_node)
1556                 line = of_alias_get_id(pdev->dev.of_node, "serial");
1557         else
1558                 line = pdev->id;
1559
1560         if (line < 0)
1561                 line = atomic_inc_return(&msm_uart_next_id) - 1;
1562
1563         if (unlikely(line < 0 || line >= UART_NR))
1564                 return -ENXIO;
1565
1566         dev_info(&pdev->dev, "msm_serial: detected port #%d\n", line);
1567
1568         port = msm_get_port_from_line(line);
1569         port->dev = &pdev->dev;
1570         msm_port = UART_TO_MSM(port);
1571
1572         id = of_match_device(msm_uartdm_table, &pdev->dev);
1573         if (id)
1574                 msm_port->is_uartdm = (unsigned long)id->data;
1575         else
1576                 msm_port->is_uartdm = 0;
1577
1578         msm_port->clk = devm_clk_get(&pdev->dev, "core");
1579         if (IS_ERR(msm_port->clk))
1580                 return PTR_ERR(msm_port->clk);
1581
1582         if (msm_port->is_uartdm) {
1583                 msm_port->pclk = devm_clk_get(&pdev->dev, "iface");
1584                 if (IS_ERR(msm_port->pclk))
1585                         return PTR_ERR(msm_port->pclk);
1586
1587                 clk_set_rate(msm_port->clk, 1843200);
1588         }
1589
1590         port->uartclk = clk_get_rate(msm_port->clk);
1591         dev_info(&pdev->dev, "uartclk = %d\n", port->uartclk);
1592
1593         resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1594         if (unlikely(!resource))
1595                 return -ENXIO;
1596         port->mapbase = resource->start;
1597
1598         irq = platform_get_irq(pdev, 0);
1599         if (unlikely(irq < 0))
1600                 return -ENXIO;
1601         port->irq = irq;
1602
1603         platform_set_drvdata(pdev, port);
1604
1605         return uart_add_one_port(&msm_uart_driver, port);
1606 }
1607
1608 static int msm_serial_remove(struct platform_device *pdev)
1609 {
1610         struct uart_port *port = platform_get_drvdata(pdev);
1611
1612         uart_remove_one_port(&msm_uart_driver, port);
1613
1614         return 0;
1615 }
1616
1617 static const struct of_device_id msm_match_table[] = {
1618         { .compatible = "qcom,msm-uart" },
1619         { .compatible = "qcom,msm-uartdm" },
1620         {}
1621 };
1622
1623 static struct platform_driver msm_platform_driver = {
1624         .remove = msm_serial_remove,
1625         .probe = msm_serial_probe,
1626         .driver = {
1627                 .name = "msm_serial",
1628                 .of_match_table = msm_match_table,
1629         },
1630 };
1631
1632 static int __init msm_serial_init(void)
1633 {
1634         int ret;
1635
1636         ret = uart_register_driver(&msm_uart_driver);
1637         if (unlikely(ret))
1638                 return ret;
1639
1640         ret = platform_driver_register(&msm_platform_driver);
1641         if (unlikely(ret))
1642                 uart_unregister_driver(&msm_uart_driver);
1643
1644         pr_info("msm_serial: driver initialized\n");
1645
1646         return ret;
1647 }
1648
1649 static void __exit msm_serial_exit(void)
1650 {
1651         platform_driver_unregister(&msm_platform_driver);
1652         uart_unregister_driver(&msm_uart_driver);
1653 }
1654
1655 module_init(msm_serial_init);
1656 module_exit(msm_serial_exit);
1657
1658 MODULE_AUTHOR("Robert Love <rlove@google.com>");
1659 MODULE_DESCRIPTION("Driver for msm7x serial device");
1660 MODULE_LICENSE("GPL");