[RFC PATCH 1/1] drivers: introduce ARM SBSA generic UART driver

Peter Hurley
2014-09-02T18:19:55Z

Hi Andre,

On 08/29/2014 12:13 PM, Andre Przywara wrote:
> The ARM Server Base System Architecture (SBSA) describes a generic
> UART which all compliant level 1 systems should implement. This is
> actually a PL011 subset, so a full PL011 implementation will satisfy
> this requirement.
> However if a system does not have a PL011, a very stripped down
> implementation complying to the SBSA defined specification will
> suffice. The Linux PL011 driver is not guaranteed to drive this
> limited device (and indeed the fast model implentation hangs the
> kernel if driven by the PL011 driver).
> So introduce a new driver just implementing the part specified by the
> SBSA (which lacks DMA, the modem control signals and many of the
> registers including baud rate control). This driver has been derived
> by the actual PL011 one, removing all unnecessary code.
>
> Signed-off-by: Andre Przywara <andre.przywara@arm.com>
> ---
> .../devicetree/bindings/serial/arm_sbsa_uart.txt | 6 +
> drivers/tty/serial/Kconfig | 28 +
> drivers/tty/serial/Makefile | 1 +
> drivers/tty/serial/sbsa_uart.c | 793 ++++++++++++++++++++
> include/uapi/linux/serial_core.h | 1 +
> 5 files changed, 829 insertions(+)
> create mode 100644 Documentation/devicetree/bindings/serial/arm_sbsa_uart.txt
> create mode 100644 drivers/tty/serial/sbsa_uart.c
>
> diff --git a/Documentation/devicetree/bindings/serial/arm_sbsa_uart.txt b/Documentation/devicetree/bindings/serial/arm_sbsa_uart.txt
> new file mode 100644
> index 0000000..8e2c5d6
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/serial/arm_sbsa_uart.txt
> @@ -0,0 +1,6 @@
> +* ARM SBSA defined generic UART
> +
> +Required properties:
> +- compatible: must be "arm,sbsa-uart"
> +- reg: exactly one register range
> +- interrupts: exactly one interrupt specifier
> diff --git a/drivers/tty/serial/Kconfig b/drivers/tty/serial/Kconfig
> index 26cec64..faecfad 100644
> --- a/drivers/tty/serial/Kconfig
> +++ b/drivers/tty/serial/Kconfig
> @@ -45,6 +45,34 @@ config SERIAL_AMBA_PL010_CONSOLE
> your boot loader (lilo or loadlin) about how to pass options to the
> kernel at boot time.)
>
> +config SERIAL_SBSA_UART
> + tristate "ARM SBSA UART serial port support"
> + select SERIAL_CORE
> + help
> + This selects the UART defined in the ARM(R) Server Base System
> + Architecture (SBSA).
> + It is a true subset of the ARM(R) PL011 UART and this driver can
> + also drive those full featured UARTs.
> + To match the SBSA, this driver will not support initialization, DMA,
> + baudrate control and modem control lines.
> +
> +config SERIAL_SBSA_UART_CONSOLE
> + bool "Support for console on ARM SBSA UART serial port"
> + depends on SERIAL_SBSA_UART=y
> + select SERIAL_CORE_CONSOLE
> + select SERIAL_EARLYCON
> + ---help---
> + Say Y here if you wish to use an ARM SBSA UART as the system
> + console (the system console is the device which receives all kernel
> + messages and warnings and which allows logins in single user mode).
> +
> + Even if you say Y here, the currently visible framebuffer console
> + (/dev/tty0) will still be used as the system console by default, but
> + you can alter that using a kernel command line option such as
> + "console=ttyAMA0". (Try "man bootparam" or see the documentation of
> + your boot loader (lilo or loadlin) about how to pass options to the
> + kernel at boot time.)
> +
> config SERIAL_AMBA_PL011
> tristate "ARM AMBA PL011 serial port support"
> depends on ARM_AMBA
> diff --git a/drivers/tty/serial/Makefile b/drivers/tty/serial/Makefile
> index 0080cc3..2e560e9 100644
> --- a/drivers/tty/serial/Makefile
> +++ b/drivers/tty/serial/Makefile
> @@ -22,6 +22,7 @@ obj-$(CONFIG_SERIAL_8250) += 8250/
>
> obj-$(CONFIG_SERIAL_AMBA_PL010) += amba-pl010.o
> obj-$(CONFIG_SERIAL_AMBA_PL011) += amba-pl011.o
> +obj-$(CONFIG_SERIAL_SBSA_UART) += sbsa_uart.o
> obj-$(CONFIG_SERIAL_CLPS711X) += clps711x.o
> obj-$(CONFIG_SERIAL_PXA) += pxa.o
> obj-$(CONFIG_SERIAL_PNX8XXX) += pnx8xxx_uart.o
> diff --git a/drivers/tty/serial/sbsa_uart.c b/drivers/tty/serial/sbsa_uart.c
> new file mode 100644
> index 0000000..941a305
> --- /dev/null
> +++ b/drivers/tty/serial/sbsa_uart.c
> @@ -0,0 +1,793 @@
> +/*
> + * Driver for ARM SBSA specified serial ports (stripped down PL011)
> + *
> + * Based on drivers/tty/char/amba-pl011.c
> + *
> + * Copyright 2014 ARM Limited
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program. If not, see <http://www.gnu.org/licenses/>.
> + *
> + * This is a driver implementing the ARM SBSA specified generic UART,
> + * which is a subset of the PL011 UART, but lacking:
> + * - DMA
> + * - hardware flow control
> + * - modem control
> + * - IrDA SIR
> + * - word lengths other than 8 bits
> + * - baudrate settings
> + */
> +
> +
> +#if defined(CONFIG_SERIAL_SBSA_UART_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
> +#define SUPPORT_SYSRQ
> +#endif
> +
> +#include <linux/module.h>
> +#include <linux/init.h>
> +#include <linux/console.h>
> +#include <linux/sysrq.h>
> +#include <linux/device.h>
> +#include <linux/tty.h>
> +#include <linux/tty_flip.h>
> +#include <linux/serial_core.h>
> +#include <linux/serial.h>
> +#include <linux/amba/serial.h>
> +#include <linux/slab.h>
> +#include <linux/types.h>
> +#include <linux/of.h>
> +#include <linux/of_device.h>
> +#include <linux/sizes.h>
> +#include <linux/io.h>
> +
> +#define UART_NR 14
> +
> +#define UART_DR_ERROR (UART011_DR_OE|UART011_DR_BE|UART011_DR_PE|UART011_DR_FE)
> +#define UART_DUMMY_DR_RX (1 << 16)
> +
> +/*
> + * Reads up to 256 characters from the FIFO or until it's empty and
> + * inserts them into the TTY layer. Returns the number of characters
> + * read from the FIFO.
> + */
> +static int sbsa_uart_fifo_to_tty(struct uart_port *port)
> +{
> + u16 status, ch;
> + unsigned int flag, max_count = 256;
> + int fifotaken = 0;
> +
> + while (max_count--) {
> + status = readw(port->membase + UART01x_FR);
> + if (status & UART01x_FR_RXFE)
> + break;
> +
> + /* Take chars from the FIFO and update status */
> + ch = readw(port->membase + UART01x_DR) | UART_DUMMY_DR_RX;
> + flag = TTY_NORMAL;
> + port->icount.rx++;
> + fifotaken++;
> +
> + if (unlikely(ch & UART_DR_ERROR)) {
> + if (ch & UART011_DR_BE) {
> + ch &= ~(UART011_DR_FE | UART011_DR_PE);
> + port->icount.brk++;
> + if (uart_handle_break(port))
> + continue;
> + } else if (ch & UART011_DR_PE)
> + port->icount.parity++;
> + else if (ch & UART011_DR_FE)
> + port->icount.frame++;
> + if (ch & UART011_DR_OE)
> + port->icount.overrun++;
> +
> + ch &= port->read_status_mask;
> +
> + if (ch & UART011_DR_BE)
> + flag = TTY_BREAK;
> + else if (ch & UART011_DR_PE)
> + flag = TTY_PARITY;
> + else if (ch & UART011_DR_FE)
> + flag = TTY_FRAME;
> + }
> +
> + if (uart_handle_sysrq_char(port, ch & 255))
> + continue;
> +
> + uart_insert_char(port, ch, UART011_DR_OE, ch, flag);
> + }
> +
> + return fifotaken;
> +}
> +
> +static void sbsa_uart_mask_irq(struct uart_port *port, u16 irqclr, u16 irqset)
> +{
> + u16 imsc;
> +
> + imsc = readw(port->membase + UART011_IMSC);
> + imsc = (imsc & ~irqclr) | irqset;
> + writew(imsc, port->membase + UART011_IMSC);
> +}
> +
> +static void sbsa_uart_stop_tx(struct uart_port *port)
> +{
> + sbsa_uart_mask_irq(port, UART011_TXIM, 0);
> +}
> +
> +static void sbsa_uart_start_tx(struct uart_port *port)
> +{
> + sbsa_uart_mask_irq(port, 0, UART011_TXIM);
> +}
> +
> +static void sbsa_uart_stop_rx(struct uart_port *port)
> +{
> + sbsa_uart_mask_irq(port, UART011_RXIM | UART011_RTIM, 0);
> +}
> +
> +static void sbsa_uart_rx_chars(struct uart_port *port)
> +__releases(&uap->port.lock)
> +__acquires(&uap->port.lock)
^^^^^^^^^^
I think sparse will choke here.

> +{
> + sbsa_uart_fifo_to_tty(port);
> +
> + spin_unlock(&port->lock);
> + tty_flip_buffer_push(&port->state->port);
> + spin_lock(&port->lock);
> +}
> +
> +static void sbsa_uart_tx_chars(struct uart_port *port)
> +{
> + struct circ_buf *xmit = &port->state->xmit;
> + int count;
> +
> + if (port->x_char) {
> + writew(port->x_char, port->membase + UART01x_DR);
> + port->icount.tx++;
> + port->x_char = 0;
> + return;
> + }
> + if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
> + sbsa_uart_stop_tx(port);
> + return;
> + }
> +
> + count = port->fifosize >> 1;
> + do {
> + writew(xmit->buf[xmit->tail], port->membase + UART01x_DR);
> + xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
> + port->icount.tx++;
> + if (uart_circ_empty(xmit))
> + break;
> + } while (--count > 0);
> +
> + if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
> + uart_write_wakeup(port);
> +
> + if (uart_circ_empty(xmit))
> + sbsa_uart_stop_tx(port);
> +}
> +
> +static irqreturn_t sbsa_uart_int(int irq, void *dev_id)
> +{
> + struct uart_port *port = dev_id;
> + unsigned long flags;
> + unsigned int status, pass_counter = 32;
> + int handled = 0;
> +
> + spin_lock_irqsave(&port->lock, flags);
> + status = readw(port->membase + UART011_RIS);
> + status &= readw(port->membase + UART011_IMSC);
> + if (status) {
> + do {
> + writew(status & ~(UART011_TXIS|UART011_RTIS|
> + UART011_RXIS),
> + port->membase + UART011_ICR);
> +
> + if (status & (UART011_RTIS|UART011_RXIS))
> + sbsa_uart_rx_chars(port);
> +
> + if (status & UART011_TXIS)
> + sbsa_uart_tx_chars(port);
> +
> + if (pass_counter-- == 0)
> + break;
> +
> + status = readw(port->membase + UART011_RIS);
> + status &= ~readw(port->membase + UART011_IMSC);
> + } while (status != 0);
> + handled = 1;
> + }
> +
> + spin_unlock_irqrestore(&port->lock, flags);
> +
> + return IRQ_RETVAL(handled);
> +}
> +
> +static unsigned int sbsa_uart_tx_empty(struct uart_port *port)
> +{
> + unsigned int status = readw(port->membase + UART01x_FR);
> +
> + return status & (UART01x_FR_BUSY|UART01x_FR_TXFF) ? 0 : TIOCSER_TEMT;
> +}
> +
> +static unsigned int sbsa_uart_get_mctrl(struct uart_port *port)
> +{
> + return 0;
> +}
> +
> +static void sbsa_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
> +{
> +}
> +
> +#ifdef CONFIG_CONSOLE_POLL
> +
> +static void sbsa_uart_quiesce_irqs(struct uart_port *port)
> +{
> + writew(readw(port->membase + UART011_RIS), port->membase + UART011_ICR);
> + /*
> + * There is no way to clear TXIM as this is "ready to transmit IRQ", so
> + * we simply mask it. start_tx() will unmask it.
> + *
> + * Note we can race with start_tx(), and if the race happens, the
> + * polling user might get another interrupt just after we clear it.
> + * But it should be OK and can happen even w/o the race, e.g.
> + * controller immediately got some new data and raised the IRQ.
> + *
> + * And whoever uses polling routines assumes that it manages the device
> + * (including tx queue), so we're also fine with start_tx()'s caller
> + * side.
> + */
> + writew(readw(port->membase + UART011_IMSC) & ~UART011_TXIM,
> + port->membase + UART011_IMSC);
> +}
> +
> +static int sbsa_uart_get_poll_char(struct uart_port *port)
> +{
> + unsigned int status;
> +
> + /*
> + * The caller might need IRQs lowered, e.g. if used with KDB NMI
> + * debugger.
> + */
> + sbsa_uart_quiesce_irqs(port);
> +
> + status = readw(port->membase + UART01x_FR);
> + if (status & UART01x_FR_RXFE)
> + return NO_POLL_CHAR;
> +
> + return readw(port->membase + UART01x_DR);
> +}
> +
> +static void sbsa_uart_put_poll_char(struct uart_port *port, unsigned char ch)
> +{
> + while (readw(port->membase + UART01x_FR) & UART01x_FR_TXFF)
> + barrier();
> +
> + writew(ch, port->membase + UART01x_DR);
> +}
> +
> +#endif /* CONFIG_CONSOLE_POLL */
> +
> +static int sbsa_uart_hwinit(struct uart_port *port)
> +{
> + /* Clear pending error and receive interrupts */
> + writew(UART011_OEIS | UART011_BEIS | UART011_PEIS | UART011_FEIS |
> + UART011_RTIS | UART011_RXIS, port->membase + UART011_ICR);
> +
> + writew(UART011_RTIM | UART011_RXIM, port->membase + UART011_IMSC);
> +
> + return 0;
> +}
> +
> +static int sbsa_uart_startup(struct uart_port *port)
> +{
> + int retval;
> +
> + retval = sbsa_uart_hwinit(port);
> + if (retval)
> + return retval;
> +
> + /*
> + * Allocate the IRQ
> + */
> + retval = request_irq(port->irq, sbsa_uart_int, 0, "uart-sbsa", port);
> + if (retval)
> + return retval;
> +
> + /*
> + * Provoke TX FIFO interrupt into asserting. Taking care to preserve
> + * baud rate and data format specified by FBRD, IBRD and LCRH as the
> + * UART may already be in use as a console.
> + */
> + spin_lock_irq(&port->lock);
> +
> + /*
> + * this does not work on the SBSA UART, because it does not have
> + * a CR and thus not loopback enable bit
> + */
> + writew(0, port->membase + UART01x_DR);
> + while (readw(port->membase + UART01x_FR) & UART01x_FR_BUSY)
> + barrier();
> +
> + /* Clear out any spuriously appearing RX interrupts and enable them */
> + writew(UART011_RTIS | UART011_RXIS, port->membase + UART011_ICR);
> + writew(UART011_RTIM | UART011_RXIM, port->membase + UART011_IMSC);
> + spin_unlock_irq(&port->lock);
> +
> + return 0;
> +}
> +
> +static void sbsa_uart_shutdown(struct uart_port *port)
> +{
> + u16 im;
> +
> + /*
> + * disable all interrupts
> + */
> + spin_lock_irq(&port->lock);
> + im = 0;
> + writew(im, port->membase + UART011_IMSC);
> + writew(0xffff, port->membase + UART011_ICR);
> + spin_unlock_irq(&port->lock);
> +
> + /*
> + * Free the interrupt
> + */
> + free_irq(port->irq, port);
> +
> +}
> +
> +static void
> +sbsa_uart_set_termios(struct uart_port *port, struct ktermios *termios,
> + struct ktermios *old)
> +{
> + unsigned long flags;
> + unsigned int baud = 115200;
> +
> + spin_lock_irqsave(&port->lock, flags);
^^^^^^^^^^^^^^^^^

Can be spin_lock_irq(&port->lock) here.

> +
> + /*
> + * Update the per-port timeout.
> + */
> + uart_update_timeout(port, termios->c_cflag, baud);
> +
> + port->read_status_mask = UART011_DR_OE | 255;
> + if (termios->c_iflag & INPCK)
> + port->read_status_mask |= UART011_DR_FE | UART011_DR_PE;
> + if (termios->c_iflag & (BRKINT | PARMRK))
^^^^^^^
(IGNBRK | BRKINT | PARMRK)

> + port->read_status_mask |= UART011_DR_BE;

Otherwise, if IGNBRK is set, read_status_mask will mask the BRK condition
so a garbage TTY_NORMAL byte will be added by uart_insert_char(). The
pl011 driver has been fixed in -next.

> +
> + /*
> + * Characters to ignore
> + */
> + port->ignore_status_mask = 0;
> + if (termios->c_iflag & IGNPAR)
> + port->ignore_status_mask |= UART011_DR_FE | UART011_DR_PE;
> + if (termios->c_iflag & IGNBRK) {
> + port->ignore_status_mask |= UART011_DR_BE;
> + /*
> + * If we're ignoring parity and break indicators,
> + * ignore overruns too (for real raw support).
> + */
> + if (termios->c_iflag & IGNPAR)
> + port->ignore_status_mask |= UART011_DR_OE;
> + }
> +
> + /*
> + * Ignore all characters if CREAD is not set.
> + */
> + if ((termios->c_cflag & CREAD) == 0)
> + port->ignore_status_mask |= UART_DUMMY_DR_RX;
> +
> + spin_unlock_irqrestore(&port->lock, flags);
> +}
> +
> +static const char *sbsa_uart_type(struct uart_port *port)
> +{
> + return port->type == PORT_SBSA ? "SBSA" : NULL;
> +}
> +
> +/*
> + * Release the memory region(s) being used by 'port'
> + */
> +static void sbsa_uart_release_port(struct uart_port *port)
> +{
> + release_mem_region(port->mapbase, SZ_4K);
> +}
> +
> +/*
> + * Request the memory region(s) being used by 'port'
> + */
> +static int sbsa_uart_request_port(struct uart_port *port)
> +{
> + return request_mem_region(port->mapbase, SZ_4K, "uart-sbsa")
> + != NULL ? 0 : -EBUSY;
> +}
> +
> +/*
> + * Configure/autoconfigure the port.
> + */
> +static void sbsa_uart_config_port(struct uart_port *port, int flags)
> +{
> + if (flags & UART_CONFIG_TYPE) {
> + port->type = PORT_SBSA;
> + sbsa_uart_request_port(port);
> + }
> +}
> +
> +/*
> + * verify the new serial_struct (for TIOCSSERIAL).
> + */
> +static int sbsa_uart_verify_port(struct uart_port *port,
> + struct serial_struct *ser)
> +{
> + int ret = 0;
> +
> + if (ser->type != PORT_UNKNOWN && ser->type != PORT_SBSA)
> + ret = -EINVAL;
> + if (ser->irq < 0 || ser->irq >= nr_irqs)
> + ret = -EINVAL;
> + return ret;
> +}
> +
> +static struct uart_ops sbsa_uart_pops = {
> + .tx_empty = sbsa_uart_tx_empty,
> + .set_mctrl = sbsa_uart_set_mctrl,
> + .get_mctrl = sbsa_uart_get_mctrl,
> + .stop_tx = sbsa_uart_stop_tx,
> + .start_tx = sbsa_uart_start_tx,
> + .stop_rx = sbsa_uart_stop_rx,
> + .enable_ms = NULL,
> + .break_ctl = NULL,
> + .startup = sbsa_uart_startup,
> + .shutdown = sbsa_uart_shutdown,
> + .flush_buffer = NULL,
> + .set_termios = sbsa_uart_set_termios,
> + .type = sbsa_uart_type,
> + .release_port = sbsa_uart_release_port,
> + .request_port = sbsa_uart_request_port,
> + .config_port = sbsa_uart_config_port,
> + .verify_port = sbsa_uart_verify_port,
> +#ifdef CONFIG_CONSOLE_POLL
> + .poll_init = sbsa_uart_hwinit,
> + .poll_get_char = sbsa_uart_get_poll_char,
> + .poll_put_char = sbsa_uart_put_poll_char,
> +#endif
> +};
> +
> +static struct uart_port *sbsa_uart_ports[UART_NR];
> +
> +#ifdef CONFIG_SERIAL_SBSA_UART_CONSOLE
> +
> +static void sbsa_uart_console_putchar(struct uart_port *port, int ch)
> +{
> + while (readw(port->membase + UART01x_FR) & UART01x_FR_TXFF)
> + barrier();
> + writew(ch, port->membase + UART01x_DR);
> +}
> +
> +static void
> +sbsa_uart_console_write(struct console *co, const char *s, unsigned int count)
> +{
> + struct uart_port *port = sbsa_uart_ports[co->index];
> + unsigned int status;
> + unsigned long flags;
> + int locked = 1;
> +
> + local_irq_save(flags);
> + if (port->sysrq)
> + locked = 0;
> + else if (oops_in_progress)
> + locked = spin_trylock(&port->lock);
> + else
> + spin_lock(&port->lock);
> +
> + uart_console_write(port, s, count, sbsa_uart_console_putchar);
> +
> + /* Finally, wait for transmitter to become empty */
> + do {
> + status = readw(port->membase + UART01x_FR);
> + } while (status & UART01x_FR_BUSY);
> +
> + if (locked)
> + spin_unlock(&port->lock);
> + local_irq_restore(flags);
> +}
> +
> +static void __init
> +sbsa_uart_console_get_options(struct uart_port *port, int *baud,
> + int *parity, int *bits)
> +{
> + *parity = 'n';
> + *bits = 8;
> + *baud = 115200;
> +}
> +
> +static int __init sbsa_uart_console_setup(struct console *co, char *options)
> +{
> + struct uart_port *port;
> + int baud = 38400;
> + int bits = 8;
> + int parity = 'n';
> + int flow = 'n';
> +
> + /*
> + * Check whether an invalid uart number has been specified, and
> + * if so, search for the first available port that does have
> + * console support.
> + */
> + if (co->index >= UART_NR)
> + co->index = 0;
> + port = sbsa_uart_ports[co->index];
> + if (!port)
> + return -ENODEV;
> +
> + if (options)
> + uart_parse_options(options, &baud, &parity, &bits, &flow);
> + else
> + sbsa_uart_console_get_options(port, &baud, &parity, &bits);
> +
> + return uart_set_options(port, co, baud, parity, bits, flow);
> +}
> +
> +static struct uart_driver sbsa_uart_reg;
> +static struct console sbsa_uart_console = {
> + .name = "ttyAMA",
> + .write = sbsa_uart_console_write,
> + .device = uart_console_device,
> + .setup = sbsa_uart_console_setup,
> + .flags = CON_PRINTBUFFER,
> + .index = -1,
> + .data = &sbsa_uart_reg,
> +};
> +
> +#define SBSA_UART_CONSOLE (&sbsa_uart_console)
> +
> +static void sbsa_uart_putc(struct uart_port *port, int c)
> +{
> + while (readw(port->membase + UART01x_FR) & UART01x_FR_TXFF)
> + ;
> + writew(c & 0xff, port->membase + UART01x_DR);
> + while (readw(port->membase + UART01x_FR) & UART01x_FR_BUSY)
> + ;
> +}
> +
> +static void sbsa_uart_early_write(struct console *con, const char *s,
> + unsigned n)
> +{
> + struct earlycon_device *dev = con->data;
> +
> + uart_console_write(&dev->port, s, n, sbsa_uart_putc);
> +}
> +
> +static int __init sbsa_uart_early_console_setup(struct earlycon_device *device,
> + const char *opt)
> +{
> + if (!device->port.membase)
> + return -ENODEV;
> +
> + device->con->write = sbsa_uart_early_write;
> + return 0;
> +}
> +EARLYCON_DECLARE(pl011, sbsa_uart_early_console_setup);
> +OF_EARLYCON_DECLARE(pl011, "arm,sbsa-uart", sbsa_uart_early_console_setup);
> +
> +#else
> +#define SBSA_UART_CONSOLE NULL
> +#endif
> +
> +static struct uart_driver sbsa_uart_reg = {
> + .owner = THIS_MODULE,
> + .driver_name = "sbsa_uart",
> + .dev_name = "ttyAMA",
> + .nr = UART_NR,
> + .cons = SBSA_UART_CONSOLE,
> +};
> +
> +#ifdef CONFIG_OF
> +
> +static int dt_probe_serial_alias(int index, struct device *dev)
> +{
> + struct device_node *np;
> + static bool seen_dev_with_alias;
> + static bool seen_dev_without_alias;
> + int ret = index;
> +
> + if (!IS_ENABLED(CONFIG_OF))
> + return ret;
> +
> + np = dev->of_node;
> + if (!np)
> + return ret;
> +
> + ret = of_alias_get_id(np, "serial");
> + if (IS_ERR_VALUE(ret)) {
> + seen_dev_without_alias = true;
> + ret = index;
> + } else {
> + seen_dev_with_alias = true;
> + if (ret >= ARRAY_SIZE(sbsa_uart_ports) ||
> + sbsa_uart_ports[ret] != NULL) {
> + dev_warn(dev, "requested serial port %d not available.\n", ret);
> + ret = index;
> + }
> + }
> +
> + if (seen_dev_with_alias && seen_dev_without_alias)
> + dev_warn(dev, "aliased and non-aliased serial devices found in device tree. Serial port enumeration may be unpredictable.\n");
> +
> + return ret;
> +}
> +
> +static const struct of_device_id arm_sbsa_match[] = {
> + { .compatible = "arm,sbsa-uart", },
> + {},
> +};
> +MODULE_DEVICE_TABLE(of, arm_sbsa_match);
> +
> +#else
> +
> +static int dt_probe_serial_alias(int index, struct device *dev)
> +{
> + static int portnr;
> +
> + return portnr++;
> +}
> +
> +#endif
> +
> +static int sbsa_uart_probe(struct platform_device *pdev)
> +{
> + struct resource *r;
> + struct uart_port *port;
> + int i, ret;
> +
> + pr_info("DT probing for PL011-based SBSA UART\n");
> + for (i = 0; i < ARRAY_SIZE(sbsa_uart_ports); i++)
> + if (sbsa_uart_ports[i] == NULL)
> + break;
> +
> + if (i == ARRAY_SIZE(sbsa_uart_ports)) {
> + ret = -EBUSY;
> + goto out;
> + }
> +
> + r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +
> + port = devm_kzalloc(&pdev->dev, sizeof(struct uart_port), GFP_KERNEL);
> + if (port == NULL) {
> + ret = -ENOMEM;
> + goto out;
> + }
> +
> + i = dt_probe_serial_alias(i, &pdev->dev);
> +
> + port->membase = devm_ioremap_resource(&pdev->dev, r);
> + if (!port->membase) {
> + ret = -ENOMEM;
> + goto out;
> + }
> +
> + port->irq = platform_get_irq(pdev, 0);
> +
> + dev_info(&pdev->dev, "found SBSA UART #%d at 0x%08llx\n", i, r->start);
> +
> + port->fifosize = 32;
> + port->dev = &pdev->dev;
> + port->mapbase = r->start;
> + port->iotype = UPIO_MEM;
> + port->ops = &sbsa_uart_pops;
> + port->flags = UPF_BOOT_AUTOCONF;
> + port->line = i;
> +
> + /* Ensure interrupts from this UART are masked and cleared */
> + writew(0, port->membase + UART011_IMSC);
> + writew(0xffff, port->membase + UART011_ICR);
> +
> + sbsa_uart_ports[i] = port;
> +
> + platform_set_drvdata(pdev, port);
> +
> + if (!sbsa_uart_reg.state) {
> + ret = uart_register_driver(&sbsa_uart_reg);
> + if (ret < 0) {
> + pr_err("Failed to register ARM SBSA UART driver\n");
> + return ret;
> + }
> + }
> +
> + ret = uart_add_one_port(&sbsa_uart_reg, port);
> + if (ret) {
> + sbsa_uart_ports[i] = NULL;
> + uart_unregister_driver(&sbsa_uart_reg);
> + }
> + out:
> + return ret;
> +}
> +
> +static int sbsa_uart_remove(struct platform_device *pdev)
> +{
> + struct uart_port *port = platform_get_drvdata(pdev);
> + bool busy = false;
> + int i;
> +
> + uart_remove_one_port(&sbsa_uart_reg, port);
> +
> + for (i = 0; i < ARRAY_SIZE(sbsa_uart_ports); i++)
> + if (sbsa_uart_ports[i] == port)
> + sbsa_uart_ports[i] = NULL;
> + else if (sbsa_uart_ports[i])
> + busy = true;
> +
> + if (!busy)
> + uart_unregister_driver(&sbsa_uart_reg);
> + return 0;
> +}
> +
> +static struct platform_driver arm_sbsa_uart_platform_driver = {
> + .probe = sbsa_uart_probe,
> + .remove = sbsa_uart_remove,
> + .driver = {
> + .name = "sbsa-uart",
> + .of_match_table = of_match_ptr(arm_sbsa_match),
> + },
> +};
> +
> +module_platform_driver(arm_sbsa_uart_platform_driver);
> +
> +#ifdef CONFIG_PM_SLEEP
> +static int sbsa_uart_suspend(struct device *dev)
> +{
> + struct uart_port *port = dev_get_drvdata(dev);
> +
> + if (!port)
> + return -EINVAL;
> +
> + return uart_suspend_port(&sbsa_uart_reg, port);
> +}
> +
> +static int sbsa_uart_resume(struct device *dev)
> +{
> + struct uart_port *port = dev_get_drvdata(dev);
> +
> + if (!port)
> + return -EINVAL;
> +
> + return uart_resume_port(&sbsa_uart_reg, port);
> +}
> +
> +static SIMPLE_DEV_PM_OPS(sbsa_uart_dev_pm_ops, sbsa_uart_suspend,
> + sbsa_uart_resume);
> +
> +#endif
> +
> +static int __init sbsa_uart_init(void)
> +{
> + pr_info("Serial: ARM SBSA generic UART (PL011) driver\n");
> +
> + return 0;
> +}
> +
> +static void __exit sbsa_uart_exit(void)
> +{
> +}
> +
> +/*
> + * While this can be a module, if builtin it's most likely the console
> + * So let's leave module_exit but move module_init to an earlier place
> + */
> +arch_initcall(sbsa_uart_init);
> +module_exit(sbsa_uart_exit);
> +
> +MODULE_AUTHOR("ARM Ltd");
> +MODULE_DESCRIPTION("ARM SBSA generic UART serial port driver");
> +MODULE_LICENSE("GPL");
> diff --git a/include/uapi/linux/serial_core.h b/include/uapi/linux/serial_core.h
> index 5820269..9f9ee0c 100644
> --- a/include/uapi/linux/serial_core.h
> +++ b/include/uapi/linux/serial_core.h
> @@ -67,6 +67,7 @@
> #define PORT_CLPS711X 33
> #define PORT_SA1100 34
> #define PORT_UART00 35
> +#define PORT_SBSA 36
> #define PORT_21285 37
>
> /* Sparc type numbers. */
>

Regards,
Peter Hurley