drivers/tty/serial/sifive.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * SiFive UART driver
   4  * Copyright (C) 2018 Paul Walmsley <paul@pwsan.com>
   5  * Copyright (C) 2018-2019 SiFive
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * Based partially on:
  18  * - drivers/tty/serial/pxa.c
  19  * - drivers/tty/serial/amba-pl011.c
  20  * - drivers/tty/serial/uartlite.c
  21  * - drivers/tty/serial/omap-serial.c
  22  * - drivers/pwm/pwm-sifive.c
  23  *
  24  * See the following sources for further documentation:
  25  * - Chapter 19 "Universal Asynchronous Receiver/Transmitter (UART)" of
  26  *   SiFive FE310-G000 v2p3
  27  * - The tree/master/src/main/scala/devices/uart directory of
  28  *   https://github.com/sifive/sifive-blocks/
  29  *
  30  * The SiFive UART design is not 8250-compatible.  The following common
  31  * features are not supported:
  32  * - Word lengths other than 8 bits
  33  * - Break handling
  34  * - Parity
  35  * - Flow control
  36  * - Modem signals (DSR, RI, etc.)
  37  * On the other hand, the design is free from the baggage of the 8250
  38  * programming model.
  39  */
  40
  41 #include <linux/clk.h>
  42 #include <linux/console.h>
  43 #include <linux/delay.h>
  44 #include <linux/init.h>
  45 #include <linux/io.h>
  46 #include <linux/irq.h>
  47 #include <linux/module.h>
  48 #include <linux/of.h>
  49 #include <linux/of_irq.h>
  50 #include <linux/platform_device.h>
  51 #include <linux/serial_core.h>
  52 #include <linux/serial_reg.h>
  53 #include <linux/slab.h>
  54 #include <linux/tty.h>
  55 #include <linux/tty_flip.h>
  56
  57 /*
  58  * Register offsets
  59  */
  60
  61 /* TXDATA */
  62 #define SIFIVE_SERIAL_TXDATA_OFFS               0x0
  63 #define SIFIVE_SERIAL_TXDATA_FULL_SHIFT         31
  64 #define SIFIVE_SERIAL_TXDATA_FULL_MASK          (1 << SIFIVE_SERIAL_TXDATA_FULL_SHIFT)
  65 #define SIFIVE_SERIAL_TXDATA_DATA_SHIFT         0
  66 #define SIFIVE_SERIAL_TXDATA_DATA_MASK          (0xff << SIFIVE_SERIAL_TXDATA_DATA_SHIFT)
  67
  68 /* RXDATA */
  69 #define SIFIVE_SERIAL_RXDATA_OFFS               0x4
  70 #define SIFIVE_SERIAL_RXDATA_EMPTY_SHIFT        31
  71 #define SIFIVE_SERIAL_RXDATA_EMPTY_MASK         (1 << SIFIVE_SERIAL_RXDATA_EMPTY_SHIFT)
  72 #define SIFIVE_SERIAL_RXDATA_DATA_SHIFT         0
  73 #define SIFIVE_SERIAL_RXDATA_DATA_MASK          (0xff << SIFIVE_SERIAL_RXDATA_DATA_SHIFT)
  74
  75 /* TXCTRL */
  76 #define SIFIVE_SERIAL_TXCTRL_OFFS               0x8
  77 #define SIFIVE_SERIAL_TXCTRL_TXCNT_SHIFT        16
  78 #define SIFIVE_SERIAL_TXCTRL_TXCNT_MASK         (0x7 << SIFIVE_SERIAL_TXCTRL_TXCNT_SHIFT)
  79 #define SIFIVE_SERIAL_TXCTRL_NSTOP_SHIFT        1
  80 #define SIFIVE_SERIAL_TXCTRL_NSTOP_MASK         (1 << SIFIVE_SERIAL_TXCTRL_NSTOP_SHIFT)
  81 #define SIFIVE_SERIAL_TXCTRL_TXEN_SHIFT         0
  82 #define SIFIVE_SERIAL_TXCTRL_TXEN_MASK          (1 << SIFIVE_SERIAL_TXCTRL_TXEN_SHIFT)
  83
  84 /* RXCTRL */
  85 #define SIFIVE_SERIAL_RXCTRL_OFFS               0xC
  86 #define SIFIVE_SERIAL_RXCTRL_RXCNT_SHIFT        16
  87 #define SIFIVE_SERIAL_RXCTRL_RXCNT_MASK         (0x7 << SIFIVE_SERIAL_TXCTRL_TXCNT_SHIFT)
  88 #define SIFIVE_SERIAL_RXCTRL_RXEN_SHIFT         0
  89 #define SIFIVE_SERIAL_RXCTRL_RXEN_MASK          (1 << SIFIVE_SERIAL_RXCTRL_RXEN_SHIFT)
  90
  91 /* IE */
  92 #define SIFIVE_SERIAL_IE_OFFS                   0x10
  93 #define SIFIVE_SERIAL_IE_RXWM_SHIFT             1
  94 #define SIFIVE_SERIAL_IE_RXWM_MASK              (1 << SIFIVE_SERIAL_IE_RXWM_SHIFT)
  95 #define SIFIVE_SERIAL_IE_TXWM_SHIFT             0
  96 #define SIFIVE_SERIAL_IE_TXWM_MASK              (1 << SIFIVE_SERIAL_IE_TXWM_SHIFT)
  97
  98 /* IP */
  99 #define SIFIVE_SERIAL_IP_OFFS                   0x14
 100 #define SIFIVE_SERIAL_IP_RXWM_SHIFT             1
 101 #define SIFIVE_SERIAL_IP_RXWM_MASK              (1 << SIFIVE_SERIAL_IP_RXWM_SHIFT)
 102 #define SIFIVE_SERIAL_IP_TXWM_SHIFT             0
 103 #define SIFIVE_SERIAL_IP_TXWM_MASK              (1 << SIFIVE_SERIAL_IP_TXWM_SHIFT)
 104
 105 /* DIV */
 106 #define SIFIVE_SERIAL_DIV_OFFS                  0x18
 107 #define SIFIVE_SERIAL_DIV_DIV_SHIFT             0
 108 #define SIFIVE_SERIAL_DIV_DIV_MASK              (0xffff << SIFIVE_SERIAL_IP_DIV_SHIFT)
 109
 110 /*
 111  * Config macros
 112  */
 113
 114 /*
 115  * SIFIVE_SERIAL_MAX_PORTS: maximum number of UARTs on a device that can
 116  *                          host a serial console
 117  */
 118 #define SIFIVE_SERIAL_MAX_PORTS                 8
 119
 120 /*
 121  * SIFIVE_DEFAULT_BAUD_RATE: default baud rate that the driver should
 122  *                           configure itself to use
 123  */
 124 #define SIFIVE_DEFAULT_BAUD_RATE                115200
 125
 126 /* SIFIVE_SERIAL_NAME: our driver's name that we pass to the operating system */
 127 #define SIFIVE_SERIAL_NAME                      "sifive-serial"
 128
 129 /* SIFIVE_TTY_PREFIX: tty name prefix for SiFive serial ports */
 130 #define SIFIVE_TTY_PREFIX                       "ttySIF"
 131
 132 /* SIFIVE_TX_FIFO_DEPTH: depth of the TX FIFO (in bytes) */
 133 #define SIFIVE_TX_FIFO_DEPTH                    8
 134
 135 /* SIFIVE_RX_FIFO_DEPTH: depth of the TX FIFO (in bytes) */
 136 #define SIFIVE_RX_FIFO_DEPTH                    8
 137
 138 #if (SIFIVE_TX_FIFO_DEPTH != SIFIVE_RX_FIFO_DEPTH)
 139 #error Driver does not support configurations with different TX, RX FIFO sizes
 140 #endif
 141
 142 /*
 143  *
 144  */
 145
 146 /**
 147  * struct sifive_serial_port - driver-specific data extension to struct uart_port
 148  * @port: struct uart_port embedded in this struct
 149  * @dev: struct device *
 150  * @ier: shadowed copy of the interrupt enable register
 151  * @clkin_rate: input clock to the UART IP block.
 152  * @baud_rate: UART serial line rate (e.g., 115200 baud)
 153  * @clk: reference to this device's clock
 154  * @clk_notifier: clock rate change notifier for upstream clock changes
 155  *
 156  * Configuration data specific to this SiFive UART.
 157  */
 158 struct sifive_serial_port {
 159         struct uart_port        port;
 160         struct device           *dev;
 161         unsigned char           ier;
 162         unsigned long           clkin_rate;
 163         unsigned long           baud_rate;
 164         struct clk              *clk;
 165         struct notifier_block   clk_notifier;
 166 };
 167
 168 /*
 169  * Structure container-of macros
 170  */
 171
 172 #define port_to_sifive_serial_port(p) (container_of((p), \
 173                                                     struct sifive_serial_port, \
 174                                                     port))
 175
 176 #define notifier_to_sifive_serial_port(nb) (container_of((nb), \
 177                                                          struct sifive_serial_port, \
 178                                                          clk_notifier))
 179
 180 /*
 181  * Forward declarations
 182  */
 183 static void sifive_serial_stop_tx(struct uart_port *port);
 184
 185 /*
 186  * Internal functions
 187  */
 188
 189 /**
 190  * __ssp_early_writel() - write to a SiFive serial port register (early)
 191  * @port: pointer to a struct uart_port record
 192  * @offs: register address offset from the IP block base address
 193  * @v: value to write to the register
 194  *
 195  * Given a pointer @port to a struct uart_port record, write the value
 196  * @v to the IP block register address offset @offs.  This function is
 197  * intended for early console use.
 198  *
 199  * Context: Intended to be used only by the earlyconsole code.
 200  */
 201 static void __ssp_early_writel(u32 v, u16 offs, struct uart_port *port)
 202 {
 203         writel_relaxed(v, port->membase + offs);
 204 }
 205
 206 /**
 207  * __ssp_early_readl() - read from a SiFive serial port register (early)
 208  * @port: pointer to a struct uart_port record
 209  * @offs: register address offset from the IP block base address
 210  *
 211  * Given a pointer @port to a struct uart_port record, read the
 212  * contents of the IP block register located at offset @offs from the
 213  * IP block base and return it.  This function is intended for early
 214  * console use.
 215  *
 216  * Context: Intended to be called only by the earlyconsole code or by
 217  *          __ssp_readl() or __ssp_writel() (in this driver)
 218  *
 219  * Returns: the register value read from the UART.
 220  */
 221 static u32 __ssp_early_readl(struct uart_port *port, u16 offs)
 222 {
 223         return readl_relaxed(port->membase + offs);
 224 }
 225
 226 /**
 227  * __ssp_writel() - write to a SiFive serial port register
 228  * @v: value to write to the register
 229  * @offs: register address offset from the IP block base address
 230  * @ssp: pointer to a struct sifive_serial_port record
 231  *
 232  * Write the value @v to the IP block register located at offset @offs from the
 233  * IP block base, given a pointer @ssp to a struct sifive_serial_port record.
 234  *
 235  * Context: Any context.
 236  */
 237 static void __ssp_writel(u32 v, u16 offs, struct sifive_serial_port *ssp)
 238 {
 239         __ssp_early_writel(v, offs, &ssp->port);
 240 }
 241
 242 /**
 243  * __ssp_readl() - read from a SiFive serial port register
 244  * @ssp: pointer to a struct sifive_serial_port record
 245  * @offs: register address offset from the IP block base address
 246  *
 247  * Read the contents of the IP block register located at offset @offs from the
 248  * IP block base, given a pointer @ssp to a struct sifive_serial_port record.
 249  *
 250  * Context: Any context.
 251  *
 252  * Returns: the value of the UART register
 253  */
 254 static u32 __ssp_readl(struct sifive_serial_port *ssp, u16 offs)
 255 {
 256         return __ssp_early_readl(&ssp->port, offs);
 257 }
 258
 259 /**
 260  * sifive_serial_is_txfifo_full() - is the TXFIFO full?
 261  * @ssp: pointer to a struct sifive_serial_port
 262  *
 263  * Read the transmit FIFO "full" bit, returning a non-zero value if the
 264  * TX FIFO is full, or zero if space remains.  Intended to be used to prevent
 265  * writes to the TX FIFO when it's full.
 266  *
 267  * Returns: SIFIVE_SERIAL_TXDATA_FULL_MASK (non-zero) if the transmit FIFO
 268  * is full, or 0 if space remains.
 269  */
 270 static int sifive_serial_is_txfifo_full(struct sifive_serial_port *ssp)
 271 {
 272         return __ssp_readl(ssp, SIFIVE_SERIAL_TXDATA_OFFS) &
 273                 SIFIVE_SERIAL_TXDATA_FULL_MASK;
 274 }
 275
 276 /**
 277  * __ssp_transmit_char() - enqueue a byte to transmit onto the TX FIFO
 278  * @ssp: pointer to a struct sifive_serial_port
 279  * @ch: character to transmit
 280  *
 281  * Enqueue a byte @ch onto the transmit FIFO, given a pointer @ssp to the
 282  * struct sifive_serial_port * to transmit on.  Caller should first check to
 283  * ensure that the TXFIFO has space; see sifive_serial_is_txfifo_full().
 284  *
 285  * Context: Any context.
 286  */
 287 static void __ssp_transmit_char(struct sifive_serial_port *ssp, int ch)
 288 {
 289         __ssp_writel(ch, SIFIVE_SERIAL_TXDATA_OFFS, ssp);
 290 }
 291
 292 /**
 293  * __ssp_transmit_chars() - enqueue multiple bytes onto the TX FIFO
 294  * @ssp: pointer to a struct sifive_serial_port
 295  *
 296  * Transfer up to a TX FIFO size's worth of characters from the Linux serial
 297  * transmit buffer to the SiFive UART TX FIFO.
 298  *
 299  * Context: Any context.  Expects @ssp->port.lock to be held by caller.
 300  */
 301 static void __ssp_transmit_chars(struct sifive_serial_port *ssp)
 302 {
 303         struct circ_buf *xmit = &ssp->port.state->xmit;
 304         int count;
 305
 306         if (ssp->port.x_char) {
 307                 __ssp_transmit_char(ssp, ssp->port.x_char);
 308                 ssp->port.icount.tx++;
 309                 ssp->port.x_char = 0;
 310                 return;
 311         }
 312         if (uart_circ_empty(xmit) || uart_tx_stopped(&ssp->port)) {
 313                 sifive_serial_stop_tx(&ssp->port);
 314                 return;
 315         }
 316         count = SIFIVE_TX_FIFO_DEPTH;
 317         do {
 318                 __ssp_transmit_char(ssp, xmit->buf[xmit->tail]);
 319                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 320                 ssp->port.icount.tx++;
 321                 if (uart_circ_empty(xmit))
 322                         break;
 323         } while (--count > 0);
 324
 325         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 326                 uart_write_wakeup(&ssp->port);
 327
 328         if (uart_circ_empty(xmit))
 329                 sifive_serial_stop_tx(&ssp->port);
 330 }
 331
 332 /**
 333  * __ssp_enable_txwm() - enable transmit watermark interrupts
 334  * @ssp: pointer to a struct sifive_serial_port
 335  *
 336  * Enable interrupt generation when the transmit FIFO watermark is reached
 337  * on the SiFive UART referred to by @ssp.
 338  */
 339 static void __ssp_enable_txwm(struct sifive_serial_port *ssp)
 340 {
 341         if (ssp->ier & SIFIVE_SERIAL_IE_TXWM_MASK)
 342                 return;
 343
 344         ssp->ier |= SIFIVE_SERIAL_IE_TXWM_MASK;
 345         __ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);
 346 }
 347
 348 /**
 349  * __ssp_enable_rxwm() - enable receive watermark interrupts
 350  * @ssp: pointer to a struct sifive_serial_port
 351  *
 352  * Enable interrupt generation when the receive FIFO watermark is reached
 353  * on the SiFive UART referred to by @ssp.
 354  */
 355 static void __ssp_enable_rxwm(struct sifive_serial_port *ssp)
 356 {
 357         if (ssp->ier & SIFIVE_SERIAL_IE_RXWM_MASK)
 358                 return;
 359
 360         ssp->ier |= SIFIVE_SERIAL_IE_RXWM_MASK;
 361         __ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);
 362 }
 363
 364 /**
 365  * __ssp_disable_txwm() - disable transmit watermark interrupts
 366  * @ssp: pointer to a struct sifive_serial_port
 367  *
 368  * Disable interrupt generation when the transmit FIFO watermark is reached
 369  * on the UART referred to by @ssp.
 370  */
 371 static void __ssp_disable_txwm(struct sifive_serial_port *ssp)
 372 {
 373         if (!(ssp->ier & SIFIVE_SERIAL_IE_TXWM_MASK))
 374                 return;
 375
 376         ssp->ier &= ~SIFIVE_SERIAL_IE_TXWM_MASK;
 377         __ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);
 378 }
 379
 380 /**
 381  * __ssp_disable_rxwm() - disable receive watermark interrupts
 382  * @ssp: pointer to a struct sifive_serial_port
 383  *
 384  * Disable interrupt generation when the receive FIFO watermark is reached
 385  * on the UART referred to by @ssp.
 386  */
 387 static void __ssp_disable_rxwm(struct sifive_serial_port *ssp)
 388 {
 389         if (!(ssp->ier & SIFIVE_SERIAL_IE_RXWM_MASK))
 390                 return;
 391
 392         ssp->ier &= ~SIFIVE_SERIAL_IE_RXWM_MASK;
 393         __ssp_writel(ssp->ier, SIFIVE_SERIAL_IE_OFFS, ssp);
 394 }
 395
 396 /**
 397  * __ssp_receive_char() - receive a byte from the UART
 398  * @ssp: pointer to a struct sifive_serial_port
 399  * @is_empty: char pointer to return whether the RX FIFO is empty
 400  *
 401  * Try to read a byte from the SiFive UART RX FIFO, referenced by
 402  * @ssp, and to return it.  Also returns the RX FIFO empty bit in
 403  * the char pointed to by @ch.  The caller must pass the byte back to the
 404  * Linux serial layer if needed.
 405  *
 406  * Returns: the byte read from the UART RX FIFO.
 407  */
 408 static char __ssp_receive_char(struct sifive_serial_port *ssp, char *is_empty)
 409 {
 410         u32 v;
 411         u8 ch;
 412
 413         v = __ssp_readl(ssp, SIFIVE_SERIAL_RXDATA_OFFS);
 414
 415         if (!is_empty)
 416                 WARN_ON(1);
 417         else
 418                 *is_empty = (v & SIFIVE_SERIAL_RXDATA_EMPTY_MASK) >>
 419                         SIFIVE_SERIAL_RXDATA_EMPTY_SHIFT;
 420
 421         ch = (v & SIFIVE_SERIAL_RXDATA_DATA_MASK) >>
 422                 SIFIVE_SERIAL_RXDATA_DATA_SHIFT;
 423
 424         return ch;
 425 }
 426
 427 /**
 428  * __ssp_receive_chars() - receive multiple bytes from the UART
 429  * @ssp: pointer to a struct sifive_serial_port
 430  *
 431  * Receive up to an RX FIFO's worth of bytes from the SiFive UART referred
 432  * to by @ssp and pass them up to the Linux serial layer.
 433  *
 434  * Context: Expects ssp->port.lock to be held by caller.
 435  */
 436 static void __ssp_receive_chars(struct sifive_serial_port *ssp)
 437 {
 438         unsigned char ch;
 439         char is_empty;
 440         int c;
 441
 442         for (c = SIFIVE_RX_FIFO_DEPTH; c > 0; --c) {
 443                 ch = __ssp_receive_char(ssp, &is_empty);
 444                 if (is_empty)
 445                         break;
 446
 447                 ssp->port.icount.rx++;
 448                 uart_insert_char(&ssp->port, 0, 0, ch, TTY_NORMAL);
 449         }
 450
 451         tty_flip_buffer_push(&ssp->port.state->port);
 452 }
 453
 454 /**
 455  * __ssp_update_div() - calculate the divisor setting by the line rate
 456  * @ssp: pointer to a struct sifive_serial_port
 457  *
 458  * Calculate the appropriate value of the clock divisor for the UART
 459  * and target line rate referred to by @ssp and write it into the
 460  * hardware.
 461  */
 462 static void __ssp_update_div(struct sifive_serial_port *ssp)
 463 {
 464         u16 div;
 465
 466         div = DIV_ROUND_UP(ssp->clkin_rate, ssp->baud_rate) - 1;
 467
 468         __ssp_writel(div, SIFIVE_SERIAL_DIV_OFFS, ssp);
 469 }
 470
 471 /**
 472  * __ssp_update_baud_rate() - set the UART "baud rate"
 473  * @ssp: pointer to a struct sifive_serial_port
 474  * @rate: new target bit rate
 475  *
 476  * Calculate the UART divisor value for the target bit rate @rate for the
 477  * SiFive UART described by @ssp and program it into the UART.  There may
 478  * be some error between the target bit rate and the actual bit rate implemented
 479  * by the UART due to clock ratio granularity.
 480  */
 481 static void __ssp_update_baud_rate(struct sifive_serial_port *ssp,
 482                                    unsigned int rate)
 483 {
 484         if (ssp->baud_rate == rate)
 485                 return;
 486
 487         ssp->baud_rate = rate;
 488         __ssp_update_div(ssp);
 489 }
 490
 491 /**
 492  * __ssp_set_stop_bits() - set the number of stop bits
 493  * @ssp: pointer to a struct sifive_serial_port
 494  * @nstop: 1 or 2 (stop bits)
 495  *
 496  * Program the SiFive UART referred to by @ssp to use @nstop stop bits.
 497  */
 498 static void __ssp_set_stop_bits(struct sifive_serial_port *ssp, char nstop)
 499 {
 500         u32 v;
 501
 502         if (nstop < 1 || nstop > 2) {
 503                 WARN_ON(1);
 504                 return;
 505         }
 506
 507         v = __ssp_readl(ssp, SIFIVE_SERIAL_TXCTRL_OFFS);
 508         v &= ~SIFIVE_SERIAL_TXCTRL_NSTOP_MASK;
 509         v |= (nstop - 1) << SIFIVE_SERIAL_TXCTRL_NSTOP_SHIFT;
 510         __ssp_writel(v, SIFIVE_SERIAL_TXCTRL_OFFS, ssp);
 511 }
 512
 513 /**
 514  * __ssp_wait_for_xmitr() - wait for an empty slot on the TX FIFO
 515  * @ssp: pointer to a struct sifive_serial_port
 516  *
 517  * Delay while the UART TX FIFO referred to by @ssp is marked as full.
 518  *
 519  * Context: Any context.
 520  */
 521 static void __maybe_unused __ssp_wait_for_xmitr(struct sifive_serial_port *ssp)
 522 {
 523         while (sifive_serial_is_txfifo_full(ssp))
 524                 udelay(1); /* XXX Could probably be more intelligent here */
 525 }
 526
 527 /*
 528  * Linux serial API functions
 529  */
 530
 531 static void sifive_serial_stop_tx(struct uart_port *port)
 532 {
 533         struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
 534
 535         __ssp_disable_txwm(ssp);
 536 }
 537
 538 static void sifive_serial_stop_rx(struct uart_port *port)
 539 {
 540         struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
 541
 542         __ssp_disable_rxwm(ssp);
 543 }
 544
 545 static void sifive_serial_start_tx(struct uart_port *port)
 546 {
 547         struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
 548
 549         __ssp_enable_txwm(ssp);
 550 }
 551
 552 static irqreturn_t sifive_serial_irq(int irq, void *dev_id)
 553 {
 554         struct sifive_serial_port *ssp = dev_id;
 555         u32 ip;
 556
 557         spin_lock(&ssp->port.lock);
 558
 559         ip = __ssp_readl(ssp, SIFIVE_SERIAL_IP_OFFS);
 560         if (!ip) {
 561                 spin_unlock(&ssp->port.lock);
 562                 return IRQ_NONE;
 563         }
 564
 565         if (ip & SIFIVE_SERIAL_IP_RXWM_MASK)
 566                 __ssp_receive_chars(ssp);
 567         if (ip & SIFIVE_SERIAL_IP_TXWM_MASK)
 568                 __ssp_transmit_chars(ssp);
 569
 570         spin_unlock(&ssp->port.lock);
 571
 572         return IRQ_HANDLED;
 573 }
 574
 575 static unsigned int sifive_serial_tx_empty(struct uart_port *port)
 576 {
 577         return TIOCSER_TEMT;
 578 }
 579
 580 static unsigned int sifive_serial_get_mctrl(struct uart_port *port)
 581 {
 582         return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR;
 583 }
 584
 585 static void sifive_serial_set_mctrl(struct uart_port *port, unsigned int mctrl)
 586 {
 587         /* IP block does not support these signals */
 588 }
 589
 590 static void sifive_serial_break_ctl(struct uart_port *port, int break_state)
 591 {
 592         /* IP block does not support sending a break */
 593 }
 594
 595 static int sifive_serial_startup(struct uart_port *port)
 596 {
 597         struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
 598
 599         __ssp_enable_rxwm(ssp);
 600
 601         return 0;
 602 }
 603
 604 static void sifive_serial_shutdown(struct uart_port *port)
 605 {
 606         struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
 607
 608         __ssp_disable_rxwm(ssp);
 609         __ssp_disable_txwm(ssp);
 610 }
 611
 612 /**
 613  * sifive_serial_clk_notifier() - clock post-rate-change notifier
 614  * @nb: pointer to the struct notifier_block, from the notifier code
 615  * @event: event mask from the notifier code
 616  * @data: pointer to the struct clk_notifier_data from the notifier code
 617  *
 618  * On the V0 SoC, the UART IP block is derived from the CPU clock source
 619  * after a synchronous divide-by-two divider, so any CPU clock rate change
 620  * requires the UART baud rate to be updated.  This presumably corrupts any
 621  * serial word currently being transmitted or received.  In order to avoid
 622  * corrupting the output data stream, we drain the transmit queue before
 623  * allowing the clock's rate to be changed.
 624  */
 625 static int sifive_serial_clk_notifier(struct notifier_block *nb,
 626                                       unsigned long event, void *data)
 627 {
 628         struct clk_notifier_data *cnd = data;
 629         struct sifive_serial_port *ssp = notifier_to_sifive_serial_port(nb);
 630
 631         if (event == PRE_RATE_CHANGE) {
 632                 /*
 633                  * The TX watermark is always set to 1 by this driver, which
 634                  * means that the TX busy bit will lower when there are 0 bytes
 635                  * left in the TX queue -- in other words, when the TX FIFO is
 636                  * empty.
 637                  */
 638                 __ssp_wait_for_xmitr(ssp);
 639                 /*
 640                  * On the cycle the TX FIFO goes empty there is still a full
 641                  * UART frame left to be transmitted in the shift register.
 642                  * The UART provides no way for software to directly determine
 643                  * when that last frame has been transmitted, so we just sleep
 644                  * here instead.  As we're not tracking the number of stop bits
 645                  * they're just worst cased here.  The rest of the serial
 646                  * framing parameters aren't configurable by software.
 647                  */
 648                 udelay(DIV_ROUND_UP(12 * 1000 * 1000, ssp->baud_rate));
 649         }
 650
 651         if (event == POST_RATE_CHANGE && ssp->clkin_rate != cnd->new_rate) {
 652                 ssp->clkin_rate = cnd->new_rate;
 653                 __ssp_update_div(ssp);
 654         }
 655
 656         return NOTIFY_OK;
 657 }
 658
 659 static void sifive_serial_set_termios(struct uart_port *port,
 660                                       struct ktermios *termios,
 661                                       struct ktermios *old)
 662 {
 663         struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
 664         unsigned long flags;
 665         u32 v, old_v;
 666         int rate;
 667         char nstop;
 668
 669         if ((termios->c_cflag & CSIZE) != CS8)
 670                 dev_err_once(ssp->port.dev, "only 8-bit words supported\n");
 671         if (termios->c_iflag & (INPCK | PARMRK))
 672                 dev_err_once(ssp->port.dev, "parity checking not supported\n");
 673         if (termios->c_iflag & BRKINT)
 674                 dev_err_once(ssp->port.dev, "BREAK detection not supported\n");
 675
 676         /* Set number of stop bits */
 677         nstop = (termios->c_cflag & CSTOPB) ? 2 : 1;
 678         __ssp_set_stop_bits(ssp, nstop);
 679
 680         /* Set line rate */
 681         rate = uart_get_baud_rate(port, termios, old, 0, ssp->clkin_rate / 16);
 682         __ssp_update_baud_rate(ssp, rate);
 683
 684         spin_lock_irqsave(&ssp->port.lock, flags);
 685
 686         /* Update the per-port timeout */
 687         uart_update_timeout(port, termios->c_cflag, rate);
 688
 689         ssp->port.read_status_mask = 0;
 690
 691         /* Ignore all characters if CREAD is not set */
 692         v = __ssp_readl(ssp, SIFIVE_SERIAL_RXCTRL_OFFS);
 693         old_v = v;
 694         if ((termios->c_cflag & CREAD) == 0)
 695                 v &= SIFIVE_SERIAL_RXCTRL_RXEN_MASK;
 696         else
 697                 v |= SIFIVE_SERIAL_RXCTRL_RXEN_MASK;
 698         if (v != old_v)
 699                 __ssp_writel(v, SIFIVE_SERIAL_RXCTRL_OFFS, ssp);
 700
 701         spin_unlock_irqrestore(&ssp->port.lock, flags);
 702 }
 703
 704 static void sifive_serial_release_port(struct uart_port *port)
 705 {
 706 }
 707
 708 static int sifive_serial_request_port(struct uart_port *port)
 709 {
 710         return 0;
 711 }
 712
 713 static void sifive_serial_config_port(struct uart_port *port, int flags)
 714 {
 715         struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
 716
 717         ssp->port.type = PORT_SIFIVE_V0;
 718 }
 719
 720 static int sifive_serial_verify_port(struct uart_port *port,
 721                                      struct serial_struct *ser)
 722 {
 723         return -EINVAL;
 724 }
 725
 726 static const char *sifive_serial_type(struct uart_port *port)
 727 {
 728         return port->type == PORT_SIFIVE_V0 ? "SiFive UART v0" : NULL;
 729 }
 730
 731 #ifdef CONFIG_CONSOLE_POLL
 732 static int sifive_serial_poll_get_char(struct uart_port *port)
 733 {
 734         struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
 735         char is_empty, ch;
 736
 737         ch = __ssp_receive_char(ssp, &is_empty);
 738         if (is_empty)
 739                 return NO_POLL_CHAR;
 740
 741         return ch;
 742 }
 743
 744 static void sifive_serial_poll_put_char(struct uart_port *port,
 745                                         unsigned char c)
 746 {
 747         struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
 748
 749         __ssp_wait_for_xmitr(ssp);
 750         __ssp_transmit_char(ssp, c);
 751 }
 752 #endif /* CONFIG_CONSOLE_POLL */
 753
 754 /*
 755  * Early console support
 756  */
 757
 758 #ifdef CONFIG_SERIAL_EARLYCON
 759 static void early_sifive_serial_putc(struct uart_port *port, int c)
 760 {
 761         while (__ssp_early_readl(port, SIFIVE_SERIAL_TXDATA_OFFS) &
 762                SIFIVE_SERIAL_TXDATA_FULL_MASK)
 763                 cpu_relax();
 764
 765         __ssp_early_writel(c, SIFIVE_SERIAL_TXDATA_OFFS, port);
 766 }
 767
 768 static void early_sifive_serial_write(struct console *con, const char *s,
 769                                       unsigned int n)
 770 {
 771         struct earlycon_device *dev = con->data;
 772         struct uart_port *port = &dev->port;
 773
 774         uart_console_write(port, s, n, early_sifive_serial_putc);
 775 }
 776
 777 static int __init early_sifive_serial_setup(struct earlycon_device *dev,
 778                                             const char *options)
 779 {
 780         struct uart_port *port = &dev->port;
 781
 782         if (!port->membase)
 783                 return -ENODEV;
 784
 785         dev->con->write = early_sifive_serial_write;
 786
 787         return 0;
 788 }
 789
 790 OF_EARLYCON_DECLARE(sifive, "sifive,uart0", early_sifive_serial_setup);
 791 OF_EARLYCON_DECLARE(sifive, "sifive,fu540-c000-uart0",
 792                     early_sifive_serial_setup);
 793 #endif /* CONFIG_SERIAL_EARLYCON */
 794
 795 /*
 796  * Linux console interface
 797  */
 798
 799 #ifdef CONFIG_SERIAL_SIFIVE_CONSOLE
 800
 801 static struct sifive_serial_port *sifive_serial_console_ports[SIFIVE_SERIAL_MAX_PORTS];
 802
 803 static void sifive_serial_console_putchar(struct uart_port *port, int ch)
 804 {
 805         struct sifive_serial_port *ssp = port_to_sifive_serial_port(port);
 806
 807         __ssp_wait_for_xmitr(ssp);
 808         __ssp_transmit_char(ssp, ch);
 809 }
 810
 811 static void sifive_serial_console_write(struct console *co, const char *s,
 812                                         unsigned int count)
 813 {
 814         struct sifive_serial_port *ssp = sifive_serial_console_ports[co->index];
 815         unsigned long flags;
 816         unsigned int ier;
 817         int locked = 1;
 818
 819         if (!ssp)
 820                 return;
 821
 822         local_irq_save(flags);
 823         if (ssp->port.sysrq)
 824                 locked = 0;
 825         else if (oops_in_progress)
 826                 locked = spin_trylock(&ssp->port.lock);
 827         else
 828                 spin_lock(&ssp->port.lock);
 829
 830         ier = __ssp_readl(ssp, SIFIVE_SERIAL_IE_OFFS);
 831         __ssp_writel(0, SIFIVE_SERIAL_IE_OFFS, ssp);
 832
 833         uart_console_write(&ssp->port, s, count, sifive_serial_console_putchar);
 834
 835         __ssp_writel(ier, SIFIVE_SERIAL_IE_OFFS, ssp);
 836
 837         if (locked)
 838                 spin_unlock(&ssp->port.lock);
 839         local_irq_restore(flags);
 840 }
 841
 842 static int __init sifive_serial_console_setup(struct console *co, char *options)
 843 {
 844         struct sifive_serial_port *ssp;
 845         int baud = SIFIVE_DEFAULT_BAUD_RATE;
 846         int bits = 8;
 847         int parity = 'n';
 848         int flow = 'n';
 849
 850         if (co->index < 0 || co->index >= SIFIVE_SERIAL_MAX_PORTS)
 851                 return -ENODEV;
 852
 853         ssp = sifive_serial_console_ports[co->index];
 854         if (!ssp)
 855                 return -ENODEV;
 856
 857         if (options)
 858                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 859
 860         return uart_set_options(&ssp->port, co, baud, parity, bits, flow);
 861 }
 862
 863 static struct uart_driver sifive_serial_uart_driver;
 864
 865 static struct console sifive_serial_console = {
 866         .name           = SIFIVE_TTY_PREFIX,
 867         .write          = sifive_serial_console_write,
 868         .device         = uart_console_device,
 869         .setup          = sifive_serial_console_setup,
 870         .flags          = CON_PRINTBUFFER,
 871         .index          = -1,
 872         .data           = &sifive_serial_uart_driver,
 873 };
 874
 875 static int __init sifive_console_init(void)
 876 {
 877         register_console(&sifive_serial_console);
 878         return 0;
 879 }
 880
 881 console_initcall(sifive_console_init);
 882
 883 static void __ssp_add_console_port(struct sifive_serial_port *ssp)
 884 {
 885         sifive_serial_console_ports[ssp->port.line] = ssp;
 886 }
 887
 888 static void __ssp_remove_console_port(struct sifive_serial_port *ssp)
 889 {
 890         sifive_serial_console_ports[ssp->port.line] = 0;
 891 }
 892
 893 #define SIFIVE_SERIAL_CONSOLE   (&sifive_serial_console)
 894
 895 #else
 896
 897 #define SIFIVE_SERIAL_CONSOLE   NULL
 898
 899 static void __ssp_add_console_port(struct sifive_serial_port *ssp)
 900 {}
 901 static void __ssp_remove_console_port(struct sifive_serial_port *ssp)
 902 {}
 903
 904 #endif
 905
 906 static const struct uart_ops sifive_serial_uops = {
 907         .tx_empty       = sifive_serial_tx_empty,
 908         .set_mctrl      = sifive_serial_set_mctrl,
 909         .get_mctrl      = sifive_serial_get_mctrl,
 910         .stop_tx        = sifive_serial_stop_tx,
 911         .start_tx       = sifive_serial_start_tx,
 912         .stop_rx        = sifive_serial_stop_rx,
 913         .break_ctl      = sifive_serial_break_ctl,
 914         .startup        = sifive_serial_startup,
 915         .shutdown       = sifive_serial_shutdown,
 916         .set_termios    = sifive_serial_set_termios,
 917         .type           = sifive_serial_type,
 918         .release_port   = sifive_serial_release_port,
 919         .request_port   = sifive_serial_request_port,
 920         .config_port    = sifive_serial_config_port,
 921         .verify_port    = sifive_serial_verify_port,
 922 #ifdef CONFIG_CONSOLE_POLL
 923         .poll_get_char  = sifive_serial_poll_get_char,
 924         .poll_put_char  = sifive_serial_poll_put_char,
 925 #endif
 926 };
 927
 928 static struct uart_driver sifive_serial_uart_driver = {
 929         .owner          = THIS_MODULE,
 930         .driver_name    = SIFIVE_SERIAL_NAME,
 931         .dev_name       = SIFIVE_TTY_PREFIX,
 932         .nr             = SIFIVE_SERIAL_MAX_PORTS,
 933         .cons           = SIFIVE_SERIAL_CONSOLE,
 934 };
 935
 936 static int sifive_serial_probe(struct platform_device *pdev)
 937 {
 938         struct sifive_serial_port *ssp;
 939         struct resource *mem;
 940         struct clk *clk;
 941         void __iomem *base;
 942         int irq, id, r;
 943
 944         irq = platform_get_irq(pdev, 0);
 945         if (irq < 0)
 946                 return -EPROBE_DEFER;
 947
 948         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 949         base = devm_ioremap_resource(&pdev->dev, mem);
 950         if (IS_ERR(base)) {
 951                 dev_err(&pdev->dev, "could not acquire device memory\n");
 952                 return PTR_ERR(base);
 953         }
 954
 955         clk = devm_clk_get(&pdev->dev, NULL);
 956         if (IS_ERR(clk)) {
 957                 dev_err(&pdev->dev, "unable to find controller clock\n");
 958                 return PTR_ERR(clk);
 959         }
 960
 961         id = of_alias_get_id(pdev->dev.of_node, "serial");
 962         if (id < 0) {
 963                 dev_err(&pdev->dev, "missing aliases entry\n");
 964                 return id;
 965         }
 966
 967 #ifdef CONFIG_SERIAL_SIFIVE_CONSOLE
 968         if (id > SIFIVE_SERIAL_MAX_PORTS) {
 969                 dev_err(&pdev->dev, "too many UARTs (%d)\n", id);
 970                 return -EINVAL;
 971         }
 972 #endif
 973
 974         ssp = devm_kzalloc(&pdev->dev, sizeof(*ssp), GFP_KERNEL);
 975         if (!ssp)
 976                 return -ENOMEM;
 977
 978         ssp->port.dev = &pdev->dev;
 979         ssp->port.type = PORT_SIFIVE_V0;
 980         ssp->port.iotype = UPIO_MEM;
 981         ssp->port.irq = irq;
 982         ssp->port.fifosize = SIFIVE_TX_FIFO_DEPTH;
 983         ssp->port.ops = &sifive_serial_uops;
 984         ssp->port.line = id;
 985         ssp->port.mapbase = mem->start;
 986         ssp->port.membase = base;
 987         ssp->dev = &pdev->dev;
 988         ssp->clk = clk;
 989         ssp->clk_notifier.notifier_call = sifive_serial_clk_notifier;
 990
 991         r = clk_notifier_register(ssp->clk, &ssp->clk_notifier);
 992         if (r) {
 993                 dev_err(&pdev->dev, "could not register clock notifier: %d\n",
 994                         r);
 995                 goto probe_out1;
 996         }
 997
 998         /* Set up clock divider */
 999         ssp->clkin_rate = clk_get_rate(ssp->clk);
1000         ssp->baud_rate = SIFIVE_DEFAULT_BAUD_RATE;
1001         ssp->port.uartclk = ssp->baud_rate * 16;
1002         __ssp_update_div(ssp);
1003
1004         platform_set_drvdata(pdev, ssp);
1005
1006         /* Enable transmits and set the watermark level to 1 */
1007         __ssp_writel((1 << SIFIVE_SERIAL_TXCTRL_TXCNT_SHIFT) |
1008                      SIFIVE_SERIAL_TXCTRL_TXEN_MASK,
1009                      SIFIVE_SERIAL_TXCTRL_OFFS, ssp);
1010
1011         /* Enable receives and set the watermark level to 0 */
1012         __ssp_writel((0 << SIFIVE_SERIAL_RXCTRL_RXCNT_SHIFT) |
1013                      SIFIVE_SERIAL_RXCTRL_RXEN_MASK,
1014                      SIFIVE_SERIAL_RXCTRL_OFFS, ssp);
1015
1016         r = request_irq(ssp->port.irq, sifive_serial_irq, ssp->port.irqflags,
1017                         dev_name(&pdev->dev), ssp);
1018         if (r) {
1019                 dev_err(&pdev->dev, "could not attach interrupt: %d\n", r);
1020                 goto probe_out2;
1021         }
1022
1023         __ssp_add_console_port(ssp);
1024
1025         r = uart_add_one_port(&sifive_serial_uart_driver, &ssp->port);
1026         if (r != 0) {
1027                 dev_err(&pdev->dev, "could not add uart: %d\n", r);
1028                 goto probe_out3;
1029         }
1030
1031         return 0;
1032
1033 probe_out3:
1034         __ssp_remove_console_port(ssp);
1035         free_irq(ssp->port.irq, ssp);
1036 probe_out2:
1037         clk_notifier_unregister(ssp->clk, &ssp->clk_notifier);
1038 probe_out1:
1039         return r;
1040 }
1041
1042 static int sifive_serial_remove(struct platform_device *dev)
1043 {
1044         struct sifive_serial_port *ssp = platform_get_drvdata(dev);
1045
1046         __ssp_remove_console_port(ssp);
1047         uart_remove_one_port(&sifive_serial_uart_driver, &ssp->port);
1048         free_irq(ssp->port.irq, ssp);
1049         clk_notifier_unregister(ssp->clk, &ssp->clk_notifier);
1050
1051         return 0;
1052 }
1053
1054 static const struct of_device_id sifive_serial_of_match[] = {
1055         { .compatible = "sifive,fu540-c000-uart0" },
1056         { .compatible = "sifive,uart0" },
1057         {},
1058 };
1059 MODULE_DEVICE_TABLE(of, sifive_serial_of_match);
1060
1061 static struct platform_driver sifive_serial_platform_driver = {
1062         .probe          = sifive_serial_probe,
1063         .remove         = sifive_serial_remove,
1064         .driver         = {
1065                 .name   = SIFIVE_SERIAL_NAME,
1066                 .of_match_table = of_match_ptr(sifive_serial_of_match),
1067         },
1068 };
1069
1070 static int __init sifive_serial_init(void)
1071 {
1072         int r;
1073
1074         r = uart_register_driver(&sifive_serial_uart_driver);
1075         if (r)
1076                 goto init_out1;
1077
1078         r = platform_driver_register(&sifive_serial_platform_driver);
1079         if (r)
1080                 goto init_out2;
1081
1082         return 0;
1083
1084 init_out2:
1085         uart_unregister_driver(&sifive_serial_uart_driver);
1086 init_out1:
1087         return r;
1088 }
1089
1090 static void __exit sifive_serial_exit(void)
1091 {
1092         platform_driver_unregister(&sifive_serial_platform_driver);
1093         uart_unregister_driver(&sifive_serial_uart_driver);
1094 }
1095
1096 module_init(sifive_serial_init);
1097 module_exit(sifive_serial_exit);
1098
1099 MODULE_DESCRIPTION("SiFive UART serial driver");
1100 MODULE_LICENSE("GPL");
1101 MODULE_AUTHOR("Paul Walmsley <paul@pwsan.com>");