drivers/tty/serial/mvebu-uart.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3 * ***************************************************************************
   4 * Marvell Armada-3700 Serial Driver
   5 * Author: Wilson Ding <dingwei@marvell.com>
   6 * Copyright (C) 2015 Marvell International Ltd.
   7 * ***************************************************************************
   8 */
   9
  10 #include <linux/clk.h>
  11 #include <linux/console.h>
  12 #include <linux/delay.h>
  13 #include <linux/device.h>
  14 #include <linux/init.h>
  15 #include <linux/io.h>
  16 #include <linux/iopoll.h>
  17 #include <linux/of.h>
  18 #include <linux/of_address.h>
  19 #include <linux/of_device.h>
  20 #include <linux/of_irq.h>
  21 #include <linux/of_platform.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/serial.h>
  24 #include <linux/serial_core.h>
  25 #include <linux/slab.h>
  26 #include <linux/tty.h>
  27 #include <linux/tty_flip.h>
  28
  29 /* Register Map */
  30 #define UART_STD_RBR            0x00
  31 #define UART_EXT_RBR            0x18
  32
  33 #define UART_STD_TSH            0x04
  34 #define UART_EXT_TSH            0x1C
  35
  36 #define UART_STD_CTRL1          0x08
  37 #define UART_EXT_CTRL1          0x04
  38 #define  CTRL_SOFT_RST          BIT(31)
  39 #define  CTRL_TXFIFO_RST        BIT(15)
  40 #define  CTRL_RXFIFO_RST        BIT(14)
  41 #define  CTRL_SND_BRK_SEQ       BIT(11)
  42 #define  CTRL_BRK_DET_INT       BIT(3)
  43 #define  CTRL_FRM_ERR_INT       BIT(2)
  44 #define  CTRL_PAR_ERR_INT       BIT(1)
  45 #define  CTRL_OVR_ERR_INT       BIT(0)
  46 #define  CTRL_BRK_INT           (CTRL_BRK_DET_INT | CTRL_FRM_ERR_INT | \
  47                                 CTRL_PAR_ERR_INT | CTRL_OVR_ERR_INT)
  48
  49 #define UART_STD_CTRL2          UART_STD_CTRL1
  50 #define UART_EXT_CTRL2          0x20
  51 #define  CTRL_STD_TX_RDY_INT    BIT(5)
  52 #define  CTRL_EXT_TX_RDY_INT    BIT(6)
  53 #define  CTRL_STD_RX_RDY_INT    BIT(4)
  54 #define  CTRL_EXT_RX_RDY_INT    BIT(5)
  55
  56 #define UART_STAT               0x0C
  57 #define  STAT_TX_FIFO_EMP       BIT(13)
  58 #define  STAT_TX_FIFO_FUL       BIT(11)
  59 #define  STAT_TX_EMP            BIT(6)
  60 #define  STAT_STD_TX_RDY        BIT(5)
  61 #define  STAT_EXT_TX_RDY        BIT(15)
  62 #define  STAT_STD_RX_RDY        BIT(4)
  63 #define  STAT_EXT_RX_RDY        BIT(14)
  64 #define  STAT_BRK_DET           BIT(3)
  65 #define  STAT_FRM_ERR           BIT(2)
  66 #define  STAT_PAR_ERR           BIT(1)
  67 #define  STAT_OVR_ERR           BIT(0)
  68 #define  STAT_BRK_ERR           (STAT_BRK_DET | STAT_FRM_ERR \
  69                                  | STAT_PAR_ERR | STAT_OVR_ERR)
  70
  71 #define UART_BRDV               0x10
  72 #define  BRDV_BAUD_MASK         0x3FF
  73
  74 #define UART_OSAMP              0x14
  75 #define  OSAMP_DEFAULT_DIVISOR  16
  76
  77 #define MVEBU_NR_UARTS          2
  78
  79 #define MVEBU_UART_TYPE         "mvebu-uart"
  80 #define DRIVER_NAME             "mvebu_serial"
  81
  82 enum {
  83         /* Either there is only one summed IRQ... */
  84         UART_IRQ_SUM = 0,
  85         /* ...or there are two separate IRQ for RX and TX */
  86         UART_RX_IRQ = 0,
  87         UART_TX_IRQ,
  88         UART_IRQ_COUNT
  89 };
  90
  91 /* Diverging register offsets */
  92 struct uart_regs_layout {
  93         unsigned int rbr;
  94         unsigned int tsh;
  95         unsigned int ctrl;
  96         unsigned int intr;
  97 };
  98
  99 /* Diverging flags */
 100 struct uart_flags {
 101         unsigned int ctrl_tx_rdy_int;
 102         unsigned int ctrl_rx_rdy_int;
 103         unsigned int stat_tx_rdy;
 104         unsigned int stat_rx_rdy;
 105 };
 106
 107 /* Driver data, a structure for each UART port */
 108 struct mvebu_uart_driver_data {
 109         bool is_ext;
 110         struct uart_regs_layout regs;
 111         struct uart_flags flags;
 112 };
 113
 114 /* Saved registers during suspend */
 115 struct mvebu_uart_pm_regs {
 116         unsigned int rbr;
 117         unsigned int tsh;
 118         unsigned int ctrl;
 119         unsigned int intr;
 120         unsigned int stat;
 121         unsigned int brdv;
 122         unsigned int osamp;
 123 };
 124
 125 /* MVEBU UART driver structure */
 126 struct mvebu_uart {
 127         struct uart_port *port;
 128         struct clk *clk;
 129         int irq[UART_IRQ_COUNT];
 130         unsigned char __iomem *nb;
 131         struct mvebu_uart_driver_data *data;
 132 #if defined(CONFIG_PM)
 133         struct mvebu_uart_pm_regs pm_regs;
 134 #endif /* CONFIG_PM */
 135 };
 136
 137 static struct mvebu_uart *to_mvuart(struct uart_port *port)
 138 {
 139         return (struct mvebu_uart *)port->private_data;
 140 }
 141
 142 #define IS_EXTENDED(port) (to_mvuart(port)->data->is_ext)
 143
 144 #define UART_RBR(port) (to_mvuart(port)->data->regs.rbr)
 145 #define UART_TSH(port) (to_mvuart(port)->data->regs.tsh)
 146 #define UART_CTRL(port) (to_mvuart(port)->data->regs.ctrl)
 147 #define UART_INTR(port) (to_mvuart(port)->data->regs.intr)
 148
 149 #define CTRL_TX_RDY_INT(port) (to_mvuart(port)->data->flags.ctrl_tx_rdy_int)
 150 #define CTRL_RX_RDY_INT(port) (to_mvuart(port)->data->flags.ctrl_rx_rdy_int)
 151 #define STAT_TX_RDY(port) (to_mvuart(port)->data->flags.stat_tx_rdy)
 152 #define STAT_RX_RDY(port) (to_mvuart(port)->data->flags.stat_rx_rdy)
 153
 154 static struct uart_port mvebu_uart_ports[MVEBU_NR_UARTS];
 155
 156 /* Core UART Driver Operations */
 157 static unsigned int mvebu_uart_tx_empty(struct uart_port *port)
 158 {
 159         unsigned long flags;
 160         unsigned int st;
 161
 162         spin_lock_irqsave(&port->lock, flags);
 163         st = readl(port->membase + UART_STAT);
 164         spin_unlock_irqrestore(&port->lock, flags);
 165
 166         return (st & STAT_TX_EMP) ? TIOCSER_TEMT : 0;
 167 }
 168
 169 static unsigned int mvebu_uart_get_mctrl(struct uart_port *port)
 170 {
 171         return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
 172 }
 173
 174 static void mvebu_uart_set_mctrl(struct uart_port *port,
 175                                  unsigned int mctrl)
 176 {
 177 /*
 178  * Even if we do not support configuring the modem control lines, this
 179  * function must be proided to the serial core
 180  */
 181 }
 182
 183 static void mvebu_uart_stop_tx(struct uart_port *port)
 184 {
 185         unsigned int ctl = readl(port->membase + UART_INTR(port));
 186
 187         ctl &= ~CTRL_TX_RDY_INT(port);
 188         writel(ctl, port->membase + UART_INTR(port));
 189 }
 190
 191 static void mvebu_uart_start_tx(struct uart_port *port)
 192 {
 193         unsigned int ctl;
 194         struct circ_buf *xmit = &port->state->xmit;
 195
 196         if (IS_EXTENDED(port) && !uart_circ_empty(xmit)) {
 197                 writel(xmit->buf[xmit->tail], port->membase + UART_TSH(port));
 198                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 199                 port->icount.tx++;
 200         }
 201
 202         ctl = readl(port->membase + UART_INTR(port));
 203         ctl |= CTRL_TX_RDY_INT(port);
 204         writel(ctl, port->membase + UART_INTR(port));
 205 }
 206
 207 static void mvebu_uart_stop_rx(struct uart_port *port)
 208 {
 209         unsigned int ctl;
 210
 211         ctl = readl(port->membase + UART_CTRL(port));
 212         ctl &= ~CTRL_BRK_INT;
 213         writel(ctl, port->membase + UART_CTRL(port));
 214
 215         ctl = readl(port->membase + UART_INTR(port));
 216         ctl &= ~CTRL_RX_RDY_INT(port);
 217         writel(ctl, port->membase + UART_INTR(port));
 218 }
 219
 220 static void mvebu_uart_break_ctl(struct uart_port *port, int brk)
 221 {
 222         unsigned int ctl;
 223         unsigned long flags;
 224
 225         spin_lock_irqsave(&port->lock, flags);
 226         ctl = readl(port->membase + UART_CTRL(port));
 227         if (brk == -1)
 228                 ctl |= CTRL_SND_BRK_SEQ;
 229         else
 230                 ctl &= ~CTRL_SND_BRK_SEQ;
 231         writel(ctl, port->membase + UART_CTRL(port));
 232         spin_unlock_irqrestore(&port->lock, flags);
 233 }
 234
 235 static void mvebu_uart_rx_chars(struct uart_port *port, unsigned int status)
 236 {
 237         struct tty_port *tport = &port->state->port;
 238         unsigned char ch = 0;
 239         char flag = 0;
 240         int ret;
 241
 242         do {
 243                 if (status & STAT_RX_RDY(port)) {
 244                         ch = readl(port->membase + UART_RBR(port));
 245                         ch &= 0xff;
 246                         flag = TTY_NORMAL;
 247                         port->icount.rx++;
 248
 249                         if (status & STAT_PAR_ERR)
 250                                 port->icount.parity++;
 251                 }
 252
 253                 /*
 254                  * For UART2, error bits are not cleared on buffer read.
 255                  * This causes interrupt loop and system hang.
 256                  */
 257                 if (IS_EXTENDED(port) && (status & STAT_BRK_ERR)) {
 258                         ret = readl(port->membase + UART_STAT);
 259                         ret |= STAT_BRK_ERR;
 260                         writel(ret, port->membase + UART_STAT);
 261                 }
 262
 263                 if (status & STAT_BRK_DET) {
 264                         port->icount.brk++;
 265                         status &= ~(STAT_FRM_ERR | STAT_PAR_ERR);
 266                         if (uart_handle_break(port))
 267                                 goto ignore_char;
 268                 }
 269
 270                 if (status & STAT_OVR_ERR)
 271                         port->icount.overrun++;
 272
 273                 if (status & STAT_FRM_ERR)
 274                         port->icount.frame++;
 275
 276                 if (uart_handle_sysrq_char(port, ch))
 277                         goto ignore_char;
 278
 279                 if (status & port->ignore_status_mask & STAT_PAR_ERR)
 280                         status &= ~STAT_RX_RDY(port);
 281
 282                 status &= port->read_status_mask;
 283
 284                 if (status & STAT_PAR_ERR)
 285                         flag = TTY_PARITY;
 286
 287                 status &= ~port->ignore_status_mask;
 288
 289                 if (status & STAT_RX_RDY(port))
 290                         tty_insert_flip_char(tport, ch, flag);
 291
 292                 if (status & STAT_BRK_DET)
 293                         tty_insert_flip_char(tport, 0, TTY_BREAK);
 294
 295                 if (status & STAT_FRM_ERR)
 296                         tty_insert_flip_char(tport, 0, TTY_FRAME);
 297
 298                 if (status & STAT_OVR_ERR)
 299                         tty_insert_flip_char(tport, 0, TTY_OVERRUN);
 300
 301 ignore_char:
 302                 status = readl(port->membase + UART_STAT);
 303         } while (status & (STAT_RX_RDY(port) | STAT_BRK_DET));
 304
 305         tty_flip_buffer_push(tport);
 306 }
 307
 308 static void mvebu_uart_tx_chars(struct uart_port *port, unsigned int status)
 309 {
 310         struct circ_buf *xmit = &port->state->xmit;
 311         unsigned int count;
 312         unsigned int st;
 313
 314         if (port->x_char) {
 315                 writel(port->x_char, port->membase + UART_TSH(port));
 316                 port->icount.tx++;
 317                 port->x_char = 0;
 318                 return;
 319         }
 320
 321         if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
 322                 mvebu_uart_stop_tx(port);
 323                 return;
 324         }
 325
 326         for (count = 0; count < port->fifosize; count++) {
 327                 writel(xmit->buf[xmit->tail], port->membase + UART_TSH(port));
 328                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 329                 port->icount.tx++;
 330
 331                 if (uart_circ_empty(xmit))
 332                         break;
 333
 334                 st = readl(port->membase + UART_STAT);
 335                 if (st & STAT_TX_FIFO_FUL)
 336                         break;
 337         }
 338
 339         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 340                 uart_write_wakeup(port);
 341
 342         if (uart_circ_empty(xmit))
 343                 mvebu_uart_stop_tx(port);
 344 }
 345
 346 static irqreturn_t mvebu_uart_isr(int irq, void *dev_id)
 347 {
 348         struct uart_port *port = (struct uart_port *)dev_id;
 349         unsigned int st = readl(port->membase + UART_STAT);
 350
 351         if (st & (STAT_RX_RDY(port) | STAT_OVR_ERR | STAT_FRM_ERR |
 352                   STAT_BRK_DET))
 353                 mvebu_uart_rx_chars(port, st);
 354
 355         if (st & STAT_TX_RDY(port))
 356                 mvebu_uart_tx_chars(port, st);
 357
 358         return IRQ_HANDLED;
 359 }
 360
 361 static irqreturn_t mvebu_uart_rx_isr(int irq, void *dev_id)
 362 {
 363         struct uart_port *port = (struct uart_port *)dev_id;
 364         unsigned int st = readl(port->membase + UART_STAT);
 365
 366         if (st & (STAT_RX_RDY(port) | STAT_OVR_ERR | STAT_FRM_ERR |
 367                         STAT_BRK_DET))
 368                 mvebu_uart_rx_chars(port, st);
 369
 370         return IRQ_HANDLED;
 371 }
 372
 373 static irqreturn_t mvebu_uart_tx_isr(int irq, void *dev_id)
 374 {
 375         struct uart_port *port = (struct uart_port *)dev_id;
 376         unsigned int st = readl(port->membase + UART_STAT);
 377
 378         if (st & STAT_TX_RDY(port))
 379                 mvebu_uart_tx_chars(port, st);
 380
 381         return IRQ_HANDLED;
 382 }
 383
 384 static int mvebu_uart_startup(struct uart_port *port)
 385 {
 386         struct mvebu_uart *mvuart = to_mvuart(port);
 387         unsigned int ctl;
 388         int ret;
 389
 390         writel(CTRL_TXFIFO_RST | CTRL_RXFIFO_RST,
 391                port->membase + UART_CTRL(port));
 392         udelay(1);
 393
 394         /* Clear the error bits of state register before IRQ request */
 395         ret = readl(port->membase + UART_STAT);
 396         ret |= STAT_BRK_ERR;
 397         writel(ret, port->membase + UART_STAT);
 398
 399         writel(CTRL_BRK_INT, port->membase + UART_CTRL(port));
 400
 401         ctl = readl(port->membase + UART_INTR(port));
 402         ctl |= CTRL_RX_RDY_INT(port);
 403         writel(ctl, port->membase + UART_INTR(port));
 404
 405         if (!mvuart->irq[UART_TX_IRQ]) {
 406                 /* Old bindings with just one interrupt (UART0 only) */
 407                 ret = devm_request_irq(port->dev, mvuart->irq[UART_IRQ_SUM],
 408                                        mvebu_uart_isr, port->irqflags,
 409                                        dev_name(port->dev), port);
 410                 if (ret) {
 411                         dev_err(port->dev, "unable to request IRQ %d\n",
 412                                 mvuart->irq[UART_IRQ_SUM]);
 413                         return ret;
 414                 }
 415         } else {
 416                 /* New bindings with an IRQ for RX and TX (both UART) */
 417                 ret = devm_request_irq(port->dev, mvuart->irq[UART_RX_IRQ],
 418                                        mvebu_uart_rx_isr, port->irqflags,
 419                                        dev_name(port->dev), port);
 420                 if (ret) {
 421                         dev_err(port->dev, "unable to request IRQ %d\n",
 422                                 mvuart->irq[UART_RX_IRQ]);
 423                         return ret;
 424                 }
 425
 426                 ret = devm_request_irq(port->dev, mvuart->irq[UART_TX_IRQ],
 427                                        mvebu_uart_tx_isr, port->irqflags,
 428                                        dev_name(port->dev),
 429                                        port);
 430                 if (ret) {
 431                         dev_err(port->dev, "unable to request IRQ %d\n",
 432                                 mvuart->irq[UART_TX_IRQ]);
 433                         devm_free_irq(port->dev, mvuart->irq[UART_RX_IRQ],
 434                                       port);
 435                         return ret;
 436                 }
 437         }
 438
 439         return 0;
 440 }
 441
 442 static void mvebu_uart_shutdown(struct uart_port *port)
 443 {
 444         struct mvebu_uart *mvuart = to_mvuart(port);
 445
 446         writel(0, port->membase + UART_INTR(port));
 447
 448         if (!mvuart->irq[UART_TX_IRQ]) {
 449                 devm_free_irq(port->dev, mvuart->irq[UART_IRQ_SUM], port);
 450         } else {
 451                 devm_free_irq(port->dev, mvuart->irq[UART_RX_IRQ], port);
 452                 devm_free_irq(port->dev, mvuart->irq[UART_TX_IRQ], port);
 453         }
 454 }
 455
 456 static unsigned int mvebu_uart_baud_rate_set(struct uart_port *port, unsigned int baud)
 457 {
 458         struct mvebu_uart *mvuart = to_mvuart(port);
 459         unsigned int d_divisor, m_divisor;
 460         u32 brdv;
 461
 462         if (IS_ERR(mvuart->clk))
 463                 return 0;
 464
 465         /*
 466          * The baudrate is derived from the UART clock thanks to two divisors:
 467          *   > D ("baud generator"): can divide the clock from 2 to 2^10 - 1.
 468          *   > M ("fractional divisor"): allows a better accuracy for
 469          *     baudrates higher than 230400.
 470          *
 471          * As the derivation of M is rather complicated, the code sticks to its
 472          * default value (x16) when all the prescalers are zeroed, and only
 473          * makes use of D to configure the desired baudrate.
 474          */
 475         m_divisor = OSAMP_DEFAULT_DIVISOR;
 476         d_divisor = DIV_ROUND_CLOSEST(port->uartclk, baud * m_divisor);
 477
 478         brdv = readl(port->membase + UART_BRDV);
 479         brdv &= ~BRDV_BAUD_MASK;
 480         brdv |= d_divisor;
 481         writel(brdv, port->membase + UART_BRDV);
 482
 483         return DIV_ROUND_CLOSEST(port->uartclk, d_divisor * m_divisor);
 484 }
 485
 486 static void mvebu_uart_set_termios(struct uart_port *port,
 487                                    struct ktermios *termios,
 488                                    struct ktermios *old)
 489 {
 490         unsigned long flags;
 491         unsigned int baud, min_baud, max_baud;
 492
 493         spin_lock_irqsave(&port->lock, flags);
 494
 495         port->read_status_mask = STAT_RX_RDY(port) | STAT_OVR_ERR |
 496                 STAT_TX_RDY(port) | STAT_TX_FIFO_FUL;
 497
 498         if (termios->c_iflag & INPCK)
 499                 port->read_status_mask |= STAT_FRM_ERR | STAT_PAR_ERR;
 500
 501         port->ignore_status_mask = 0;
 502         if (termios->c_iflag & IGNPAR)
 503                 port->ignore_status_mask |=
 504                         STAT_FRM_ERR | STAT_PAR_ERR | STAT_OVR_ERR;
 505
 506         if ((termios->c_cflag & CREAD) == 0)
 507                 port->ignore_status_mask |= STAT_RX_RDY(port) | STAT_BRK_ERR;
 508
 509         /*
 510          * Maximal divisor is 1023 * 16 when using default (x16) scheme.
 511          * Maximum achievable frequency with simple baudrate divisor is 230400.
 512          * Since the error per bit frame would be of more than 15%, achieving
 513          * higher frequencies would require to implement the fractional divisor
 514          * feature.
 515          */
 516         min_baud = DIV_ROUND_UP(port->uartclk, 1023 * 16);
 517         max_baud = 230400;
 518
 519         baud = uart_get_baud_rate(port, termios, old, min_baud, max_baud);
 520         baud = mvebu_uart_baud_rate_set(port, baud);
 521
 522         /* In case baudrate cannot be changed, report previous old value */
 523         if (baud == 0 && old)
 524                 baud = tty_termios_baud_rate(old);
 525
 526         /* Only the following flag changes are supported */
 527         if (old) {
 528                 termios->c_iflag &= INPCK | IGNPAR;
 529                 termios->c_iflag |= old->c_iflag & ~(INPCK | IGNPAR);
 530                 termios->c_cflag &= CREAD | CBAUD;
 531                 termios->c_cflag |= old->c_cflag & ~(CREAD | CBAUD);
 532                 termios->c_cflag |= CS8;
 533         }
 534
 535         if (baud != 0) {
 536                 tty_termios_encode_baud_rate(termios, baud, baud);
 537                 uart_update_timeout(port, termios->c_cflag, baud);
 538         }
 539
 540         spin_unlock_irqrestore(&port->lock, flags);
 541 }
 542
 543 static const char *mvebu_uart_type(struct uart_port *port)
 544 {
 545         return MVEBU_UART_TYPE;
 546 }
 547
 548 static void mvebu_uart_release_port(struct uart_port *port)
 549 {
 550         /* Nothing to do here */
 551 }
 552
 553 static int mvebu_uart_request_port(struct uart_port *port)
 554 {
 555         return 0;
 556 }
 557
 558 #ifdef CONFIG_CONSOLE_POLL
 559 static int mvebu_uart_get_poll_char(struct uart_port *port)
 560 {
 561         unsigned int st = readl(port->membase + UART_STAT);
 562
 563         if (!(st & STAT_RX_RDY(port)))
 564                 return NO_POLL_CHAR;
 565
 566         return readl(port->membase + UART_RBR(port));
 567 }
 568
 569 static void mvebu_uart_put_poll_char(struct uart_port *port, unsigned char c)
 570 {
 571         unsigned int st;
 572
 573         for (;;) {
 574                 st = readl(port->membase + UART_STAT);
 575
 576                 if (!(st & STAT_TX_FIFO_FUL))
 577                         break;
 578
 579                 udelay(1);
 580         }
 581
 582         writel(c, port->membase + UART_TSH(port));
 583 }
 584 #endif
 585
 586 static const struct uart_ops mvebu_uart_ops = {
 587         .tx_empty       = mvebu_uart_tx_empty,
 588         .set_mctrl      = mvebu_uart_set_mctrl,
 589         .get_mctrl      = mvebu_uart_get_mctrl,
 590         .stop_tx        = mvebu_uart_stop_tx,
 591         .start_tx       = mvebu_uart_start_tx,
 592         .stop_rx        = mvebu_uart_stop_rx,
 593         .break_ctl      = mvebu_uart_break_ctl,
 594         .startup        = mvebu_uart_startup,
 595         .shutdown       = mvebu_uart_shutdown,
 596         .set_termios    = mvebu_uart_set_termios,
 597         .type           = mvebu_uart_type,
 598         .release_port   = mvebu_uart_release_port,
 599         .request_port   = mvebu_uart_request_port,
 600 #ifdef CONFIG_CONSOLE_POLL
 601         .poll_get_char  = mvebu_uart_get_poll_char,
 602         .poll_put_char  = mvebu_uart_put_poll_char,
 603 #endif
 604 };
 605
 606 /* Console Driver Operations  */
 607
 608 #ifdef CONFIG_SERIAL_MVEBU_CONSOLE
 609 /* Early Console */
 610 static void mvebu_uart_putc(struct uart_port *port, int c)
 611 {
 612         unsigned int st;
 613
 614         for (;;) {
 615                 st = readl(port->membase + UART_STAT);
 616                 if (!(st & STAT_TX_FIFO_FUL))
 617                         break;
 618         }
 619
 620         /* At early stage, DT is not parsed yet, only use UART0 */
 621         writel(c, port->membase + UART_STD_TSH);
 622
 623         for (;;) {
 624                 st = readl(port->membase + UART_STAT);
 625                 if (st & STAT_TX_FIFO_EMP)
 626                         break;
 627         }
 628 }
 629
 630 static void mvebu_uart_putc_early_write(struct console *con,
 631                                         const char *s,
 632                                         unsigned n)
 633 {
 634         struct earlycon_device *dev = con->data;
 635
 636         uart_console_write(&dev->port, s, n, mvebu_uart_putc);
 637 }
 638
 639 static int __init
 640 mvebu_uart_early_console_setup(struct earlycon_device *device,
 641                                const char *opt)
 642 {
 643         if (!device->port.membase)
 644                 return -ENODEV;
 645
 646         device->con->write = mvebu_uart_putc_early_write;
 647
 648         return 0;
 649 }
 650
 651 EARLYCON_DECLARE(ar3700_uart, mvebu_uart_early_console_setup);
 652 OF_EARLYCON_DECLARE(ar3700_uart, "marvell,armada-3700-uart",
 653                     mvebu_uart_early_console_setup);
 654
 655 static void wait_for_xmitr(struct uart_port *port)
 656 {
 657         u32 val;
 658
 659         readl_poll_timeout_atomic(port->membase + UART_STAT, val,
 660                                   (val & STAT_TX_RDY(port)), 1, 10000);
 661 }
 662
 663 static void wait_for_xmite(struct uart_port *port)
 664 {
 665         u32 val;
 666
 667         readl_poll_timeout_atomic(port->membase + UART_STAT, val,
 668                                   (val & STAT_TX_EMP), 1, 10000);
 669 }
 670
 671 static void mvebu_uart_console_putchar(struct uart_port *port, int ch)
 672 {
 673         wait_for_xmitr(port);
 674         writel(ch, port->membase + UART_TSH(port));
 675 }
 676
 677 static void mvebu_uart_console_write(struct console *co, const char *s,
 678                                      unsigned int count)
 679 {
 680         struct uart_port *port = &mvebu_uart_ports[co->index];
 681         unsigned long flags;
 682         unsigned int ier, intr, ctl;
 683         int locked = 1;
 684
 685         if (oops_in_progress)
 686                 locked = spin_trylock_irqsave(&port->lock, flags);
 687         else
 688                 spin_lock_irqsave(&port->lock, flags);
 689
 690         ier = readl(port->membase + UART_CTRL(port)) & CTRL_BRK_INT;
 691         intr = readl(port->membase + UART_INTR(port)) &
 692                 (CTRL_RX_RDY_INT(port) | CTRL_TX_RDY_INT(port));
 693         writel(0, port->membase + UART_CTRL(port));
 694         writel(0, port->membase + UART_INTR(port));
 695
 696         uart_console_write(port, s, count, mvebu_uart_console_putchar);
 697
 698         wait_for_xmite(port);
 699
 700         if (ier)
 701                 writel(ier, port->membase + UART_CTRL(port));
 702
 703         if (intr) {
 704                 ctl = intr | readl(port->membase + UART_INTR(port));
 705                 writel(ctl, port->membase + UART_INTR(port));
 706         }
 707
 708         if (locked)
 709                 spin_unlock_irqrestore(&port->lock, flags);
 710 }
 711
 712 static int mvebu_uart_console_setup(struct console *co, char *options)
 713 {
 714         struct uart_port *port;
 715         int baud = 9600;
 716         int bits = 8;
 717         int parity = 'n';
 718         int flow = 'n';
 719
 720         if (co->index < 0 || co->index >= MVEBU_NR_UARTS)
 721                 return -EINVAL;
 722
 723         port = &mvebu_uart_ports[co->index];
 724
 725         if (!port->mapbase || !port->membase) {
 726                 pr_debug("console on ttyMV%i not present\n", co->index);
 727                 return -ENODEV;
 728         }
 729
 730         if (options)
 731                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 732
 733         return uart_set_options(port, co, baud, parity, bits, flow);
 734 }
 735
 736 static struct uart_driver mvebu_uart_driver;
 737
 738 static struct console mvebu_uart_console = {
 739         .name   = "ttyMV",
 740         .write  = mvebu_uart_console_write,
 741         .device = uart_console_device,
 742         .setup  = mvebu_uart_console_setup,
 743         .flags  = CON_PRINTBUFFER,
 744         .index  = -1,
 745         .data   = &mvebu_uart_driver,
 746 };
 747
 748 static int __init mvebu_uart_console_init(void)
 749 {
 750         register_console(&mvebu_uart_console);
 751         return 0;
 752 }
 753
 754 console_initcall(mvebu_uart_console_init);
 755
 756
 757 #endif /* CONFIG_SERIAL_MVEBU_CONSOLE */
 758
 759 static struct uart_driver mvebu_uart_driver = {
 760         .owner                  = THIS_MODULE,
 761         .driver_name            = DRIVER_NAME,
 762         .dev_name               = "ttyMV",
 763         .nr                     = MVEBU_NR_UARTS,
 764 #ifdef CONFIG_SERIAL_MVEBU_CONSOLE
 765         .cons                   = &mvebu_uart_console,
 766 #endif
 767 };
 768
 769 #if defined(CONFIG_PM)
 770 static int mvebu_uart_suspend(struct device *dev)
 771 {
 772         struct mvebu_uart *mvuart = dev_get_drvdata(dev);
 773         struct uart_port *port = mvuart->port;
 774
 775         uart_suspend_port(&mvebu_uart_driver, port);
 776
 777         mvuart->pm_regs.rbr = readl(port->membase + UART_RBR(port));
 778         mvuart->pm_regs.tsh = readl(port->membase + UART_TSH(port));
 779         mvuart->pm_regs.ctrl = readl(port->membase + UART_CTRL(port));
 780         mvuart->pm_regs.intr = readl(port->membase + UART_INTR(port));
 781         mvuart->pm_regs.stat = readl(port->membase + UART_STAT);
 782         mvuart->pm_regs.brdv = readl(port->membase + UART_BRDV);
 783         mvuart->pm_regs.osamp = readl(port->membase + UART_OSAMP);
 784
 785         device_set_wakeup_enable(dev, true);
 786
 787         return 0;
 788 }
 789
 790 static int mvebu_uart_resume(struct device *dev)
 791 {
 792         struct mvebu_uart *mvuart = dev_get_drvdata(dev);
 793         struct uart_port *port = mvuart->port;
 794
 795         writel(mvuart->pm_regs.rbr, port->membase + UART_RBR(port));
 796         writel(mvuart->pm_regs.tsh, port->membase + UART_TSH(port));
 797         writel(mvuart->pm_regs.ctrl, port->membase + UART_CTRL(port));
 798         writel(mvuart->pm_regs.intr, port->membase + UART_INTR(port));
 799         writel(mvuart->pm_regs.stat, port->membase + UART_STAT);
 800         writel(mvuart->pm_regs.brdv, port->membase + UART_BRDV);
 801         writel(mvuart->pm_regs.osamp, port->membase + UART_OSAMP);
 802
 803         uart_resume_port(&mvebu_uart_driver, port);
 804
 805         return 0;
 806 }
 807
 808 static const struct dev_pm_ops mvebu_uart_pm_ops = {
 809         .suspend        = mvebu_uart_suspend,
 810         .resume         = mvebu_uart_resume,
 811 };
 812 #endif /* CONFIG_PM */
 813
 814 static const struct of_device_id mvebu_uart_of_match[];
 815
 816 /* Counter to keep track of each UART port id when not using CONFIG_OF */
 817 static int uart_num_counter;
 818
 819 static int mvebu_uart_probe(struct platform_device *pdev)
 820 {
 821         struct resource *reg = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 822         const struct of_device_id *match = of_match_device(mvebu_uart_of_match,
 823                                                            &pdev->dev);
 824         struct uart_port *port;
 825         struct mvebu_uart *mvuart;
 826         int ret, id, irq;
 827
 828         if (!reg) {
 829                 dev_err(&pdev->dev, "no registers defined\n");
 830                 return -EINVAL;
 831         }
 832
 833         /* Assume that all UART ports have a DT alias or none has */
 834         id = of_alias_get_id(pdev->dev.of_node, "serial");
 835         if (!pdev->dev.of_node || id < 0)
 836                 pdev->id = uart_num_counter++;
 837         else
 838                 pdev->id = id;
 839
 840         if (pdev->id >= MVEBU_NR_UARTS) {
 841                 dev_err(&pdev->dev, "cannot have more than %d UART ports\n",
 842                         MVEBU_NR_UARTS);
 843                 return -EINVAL;
 844         }
 845
 846         port = &mvebu_uart_ports[pdev->id];
 847
 848         spin_lock_init(&port->lock);
 849
 850         port->dev        = &pdev->dev;
 851         port->type       = PORT_MVEBU;
 852         port->ops        = &mvebu_uart_ops;
 853         port->regshift   = 0;
 854
 855         port->fifosize   = 32;
 856         port->iotype     = UPIO_MEM32;
 857         port->flags      = UPF_FIXED_PORT;
 858         port->line       = pdev->id;
 859
 860         /*
 861          * IRQ number is not stored in this structure because we may have two of
 862          * them per port (RX and TX). Instead, use the driver UART structure
 863          * array so called ->irq[].
 864          */
 865         port->irq        = 0;
 866         port->irqflags   = 0;
 867         port->mapbase    = reg->start;
 868
 869         port->membase = devm_ioremap_resource(&pdev->dev, reg);
 870         if (IS_ERR(port->membase))
 871                 return PTR_ERR(port->membase);
 872
 873         mvuart = devm_kzalloc(&pdev->dev, sizeof(struct mvebu_uart),
 874                               GFP_KERNEL);
 875         if (!mvuart)
 876                 return -ENOMEM;
 877
 878         /* Get controller data depending on the compatible string */
 879         mvuart->data = (struct mvebu_uart_driver_data *)match->data;
 880         mvuart->port = port;
 881
 882         port->private_data = mvuart;
 883         platform_set_drvdata(pdev, mvuart);
 884
 885         /* Get fixed clock frequency */
 886         mvuart->clk = devm_clk_get(&pdev->dev, NULL);
 887         if (IS_ERR(mvuart->clk)) {
 888                 if (PTR_ERR(mvuart->clk) == -EPROBE_DEFER)
 889                         return PTR_ERR(mvuart->clk);
 890
 891                 if (IS_EXTENDED(port)) {
 892                         dev_err(&pdev->dev, "unable to get UART clock\n");
 893                         return PTR_ERR(mvuart->clk);
 894                 }
 895         } else {
 896                 if (!clk_prepare_enable(mvuart->clk))
 897                         port->uartclk = clk_get_rate(mvuart->clk);
 898         }
 899
 900         /* Manage interrupts */
 901         if (platform_irq_count(pdev) == 1) {
 902                 /* Old bindings: no name on the single unamed UART0 IRQ */
 903                 irq = platform_get_irq(pdev, 0);
 904                 if (irq < 0) {
 905                         dev_err(&pdev->dev, "unable to get UART IRQ\n");
 906                         return irq;
 907                 }
 908
 909                 mvuart->irq[UART_IRQ_SUM] = irq;
 910         } else {
 911                 /*
 912                  * New bindings: named interrupts (RX, TX) for both UARTS,
 913                  * only make use of uart-rx and uart-tx interrupts, do not use
 914                  * uart-sum of UART0 port.
 915                  */
 916                 irq = platform_get_irq_byname(pdev, "uart-rx");
 917                 if (irq < 0) {
 918                         dev_err(&pdev->dev, "unable to get 'uart-rx' IRQ\n");
 919                         return irq;
 920                 }
 921
 922                 mvuart->irq[UART_RX_IRQ] = irq;
 923
 924                 irq = platform_get_irq_byname(pdev, "uart-tx");
 925                 if (irq < 0) {
 926                         dev_err(&pdev->dev, "unable to get 'uart-tx' IRQ\n");
 927                         return irq;
 928                 }
 929
 930                 mvuart->irq[UART_TX_IRQ] = irq;
 931         }
 932
 933         /* UART Soft Reset*/
 934         writel(CTRL_SOFT_RST, port->membase + UART_CTRL(port));
 935         udelay(1);
 936         writel(0, port->membase + UART_CTRL(port));
 937
 938         ret = uart_add_one_port(&mvebu_uart_driver, port);
 939         if (ret)
 940                 return ret;
 941         return 0;
 942 }
 943
 944 static struct mvebu_uart_driver_data uart_std_driver_data = {
 945         .is_ext = false,
 946         .regs.rbr = UART_STD_RBR,
 947         .regs.tsh = UART_STD_TSH,
 948         .regs.ctrl = UART_STD_CTRL1,
 949         .regs.intr = UART_STD_CTRL2,
 950         .flags.ctrl_tx_rdy_int = CTRL_STD_TX_RDY_INT,
 951         .flags.ctrl_rx_rdy_int = CTRL_STD_RX_RDY_INT,
 952         .flags.stat_tx_rdy = STAT_STD_TX_RDY,
 953         .flags.stat_rx_rdy = STAT_STD_RX_RDY,
 954 };
 955
 956 static struct mvebu_uart_driver_data uart_ext_driver_data = {
 957         .is_ext = true,
 958         .regs.rbr = UART_EXT_RBR,
 959         .regs.tsh = UART_EXT_TSH,
 960         .regs.ctrl = UART_EXT_CTRL1,
 961         .regs.intr = UART_EXT_CTRL2,
 962         .flags.ctrl_tx_rdy_int = CTRL_EXT_TX_RDY_INT,
 963         .flags.ctrl_rx_rdy_int = CTRL_EXT_RX_RDY_INT,
 964         .flags.stat_tx_rdy = STAT_EXT_TX_RDY,
 965         .flags.stat_rx_rdy = STAT_EXT_RX_RDY,
 966 };
 967
 968 /* Match table for of_platform binding */
 969 static const struct of_device_id mvebu_uart_of_match[] = {
 970         {
 971                 .compatible = "marvell,armada-3700-uart",
 972                 .data = (void *)&uart_std_driver_data,
 973         },
 974         {
 975                 .compatible = "marvell,armada-3700-uart-ext",
 976                 .data = (void *)&uart_ext_driver_data,
 977         },
 978         {}
 979 };
 980
 981 static struct platform_driver mvebu_uart_platform_driver = {
 982         .probe  = mvebu_uart_probe,
 983         .driver = {
 984                 .name  = "mvebu-uart",
 985                 .of_match_table = of_match_ptr(mvebu_uart_of_match),
 986                 .suppress_bind_attrs = true,
 987 #if defined(CONFIG_PM)
 988                 .pm     = &mvebu_uart_pm_ops,
 989 #endif /* CONFIG_PM */
 990         },
 991 };
 992
 993 static int __init mvebu_uart_init(void)
 994 {
 995         int ret;
 996
 997         ret = uart_register_driver(&mvebu_uart_driver);
 998         if (ret)
 999                 return ret;
1000
1001         ret = platform_driver_register(&mvebu_uart_platform_driver);
1002         if (ret)
1003                 uart_unregister_driver(&mvebu_uart_driver);
1004
1005         return ret;
1006 }
1007 arch_initcall(mvebu_uart_init);