linux/drivers/tty/serial/stm32-usart.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) Maxime Coquelin 2015
 * Copyright (C) STMicroelectronics SA 2017
 * Authors:  Maxime Coquelin <[email protected]>
 *	     Gerald Baeza <[email protected]>
 *	     Erwan Le Ray <[email protected]>
 *
 * Inspired by st-asc.c from STMicroelectronics (c)
 */

#include <linux/bitfield.h>
#include <linux/clk.h>
#include <linux/console.h>
#include <linux/delay.h>
#include <linux/dma-direction.h>
#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/irq.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/pm_wakeirq.h>
#include <linux/serial_core.h>
#include <linux/serial.h>
#include <linux/spinlock.h>
#include <linux/sysrq.h>
#include <linux/tty_flip.h>
#include <linux/tty.h>

#include "serial_mctrl_gpio.h"
#include "stm32-usart.h"


/* Register offsets */
static struct stm32_usart_info __maybe_unused stm32f4_info =;

static struct stm32_usart_info __maybe_unused stm32f7_info =;

static struct stm32_usart_info __maybe_unused stm32h7_info =;

static void stm32_usart_stop_tx(struct uart_port *port);
static void stm32_usart_transmit_chars(struct uart_port *port);
static void __maybe_unused stm32_usart_console_putchar(struct uart_port *port, unsigned char ch);

static inline struct stm32_port *to_stm32_port(struct uart_port *port)
{}

static void stm32_usart_set_bits(struct uart_port *port, u32 reg, u32 bits)
{}

static void stm32_usart_clr_bits(struct uart_port *port, u32 reg, u32 bits)
{}

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

static void stm32_usart_rs485_rts_enable(struct uart_port *port)
{}

static void stm32_usart_rs485_rts_disable(struct uart_port *port)
{}

static void stm32_usart_config_reg_rs485(u32 *cr1, u32 *cr3, u32 delay_ADE,
					 u32 delay_DDE, u32 baud)
{}

static int stm32_usart_config_rs485(struct uart_port *port, struct ktermios *termios,
				    struct serial_rs485 *rs485conf)
{}

static int stm32_usart_init_rs485(struct uart_port *port,
				  struct platform_device *pdev)
{}

static bool stm32_usart_rx_dma_started(struct stm32_port *stm32_port)
{}

static void stm32_usart_rx_dma_terminate(struct stm32_port *stm32_port)
{}

static int stm32_usart_dma_pause_resume(struct stm32_port *stm32_port,
					struct dma_chan *chan,
					enum dma_status expected_status,
					int dmaengine_pause_or_resume(struct dma_chan *),
					bool stm32_usart_xx_dma_started(struct stm32_port *),
					void stm32_usart_xx_dma_terminate(struct stm32_port *))
{}

static int stm32_usart_rx_dma_pause(struct stm32_port *stm32_port)
{}

static int stm32_usart_rx_dma_resume(struct stm32_port *stm32_port)
{}

/* Return true when data is pending (in pio mode), and false when no data is pending. */
static bool stm32_usart_pending_rx_pio(struct uart_port *port, u32 *sr)
{}

static u8 stm32_usart_get_char_pio(struct uart_port *port)
{}

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

static void stm32_usart_push_buffer_dma(struct uart_port *port, unsigned int dma_size)
{}

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

static unsigned int stm32_usart_receive_chars(struct uart_port *port, bool force_dma_flush)
{}

static void stm32_usart_rx_dma_complete(void *arg)
{}

static int stm32_usart_rx_dma_start_or_resume(struct uart_port *port)
{}

static void stm32_usart_tx_dma_terminate(struct stm32_port *stm32_port)
{}

static bool stm32_usart_tx_dma_started(struct stm32_port *stm32_port)
{}

static int stm32_usart_tx_dma_pause(struct stm32_port *stm32_port)
{}

static int stm32_usart_tx_dma_resume(struct stm32_port *stm32_port)
{}

static void stm32_usart_tx_dma_complete(void *arg)
{}

static void stm32_usart_tx_interrupt_enable(struct uart_port *port)
{}

static void stm32_usart_tc_interrupt_enable(struct uart_port *port)
{}

static void stm32_usart_tx_interrupt_disable(struct uart_port *port)
{}

static void stm32_usart_tc_interrupt_disable(struct uart_port *port)
{}

static void stm32_usart_transmit_chars_pio(struct uart_port *port)
{}

static void stm32_usart_transmit_chars_dma(struct uart_port *port)
{}

static void stm32_usart_transmit_chars(struct uart_port *port)
{}

static irqreturn_t stm32_usart_interrupt(int irq, void *ptr)
{}

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

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

static void stm32_usart_enable_ms(struct uart_port *port)
{}

static void stm32_usart_disable_ms(struct uart_port *port)
{}

/* Transmit stop */
static void stm32_usart_stop_tx(struct uart_port *port)
{}

/* There are probably characters waiting to be transmitted. */
static void stm32_usart_start_tx(struct uart_port *port)
{}

/* Flush the transmit buffer. */
static void stm32_usart_flush_buffer(struct uart_port *port)
{}

/* Throttle the remote when input buffer is about to overflow. */
static void stm32_usart_throttle(struct uart_port *port)
{}

/* Unthrottle the remote, the input buffer can now accept data. */
static void stm32_usart_unthrottle(struct uart_port *port)
{}

/* Receive stop */
static void stm32_usart_stop_rx(struct uart_port *port)
{}

static void stm32_usart_break_ctl(struct uart_port *port, int break_state)
{}

static int stm32_usart_startup(struct uart_port *port)
{}

static void stm32_usart_shutdown(struct uart_port *port)
{}

static const unsigned int stm32_usart_presc_val[] =;

static void stm32_usart_set_termios(struct uart_port *port,
				    struct ktermios *termios,
				    const struct ktermios *old)
{}

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

static void stm32_usart_release_port(struct uart_port *port)
{}

static int stm32_usart_request_port(struct uart_port *port)
{}

static void stm32_usart_config_port(struct uart_port *port, int flags)
{}

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

static void stm32_usart_pm(struct uart_port *port, unsigned int state,
			   unsigned int oldstate)
{}

#if defined(CONFIG_CONSOLE_POLL)

 /* Callbacks for characters polling in debug context (i.e. KGDB). */
static int stm32_usart_poll_init(struct uart_port *port)
{}

static int stm32_usart_poll_get_char(struct uart_port *port)
{}

static void stm32_usart_poll_put_char(struct uart_port *port, unsigned char ch)
{}
#endif /* CONFIG_CONSOLE_POLL */

static const struct uart_ops stm32_uart_ops =;

struct stm32_usart_thresh_ratio {};

static const struct stm32_usart_thresh_ratio stm32h7_usart_fifo_thresh_cfg[] =;

static int stm32_usart_get_thresh_value(u32 fifo_size, int index)
{}

static int stm32_usart_get_ftcfg(struct platform_device *pdev, struct stm32_port *stm32port,
				 const char *p, int *ftcfg)
{}

static void stm32_usart_deinit_port(struct stm32_port *stm32port)
{}

static const struct serial_rs485 stm32_rs485_supported =;

static int stm32_usart_init_port(struct stm32_port *stm32port,
				 struct platform_device *pdev)
{}

static struct stm32_port *stm32_usart_of_get_port(struct platform_device *pdev)
{}

#ifdef CONFIG_OF
static const struct of_device_id stm32_match[] =;

MODULE_DEVICE_TABLE(of, stm32_match);
#endif

static void stm32_usart_of_dma_rx_remove(struct stm32_port *stm32port,
					 struct platform_device *pdev)
{}

static int stm32_usart_of_dma_rx_probe(struct stm32_port *stm32port,
				       struct platform_device *pdev)
{}

static void stm32_usart_of_dma_tx_remove(struct stm32_port *stm32port,
					 struct platform_device *pdev)
{}

static int stm32_usart_of_dma_tx_probe(struct stm32_port *stm32port,
				       struct platform_device *pdev)
{}

static int stm32_usart_serial_probe(struct platform_device *pdev)
{}

static void stm32_usart_serial_remove(struct platform_device *pdev)
{}

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

#ifdef CONFIG_SERIAL_STM32_CONSOLE
static void stm32_usart_console_write(struct console *co, const char *s,
				      unsigned int cnt)
{}

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

static struct console stm32_console =;

#define STM32_SERIAL_CONSOLE

#else
#define STM32_SERIAL_CONSOLE
#endif /* CONFIG_SERIAL_STM32_CONSOLE */

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

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

static int __init early_stm32_h7_serial_setup(struct earlycon_device *device, const char *options)
{}

static int __init early_stm32_f7_serial_setup(struct earlycon_device *device, const char *options)
{}

static int __init early_stm32_f4_serial_setup(struct earlycon_device *device, const char *options)
{}

OF_EARLYCON_DECLARE();
OF_EARLYCON_DECLARE();
OF_EARLYCON_DECLARE();
#endif /* CONFIG_SERIAL_EARLYCON */

static struct uart_driver stm32_usart_driver =;

static int __maybe_unused stm32_usart_serial_en_wakeup(struct uart_port *port,
						       bool enable)
{}

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

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

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

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

static const struct dev_pm_ops stm32_serial_pm_ops =;

static struct platform_driver stm32_serial_driver =;

static int __init stm32_usart_init(void)
{}

static void __exit stm32_usart_exit(void)
{}

module_init();
module_exit(stm32_usart_exit);

MODULE_ALIAS();
MODULE_DESCRIPTION();
MODULE_LICENSE();