linux/drivers/tty/serial/sunplus-uart.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Sunplus SoC UART driver
 *
 * Author: Hammer Hsieh <[email protected]>
 *
 * Note1: This driver is 8250-like uart, but are not register compatible.
 *
 * Note2: On some buses, for preventing data incoherence, must do a read
 * for ensure write made it to hardware. In this driver, function startup
 * and shutdown did not do a read but only do a write directly. For what?
 * In Sunplus bus communication between memory bus and peripheral bus with
 * posted write, it will send a specific command after last write command
 * to make sure write done. Then memory bus identify the specific command
 * and send done signal back to master device. After master device received
 * done signal, then proceed next write command. It is no need to do a read
 * before write.
 */
#include <linux/clk.h>
#include <linux/console.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/reset.h>
#include <linux/serial_core.h>
#include <linux/serial_reg.h>
#include <linux/sysrq.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <asm/irq.h>

/* Register offsets */
#define SUP_UART_DATA
#define SUP_UART_LSR
#define SUP_UART_MSR
#define SUP_UART_LCR
#define SUP_UART_MCR
#define SUP_UART_DIV_L
#define SUP_UART_DIV_H
#define SUP_UART_ISC
#define SUP_UART_TX_RESIDUE
#define SUP_UART_RX_RESIDUE

/* Line Status Register bits */
#define SUP_UART_LSR_BC
#define SUP_UART_LSR_FE
#define SUP_UART_LSR_OE
#define SUP_UART_LSR_PE
#define SUP_UART_LSR_RX
#define SUP_UART_LSR_TX
#define SUP_UART_LSR_TX_NOT_FULL
#define SUP_UART_LSR_BRK_ERROR_BITS

/* Line Control Register bits */
#define SUP_UART_LCR_SBC

/* Modem Control Register bits */
#define SUP_UART_MCR_RI
#define SUP_UART_MCR_DCD

/* Interrupt Status/Control Register bits */
#define SUP_UART_ISC_RXM
#define SUP_UART_ISC_TXM
#define SUP_UART_ISC_RX
#define SUP_UART_ISC_TX

#define SUP_DUMMY_READ
#define SUP_UART_NR

struct sunplus_uart_port {};

static void sp_uart_put_char(struct uart_port *port, unsigned int ch)
{}

static u32 sunplus_tx_buf_not_full(struct uart_port *port)
{}

static unsigned int sunplus_tx_empty(struct uart_port *port)
{}

static void sunplus_set_mctrl(struct uart_port *port, unsigned int mctrl)
{}

static unsigned int sunplus_get_mctrl(struct uart_port *port)
{}

static void sunplus_stop_tx(struct uart_port *port)
{}

static void sunplus_start_tx(struct uart_port *port)
{}

static void sunplus_stop_rx(struct uart_port *port)
{}

static void sunplus_break_ctl(struct uart_port *port, int ctl)
{}

static void transmit_chars(struct uart_port *port)
{}

static void receive_chars(struct uart_port *port)
{}

static irqreturn_t sunplus_uart_irq(int irq, void *args)
{}

static int sunplus_startup(struct uart_port *port)
{}

static void sunplus_shutdown(struct uart_port *port)
{}

static void sunplus_set_termios(struct uart_port *port,
				struct ktermios *termios,
				const struct ktermios *oldtermios)
{}

static void sunplus_set_ldisc(struct uart_port *port, struct ktermios *termios)
{}

static const char *sunplus_type(struct uart_port *port)
{}

static void sunplus_config_port(struct uart_port *port, int type)
{}

static int sunplus_verify_port(struct uart_port *port, struct serial_struct *ser)
{}

#if defined(CONFIG_SERIAL_SUNPLUS_CONSOLE) || defined(CONFIG_CONSOLE_POLL)
static void wait_for_xmitr(struct uart_port *port)
{}
#endif

#ifdef CONFIG_CONSOLE_POLL
static void sunplus_poll_put_char(struct uart_port *port, unsigned char data)
{}

static int sunplus_poll_get_char(struct uart_port *port)
{}
#endif

static const struct uart_ops sunplus_uart_ops =;

#ifdef CONFIG_SERIAL_SUNPLUS_CONSOLE
static struct sunplus_uart_port *sunplus_console_ports[SUP_UART_NR];

static void sunplus_uart_console_putchar(struct uart_port *port,
					 unsigned char ch)
{}

static void sunplus_console_write(struct console *co,
				  const char *s,
				  unsigned int count)
{}

static int __init sunplus_console_setup(struct console *co, char *options)
{}

static struct uart_driver sunplus_uart_driver;
static struct console sunplus_uart_console =;

#define SERIAL_SUNPLUS_CONSOLE
#else
#define SERIAL_SUNPLUS_CONSOLE
#endif

static struct uart_driver sunplus_uart_driver =;

static void sunplus_uart_disable_unprepare(void *data)
{}

static void sunplus_uart_reset_control_assert(void *data)
{}

static int sunplus_uart_probe(struct platform_device *pdev)
{}

static void sunplus_uart_remove(struct platform_device *pdev)
{}

static int __maybe_unused sunplus_uart_suspend(struct device *dev)
{}

static int __maybe_unused sunplus_uart_resume(struct device *dev)
{}

static const struct dev_pm_ops sunplus_uart_pm_ops =;

static const struct of_device_id sp_uart_of_match[] =;
MODULE_DEVICE_TABLE(of, sp_uart_of_match);

static struct platform_driver sunplus_uart_platform_driver =;

static int __init sunplus_uart_init(void)
{}
module_init();

static void __exit sunplus_uart_exit(void)
{}
module_exit(sunplus_uart_exit);

#ifdef CONFIG_SERIAL_EARLYCON
static void sunplus_uart_putc(struct uart_port *port, unsigned char c)
{}

static void sunplus_uart_early_write(struct console *con, const char *s, unsigned int n)
{}

static int __init
sunplus_uart_early_setup(struct earlycon_device *dev, const char *opt)
{}
OF_EARLYCON_DECLARE();
#endif

MODULE_DESCRIPTION();
MODULE_AUTHOR();
MODULE_LICENSE();