drivers/tty/serial/amba-pl011.c

   1 /*
   2  *  Driver for AMBA serial ports
   3  *
   4  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
   5  *
   6  *  Copyright 1999 ARM Limited
   7  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
   8  *  Copyright (C) 2010 ST-Ericsson SA
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  *
  24  * This is a generic driver for ARM AMBA-type serial ports.  They
  25  * have a lot of 16550-like features, but are not register compatible.
  26  * Note that although they do have CTS, DCD and DSR inputs, they do
  27  * not have an RI input, nor do they have DTR or RTS outputs.  If
  28  * required, these have to be supplied via some other means (eg, GPIO)
  29  * and hooked into this driver.
  30  */
  31
  32
  33 #if defined(CONFIG_SERIAL_AMBA_PL011_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  34 #define SUPPORT_SYSRQ
  35 #endif
  36
  37 #include <linux/module.h>
  38 #include <linux/ioport.h>
  39 #include <linux/init.h>
  40 #include <linux/console.h>
  41 #include <linux/sysrq.h>
  42 #include <linux/device.h>
  43 #include <linux/tty.h>
  44 #include <linux/tty_flip.h>
  45 #include <linux/serial_core.h>
  46 #include <linux/serial.h>
  47 #include <linux/amba/bus.h>
  48 #include <linux/amba/serial.h>
  49 #include <linux/clk.h>
  50 #include <linux/slab.h>
  51 #include <linux/dmaengine.h>
  52 #include <linux/dma-mapping.h>
  53 #include <linux/scatterlist.h>
  54 #include <linux/delay.h>
  55 #include <linux/types.h>
  56 #include <linux/of.h>
  57 #include <linux/of_device.h>
  58 #include <linux/pinctrl/consumer.h>
  59 #include <linux/sizes.h>
  60 #include <linux/io.h>
  61 #include <linux/acpi.h>
  62
  63 #include "amba-pl011.h"
  64
  65 #define UART_NR                 14
  66
  67 #define SERIAL_AMBA_MAJOR       204
  68 #define SERIAL_AMBA_MINOR       64
  69 #define SERIAL_AMBA_NR          UART_NR
  70
  71 #define AMBA_ISR_PASS_LIMIT     256
  72
  73 #define UART_DR_ERROR           (UART011_DR_OE|UART011_DR_BE|UART011_DR_PE|UART011_DR_FE)
  74 #define UART_DUMMY_DR_RX        (1 << 16)
  75
  76 static u16 pl011_std_offsets[REG_ARRAY_SIZE] = {
  77         [REG_DR] = UART01x_DR,
  78         [REG_FR] = UART01x_FR,
  79         [REG_LCRH_RX] = UART011_LCRH,
  80         [REG_LCRH_TX] = UART011_LCRH,
  81         [REG_IBRD] = UART011_IBRD,
  82         [REG_FBRD] = UART011_FBRD,
  83         [REG_CR] = UART011_CR,
  84         [REG_IFLS] = UART011_IFLS,
  85         [REG_IMSC] = UART011_IMSC,
  86         [REG_RIS] = UART011_RIS,
  87         [REG_MIS] = UART011_MIS,
  88         [REG_ICR] = UART011_ICR,
  89         [REG_DMACR] = UART011_DMACR,
  90 };
  91
  92 /* There is by now at least one vendor with differing details, so handle it */
  93 struct vendor_data {
  94         const u16               *reg_offset;
  95         unsigned int            ifls;
  96         unsigned int            fr_busy;
  97         unsigned int            fr_dsr;
  98         unsigned int            fr_cts;
  99         unsigned int            fr_ri;
 100         unsigned int            inv_fr;
 101         bool                    access_32b;
 102         bool                    oversampling;
 103         bool                    dma_threshold;
 104         bool                    cts_event_workaround;
 105         bool                    always_enabled;
 106         bool                    fixed_options;
 107
 108         unsigned int (*get_fifosize)(struct amba_device *dev);
 109 };
 110
 111 static unsigned int get_fifosize_arm(struct amba_device *dev)
 112 {
 113         return amba_rev(dev) < 3 ? 16 : 32;
 114 }
 115
 116 static struct vendor_data vendor_arm = {
 117         .reg_offset             = pl011_std_offsets,
 118         .ifls                   = UART011_IFLS_RX4_8|UART011_IFLS_TX4_8,
 119         .fr_busy                = UART01x_FR_BUSY,
 120         .fr_dsr                 = UART01x_FR_DSR,
 121         .fr_cts                 = UART01x_FR_CTS,
 122         .fr_ri                  = UART011_FR_RI,
 123         .oversampling           = false,
 124         .dma_threshold          = false,
 125         .cts_event_workaround   = false,
 126         .always_enabled         = false,
 127         .fixed_options          = false,
 128         .get_fifosize           = get_fifosize_arm,
 129 };
 130
 131 static const struct vendor_data vendor_sbsa = {
 132         .reg_offset             = pl011_std_offsets,
 133         .fr_busy                = UART01x_FR_BUSY,
 134         .fr_dsr                 = UART01x_FR_DSR,
 135         .fr_cts                 = UART01x_FR_CTS,
 136         .fr_ri                  = UART011_FR_RI,
 137         .access_32b             = true,
 138         .oversampling           = false,
 139         .dma_threshold          = false,
 140         .cts_event_workaround   = false,
 141         .always_enabled         = true,
 142         .fixed_options          = true,
 143 };
 144
 145 #ifdef CONFIG_ACPI_SPCR_TABLE
 146 static const struct vendor_data vendor_qdt_qdf2400_e44 = {
 147         .reg_offset             = pl011_std_offsets,
 148         .fr_busy                = UART011_FR_TXFE,
 149         .fr_dsr                 = UART01x_FR_DSR,
 150         .fr_cts                 = UART01x_FR_CTS,
 151         .fr_ri                  = UART011_FR_RI,
 152         .inv_fr                 = UART011_FR_TXFE,
 153         .access_32b             = true,
 154         .oversampling           = false,
 155         .dma_threshold          = false,
 156         .cts_event_workaround   = false,
 157         .always_enabled         = true,
 158         .fixed_options          = true,
 159 };
 160 #endif
 161
 162 static u16 pl011_st_offsets[REG_ARRAY_SIZE] = {
 163         [REG_DR] = UART01x_DR,
 164         [REG_ST_DMAWM] = ST_UART011_DMAWM,
 165         [REG_ST_TIMEOUT] = ST_UART011_TIMEOUT,
 166         [REG_FR] = UART01x_FR,
 167         [REG_LCRH_RX] = ST_UART011_LCRH_RX,
 168         [REG_LCRH_TX] = ST_UART011_LCRH_TX,
 169         [REG_IBRD] = UART011_IBRD,
 170         [REG_FBRD] = UART011_FBRD,
 171         [REG_CR] = UART011_CR,
 172         [REG_IFLS] = UART011_IFLS,
 173         [REG_IMSC] = UART011_IMSC,
 174         [REG_RIS] = UART011_RIS,
 175         [REG_MIS] = UART011_MIS,
 176         [REG_ICR] = UART011_ICR,
 177         [REG_DMACR] = UART011_DMACR,
 178         [REG_ST_XFCR] = ST_UART011_XFCR,
 179         [REG_ST_XON1] = ST_UART011_XON1,
 180         [REG_ST_XON2] = ST_UART011_XON2,
 181         [REG_ST_XOFF1] = ST_UART011_XOFF1,
 182         [REG_ST_XOFF2] = ST_UART011_XOFF2,
 183         [REG_ST_ITCR] = ST_UART011_ITCR,
 184         [REG_ST_ITIP] = ST_UART011_ITIP,
 185         [REG_ST_ABCR] = ST_UART011_ABCR,
 186         [REG_ST_ABIMSC] = ST_UART011_ABIMSC,
 187 };
 188
 189 static unsigned int get_fifosize_st(struct amba_device *dev)
 190 {
 191         return 64;
 192 }
 193
 194 static struct vendor_data vendor_st = {
 195         .reg_offset             = pl011_st_offsets,
 196         .ifls                   = UART011_IFLS_RX_HALF|UART011_IFLS_TX_HALF,
 197         .fr_busy                = UART01x_FR_BUSY,
 198         .fr_dsr                 = UART01x_FR_DSR,
 199         .fr_cts                 = UART01x_FR_CTS,
 200         .fr_ri                  = UART011_FR_RI,
 201         .oversampling           = true,
 202         .dma_threshold          = true,
 203         .cts_event_workaround   = true,
 204         .always_enabled         = false,
 205         .fixed_options          = false,
 206         .get_fifosize           = get_fifosize_st,
 207 };
 208
 209 static const u16 pl011_zte_offsets[REG_ARRAY_SIZE] = {
 210         [REG_DR] = ZX_UART011_DR,
 211         [REG_FR] = ZX_UART011_FR,
 212         [REG_LCRH_RX] = ZX_UART011_LCRH,
 213         [REG_LCRH_TX] = ZX_UART011_LCRH,
 214         [REG_IBRD] = ZX_UART011_IBRD,
 215         [REG_FBRD] = ZX_UART011_FBRD,
 216         [REG_CR] = ZX_UART011_CR,
 217         [REG_IFLS] = ZX_UART011_IFLS,
 218         [REG_IMSC] = ZX_UART011_IMSC,
 219         [REG_RIS] = ZX_UART011_RIS,
 220         [REG_MIS] = ZX_UART011_MIS,
 221         [REG_ICR] = ZX_UART011_ICR,
 222         [REG_DMACR] = ZX_UART011_DMACR,
 223 };
 224
 225 static unsigned int get_fifosize_zte(struct amba_device *dev)
 226 {
 227         return 16;
 228 }
 229
 230 static struct vendor_data vendor_zte = {
 231         .reg_offset             = pl011_zte_offsets,
 232         .access_32b             = true,
 233         .ifls                   = UART011_IFLS_RX4_8|UART011_IFLS_TX4_8,
 234         .fr_busy                = ZX_UART01x_FR_BUSY,
 235         .fr_dsr                 = ZX_UART01x_FR_DSR,
 236         .fr_cts                 = ZX_UART01x_FR_CTS,
 237         .fr_ri                  = ZX_UART011_FR_RI,
 238         .get_fifosize           = get_fifosize_zte,
 239 };
 240
 241 /* Deals with DMA transactions */
 242
 243 struct pl011_sgbuf {
 244         struct scatterlist sg;
 245         char *buf;
 246 };
 247
 248 struct pl011_dmarx_data {
 249         struct dma_chan         *chan;
 250         struct completion       complete;
 251         bool                    use_buf_b;
 252         struct pl011_sgbuf      sgbuf_a;
 253         struct pl011_sgbuf      sgbuf_b;
 254         dma_cookie_t            cookie;
 255         bool                    running;
 256         struct timer_list       timer;
 257         unsigned int last_residue;
 258         unsigned long last_jiffies;
 259         bool auto_poll_rate;
 260         unsigned int poll_rate;
 261         unsigned int poll_timeout;
 262 };
 263
 264 struct pl011_dmatx_data {
 265         struct dma_chan         *chan;
 266         struct scatterlist      sg;
 267         char                    *buf;
 268         bool                    queued;
 269 };
 270
 271 /*
 272  * We wrap our port structure around the generic uart_port.
 273  */
 274 struct uart_amba_port {
 275         struct uart_port        port;
 276         const u16               *reg_offset;
 277         struct clk              *clk;
 278         const struct vendor_data *vendor;
 279         unsigned int            dmacr;          /* dma control reg */
 280         unsigned int            im;             /* interrupt mask */
 281         unsigned int            old_status;
 282         unsigned int            fifosize;       /* vendor-specific */
 283         unsigned int            old_cr;         /* state during shutdown */
 284         bool                    autorts;
 285         unsigned int            fixed_baud;     /* vendor-set fixed baud rate */
 286         char                    type[12];
 287 #ifdef CONFIG_DMA_ENGINE
 288         /* DMA stuff */
 289         bool                    using_tx_dma;
 290         bool                    using_rx_dma;
 291         struct pl011_dmarx_data dmarx;
 292         struct pl011_dmatx_data dmatx;
 293         bool                    dma_probed;
 294 #endif
 295 };
 296
 297 static unsigned int pl011_reg_to_offset(const struct uart_amba_port *uap,
 298         unsigned int reg)
 299 {
 300         return uap->reg_offset[reg];
 301 }
 302
 303 static unsigned int pl011_read(const struct uart_amba_port *uap,
 304         unsigned int reg)
 305 {
 306         void __iomem *addr = uap->port.membase + pl011_reg_to_offset(uap, reg);
 307
 308         return (uap->port.iotype == UPIO_MEM32) ?
 309                 readl_relaxed(addr) : readw_relaxed(addr);
 310 }
 311
 312 static void pl011_write(unsigned int val, const struct uart_amba_port *uap,
 313         unsigned int reg)
 314 {
 315         void __iomem *addr = uap->port.membase + pl011_reg_to_offset(uap, reg);
 316
 317         if (uap->port.iotype == UPIO_MEM32)
 318                 writel_relaxed(val, addr);
 319         else
 320                 writew_relaxed(val, addr);
 321 }
 322
 323 /*
 324  * Reads up to 256 characters from the FIFO or until it's empty and
 325  * inserts them into the TTY layer. Returns the number of characters
 326  * read from the FIFO.
 327  */
 328 static int pl011_fifo_to_tty(struct uart_amba_port *uap)
 329 {
 330         u16 status;
 331         unsigned int ch, flag, max_count = 256;
 332         int fifotaken = 0;
 333
 334         while (max_count--) {
 335                 status = pl011_read(uap, REG_FR);
 336                 if (status & UART01x_FR_RXFE)
 337                         break;
 338
 339                 /* Take chars from the FIFO and update status */
 340                 ch = pl011_read(uap, REG_DR) | UART_DUMMY_DR_RX;
 341                 flag = TTY_NORMAL;
 342                 uap->port.icount.rx++;
 343                 fifotaken++;
 344
 345                 if (unlikely(ch & UART_DR_ERROR)) {
 346                         if (ch & UART011_DR_BE) {
 347                                 ch &= ~(UART011_DR_FE | UART011_DR_PE);
 348                                 uap->port.icount.brk++;
 349                                 if (uart_handle_break(&uap->port))
 350                                         continue;
 351                         } else if (ch & UART011_DR_PE)
 352                                 uap->port.icount.parity++;
 353                         else if (ch & UART011_DR_FE)
 354                                 uap->port.icount.frame++;
 355                         if (ch & UART011_DR_OE)
 356                                 uap->port.icount.overrun++;
 357
 358                         ch &= uap->port.read_status_mask;
 359
 360                         if (ch & UART011_DR_BE)
 361                                 flag = TTY_BREAK;
 362                         else if (ch & UART011_DR_PE)
 363                                 flag = TTY_PARITY;
 364                         else if (ch & UART011_DR_FE)
 365                                 flag = TTY_FRAME;
 366                 }
 367
 368                 if (uart_handle_sysrq_char(&uap->port, ch & 255))
 369                         continue;
 370
 371                 uart_insert_char(&uap->port, ch, UART011_DR_OE, ch, flag);
 372         }
 373
 374         return fifotaken;
 375 }
 376
 377
 378 /*
 379  * All the DMA operation mode stuff goes inside this ifdef.
 380  * This assumes that you have a generic DMA device interface,
 381  * no custom DMA interfaces are supported.
 382  */
 383 #ifdef CONFIG_DMA_ENGINE
 384
 385 #define PL011_DMA_BUFFER_SIZE PAGE_SIZE
 386
 387 static int pl011_sgbuf_init(struct dma_chan *chan, struct pl011_sgbuf *sg,
 388         enum dma_data_direction dir)
 389 {
 390         dma_addr_t dma_addr;
 391
 392         sg->buf = dma_alloc_coherent(chan->device->dev,
 393                 PL011_DMA_BUFFER_SIZE, &dma_addr, GFP_KERNEL);
 394         if (!sg->buf)
 395                 return -ENOMEM;
 396
 397         sg_init_table(&sg->sg, 1);
 398         sg_set_page(&sg->sg, phys_to_page(dma_addr),
 399                 PL011_DMA_BUFFER_SIZE, offset_in_page(dma_addr));
 400         sg_dma_address(&sg->sg) = dma_addr;
 401         sg_dma_len(&sg->sg) = PL011_DMA_BUFFER_SIZE;
 402
 403         return 0;
 404 }
 405
 406 static void pl011_sgbuf_free(struct dma_chan *chan, struct pl011_sgbuf *sg,
 407         enum dma_data_direction dir)
 408 {
 409         if (sg->buf) {
 410                 dma_free_coherent(chan->device->dev,
 411                         PL011_DMA_BUFFER_SIZE, sg->buf,
 412                         sg_dma_address(&sg->sg));
 413         }
 414 }
 415
 416 static void pl011_dma_probe(struct uart_amba_port *uap)
 417 {
 418         /* DMA is the sole user of the platform data right now */
 419         struct amba_pl011_data *plat = dev_get_platdata(uap->port.dev);
 420         struct device *dev = uap->port.dev;
 421         struct dma_slave_config tx_conf = {
 422                 .dst_addr = uap->port.mapbase +
 423                                  pl011_reg_to_offset(uap, REG_DR),
 424                 .dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE,
 425                 .direction = DMA_MEM_TO_DEV,
 426                 .dst_maxburst = uap->fifosize >> 1,
 427                 .device_fc = false,
 428         };
 429         struct dma_chan *chan;
 430         dma_cap_mask_t mask;
 431
 432         uap->dma_probed = true;
 433         chan = dma_request_slave_channel_reason(dev, "tx");
 434         if (IS_ERR(chan)) {
 435                 if (PTR_ERR(chan) == -EPROBE_DEFER) {
 436                         uap->dma_probed = false;
 437                         return;
 438                 }
 439
 440                 /* We need platform data */
 441                 if (!plat || !plat->dma_filter) {
 442                         dev_info(uap->port.dev, "no DMA platform data\n");
 443                         return;
 444                 }
 445
 446                 /* Try to acquire a generic DMA engine slave TX channel */
 447                 dma_cap_zero(mask);
 448                 dma_cap_set(DMA_SLAVE, mask);
 449
 450                 chan = dma_request_channel(mask, plat->dma_filter,
 451                                                 plat->dma_tx_param);
 452                 if (!chan) {
 453                         dev_err(uap->port.dev, "no TX DMA channel!\n");
 454                         return;
 455                 }
 456         }
 457
 458         dmaengine_slave_config(chan, &tx_conf);
 459         uap->dmatx.chan = chan;
 460
 461         dev_info(uap->port.dev, "DMA channel TX %s\n",
 462                  dma_chan_name(uap->dmatx.chan));
 463
 464         /* Optionally make use of an RX channel as well */
 465         chan = dma_request_slave_channel(dev, "rx");
 466
 467         if (!chan && plat && plat->dma_rx_param) {
 468                 chan = dma_request_channel(mask, plat->dma_filter, plat->dma_rx_param);
 469
 470                 if (!chan) {
 471                         dev_err(uap->port.dev, "no RX DMA channel!\n");
 472                         return;
 473                 }
 474         }
 475
 476         if (chan) {
 477                 struct dma_slave_config rx_conf = {
 478                         .src_addr = uap->port.mapbase +
 479                                 pl011_reg_to_offset(uap, REG_DR),
 480                         .src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE,
 481                         .direction = DMA_DEV_TO_MEM,
 482                         .src_maxburst = uap->fifosize >> 2,
 483                         .device_fc = false,
 484                 };
 485                 struct dma_slave_caps caps;
 486
 487                 /*
 488                  * Some DMA controllers provide information on their capabilities.
 489                  * If the controller does, check for suitable residue processing
 490                  * otherwise assime all is well.
 491                  */
 492                 if (0 == dma_get_slave_caps(chan, &caps)) {
 493                         if (caps.residue_granularity ==
 494                                         DMA_RESIDUE_GRANULARITY_DESCRIPTOR) {
 495                                 dma_release_channel(chan);
 496                                 dev_info(uap->port.dev,
 497                                         "RX DMA disabled - no residue processing\n");
 498                                 return;
 499                         }
 500                 }
 501                 dmaengine_slave_config(chan, &rx_conf);
 502                 uap->dmarx.chan = chan;
 503
 504                 uap->dmarx.auto_poll_rate = false;
 505                 if (plat && plat->dma_rx_poll_enable) {
 506                         /* Set poll rate if specified. */
 507                         if (plat->dma_rx_poll_rate) {
 508                                 uap->dmarx.auto_poll_rate = false;
 509                                 uap->dmarx.poll_rate = plat->dma_rx_poll_rate;
 510                         } else {
 511                                 /*
 512                                  * 100 ms defaults to poll rate if not
 513                                  * specified. This will be adjusted with
 514                                  * the baud rate at set_termios.
 515                                  */
 516                                 uap->dmarx.auto_poll_rate = true;
 517                                 uap->dmarx.poll_rate =  100;
 518                         }
 519                         /* 3 secs defaults poll_timeout if not specified. */
 520                         if (plat->dma_rx_poll_timeout)
 521                                 uap->dmarx.poll_timeout =
 522                                         plat->dma_rx_poll_timeout;
 523                         else
 524                                 uap->dmarx.poll_timeout = 3000;
 525                 } else if (!plat && dev->of_node) {
 526                         uap->dmarx.auto_poll_rate = of_property_read_bool(
 527                                                 dev->of_node, "auto-poll");
 528                         if (uap->dmarx.auto_poll_rate) {
 529                                 u32 x;
 530
 531                                 if (0 == of_property_read_u32(dev->of_node,
 532                                                 "poll-rate-ms", &x))
 533                                         uap->dmarx.poll_rate = x;
 534                                 else
 535                                         uap->dmarx.poll_rate = 100;
 536                                 if (0 == of_property_read_u32(dev->of_node,
 537                                                 "poll-timeout-ms", &x))
 538                                         uap->dmarx.poll_timeout = x;
 539                                 else
 540                                         uap->dmarx.poll_timeout = 3000;
 541                         }
 542                 }
 543                 dev_info(uap->port.dev, "DMA channel RX %s\n",
 544                          dma_chan_name(uap->dmarx.chan));
 545         }
 546 }
 547
 548 static void pl011_dma_remove(struct uart_amba_port *uap)
 549 {
 550         if (uap->dmatx.chan)
 551                 dma_release_channel(uap->dmatx.chan);
 552         if (uap->dmarx.chan)
 553                 dma_release_channel(uap->dmarx.chan);
 554 }
 555
 556 /* Forward declare these for the refill routine */
 557 static int pl011_dma_tx_refill(struct uart_amba_port *uap);
 558 static void pl011_start_tx_pio(struct uart_amba_port *uap);
 559
 560 /*
 561  * The current DMA TX buffer has been sent.
 562  * Try to queue up another DMA buffer.
 563  */
 564 static void pl011_dma_tx_callback(void *data)
 565 {
 566         struct uart_amba_port *uap = data;
 567         struct pl011_dmatx_data *dmatx = &uap->dmatx;
 568         unsigned long flags;
 569         u16 dmacr;
 570
 571         spin_lock_irqsave(&uap->port.lock, flags);
 572         if (uap->dmatx.queued)
 573                 dma_unmap_sg(dmatx->chan->device->dev, &dmatx->sg, 1,
 574                              DMA_TO_DEVICE);
 575
 576         dmacr = uap->dmacr;
 577         uap->dmacr = dmacr & ~UART011_TXDMAE;
 578         pl011_write(uap->dmacr, uap, REG_DMACR);
 579
 580         /*
 581          * If TX DMA was disabled, it means that we've stopped the DMA for
 582          * some reason (eg, XOFF received, or we want to send an X-char.)
 583          *
 584          * Note: we need to be careful here of a potential race between DMA
 585          * and the rest of the driver - if the driver disables TX DMA while
 586          * a TX buffer completing, we must update the tx queued status to
 587          * get further refills (hence we check dmacr).
 588          */
 589         if (!(dmacr & UART011_TXDMAE) || uart_tx_stopped(&uap->port) ||
 590             uart_circ_empty(&uap->port.state->xmit)) {
 591                 uap->dmatx.queued = false;
 592                 spin_unlock_irqrestore(&uap->port.lock, flags);
 593                 return;
 594         }
 595
 596         if (pl011_dma_tx_refill(uap) <= 0)
 597                 /*
 598                  * We didn't queue a DMA buffer for some reason, but we
 599                  * have data pending to be sent.  Re-enable the TX IRQ.
 600                  */
 601                 pl011_start_tx_pio(uap);
 602
 603         spin_unlock_irqrestore(&uap->port.lock, flags);
 604 }
 605
 606 /*
 607  * Try to refill the TX DMA buffer.
 608  * Locking: called with port lock held and IRQs disabled.
 609  * Returns:
 610  *   1 if we queued up a TX DMA buffer.
 611  *   0 if we didn't want to handle this by DMA
 612  *  <0 on error
 613  */
 614 static int pl011_dma_tx_refill(struct uart_amba_port *uap)
 615 {
 616         struct pl011_dmatx_data *dmatx = &uap->dmatx;
 617         struct dma_chan *chan = dmatx->chan;
 618         struct dma_device *dma_dev = chan->device;
 619         struct dma_async_tx_descriptor *desc;
 620         struct circ_buf *xmit = &uap->port.state->xmit;
 621         unsigned int count;
 622
 623         /*
 624          * Try to avoid the overhead involved in using DMA if the
 625          * transaction fits in the first half of the FIFO, by using
 626          * the standard interrupt handling.  This ensures that we
 627          * issue a uart_write_wakeup() at the appropriate time.
 628          */
 629         count = uart_circ_chars_pending(xmit);
 630         if (count < (uap->fifosize >> 1)) {
 631                 uap->dmatx.queued = false;
 632                 return 0;
 633         }
 634
 635         /*
 636          * Bodge: don't send the last character by DMA, as this
 637          * will prevent XON from notifying us to restart DMA.
 638          */
 639         count -= 1;
 640
 641         /* Else proceed to copy the TX chars to the DMA buffer and fire DMA */
 642         if (count > PL011_DMA_BUFFER_SIZE)
 643                 count = PL011_DMA_BUFFER_SIZE;
 644
 645         if (xmit->tail < xmit->head)
 646                 memcpy(&dmatx->buf[0], &xmit->buf[xmit->tail], count);
 647         else {
 648                 size_t first = UART_XMIT_SIZE - xmit->tail;
 649                 size_t second;
 650
 651                 if (first > count)
 652                         first = count;
 653                 second = count - first;
 654
 655                 memcpy(&dmatx->buf[0], &xmit->buf[xmit->tail], first);
 656                 if (second)
 657                         memcpy(&dmatx->buf[first], &xmit->buf[0], second);
 658         }
 659
 660         dmatx->sg.length = count;
 661
 662         if (dma_map_sg(dma_dev->dev, &dmatx->sg, 1, DMA_TO_DEVICE) != 1) {
 663                 uap->dmatx.queued = false;
 664                 dev_dbg(uap->port.dev, "unable to map TX DMA\n");
 665                 return -EBUSY;
 666         }
 667
 668         desc = dmaengine_prep_slave_sg(chan, &dmatx->sg, 1, DMA_MEM_TO_DEV,
 669                                              DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
 670         if (!desc) {
 671                 dma_unmap_sg(dma_dev->dev, &dmatx->sg, 1, DMA_TO_DEVICE);
 672                 uap->dmatx.queued = false;
 673                 /*
 674                  * If DMA cannot be used right now, we complete this
 675                  * transaction via IRQ and let the TTY layer retry.
 676                  */
 677                 dev_dbg(uap->port.dev, "TX DMA busy\n");
 678                 return -EBUSY;
 679         }
 680
 681         /* Some data to go along to the callback */
 682         desc->callback = pl011_dma_tx_callback;
 683         desc->callback_param = uap;
 684
 685         /* All errors should happen at prepare time */
 686         dmaengine_submit(desc);
 687
 688         /* Fire the DMA transaction */
 689         dma_dev->device_issue_pending(chan);
 690
 691         uap->dmacr |= UART011_TXDMAE;
 692         pl011_write(uap->dmacr, uap, REG_DMACR);
 693         uap->dmatx.queued = true;
 694
 695         /*
 696          * Now we know that DMA will fire, so advance the ring buffer
 697          * with the stuff we just dispatched.
 698          */
 699         xmit->tail = (xmit->tail + count) & (UART_XMIT_SIZE - 1);
 700         uap->port.icount.tx += count;
 701
 702         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 703                 uart_write_wakeup(&uap->port);
 704
 705         return 1;
 706 }
 707
 708 /*
 709  * We received a transmit interrupt without a pending X-char but with
 710  * pending characters.
 711  * Locking: called with port lock held and IRQs disabled.
 712  * Returns:
 713  *   false if we want to use PIO to transmit
 714  *   true if we queued a DMA buffer
 715  */
 716 static bool pl011_dma_tx_irq(struct uart_amba_port *uap)
 717 {
 718         if (!uap->using_tx_dma)
 719                 return false;
 720
 721         /*
 722          * If we already have a TX buffer queued, but received a
 723          * TX interrupt, it will be because we've just sent an X-char.
 724          * Ensure the TX DMA is enabled and the TX IRQ is disabled.
 725          */
 726         if (uap->dmatx.queued) {
 727                 uap->dmacr |= UART011_TXDMAE;
 728                 pl011_write(uap->dmacr, uap, REG_DMACR);
 729                 uap->im &= ~UART011_TXIM;
 730                 pl011_write(uap->im, uap, REG_IMSC);
 731                 return true;
 732         }
 733
 734         /*
 735          * We don't have a TX buffer queued, so try to queue one.
 736          * If we successfully queued a buffer, mask the TX IRQ.
 737          */
 738         if (pl011_dma_tx_refill(uap) > 0) {
 739                 uap->im &= ~UART011_TXIM;
 740                 pl011_write(uap->im, uap, REG_IMSC);
 741                 return true;
 742         }
 743         return false;
 744 }
 745
 746 /*
 747  * Stop the DMA transmit (eg, due to received XOFF).
 748  * Locking: called with port lock held and IRQs disabled.
 749  */
 750 static inline void pl011_dma_tx_stop(struct uart_amba_port *uap)
 751 {
 752         if (uap->dmatx.queued) {
 753                 uap->dmacr &= ~UART011_TXDMAE;
 754                 pl011_write(uap->dmacr, uap, REG_DMACR);
 755         }
 756 }
 757
 758 /*
 759  * Try to start a DMA transmit, or in the case of an XON/OFF
 760  * character queued for send, try to get that character out ASAP.
 761  * Locking: called with port lock held and IRQs disabled.
 762  * Returns:
 763  *   false if we want the TX IRQ to be enabled
 764  *   true if we have a buffer queued
 765  */
 766 static inline bool pl011_dma_tx_start(struct uart_amba_port *uap)
 767 {
 768         u16 dmacr;
 769
 770         if (!uap->using_tx_dma)
 771                 return false;
 772
 773         if (!uap->port.x_char) {
 774                 /* no X-char, try to push chars out in DMA mode */
 775                 bool ret = true;
 776
 777                 if (!uap->dmatx.queued) {
 778                         if (pl011_dma_tx_refill(uap) > 0) {
 779                                 uap->im &= ~UART011_TXIM;
 780                                 pl011_write(uap->im, uap, REG_IMSC);
 781                         } else
 782                                 ret = false;
 783                 } else if (!(uap->dmacr & UART011_TXDMAE)) {
 784                         uap->dmacr |= UART011_TXDMAE;
 785                         pl011_write(uap->dmacr, uap, REG_DMACR);
 786                 }
 787                 return ret;
 788         }
 789
 790         /*
 791          * We have an X-char to send.  Disable DMA to prevent it loading
 792          * the TX fifo, and then see if we can stuff it into the FIFO.
 793          */
 794         dmacr = uap->dmacr;
 795         uap->dmacr &= ~UART011_TXDMAE;
 796         pl011_write(uap->dmacr, uap, REG_DMACR);
 797
 798         if (pl011_read(uap, REG_FR) & UART01x_FR_TXFF) {
 799                 /*
 800                  * No space in the FIFO, so enable the transmit interrupt
 801                  * so we know when there is space.  Note that once we've
 802                  * loaded the character, we should just re-enable DMA.
 803                  */
 804                 return false;
 805         }
 806
 807         pl011_write(uap->port.x_char, uap, REG_DR);
 808         uap->port.icount.tx++;
 809         uap->port.x_char = 0;
 810
 811         /* Success - restore the DMA state */
 812         uap->dmacr = dmacr;
 813         pl011_write(dmacr, uap, REG_DMACR);
 814
 815         return true;
 816 }
 817
 818 /*
 819  * Flush the transmit buffer.
 820  * Locking: called with port lock held and IRQs disabled.
 821  */
 822 static void pl011_dma_flush_buffer(struct uart_port *port)
 823 __releases(&uap->port.lock)
 824 __acquires(&uap->port.lock)
 825 {
 826         struct uart_amba_port *uap =
 827             container_of(port, struct uart_amba_port, port);
 828
 829         if (!uap->using_tx_dma)
 830                 return;
 831
 832         dmaengine_terminate_async(uap->dmatx.chan);
 833
 834         if (uap->dmatx.queued) {
 835                 dma_unmap_sg(uap->dmatx.chan->device->dev, &uap->dmatx.sg, 1,
 836                              DMA_TO_DEVICE);
 837                 uap->dmatx.queued = false;
 838                 uap->dmacr &= ~UART011_TXDMAE;
 839                 pl011_write(uap->dmacr, uap, REG_DMACR);
 840         }
 841 }
 842
 843 static void pl011_dma_rx_callback(void *data);
 844
 845 static int pl011_dma_rx_trigger_dma(struct uart_amba_port *uap)
 846 {
 847         struct dma_chan *rxchan = uap->dmarx.chan;
 848         struct pl011_dmarx_data *dmarx = &uap->dmarx;
 849         struct dma_async_tx_descriptor *desc;
 850         struct pl011_sgbuf *sgbuf;
 851
 852         if (!rxchan)
 853                 return -EIO;
 854
 855         /* Start the RX DMA job */
 856         sgbuf = uap->dmarx.use_buf_b ?
 857                 &uap->dmarx.sgbuf_b : &uap->dmarx.sgbuf_a;
 858         desc = dmaengine_prep_slave_sg(rxchan, &sgbuf->sg, 1,
 859                                         DMA_DEV_TO_MEM,
 860                                         DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
 861         /*
 862          * If the DMA engine is busy and cannot prepare a
 863          * channel, no big deal, the driver will fall back
 864          * to interrupt mode as a result of this error code.
 865          */
 866         if (!desc) {
 867                 uap->dmarx.running = false;
 868                 dmaengine_terminate_all(rxchan);
 869                 return -EBUSY;
 870         }
 871
 872         /* Some data to go along to the callback */
 873         desc->callback = pl011_dma_rx_callback;
 874         desc->callback_param = uap;
 875         dmarx->cookie = dmaengine_submit(desc);
 876         dma_async_issue_pending(rxchan);
 877
 878         uap->dmacr |= UART011_RXDMAE;
 879         pl011_write(uap->dmacr, uap, REG_DMACR);
 880         uap->dmarx.running = true;
 881
 882         uap->im &= ~UART011_RXIM;
 883         pl011_write(uap->im, uap, REG_IMSC);
 884
 885         return 0;
 886 }
 887
 888 /*
 889  * This is called when either the DMA job is complete, or
 890  * the FIFO timeout interrupt occurred. This must be called
 891  * with the port spinlock uap->port.lock held.
 892  */
 893 static void pl011_dma_rx_chars(struct uart_amba_port *uap,
 894                                u32 pending, bool use_buf_b,
 895                                bool readfifo)
 896 {
 897         struct tty_port *port = &uap->port.state->port;
 898         struct pl011_sgbuf *sgbuf = use_buf_b ?
 899                 &uap->dmarx.sgbuf_b : &uap->dmarx.sgbuf_a;
 900         int dma_count = 0;
 901         u32 fifotaken = 0; /* only used for vdbg() */
 902
 903         struct pl011_dmarx_data *dmarx = &uap->dmarx;
 904         int dmataken = 0;
 905
 906         if (uap->dmarx.poll_rate) {
 907                 /* The data can be taken by polling */
 908                 dmataken = sgbuf->sg.length - dmarx->last_residue;
 909                 /* Recalculate the pending size */
 910                 if (pending >= dmataken)
 911                         pending -= dmataken;
 912         }
 913
 914         /* Pick the remain data from the DMA */
 915         if (pending) {
 916
 917                 /*
 918                  * First take all chars in the DMA pipe, then look in the FIFO.
 919                  * Note that tty_insert_flip_buf() tries to take as many chars
 920                  * as it can.
 921                  */
 922                 dma_count = tty_insert_flip_string(port, sgbuf->buf + dmataken,
 923                                 pending);
 924
 925                 uap->port.icount.rx += dma_count;
 926                 if (dma_count < pending)
 927                         dev_warn(uap->port.dev,
 928                                  "couldn't insert all characters (TTY is full?)\n");
 929         }
 930
 931         /* Reset the last_residue for Rx DMA poll */
 932         if (uap->dmarx.poll_rate)
 933                 dmarx->last_residue = sgbuf->sg.length;
 934
 935         /*
 936          * Only continue with trying to read the FIFO if all DMA chars have
 937          * been taken first.
 938          */
 939         if (dma_count == pending && readfifo) {
 940                 /* Clear any error flags */
 941                 pl011_write(UART011_OEIS | UART011_BEIS | UART011_PEIS |
 942                             UART011_FEIS, uap, REG_ICR);
 943
 944                 /*
 945                  * If we read all the DMA'd characters, and we had an
 946                  * incomplete buffer, that could be due to an rx error, or
 947                  * maybe we just timed out. Read any pending chars and check
 948                  * the error status.
 949                  *
 950                  * Error conditions will only occur in the FIFO, these will
 951                  * trigger an immediate interrupt and stop the DMA job, so we
 952                  * will always find the error in the FIFO, never in the DMA
 953                  * buffer.
 954                  */
 955                 fifotaken = pl011_fifo_to_tty(uap);
 956         }
 957
 958         spin_unlock(&uap->port.lock);
 959         dev_vdbg(uap->port.dev,
 960                  "Took %d chars from DMA buffer and %d chars from the FIFO\n",
 961                  dma_count, fifotaken);
 962         tty_flip_buffer_push(port);
 963         spin_lock(&uap->port.lock);
 964 }
 965
 966 static void pl011_dma_rx_irq(struct uart_amba_port *uap)
 967 {
 968         struct pl011_dmarx_data *dmarx = &uap->dmarx;
 969         struct dma_chan *rxchan = dmarx->chan;
 970         struct pl011_sgbuf *sgbuf = dmarx->use_buf_b ?
 971                 &dmarx->sgbuf_b : &dmarx->sgbuf_a;
 972         size_t pending;
 973         struct dma_tx_state state;
 974         enum dma_status dmastat;
 975
 976         /*
 977          * Pause the transfer so we can trust the current counter,
 978          * do this before we pause the PL011 block, else we may
 979          * overflow the FIFO.
 980          */
 981         if (dmaengine_pause(rxchan))
 982                 dev_err(uap->port.dev, "unable to pause DMA transfer\n");
 983         dmastat = rxchan->device->device_tx_status(rxchan,
 984                                                    dmarx->cookie, &state);
 985         if (dmastat != DMA_PAUSED)
 986                 dev_err(uap->port.dev, "unable to pause DMA transfer\n");
 987
 988         /* Disable RX DMA - incoming data will wait in the FIFO */
 989         uap->dmacr &= ~UART011_RXDMAE;
 990         pl011_write(uap->dmacr, uap, REG_DMACR);
 991         uap->dmarx.running = false;
 992
 993         pending = sgbuf->sg.length - state.residue;
 994         BUG_ON(pending > PL011_DMA_BUFFER_SIZE);
 995         /* Then we terminate the transfer - we now know our residue */
 996         dmaengine_terminate_all(rxchan);
 997
 998         /*
 999          * This will take the chars we have so far and insert
1000          * into the framework.
1001          */
1002         pl011_dma_rx_chars(uap, pending, dmarx->use_buf_b, true);
1003
1004         /* Switch buffer & re-trigger DMA job */
1005         dmarx->use_buf_b = !dmarx->use_buf_b;
1006         if (pl011_dma_rx_trigger_dma(uap)) {
1007                 dev_dbg(uap->port.dev, "could not retrigger RX DMA job "
1008                         "fall back to interrupt mode\n");
1009                 uap->im |= UART011_RXIM;
1010                 pl011_write(uap->im, uap, REG_IMSC);
1011         }
1012 }
1013
1014 static void pl011_dma_rx_callback(void *data)
1015 {
1016         struct uart_amba_port *uap = data;
1017         struct pl011_dmarx_data *dmarx = &uap->dmarx;
1018         struct dma_chan *rxchan = dmarx->chan;
1019         bool lastbuf = dmarx->use_buf_b;
1020         struct pl011_sgbuf *sgbuf = dmarx->use_buf_b ?
1021                 &dmarx->sgbuf_b : &dmarx->sgbuf_a;
1022         size_t pending;
1023         struct dma_tx_state state;
1024         int ret;
1025
1026         /*
1027          * This completion interrupt occurs typically when the
1028          * RX buffer is totally stuffed but no timeout has yet
1029          * occurred. When that happens, we just want the RX
1030          * routine to flush out the secondary DMA buffer while
1031          * we immediately trigger the next DMA job.
1032          */
1033         spin_lock_irq(&uap->port.lock);
1034         /*
1035          * Rx data can be taken by the UART interrupts during
1036          * the DMA irq handler. So we check the residue here.
1037          */
1038         rxchan->device->device_tx_status(rxchan, dmarx->cookie, &state);
1039         pending = sgbuf->sg.length - state.residue;
1040         BUG_ON(pending > PL011_DMA_BUFFER_SIZE);
1041         /* Then we terminate the transfer - we now know our residue */
1042         dmaengine_terminate_all(rxchan);
1043
1044         uap->dmarx.running = false;
1045         dmarx->use_buf_b = !lastbuf;
1046         ret = pl011_dma_rx_trigger_dma(uap);
1047
1048         pl011_dma_rx_chars(uap, pending, lastbuf, false);
1049         spin_unlock_irq(&uap->port.lock);
1050         /*
1051          * Do this check after we picked the DMA chars so we don't
1052          * get some IRQ immediately from RX.
1053          */
1054         if (ret) {
1055                 dev_dbg(uap->port.dev, "could not retrigger RX DMA job "
1056                         "fall back to interrupt mode\n");
1057                 uap->im |= UART011_RXIM;
1058                 pl011_write(uap->im, uap, REG_IMSC);
1059         }
1060 }
1061
1062 /*
1063  * Stop accepting received characters, when we're shutting down or
1064  * suspending this port.
1065  * Locking: called with port lock held and IRQs disabled.
1066  */
1067 static inline void pl011_dma_rx_stop(struct uart_amba_port *uap)
1068 {
1069         if (!uap->using_rx_dma)
1070                 return;
1071
1072         /* FIXME.  Just disable the DMA enable */
1073         uap->dmacr &= ~UART011_RXDMAE;
1074         pl011_write(uap->dmacr, uap, REG_DMACR);
1075 }
1076
1077 /*
1078  * Timer handler for Rx DMA polling.
1079  * Every polling, It checks the residue in the dma buffer and transfer
1080  * data to the tty. Also, last_residue is updated for the next polling.
1081  */
1082 static void pl011_dma_rx_poll(unsigned long args)
1083 {
1084         struct uart_amba_port *uap = (struct uart_amba_port *)args;
1085         struct tty_port *port = &uap->port.state->port;
1086         struct pl011_dmarx_data *dmarx = &uap->dmarx;
1087         struct dma_chan *rxchan = uap->dmarx.chan;
1088         unsigned long flags = 0;
1089         unsigned int dmataken = 0;
1090         unsigned int size = 0;
1091         struct pl011_sgbuf *sgbuf;
1092         int dma_count;
1093         struct dma_tx_state state;
1094
1095         sgbuf = dmarx->use_buf_b ? &uap->dmarx.sgbuf_b : &uap->dmarx.sgbuf_a;
1096         rxchan->device->device_tx_status(rxchan, dmarx->cookie, &state);
1097         if (likely(state.residue < dmarx->last_residue)) {
1098                 dmataken = sgbuf->sg.length - dmarx->last_residue;
1099                 size = dmarx->last_residue - state.residue;
1100                 dma_count = tty_insert_flip_string(port, sgbuf->buf + dmataken,
1101                                 size);
1102                 if (dma_count == size)
1103                         dmarx->last_residue =  state.residue;
1104                 dmarx->last_jiffies = jiffies;
1105         }
1106         tty_flip_buffer_push(port);
1107
1108         /*
1109          * If no data is received in poll_timeout, the driver will fall back
1110          * to interrupt mode. We will retrigger DMA at the first interrupt.
1111          */
1112         if (jiffies_to_msecs(jiffies - dmarx->last_jiffies)
1113                         > uap->dmarx.poll_timeout) {
1114
1115                 spin_lock_irqsave(&uap->port.lock, flags);
1116                 pl011_dma_rx_stop(uap);
1117                 uap->im |= UART011_RXIM;
1118                 pl011_write(uap->im, uap, REG_IMSC);
1119                 spin_unlock_irqrestore(&uap->port.lock, flags);
1120
1121                 uap->dmarx.running = false;
1122                 dmaengine_terminate_all(rxchan);
1123                 del_timer(&uap->dmarx.timer);
1124         } else {
1125                 mod_timer(&uap->dmarx.timer,
1126                         jiffies + msecs_to_jiffies(uap->dmarx.poll_rate));
1127         }
1128 }
1129
1130 static void pl011_dma_startup(struct uart_amba_port *uap)
1131 {
1132         int ret;
1133
1134         if (!uap->dma_probed)
1135                 pl011_dma_probe(uap);
1136
1137         if (!uap->dmatx.chan)
1138                 return;
1139
1140         uap->dmatx.buf = kmalloc(PL011_DMA_BUFFER_SIZE, GFP_KERNEL | __GFP_DMA);
1141         if (!uap->dmatx.buf) {
1142                 dev_err(uap->port.dev, "no memory for DMA TX buffer\n");
1143                 uap->port.fifosize = uap->fifosize;
1144                 return;
1145         }
1146
1147         sg_init_one(&uap->dmatx.sg, uap->dmatx.buf, PL011_DMA_BUFFER_SIZE);
1148
1149         /* The DMA buffer is now the FIFO the TTY subsystem can use */
1150         uap->port.fifosize = PL011_DMA_BUFFER_SIZE;
1151         uap->using_tx_dma = true;
1152
1153         if (!uap->dmarx.chan)
1154                 goto skip_rx;
1155
1156         /* Allocate and map DMA RX buffers */
1157         ret = pl011_sgbuf_init(uap->dmarx.chan, &uap->dmarx.sgbuf_a,
1158                                DMA_FROM_DEVICE);
1159         if (ret) {
1160                 dev_err(uap->port.dev, "failed to init DMA %s: %d\n",
1161                         "RX buffer A", ret);
1162                 goto skip_rx;
1163         }
1164
1165         ret = pl011_sgbuf_init(uap->dmarx.chan, &uap->dmarx.sgbuf_b,
1166                                DMA_FROM_DEVICE);
1167         if (ret) {
1168                 dev_err(uap->port.dev, "failed to init DMA %s: %d\n",
1169                         "RX buffer B", ret);
1170                 pl011_sgbuf_free(uap->dmarx.chan, &uap->dmarx.sgbuf_a,
1171                                  DMA_FROM_DEVICE);
1172                 goto skip_rx;
1173         }
1174
1175         uap->using_rx_dma = true;
1176
1177 skip_rx:
1178         /* Turn on DMA error (RX/TX will be enabled on demand) */
1179         uap->dmacr |= UART011_DMAONERR;
1180         pl011_write(uap->dmacr, uap, REG_DMACR);
1181
1182         /*
1183          * ST Micro variants has some specific dma burst threshold
1184          * compensation. Set this to 16 bytes, so burst will only
1185          * be issued above/below 16 bytes.
1186          */
1187         if (uap->vendor->dma_threshold)
1188                 pl011_write(ST_UART011_DMAWM_RX_16 | ST_UART011_DMAWM_TX_16,
1189                             uap, REG_ST_DMAWM);
1190
1191         if (uap->using_rx_dma) {
1192                 if (pl011_dma_rx_trigger_dma(uap))
1193                         dev_dbg(uap->port.dev, "could not trigger initial "
1194                                 "RX DMA job, fall back to interrupt mode\n");
1195                 if (uap->dmarx.poll_rate) {
1196                         init_timer(&(uap->dmarx.timer));
1197                         uap->dmarx.timer.function = pl011_dma_rx_poll;
1198                         uap->dmarx.timer.data = (unsigned long)uap;
1199                         mod_timer(&uap->dmarx.timer,
1200                                 jiffies +
1201                                 msecs_to_jiffies(uap->dmarx.poll_rate));
1202                         uap->dmarx.last_residue = PL011_DMA_BUFFER_SIZE;
1203                         uap->dmarx.last_jiffies = jiffies;
1204                 }
1205         }
1206 }
1207
1208 static void pl011_dma_shutdown(struct uart_amba_port *uap)
1209 {
1210         if (!(uap->using_tx_dma || uap->using_rx_dma))
1211                 return;
1212
1213         /* Disable RX and TX DMA */
1214         while (pl011_read(uap, REG_FR) & uap->vendor->fr_busy)
1215                 cpu_relax();
1216
1217         spin_lock_irq(&uap->port.lock);
1218         uap->dmacr &= ~(UART011_DMAONERR | UART011_RXDMAE | UART011_TXDMAE);
1219         pl011_write(uap->dmacr, uap, REG_DMACR);
1220         spin_unlock_irq(&uap->port.lock);
1221
1222         if (uap->using_tx_dma) {
1223                 /* In theory, this should already be done by pl011_dma_flush_buffer */
1224                 dmaengine_terminate_all(uap->dmatx.chan);
1225                 if (uap->dmatx.queued) {
1226                         dma_unmap_sg(uap->dmatx.chan->device->dev, &uap->dmatx.sg, 1,
1227                                      DMA_TO_DEVICE);
1228                         uap->dmatx.queued = false;
1229                 }
1230
1231                 kfree(uap->dmatx.buf);
1232                 uap->using_tx_dma = false;
1233         }
1234
1235         if (uap->using_rx_dma) {
1236                 dmaengine_terminate_all(uap->dmarx.chan);
1237                 /* Clean up the RX DMA */
1238                 pl011_sgbuf_free(uap->dmarx.chan, &uap->dmarx.sgbuf_a, DMA_FROM_DEVICE);
1239                 pl011_sgbuf_free(uap->dmarx.chan, &uap->dmarx.sgbuf_b, DMA_FROM_DEVICE);
1240                 if (uap->dmarx.poll_rate)
1241                         del_timer_sync(&uap->dmarx.timer);
1242                 uap->using_rx_dma = false;
1243         }
1244 }
1245
1246 static inline bool pl011_dma_rx_available(struct uart_amba_port *uap)
1247 {
1248         return uap->using_rx_dma;
1249 }
1250
1251 static inline bool pl011_dma_rx_running(struct uart_amba_port *uap)
1252 {
1253         return uap->using_rx_dma && uap->dmarx.running;
1254 }
1255
1256 #else
1257 /* Blank functions if the DMA engine is not available */
1258 static inline void pl011_dma_probe(struct uart_amba_port *uap)
1259 {
1260 }
1261
1262 static inline void pl011_dma_remove(struct uart_amba_port *uap)
1263 {
1264 }
1265
1266 static inline void pl011_dma_startup(struct uart_amba_port *uap)
1267 {
1268 }
1269
1270 static inline void pl011_dma_shutdown(struct uart_amba_port *uap)
1271 {
1272 }
1273
1274 static inline bool pl011_dma_tx_irq(struct uart_amba_port *uap)
1275 {
1276         return false;
1277 }
1278
1279 static inline void pl011_dma_tx_stop(struct uart_amba_port *uap)
1280 {
1281 }
1282
1283 static inline bool pl011_dma_tx_start(struct uart_amba_port *uap)
1284 {
1285         return false;
1286 }
1287
1288 static inline void pl011_dma_rx_irq(struct uart_amba_port *uap)
1289 {
1290 }
1291
1292 static inline void pl011_dma_rx_stop(struct uart_amba_port *uap)
1293 {
1294 }
1295
1296 static inline int pl011_dma_rx_trigger_dma(struct uart_amba_port *uap)
1297 {
1298         return -EIO;
1299 }
1300
1301 static inline bool pl011_dma_rx_available(struct uart_amba_port *uap)
1302 {
1303         return false;
1304 }
1305
1306 static inline bool pl011_dma_rx_running(struct uart_amba_port *uap)
1307 {
1308         return false;
1309 }
1310
1311 #define pl011_dma_flush_buffer  NULL
1312 #endif
1313
1314 static void pl011_stop_tx(struct uart_port *port)
1315 {
1316         struct uart_amba_port *uap =
1317             container_of(port, struct uart_amba_port, port);
1318
1319         uap->im &= ~UART011_TXIM;
1320         pl011_write(uap->im, uap, REG_IMSC);
1321         pl011_dma_tx_stop(uap);
1322 }
1323
1324 static bool pl011_tx_chars(struct uart_amba_port *uap, bool from_irq);
1325
1326 /* Start TX with programmed I/O only (no DMA) */
1327 static void pl011_start_tx_pio(struct uart_amba_port *uap)
1328 {
1329         if (pl011_tx_chars(uap, false)) {
1330                 uap->im |= UART011_TXIM;
1331                 pl011_write(uap->im, uap, REG_IMSC);
1332         }
1333 }
1334
1335 static void pl011_start_tx(struct uart_port *port)
1336 {
1337         struct uart_amba_port *uap =
1338             container_of(port, struct uart_amba_port, port);
1339
1340         if (!pl011_dma_tx_start(uap))
1341                 pl011_start_tx_pio(uap);
1342 }
1343
1344 static void pl011_stop_rx(struct uart_port *port)
1345 {
1346         struct uart_amba_port *uap =
1347             container_of(port, struct uart_amba_port, port);
1348
1349         uap->im &= ~(UART011_RXIM|UART011_RTIM|UART011_FEIM|
1350                      UART011_PEIM|UART011_BEIM|UART011_OEIM);
1351         pl011_write(uap->im, uap, REG_IMSC);
1352
1353         pl011_dma_rx_stop(uap);
1354 }
1355
1356 static void pl011_enable_ms(struct uart_port *port)
1357 {
1358         struct uart_amba_port *uap =
1359             container_of(port, struct uart_amba_port, port);
1360
1361         uap->im |= UART011_RIMIM|UART011_CTSMIM|UART011_DCDMIM|UART011_DSRMIM;
1362         pl011_write(uap->im, uap, REG_IMSC);
1363 }
1364
1365 static void pl011_rx_chars(struct uart_amba_port *uap)
1366 __releases(&uap->port.lock)
1367 __acquires(&uap->port.lock)
1368 {
1369         pl011_fifo_to_tty(uap);
1370
1371         spin_unlock(&uap->port.lock);
1372         tty_flip_buffer_push(&uap->port.state->port);
1373         /*
1374          * If we were temporarily out of DMA mode for a while,
1375          * attempt to switch back to DMA mode again.
1376          */
1377         if (pl011_dma_rx_available(uap)) {
1378                 if (pl011_dma_rx_trigger_dma(uap)) {
1379                         dev_dbg(uap->port.dev, "could not trigger RX DMA job "
1380                                 "fall back to interrupt mode again\n");
1381                         uap->im |= UART011_RXIM;
1382                         pl011_write(uap->im, uap, REG_IMSC);
1383                 } else {
1384 #ifdef CONFIG_DMA_ENGINE
1385                         /* Start Rx DMA poll */
1386                         if (uap->dmarx.poll_rate) {
1387                                 uap->dmarx.last_jiffies = jiffies;
1388                                 uap->dmarx.last_residue = PL011_DMA_BUFFER_SIZE;
1389                                 mod_timer(&uap->dmarx.timer,
1390                                         jiffies +
1391                                         msecs_to_jiffies(uap->dmarx.poll_rate));
1392                         }
1393 #endif
1394                 }
1395         }
1396         spin_lock(&uap->port.lock);
1397 }
1398
1399 static bool pl011_tx_char(struct uart_amba_port *uap, unsigned char c,
1400                           bool from_irq)
1401 {
1402         if (unlikely(!from_irq) &&
1403             pl011_read(uap, REG_FR) & UART01x_FR_TXFF)
1404                 return false; /* unable to transmit character */
1405
1406         pl011_write(c, uap, REG_DR);
1407         uap->port.icount.tx++;
1408
1409         return true;
1410 }
1411
1412 /* Returns true if tx interrupts have to be (kept) enabled  */
1413 static bool pl011_tx_chars(struct uart_amba_port *uap, bool from_irq)
1414 {
1415         struct circ_buf *xmit = &uap->port.state->xmit;
1416         int count = uap->fifosize >> 1;
1417
1418         if (uap->port.x_char) {
1419                 if (!pl011_tx_char(uap, uap->port.x_char, from_irq))
1420                         return true;
1421                 uap->port.x_char = 0;
1422                 --count;
1423         }
1424         if (uart_circ_empty(xmit) || uart_tx_stopped(&uap->port)) {
1425                 pl011_stop_tx(&uap->port);
1426                 return false;
1427         }
1428
1429         /* If we are using DMA mode, try to send some characters. */
1430         if (pl011_dma_tx_irq(uap))
1431                 return true;
1432
1433         do {
1434                 if (likely(from_irq) && count-- == 0)
1435                         break;
1436
1437                 if (!pl011_tx_char(uap, xmit->buf[xmit->tail], from_irq))
1438                         break;
1439
1440                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
1441         } while (!uart_circ_empty(xmit));
1442
1443         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
1444                 uart_write_wakeup(&uap->port);
1445
1446         if (uart_circ_empty(xmit)) {
1447                 pl011_stop_tx(&uap->port);
1448                 return false;
1449         }
1450         return true;
1451 }
1452
1453 static void pl011_modem_status(struct uart_amba_port *uap)
1454 {
1455         unsigned int status, delta;
1456
1457         status = pl011_read(uap, REG_FR) & UART01x_FR_MODEM_ANY;
1458
1459         delta = status ^ uap->old_status;
1460         uap->old_status = status;
1461
1462         if (!delta)
1463                 return;
1464
1465         if (delta & UART01x_FR_DCD)
1466                 uart_handle_dcd_change(&uap->port, status & UART01x_FR_DCD);
1467
1468         if (delta & uap->vendor->fr_dsr)
1469                 uap->port.icount.dsr++;
1470
1471         if (delta & uap->vendor->fr_cts)
1472                 uart_handle_cts_change(&uap->port,
1473                                        status & uap->vendor->fr_cts);
1474
1475         wake_up_interruptible(&uap->port.state->port.delta_msr_wait);
1476 }
1477
1478 static void check_apply_cts_event_workaround(struct uart_amba_port *uap)
1479 {
1480         unsigned int dummy_read;
1481
1482         if (!uap->vendor->cts_event_workaround)
1483                 return;
1484
1485         /* workaround to make sure that all bits are unlocked.. */
1486         pl011_write(0x00, uap, REG_ICR);
1487
1488         /*
1489          * WA: introduce 26ns(1 uart clk) delay before W1C;
1490          * single apb access will incur 2 pclk(133.12Mhz) delay,
1491          * so add 2 dummy reads
1492          */
1493         dummy_read = pl011_read(uap, REG_ICR);
1494         dummy_read = pl011_read(uap, REG_ICR);
1495 }
1496
1497 static irqreturn_t pl011_int(int irq, void *dev_id)
1498 {
1499         struct uart_amba_port *uap = dev_id;
1500         unsigned long flags;
1501         unsigned int status, pass_counter = AMBA_ISR_PASS_LIMIT;
1502         u16 imsc;
1503         int handled = 0;
1504
1505         spin_lock_irqsave(&uap->port.lock, flags);
1506         imsc = pl011_read(uap, REG_IMSC);
1507         status = pl011_read(uap, REG_RIS) & imsc;
1508         if (status) {
1509                 do {
1510                         check_apply_cts_event_workaround(uap);
1511
1512                         pl011_write(status & ~(UART011_TXIS|UART011_RTIS|
1513                                                UART011_RXIS),
1514                                     uap, REG_ICR);
1515
1516                         if (status & (UART011_RTIS|UART011_RXIS)) {
1517                                 if (pl011_dma_rx_running(uap))
1518                                         pl011_dma_rx_irq(uap);
1519                                 else
1520                                         pl011_rx_chars(uap);
1521                         }
1522                         if (status & (UART011_DSRMIS|UART011_DCDMIS|
1523                                       UART011_CTSMIS|UART011_RIMIS))
1524                                 pl011_modem_status(uap);
1525                         if (status & UART011_TXIS)
1526                                 pl011_tx_chars(uap, true);
1527
1528                         if (pass_counter-- == 0)
1529                                 break;
1530
1531                         status = pl011_read(uap, REG_RIS) & imsc;
1532                 } while (status != 0);
1533                 handled = 1;
1534         }
1535
1536         spin_unlock_irqrestore(&uap->port.lock, flags);
1537
1538         return IRQ_RETVAL(handled);
1539 }
1540
1541 static unsigned int pl011_tx_empty(struct uart_port *port)
1542 {
1543         struct uart_amba_port *uap =
1544             container_of(port, struct uart_amba_port, port);
1545
1546         /* Allow feature register bits to be inverted to work around errata */
1547         unsigned int status = pl011_read(uap, REG_FR) ^ uap->vendor->inv_fr;
1548
1549         return status & (uap->vendor->fr_busy | UART01x_FR_TXFF) ?
1550                                                         0 : TIOCSER_TEMT;
1551 }
1552
1553 static unsigned int pl011_get_mctrl(struct uart_port *port)
1554 {
1555         struct uart_amba_port *uap =
1556             container_of(port, struct uart_amba_port, port);
1557         unsigned int result = 0;
1558         unsigned int status = pl011_read(uap, REG_FR);
1559
1560 #define TIOCMBIT(uartbit, tiocmbit)     \
1561         if (status & uartbit)           \
1562                 result |= tiocmbit
1563
1564         TIOCMBIT(UART01x_FR_DCD, TIOCM_CAR);
1565         TIOCMBIT(uap->vendor->fr_dsr, TIOCM_DSR);
1566         TIOCMBIT(uap->vendor->fr_cts, TIOCM_CTS);
1567         TIOCMBIT(uap->vendor->fr_ri, TIOCM_RNG);
1568 #undef TIOCMBIT
1569         return result;
1570 }
1571
1572 static void pl011_set_mctrl(struct uart_port *port, unsigned int mctrl)
1573 {
1574         struct uart_amba_port *uap =
1575             container_of(port, struct uart_amba_port, port);
1576         unsigned int cr;
1577
1578         cr = pl011_read(uap, REG_CR);
1579
1580 #define TIOCMBIT(tiocmbit, uartbit)             \
1581         if (mctrl & tiocmbit)           \
1582                 cr |= uartbit;          \
1583         else                            \
1584                 cr &= ~uartbit
1585
1586         TIOCMBIT(TIOCM_RTS, UART011_CR_RTS);
1587         TIOCMBIT(TIOCM_DTR, UART011_CR_DTR);
1588         TIOCMBIT(TIOCM_OUT1, UART011_CR_OUT1);
1589         TIOCMBIT(TIOCM_OUT2, UART011_CR_OUT2);
1590         TIOCMBIT(TIOCM_LOOP, UART011_CR_LBE);
1591
1592         if (uap->autorts) {
1593                 /* We need to disable auto-RTS if we want to turn RTS off */
1594                 TIOCMBIT(TIOCM_RTS, UART011_CR_RTSEN);
1595         }
1596 #undef TIOCMBIT
1597
1598         pl011_write(cr, uap, REG_CR);
1599 }
1600
1601 static void pl011_break_ctl(struct uart_port *port, int break_state)
1602 {
1603         struct uart_amba_port *uap =
1604             container_of(port, struct uart_amba_port, port);
1605         unsigned long flags;
1606         unsigned int lcr_h;
1607
1608         spin_lock_irqsave(&uap->port.lock, flags);
1609         lcr_h = pl011_read(uap, REG_LCRH_TX);
1610         if (break_state == -1)
1611                 lcr_h |= UART01x_LCRH_BRK;
1612         else
1613                 lcr_h &= ~UART01x_LCRH_BRK;
1614         pl011_write(lcr_h, uap, REG_LCRH_TX);
1615         spin_unlock_irqrestore(&uap->port.lock, flags);
1616 }
1617
1618 #ifdef CONFIG_CONSOLE_POLL
1619
1620 static void pl011_quiesce_irqs(struct uart_port *port)
1621 {
1622         struct uart_amba_port *uap =
1623             container_of(port, struct uart_amba_port, port);
1624
1625         pl011_write(pl011_read(uap, REG_MIS), uap, REG_ICR);
1626         /*
1627          * There is no way to clear TXIM as this is "ready to transmit IRQ", so
1628          * we simply mask it. start_tx() will unmask it.
1629          *
1630          * Note we can race with start_tx(), and if the race happens, the
1631          * polling user might get another interrupt just after we clear it.
1632          * But it should be OK and can happen even w/o the race, e.g.
1633          * controller immediately got some new data and raised the IRQ.
1634          *
1635          * And whoever uses polling routines assumes that it manages the device
1636          * (including tx queue), so we're also fine with start_tx()'s caller
1637          * side.
1638          */
1639         pl011_write(pl011_read(uap, REG_IMSC) & ~UART011_TXIM, uap,
1640                     REG_IMSC);
1641 }
1642
1643 static int pl011_get_poll_char(struct uart_port *port)
1644 {
1645         struct uart_amba_port *uap =
1646             container_of(port, struct uart_amba_port, port);
1647         unsigned int status;
1648
1649         /*
1650          * The caller might need IRQs lowered, e.g. if used with KDB NMI
1651          * debugger.
1652          */
1653         pl011_quiesce_irqs(port);
1654
1655         status = pl011_read(uap, REG_FR);
1656         if (status & UART01x_FR_RXFE)
1657                 return NO_POLL_CHAR;
1658
1659         return pl011_read(uap, REG_DR);
1660 }
1661
1662 static void pl011_put_poll_char(struct uart_port *port,
1663                          unsigned char ch)
1664 {
1665         struct uart_amba_port *uap =
1666             container_of(port, struct uart_amba_port, port);
1667
1668         while (pl011_read(uap, REG_FR) & UART01x_FR_TXFF)
1669                 cpu_relax();
1670
1671         pl011_write(ch, uap, REG_DR);
1672 }
1673
1674 #endif /* CONFIG_CONSOLE_POLL */
1675
1676 static int pl011_hwinit(struct uart_port *port)
1677 {
1678         struct uart_amba_port *uap =
1679             container_of(port, struct uart_amba_port, port);
1680         int retval;
1681
1682         /* Optionaly enable pins to be muxed in and configured */
1683         pinctrl_pm_select_default_state(port->dev);
1684
1685         /*
1686          * Try to enable the clock producer.
1687          */
1688         retval = clk_prepare_enable(uap->clk);
1689         if (retval)
1690                 return retval;
1691
1692         uap->port.uartclk = clk_get_rate(uap->clk);
1693
1694         /* Clear pending error and receive interrupts */
1695         pl011_write(UART011_OEIS | UART011_BEIS | UART011_PEIS |
1696                     UART011_FEIS | UART011_RTIS | UART011_RXIS,
1697                     uap, REG_ICR);
1698
1699         /*
1700          * Save interrupts enable mask, and enable RX interrupts in case if
1701          * the interrupt is used for NMI entry.
1702          */
1703         uap->im = pl011_read(uap, REG_IMSC);
1704         pl011_write(UART011_RTIM | UART011_RXIM, uap, REG_IMSC);
1705
1706         if (dev_get_platdata(uap->port.dev)) {
1707                 struct amba_pl011_data *plat;
1708
1709                 plat = dev_get_platdata(uap->port.dev);
1710                 if (plat->init)
1711                         plat->init();
1712         }
1713         return 0;
1714 }
1715
1716 static bool pl011_split_lcrh(const struct uart_amba_port *uap)
1717 {
1718         return pl011_reg_to_offset(uap, REG_LCRH_RX) !=
1719                pl011_reg_to_offset(uap, REG_LCRH_TX);
1720 }
1721
1722 static void pl011_write_lcr_h(struct uart_amba_port *uap, unsigned int lcr_h)
1723 {
1724         pl011_write(lcr_h, uap, REG_LCRH_RX);
1725         if (pl011_split_lcrh(uap)) {
1726                 int i;
1727                 /*
1728                  * Wait 10 PCLKs before writing LCRH_TX register,
1729                  * to get this delay write read only register 10 times
1730                  */
1731                 for (i = 0; i < 10; ++i)
1732                         pl011_write(0xff, uap, REG_MIS);
1733                 pl011_write(lcr_h, uap, REG_LCRH_TX);
1734         }
1735 }
1736
1737 static int pl011_allocate_irq(struct uart_amba_port *uap)
1738 {
1739         pl011_write(uap->im, uap, REG_IMSC);
1740
1741         return request_irq(uap->port.irq, pl011_int, 0, "uart-pl011", uap);
1742 }
1743
1744 /*
1745  * Enable interrupts, only timeouts when using DMA
1746  * if initial RX DMA job failed, start in interrupt mode
1747  * as well.
1748  */
1749 static void pl011_enable_interrupts(struct uart_amba_port *uap)
1750 {
1751         unsigned int i;
1752
1753         spin_lock_irq(&uap->port.lock);
1754
1755         /* Clear out any spuriously appearing RX interrupts */
1756         pl011_write(UART011_RTIS | UART011_RXIS, uap, REG_ICR);
1757
1758         /*
1759          * RXIS is asserted only when the RX FIFO transitions from below
1760          * to above the trigger threshold.  If the RX FIFO is already
1761          * full to the threshold this can't happen and RXIS will now be
1762          * stuck off.  Drain the RX FIFO explicitly to fix this:
1763          */
1764         for (i = 0; i < uap->fifosize * 2; ++i) {
1765                 if (pl011_read(uap, REG_FR) & UART01x_FR_RXFE)
1766                         break;
1767
1768                 pl011_read(uap, REG_DR);
1769         }
1770
1771         uap->im = UART011_RTIM;
1772         if (!pl011_dma_rx_running(uap))
1773                 uap->im |= UART011_RXIM;
1774         pl011_write(uap->im, uap, REG_IMSC);
1775         spin_unlock_irq(&uap->port.lock);
1776 }
1777
1778 static int pl011_startup(struct uart_port *port)
1779 {
1780         struct uart_amba_port *uap =
1781             container_of(port, struct uart_amba_port, port);
1782         unsigned int cr;
1783         int retval;
1784
1785         retval = pl011_hwinit(port);
1786         if (retval)
1787                 goto clk_dis;
1788
1789         retval = pl011_allocate_irq(uap);
1790         if (retval)
1791                 goto clk_dis;
1792
1793         pl011_write(uap->vendor->ifls, uap, REG_IFLS);
1794
1795         spin_lock_irq(&uap->port.lock);
1796
1797         /* restore RTS and DTR */
1798         cr = uap->old_cr & (UART011_CR_RTS | UART011_CR_DTR);
1799         cr |= UART01x_CR_UARTEN | UART011_CR_RXE | UART011_CR_TXE;
1800         pl011_write(cr, uap, REG_CR);
1801
1802         spin_unlock_irq(&uap->port.lock);
1803
1804         /*
1805          * initialise the old status of the modem signals
1806          */
1807         uap->old_status = pl011_read(uap, REG_FR) & UART01x_FR_MODEM_ANY;
1808
1809         /* Startup DMA */
1810         pl011_dma_startup(uap);
1811
1812         pl011_enable_interrupts(uap);
1813
1814         return 0;
1815
1816  clk_dis:
1817         clk_disable_unprepare(uap->clk);
1818         return retval;
1819 }
1820
1821 static int sbsa_uart_startup(struct uart_port *port)
1822 {
1823         struct uart_amba_port *uap =
1824                 container_of(port, struct uart_amba_port, port);
1825         int retval;
1826
1827         retval = pl011_hwinit(port);
1828         if (retval)
1829                 return retval;
1830
1831         retval = pl011_allocate_irq(uap);
1832         if (retval)
1833                 return retval;
1834
1835         /* The SBSA UART does not support any modem status lines. */
1836         uap->old_status = 0;
1837
1838         pl011_enable_interrupts(uap);
1839
1840         return 0;
1841 }
1842
1843 static void pl011_shutdown_channel(struct uart_amba_port *uap,
1844                                         unsigned int lcrh)
1845 {
1846       unsigned long val;
1847
1848       val = pl011_read(uap, lcrh);
1849       val &= ~(UART01x_LCRH_BRK | UART01x_LCRH_FEN);
1850       pl011_write(val, uap, lcrh);
1851 }
1852
1853 /*
1854  * disable the port. It should not disable RTS and DTR.
1855  * Also RTS and DTR state should be preserved to restore
1856  * it during startup().
1857  */
1858 static void pl011_disable_uart(struct uart_amba_port *uap)
1859 {
1860         unsigned int cr;
1861
1862         uap->autorts = false;
1863         spin_lock_irq(&uap->port.lock);
1864         cr = pl011_read(uap, REG_CR);
1865         uap->old_cr = cr;
1866         cr &= UART011_CR_RTS | UART011_CR_DTR;
1867         cr |= UART01x_CR_UARTEN | UART011_CR_TXE;
1868         pl011_write(cr, uap, REG_CR);
1869         spin_unlock_irq(&uap->port.lock);
1870
1871         /*
1872          * disable break condition and fifos
1873          */
1874         pl011_shutdown_channel(uap, REG_LCRH_RX);
1875         if (pl011_split_lcrh(uap))
1876                 pl011_shutdown_channel(uap, REG_LCRH_TX);
1877 }
1878
1879 static void pl011_disable_interrupts(struct uart_amba_port *uap)
1880 {
1881         spin_lock_irq(&uap->port.lock);
1882
1883         /* mask all interrupts and clear all pending ones */
1884         uap->im = 0;
1885         pl011_write(uap->im, uap, REG_IMSC);
1886         pl011_write(0xffff, uap, REG_ICR);
1887
1888         spin_unlock_irq(&uap->port.lock);
1889 }
1890
1891 static void pl011_shutdown(struct uart_port *port)
1892 {
1893         struct uart_amba_port *uap =
1894                 container_of(port, struct uart_amba_port, port);
1895
1896         pl011_disable_interrupts(uap);
1897
1898         pl011_dma_shutdown(uap);
1899
1900         free_irq(uap->port.irq, uap);
1901
1902         pl011_disable_uart(uap);
1903
1904         /*
1905          * Shut down the clock producer
1906          */
1907         clk_disable_unprepare(uap->clk);
1908         /* Optionally let pins go into sleep states */
1909         pinctrl_pm_select_sleep_state(port->dev);
1910
1911         if (dev_get_platdata(uap->port.dev)) {
1912                 struct amba_pl011_data *plat;
1913
1914                 plat = dev_get_platdata(uap->port.dev);
1915                 if (plat->exit)
1916                         plat->exit();
1917         }
1918
1919         if (uap->port.ops->flush_buffer)
1920                 uap->port.ops->flush_buffer(port);
1921 }
1922
1923 static void sbsa_uart_shutdown(struct uart_port *port)
1924 {
1925         struct uart_amba_port *uap =
1926                 container_of(port, struct uart_amba_port, port);
1927
1928         pl011_disable_interrupts(uap);
1929
1930         free_irq(uap->port.irq, uap);
1931
1932         if (uap->port.ops->flush_buffer)
1933                 uap->port.ops->flush_buffer(port);
1934 }
1935
1936 static void
1937 pl011_setup_status_masks(struct uart_port *port, struct ktermios *termios)
1938 {
1939         port->read_status_mask = UART011_DR_OE | 255;
1940         if (termios->c_iflag & INPCK)
1941                 port->read_status_mask |= UART011_DR_FE | UART011_DR_PE;
1942         if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
1943                 port->read_status_mask |= UART011_DR_BE;
1944
1945         /*
1946          * Characters to ignore
1947          */
1948         port->ignore_status_mask = 0;
1949         if (termios->c_iflag & IGNPAR)
1950                 port->ignore_status_mask |= UART011_DR_FE | UART011_DR_PE;
1951         if (termios->c_iflag & IGNBRK) {
1952                 port->ignore_status_mask |= UART011_DR_BE;
1953                 /*
1954                  * If we're ignoring parity and break indicators,
1955                  * ignore overruns too (for real raw support).
1956                  */
1957                 if (termios->c_iflag & IGNPAR)
1958                         port->ignore_status_mask |= UART011_DR_OE;
1959         }
1960
1961         /*
1962          * Ignore all characters if CREAD is not set.
1963          */
1964         if ((termios->c_cflag & CREAD) == 0)
1965                 port->ignore_status_mask |= UART_DUMMY_DR_RX;
1966 }
1967
1968 static void
1969 pl011_set_termios(struct uart_port *port, struct ktermios *termios,
1970                      struct ktermios *old)
1971 {
1972         struct uart_amba_port *uap =
1973             container_of(port, struct uart_amba_port, port);
1974         unsigned int lcr_h, old_cr;
1975         unsigned long flags;
1976         unsigned int baud, quot, clkdiv;
1977
1978         if (uap->vendor->oversampling)
1979                 clkdiv = 8;
1980         else
1981                 clkdiv = 16;
1982
1983         /*
1984          * Ask the core to calculate the divisor for us.
1985          */
1986         baud = uart_get_baud_rate(port, termios, old, 0,
1987                                   port->uartclk / clkdiv);
1988 #ifdef CONFIG_DMA_ENGINE
1989         /*
1990          * Adjust RX DMA polling rate with baud rate if not specified.
1991          */
1992         if (uap->dmarx.auto_poll_rate)
1993                 uap->dmarx.poll_rate = DIV_ROUND_UP(10000000, baud);
1994 #endif
1995
1996         if (baud > port->uartclk/16)
1997                 quot = DIV_ROUND_CLOSEST(port->uartclk * 8, baud);
1998         else
1999                 quot = DIV_ROUND_CLOSEST(port->uartclk * 4, baud);
2000
2001         switch (termios->c_cflag & CSIZE) {
2002         case CS5:
2003                 lcr_h = UART01x_LCRH_WLEN_5;
2004                 break;
2005         case CS6:
2006                 lcr_h = UART01x_LCRH_WLEN_6;
2007                 break;
2008         case CS7:
2009                 lcr_h = UART01x_LCRH_WLEN_7;
2010                 break;
2011         default: // CS8
2012                 lcr_h = UART01x_LCRH_WLEN_8;
2013                 break;
2014         }
2015         if (termios->c_cflag & CSTOPB)
2016                 lcr_h |= UART01x_LCRH_STP2;
2017         if (termios->c_cflag & PARENB) {
2018                 lcr_h |= UART01x_LCRH_PEN;
2019                 if (!(termios->c_cflag & PARODD))
2020                         lcr_h |= UART01x_LCRH_EPS;
2021                 if (termios->c_cflag & CMSPAR)
2022                         lcr_h |= UART011_LCRH_SPS;
2023         }
2024         if (uap->fifosize > 1)
2025                 lcr_h |= UART01x_LCRH_FEN;
2026
2027         spin_lock_irqsave(&port->lock, flags);
2028
2029         /*
2030          * Update the per-port timeout.
2031          */
2032         uart_update_timeout(port, termios->c_cflag, baud);
2033
2034         pl011_setup_status_masks(port, termios);
2035
2036         if (UART_ENABLE_MS(port, termios->c_cflag))
2037                 pl011_enable_ms(port);
2038
2039         /* first, disable everything */
2040         old_cr = pl011_read(uap, REG_CR);
2041         pl011_write(0, uap, REG_CR);
2042
2043         if (termios->c_cflag & CRTSCTS) {
2044                 if (old_cr & UART011_CR_RTS)
2045                         old_cr |= UART011_CR_RTSEN;
2046
2047                 old_cr |= UART011_CR_CTSEN;
2048                 uap->autorts = true;
2049         } else {
2050                 old_cr &= ~(UART011_CR_CTSEN | UART011_CR_RTSEN);
2051                 uap->autorts = false;
2052         }
2053
2054         if (uap->vendor->oversampling) {
2055                 if (baud > port->uartclk / 16)
2056                         old_cr |= ST_UART011_CR_OVSFACT;
2057                 else
2058                         old_cr &= ~ST_UART011_CR_OVSFACT;
2059         }
2060
2061         /*
2062          * Workaround for the ST Micro oversampling variants to
2063          * increase the bitrate slightly, by lowering the divisor,
2064          * to avoid delayed sampling of start bit at high speeds,
2065          * else we see data corruption.
2066          */
2067         if (uap->vendor->oversampling) {
2068                 if ((baud >= 3000000) && (baud < 3250000) && (quot > 1))
2069                         quot -= 1;
2070                 else if ((baud > 3250000) && (quot > 2))
2071                         quot -= 2;
2072         }
2073         /* Set baud rate */
2074         pl011_write(quot & 0x3f, uap, REG_FBRD);
2075         pl011_write(quot >> 6, uap, REG_IBRD);
2076
2077         /*
2078          * ----------v----------v----------v----------v-----
2079          * NOTE: REG_LCRH_TX and REG_LCRH_RX MUST BE WRITTEN AFTER
2080          * REG_FBRD & REG_IBRD.
2081          * ----------^----------^----------^----------^-----
2082          */
2083         pl011_write_lcr_h(uap, lcr_h);
2084         pl011_write(old_cr, uap, REG_CR);
2085
2086         spin_unlock_irqrestore(&port->lock, flags);
2087 }
2088
2089 static void
2090 sbsa_uart_set_termios(struct uart_port *port, struct ktermios *termios,
2091                       struct ktermios *old)
2092 {
2093         struct uart_amba_port *uap =
2094             container_of(port, struct uart_amba_port, port);
2095         unsigned long flags;
2096
2097         tty_termios_encode_baud_rate(termios, uap->fixed_baud, uap->fixed_baud);
2098
2099         /* The SBSA UART only supports 8n1 without hardware flow control. */
2100         termios->c_cflag &= ~(CSIZE | CSTOPB | PARENB | PARODD);
2101         termios->c_cflag &= ~(CMSPAR | CRTSCTS);
2102         termios->c_cflag |= CS8 | CLOCAL;
2103
2104         spin_lock_irqsave(&port->lock, flags);
2105         uart_update_timeout(port, CS8, uap->fixed_baud);
2106         pl011_setup_status_masks(port, termios);
2107         spin_unlock_irqrestore(&port->lock, flags);
2108 }
2109
2110 static const char *pl011_type(struct uart_port *port)
2111 {
2112         struct uart_amba_port *uap =
2113             container_of(port, struct uart_amba_port, port);
2114         return uap->port.type == PORT_AMBA ? uap->type : NULL;
2115 }
2116
2117 /*
2118  * Configure/autoconfigure the port.
2119  */
2120 static void pl011_config_port(struct uart_port *port, int flags)
2121 {
2122         if (flags & UART_CONFIG_TYPE)
2123                 port->type = PORT_AMBA;
2124 }
2125
2126 /*
2127  * verify the new serial_struct (for TIOCSSERIAL).
2128  */
2129 static int pl011_verify_port(struct uart_port *port, struct serial_struct *ser)
2130 {
2131         int ret = 0;
2132         if (ser->type != PORT_UNKNOWN && ser->type != PORT_AMBA)
2133                 ret = -EINVAL;
2134         if (ser->irq < 0 || ser->irq >= nr_irqs)
2135                 ret = -EINVAL;
2136         if (ser->baud_base < 9600)
2137                 ret = -EINVAL;
2138         if (port->mapbase != (unsigned long) ser->iomem_base)
2139                 ret = -EINVAL;
2140         return ret;
2141 }
2142
2143 static const struct uart_ops amba_pl011_pops = {
2144         .tx_empty       = pl011_tx_empty,
2145         .set_mctrl      = pl011_set_mctrl,
2146         .get_mctrl      = pl011_get_mctrl,
2147         .stop_tx        = pl011_stop_tx,
2148         .start_tx       = pl011_start_tx,
2149         .stop_rx        = pl011_stop_rx,
2150         .enable_ms      = pl011_enable_ms,
2151         .break_ctl      = pl011_break_ctl,
2152         .startup        = pl011_startup,
2153         .shutdown       = pl011_shutdown,
2154         .flush_buffer   = pl011_dma_flush_buffer,
2155         .set_termios    = pl011_set_termios,
2156         .type           = pl011_type,
2157         .config_port    = pl011_config_port,
2158         .verify_port    = pl011_verify_port,
2159 #ifdef CONFIG_CONSOLE_POLL
2160         .poll_init     = pl011_hwinit,
2161         .poll_get_char = pl011_get_poll_char,
2162         .poll_put_char = pl011_put_poll_char,
2163 #endif
2164 };
2165
2166 static void sbsa_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
2167 {
2168 }
2169
2170 static unsigned int sbsa_uart_get_mctrl(struct uart_port *port)
2171 {
2172         return 0;
2173 }
2174
2175 static const struct uart_ops sbsa_uart_pops = {
2176         .tx_empty       = pl011_tx_empty,
2177         .set_mctrl      = sbsa_uart_set_mctrl,
2178         .get_mctrl      = sbsa_uart_get_mctrl,
2179         .stop_tx        = pl011_stop_tx,
2180         .start_tx       = pl011_start_tx,
2181         .stop_rx        = pl011_stop_rx,
2182         .startup        = sbsa_uart_startup,
2183         .shutdown       = sbsa_uart_shutdown,
2184         .set_termios    = sbsa_uart_set_termios,
2185         .type           = pl011_type,
2186         .config_port    = pl011_config_port,
2187         .verify_port    = pl011_verify_port,
2188 #ifdef CONFIG_CONSOLE_POLL
2189         .poll_init     = pl011_hwinit,
2190         .poll_get_char = pl011_get_poll_char,
2191         .poll_put_char = pl011_put_poll_char,
2192 #endif
2193 };
2194
2195 static struct uart_amba_port *amba_ports[UART_NR];
2196
2197 #ifdef CONFIG_SERIAL_AMBA_PL011_CONSOLE
2198
2199 static void pl011_console_putchar(struct uart_port *port, int ch)
2200 {
2201         struct uart_amba_port *uap =
2202             container_of(port, struct uart_amba_port, port);
2203
2204         while (pl011_read(uap, REG_FR) & UART01x_FR_TXFF)
2205                 cpu_relax();
2206         pl011_write(ch, uap, REG_DR);
2207 }
2208
2209 static void
2210 pl011_console_write(struct console *co, const char *s, unsigned int count)
2211 {
2212         struct uart_amba_port *uap = amba_ports[co->index];
2213         unsigned int old_cr = 0, new_cr;
2214         unsigned long flags;
2215         int locked = 1;
2216
2217         clk_enable(uap->clk);
2218
2219         local_irq_save(flags);
2220         if (uap->port.sysrq)
2221                 locked = 0;
2222         else if (oops_in_progress)
2223                 locked = spin_trylock(&uap->port.lock);
2224         else
2225                 spin_lock(&uap->port.lock);
2226
2227         /*
2228          *      First save the CR then disable the interrupts
2229          */
2230         if (!uap->vendor->always_enabled) {
2231                 old_cr = pl011_read(uap, REG_CR);
2232                 new_cr = old_cr & ~UART011_CR_CTSEN;
2233                 new_cr |= UART01x_CR_UARTEN | UART011_CR_TXE;
2234                 pl011_write(new_cr, uap, REG_CR);
2235         }
2236
2237         uart_console_write(&uap->port, s, count, pl011_console_putchar);
2238
2239         /*
2240          *      Finally, wait for transmitter to become empty and restore the
2241          *      TCR. Allow feature register bits to be inverted to work around
2242          *      errata.
2243          */
2244         while ((pl011_read(uap, REG_FR) ^ uap->vendor->inv_fr)
2245                                                 & uap->vendor->fr_busy)
2246                 cpu_relax();
2247         if (!uap->vendor->always_enabled)
2248                 pl011_write(old_cr, uap, REG_CR);
2249
2250         if (locked)
2251                 spin_unlock(&uap->port.lock);
2252         local_irq_restore(flags);
2253
2254         clk_disable(uap->clk);
2255 }
2256
2257 static void pl011_console_get_options(struct uart_amba_port *uap, int *baud,
2258                                       int *parity, int *bits)
2259 {
2260         if (pl011_read(uap, REG_CR) & UART01x_CR_UARTEN) {
2261                 unsigned int lcr_h, ibrd, fbrd;
2262
2263                 lcr_h = pl011_read(uap, REG_LCRH_TX);
2264
2265                 *parity = 'n';
2266                 if (lcr_h & UART01x_LCRH_PEN) {
2267                         if (lcr_h & UART01x_LCRH_EPS)
2268                                 *parity = 'e';
2269                         else
2270                                 *parity = 'o';
2271                 }
2272
2273                 if ((lcr_h & 0x60) == UART01x_LCRH_WLEN_7)
2274                         *bits = 7;
2275                 else
2276                         *bits = 8;
2277
2278                 ibrd = pl011_read(uap, REG_IBRD);
2279                 fbrd = pl011_read(uap, REG_FBRD);
2280
2281                 *baud = uap->port.uartclk * 4 / (64 * ibrd + fbrd);
2282
2283                 if (uap->vendor->oversampling) {
2284                         if (pl011_read(uap, REG_CR)
2285                                   & ST_UART011_CR_OVSFACT)
2286                                 *baud *= 2;
2287                 }
2288         }
2289 }
2290
2291 static int pl011_console_setup(struct console *co, char *options)
2292 {
2293         struct uart_amba_port *uap;
2294         int baud = 38400;
2295         int bits = 8;
2296         int parity = 'n';
2297         int flow = 'n';
2298         int ret;
2299
2300         /*
2301          * Check whether an invalid uart number has been specified, and
2302          * if so, search for the first available port that does have
2303          * console support.
2304          */
2305         if (co->index >= UART_NR)
2306                 co->index = 0;
2307         uap = amba_ports[co->index];
2308         if (!uap)
2309                 return -ENODEV;
2310
2311         /* Allow pins to be muxed in and configured */
2312         pinctrl_pm_select_default_state(uap->port.dev);
2313
2314         ret = clk_prepare(uap->clk);
2315         if (ret)
2316                 return ret;
2317
2318         if (dev_get_platdata(uap->port.dev)) {
2319                 struct amba_pl011_data *plat;
2320
2321                 plat = dev_get_platdata(uap->port.dev);
2322                 if (plat->init)
2323                         plat->init();
2324         }
2325
2326         uap->port.uartclk = clk_get_rate(uap->clk);
2327
2328         if (uap->vendor->fixed_options) {
2329                 baud = uap->fixed_baud;
2330         } else {
2331                 if (options)
2332                         uart_parse_options(options,
2333                                            &baud, &parity, &bits, &flow);
2334                 else
2335                         pl011_console_get_options(uap, &baud, &parity, &bits);
2336         }
2337
2338         return uart_set_options(&uap->port, co, baud, parity, bits, flow);
2339 }
2340
2341 /**
2342  *      pl011_console_match - non-standard console matching
2343  *      @co:      registering console
2344  *      @name:    name from console command line
2345  *      @idx:     index from console command line
2346  *      @options: ptr to option string from console command line
2347  *
2348  *      Only attempts to match console command lines of the form:
2349  *          console=pl011,mmio|mmio32,<addr>[,<options>]
2350  *          console=pl011,0x<addr>[,<options>]
2351  *      This form is used to register an initial earlycon boot console and
2352  *      replace it with the amba_console at pl011 driver init.
2353  *
2354  *      Performs console setup for a match (as required by interface)
2355  *      If no <options> are specified, then assume the h/w is already setup.
2356  *
2357  *      Returns 0 if console matches; otherwise non-zero to use default matching
2358  */
2359 static int pl011_console_match(struct console *co, char *name, int idx,
2360                                char *options)
2361 {
2362         unsigned char iotype;
2363         resource_size_t addr;
2364         int i;
2365
2366         /*
2367          * Systems affected by the Qualcomm Technologies QDF2400 E44 erratum
2368          * have a distinct console name, so make sure we check for that.
2369          * The actual implementation of the erratum occurs in the probe
2370          * function.
2371          */
2372         if ((strcmp(name, "qdf2400_e44") != 0) && (strcmp(name, "pl011") != 0))
2373                 return -ENODEV;
2374
2375         if (uart_parse_earlycon(options, &iotype, &addr, &options))
2376                 return -ENODEV;
2377
2378         if (iotype != UPIO_MEM && iotype != UPIO_MEM32)
2379                 return -ENODEV;
2380
2381         /* try to match the port specified on the command line */
2382         for (i = 0; i < ARRAY_SIZE(amba_ports); i++) {
2383                 struct uart_port *port;
2384
2385                 if (!amba_ports[i])
2386                         continue;
2387
2388                 port = &amba_ports[i]->port;
2389
2390                 if (port->mapbase != addr)
2391                         continue;
2392
2393                 co->index = i;
2394                 port->cons = co;
2395                 return pl011_console_setup(co, options);
2396         }
2397
2398         return -ENODEV;
2399 }
2400
2401 static struct uart_driver amba_reg;
2402 static struct console amba_console = {
2403         .name           = "ttyAMA",
2404         .write          = pl011_console_write,
2405         .device         = uart_console_device,
2406         .setup          = pl011_console_setup,
2407         .match          = pl011_console_match,
2408         .flags          = CON_PRINTBUFFER | CON_ANYTIME,
2409         .index          = -1,
2410         .data           = &amba_reg,
2411 };
2412
2413 #define AMBA_CONSOLE    (&amba_console)
2414
2415 static void qdf2400_e44_putc(struct uart_port *port, int c)
2416 {
2417         while (readl(port->membase + UART01x_FR) & UART01x_FR_TXFF)
2418                 cpu_relax();
2419         writel(c, port->membase + UART01x_DR);
2420         while (!(readl(port->membase + UART01x_FR) & UART011_FR_TXFE))
2421                 cpu_relax();
2422 }
2423
2424 static void qdf2400_e44_early_write(struct console *con, const char *s, unsigned n)
2425 {
2426         struct earlycon_device *dev = con->data;
2427
2428         uart_console_write(&dev->port, s, n, qdf2400_e44_putc);
2429 }
2430
2431 static void pl011_putc(struct uart_port *port, int c)
2432 {
2433         while (readl(port->membase + UART01x_FR) & UART01x_FR_TXFF)
2434                 cpu_relax();
2435         if (port->iotype == UPIO_MEM32)
2436                 writel(c, port->membase + UART01x_DR);
2437         else
2438                 writeb(c, port->membase + UART01x_DR);
2439         while (readl(port->membase + UART01x_FR) & UART01x_FR_BUSY)
2440                 cpu_relax();
2441 }
2442
2443 static void pl011_early_write(struct console *con, const char *s, unsigned n)
2444 {
2445         struct earlycon_device *dev = con->data;
2446
2447         uart_console_write(&dev->port, s, n, pl011_putc);
2448 }
2449
2450 /*
2451  * On non-ACPI systems, earlycon is enabled by specifying
2452  * "earlycon=pl011,<address>" on the kernel command line.
2453  *
2454  * On ACPI ARM64 systems, an "early" console is enabled via the SPCR table,
2455  * by specifying only "earlycon" on the command line.  Because it requires
2456  * SPCR, the console starts after ACPI is parsed, which is later than a
2457  * traditional early console.
2458  *
2459  * To get the traditional early console that starts before ACPI is parsed,
2460  * specify the full "earlycon=pl011,<address>" option.
2461  */
2462 static int __init pl011_early_console_setup(struct earlycon_device *device,
2463                                             const char *opt)
2464 {
2465         if (!device->port.membase)
2466                 return -ENODEV;
2467
2468         device->con->write = pl011_early_write;
2469
2470         return 0;
2471 }
2472 OF_EARLYCON_DECLARE(pl011, "arm,pl011", pl011_early_console_setup);
2473 OF_EARLYCON_DECLARE(pl011, "arm,sbsa-uart", pl011_early_console_setup);
2474
2475 /*
2476  * On Qualcomm Datacenter Technologies QDF2400 SOCs affected by
2477  * Erratum 44, traditional earlycon can be enabled by specifying
2478  * "earlycon=qdf2400_e44,<address>".  Any options are ignored.
2479  *
2480  * Alternatively, you can just specify "earlycon", and the early console
2481  * will be enabled with the information from the SPCR table.  In this
2482  * case, the SPCR code will detect the need for the E44 work-around,
2483  * and set the console name to "qdf2400_e44".
2484  */
2485 static int __init
2486 qdf2400_e44_early_console_setup(struct earlycon_device *device,
2487                                 const char *opt)
2488 {
2489         if (!device->port.membase)
2490                 return -ENODEV;
2491
2492         device->con->write = qdf2400_e44_early_write;
2493         return 0;
2494 }
2495 EARLYCON_DECLARE(qdf2400_e44, qdf2400_e44_early_console_setup);
2496
2497 #else
2498 #define AMBA_CONSOLE    NULL
2499 #endif
2500
2501 static struct uart_driver amba_reg = {
2502         .owner                  = THIS_MODULE,
2503         .driver_name            = "ttyAMA",
2504         .dev_name               = "ttyAMA",
2505         .major                  = SERIAL_AMBA_MAJOR,
2506         .minor                  = SERIAL_AMBA_MINOR,
2507         .nr                     = UART_NR,
2508         .cons                   = AMBA_CONSOLE,
2509 };
2510
2511 static int pl011_probe_dt_alias(int index, struct device *dev)
2512 {
2513         struct device_node *np;
2514         static bool seen_dev_with_alias = false;
2515         static bool seen_dev_without_alias = false;
2516         int ret = index;
2517
2518         if (!IS_ENABLED(CONFIG_OF))
2519                 return ret;
2520
2521         np = dev->of_node;
2522         if (!np)
2523                 return ret;
2524
2525         ret = of_alias_get_id(np, "serial");
2526         if (ret < 0) {
2527                 seen_dev_without_alias = true;
2528                 ret = index;
2529         } else {
2530                 seen_dev_with_alias = true;
2531                 if (ret >= ARRAY_SIZE(amba_ports) || amba_ports[ret] != NULL) {
2532                         dev_warn(dev, "requested serial port %d  not available.\n", ret);
2533                         ret = index;
2534                 }
2535         }
2536
2537         if (seen_dev_with_alias && seen_dev_without_alias)
2538                 dev_warn(dev, "aliased and non-aliased serial devices found in device tree. Serial port enumeration may be unpredictable.\n");
2539
2540         return ret;
2541 }
2542
2543 /* unregisters the driver also if no more ports are left */
2544 static void pl011_unregister_port(struct uart_amba_port *uap)
2545 {
2546         int i;
2547         bool busy = false;
2548
2549         for (i = 0; i < ARRAY_SIZE(amba_ports); i++) {
2550                 if (amba_ports[i] == uap)
2551                         amba_ports[i] = NULL;
2552                 else if (amba_ports[i])
2553                         busy = true;
2554         }
2555         pl011_dma_remove(uap);
2556         if (!busy)
2557                 uart_unregister_driver(&amba_reg);
2558 }
2559
2560 static int pl011_find_free_port(void)
2561 {
2562         int i;
2563
2564         for (i = 0; i < ARRAY_SIZE(amba_ports); i++)
2565                 if (amba_ports[i] == NULL)
2566                         return i;
2567
2568         return -EBUSY;
2569 }
2570
2571 static int pl011_setup_port(struct device *dev, struct uart_amba_port *uap,
2572                             struct resource *mmiobase, int index)
2573 {
2574         void __iomem *base;
2575
2576         base = devm_ioremap_resource(dev, mmiobase);
2577         if (IS_ERR(base))
2578                 return PTR_ERR(base);
2579
2580         index = pl011_probe_dt_alias(index, dev);
2581
2582         uap->old_cr = 0;
2583         uap->port.dev = dev;
2584         uap->port.mapbase = mmiobase->start;
2585         uap->port.membase = base;
2586         uap->port.fifosize = uap->fifosize;
2587         uap->port.flags = UPF_BOOT_AUTOCONF;
2588         uap->port.line = index;
2589         spin_lock_init(&uap->port.lock);
2590
2591         amba_ports[index] = uap;
2592
2593         return 0;
2594 }
2595
2596 static int pl011_register_port(struct uart_amba_port *uap)
2597 {
2598         int ret, i;
2599
2600         /* Ensure interrupts from this UART are masked and cleared */
2601         pl011_write(0, uap, REG_IMSC);
2602         pl011_write(0xffff, uap, REG_ICR);
2603
2604         if (!amba_reg.state) {
2605                 ret = uart_register_driver(&amba_reg);
2606                 if (ret < 0) {
2607                         dev_err(uap->port.dev,
2608                                 "Failed to register AMBA-PL011 driver\n");
2609                         for (i = 0; i < ARRAY_SIZE(amba_ports); i++)
2610                                 if (amba_ports[i] == uap)
2611                                         amba_ports[i] = NULL;
2612                         return ret;
2613                 }
2614         }
2615
2616         ret = uart_add_one_port(&amba_reg, &uap->port);
2617         if (ret)
2618                 pl011_unregister_port(uap);
2619
2620         return ret;
2621 }
2622
2623 static int pl011_probe(struct amba_device *dev, const struct amba_id *id)
2624 {
2625         struct uart_amba_port *uap;
2626         struct vendor_data *vendor = id->data;
2627         int portnr, ret;
2628
2629         portnr = pl011_find_free_port();
2630         if (portnr < 0)
2631                 return portnr;
2632
2633         uap = devm_kzalloc(&dev->dev, sizeof(struct uart_amba_port),
2634                            GFP_KERNEL);
2635         if (!uap)
2636                 return -ENOMEM;
2637
2638         uap->clk = devm_clk_get(&dev->dev, NULL);
2639         if (IS_ERR(uap->clk))
2640                 return PTR_ERR(uap->clk);
2641
2642         uap->reg_offset = vendor->reg_offset;
2643         uap->vendor = vendor;
2644         uap->fifosize = vendor->get_fifosize(dev);
2645         uap->port.iotype = vendor->access_32b ? UPIO_MEM32 : UPIO_MEM;
2646         uap->port.irq = dev->irq[0];
2647         uap->port.ops = &amba_pl011_pops;
2648
2649         snprintf(uap->type, sizeof(uap->type), "PL011 rev%u", amba_rev(dev));
2650
2651         ret = pl011_setup_port(&dev->dev, uap, &dev->res, portnr);
2652         if (ret)
2653                 return ret;
2654
2655         amba_set_drvdata(dev, uap);
2656
2657         return pl011_register_port(uap);
2658 }
2659
2660 static int pl011_remove(struct amba_device *dev)
2661 {
2662         struct uart_amba_port *uap = amba_get_drvdata(dev);
2663
2664         uart_remove_one_port(&amba_reg, &uap->port);
2665         pl011_unregister_port(uap);
2666         return 0;
2667 }
2668
2669 #ifdef CONFIG_PM_SLEEP
2670 static int pl011_suspend(struct device *dev)
2671 {
2672         struct uart_amba_port *uap = dev_get_drvdata(dev);
2673
2674         if (!uap)
2675                 return -EINVAL;
2676
2677         return uart_suspend_port(&amba_reg, &uap->port);
2678 }
2679
2680 static int pl011_resume(struct device *dev)
2681 {
2682         struct uart_amba_port *uap = dev_get_drvdata(dev);
2683
2684         if (!uap)
2685                 return -EINVAL;
2686
2687         return uart_resume_port(&amba_reg, &uap->port);
2688 }
2689 #endif
2690
2691 static SIMPLE_DEV_PM_OPS(pl011_dev_pm_ops, pl011_suspend, pl011_resume);
2692
2693 static int sbsa_uart_probe(struct platform_device *pdev)
2694 {
2695         struct uart_amba_port *uap;
2696         struct resource *r;
2697         int portnr, ret;
2698         int baudrate;
2699
2700         /*
2701          * Check the mandatory baud rate parameter in the DT node early
2702          * so that we can easily exit with the error.
2703          */
2704         if (pdev->dev.of_node) {
2705                 struct device_node *np = pdev->dev.of_node;
2706
2707                 ret = of_property_read_u32(np, "current-speed", &baudrate);
2708                 if (ret)
2709                         return ret;
2710         } else {
2711                 baudrate = 115200;
2712         }
2713
2714         portnr = pl011_find_free_port();
2715         if (portnr < 0)
2716                 return portnr;
2717
2718         uap = devm_kzalloc(&pdev->dev, sizeof(struct uart_amba_port),
2719                            GFP_KERNEL);
2720         if (!uap)
2721                 return -ENOMEM;
2722
2723         ret = platform_get_irq(pdev, 0);
2724         if (ret < 0) {
2725                 if (ret != -EPROBE_DEFER)
2726                         dev_err(&pdev->dev, "cannot obtain irq\n");
2727                 return ret;
2728         }
2729         uap->port.irq   = ret;
2730
2731 #ifdef CONFIG_ACPI_SPCR_TABLE
2732         if (qdf2400_e44_present) {
2733                 dev_info(&pdev->dev, "working around QDF2400 SoC erratum 44\n");
2734                 uap->vendor = &vendor_qdt_qdf2400_e44;
2735         } else
2736 #endif
2737                 uap->vendor = &vendor_sbsa;
2738
2739         uap->reg_offset = uap->vendor->reg_offset;
2740         uap->fifosize   = 32;
2741         uap->port.iotype = uap->vendor->access_32b ? UPIO_MEM32 : UPIO_MEM;
2742         uap->port.ops   = &sbsa_uart_pops;
2743         uap->fixed_baud = baudrate;
2744
2745         snprintf(uap->type, sizeof(uap->type), "SBSA");
2746
2747         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2748
2749         ret = pl011_setup_port(&pdev->dev, uap, r, portnr);
2750         if (ret)
2751                 return ret;
2752
2753         platform_set_drvdata(pdev, uap);
2754
2755         return pl011_register_port(uap);
2756 }
2757
2758 static int sbsa_uart_remove(struct platform_device *pdev)
2759 {
2760         struct uart_amba_port *uap = platform_get_drvdata(pdev);
2761
2762         uart_remove_one_port(&amba_reg, &uap->port);
2763         pl011_unregister_port(uap);
2764         return 0;
2765 }
2766
2767 static const struct of_device_id sbsa_uart_of_match[] = {
2768         { .compatible = "arm,sbsa-uart", },
2769         {},
2770 };
2771 MODULE_DEVICE_TABLE(of, sbsa_uart_of_match);
2772
2773 static const struct acpi_device_id sbsa_uart_acpi_match[] = {
2774         { "ARMH0011", 0 },
2775         { "ARMHB000", 0 },
2776         {},
2777 };
2778 MODULE_DEVICE_TABLE(acpi, sbsa_uart_acpi_match);
2779
2780 static struct platform_driver arm_sbsa_uart_platform_driver = {
2781         .probe          = sbsa_uart_probe,
2782         .remove         = sbsa_uart_remove,
2783         .driver = {
2784                 .name   = "sbsa-uart",
2785                 .of_match_table = of_match_ptr(sbsa_uart_of_match),
2786                 .acpi_match_table = ACPI_PTR(sbsa_uart_acpi_match),
2787                 .suppress_bind_attrs = IS_BUILTIN(CONFIG_SERIAL_AMBA_PL011),
2788         },
2789 };
2790
2791 static const struct amba_id pl011_ids[] = {
2792         {
2793                 .id     = 0x00041011,
2794                 .mask   = 0x000fffff,
2795                 .data   = &vendor_arm,
2796         },
2797         {
2798                 .id     = 0x00380802,
2799                 .mask   = 0x00ffffff,
2800                 .data   = &vendor_st,
2801         },
2802         {
2803                 .id     = AMBA_LINUX_ID(0x00, 0x1, 0xffe),
2804                 .mask   = 0x00ffffff,
2805                 .data   = &vendor_zte,
2806         },
2807         { 0, 0 },
2808 };
2809
2810 MODULE_DEVICE_TABLE(amba, pl011_ids);
2811
2812 static struct amba_driver pl011_driver = {
2813         .drv = {
2814                 .name   = "uart-pl011",
2815                 .pm     = &pl011_dev_pm_ops,
2816                 .suppress_bind_attrs = IS_BUILTIN(CONFIG_SERIAL_AMBA_PL011),
2817         },
2818         .id_table       = pl011_ids,
2819         .probe          = pl011_probe,
2820         .remove         = pl011_remove,
2821 };
2822
2823 static int __init pl011_init(void)
2824 {
2825         printk(KERN_INFO "Serial: AMBA PL011 UART driver\n");
2826
2827         if (platform_driver_register(&arm_sbsa_uart_platform_driver))
2828                 pr_warn("could not register SBSA UART platform driver\n");
2829         return amba_driver_register(&pl011_driver);
2830 }
2831
2832 static void __exit pl011_exit(void)
2833 {
2834         platform_driver_unregister(&arm_sbsa_uart_platform_driver);
2835         amba_driver_unregister(&pl011_driver);
2836 }
2837
2838 /*
2839  * While this can be a module, if builtin it's most likely the console
2840  * So let's leave module_exit but move module_init to an earlier place
2841  */
2842 arch_initcall(pl011_init);
2843 module_exit(pl011_exit);
2844
2845 MODULE_AUTHOR("ARM Ltd/Deep Blue Solutions Ltd");
2846 MODULE_DESCRIPTION("ARM AMBA serial port driver");
2847 MODULE_LICENSE("GPL");