drivers/serial/uart_sedi.c

/*
 * Copyright (c) 2023 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <errno.h>
#include <zephyr/device.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/pm/device.h>
#include "sedi_driver_uart.h"

#ifdef CONFIG_UART_INTERRUPT_DRIVEN
static void uart_sedi_isr(void *arg);
static void uart_sedi_cb(struct device *port);
#endif

#define DT_DRV_COMPAT intel_sedi_uart

#ifdef CONFIG_UART_INTERRUPT_DRIVEN
/*  UART IRQ handler declaration.  */
#define  UART_IRQ_HANDLER_DECL(n) \
	static void irq_config_uart_##n(const struct device *dev)

/* Setting configuration function. */
#define UART_CONFIG_IRQ_HANDLER_SET(n) \
	.uart_irq_config_func = irq_config_uart_##n
#define UART_IRQ_HANDLER_DEFINE(n)				       \
	static void irq_config_uart_##n(const struct device *dev)      \
	{							       \
		ARG_UNUSED(dev);				       \
		IRQ_CONNECT(DT_INST_IRQN(n),			       \
			    DT_INST_IRQ(n, priority), uart_sedi_isr,   \
			    DEVICE_DT_GET(DT_NODELABEL(uart##n)),      \
			    DT_INST_IRQ(n, sense));		       \
		irq_enable(DT_INST_IRQN(n));			       \
	}
#else /*CONFIG_UART_INTERRUPT_DRIVEN */
#define UART_IRQ_HANDLER_DECL(n)
#define UART_CONFIG_IRQ_HANDLER_SET(n) (0)

#define UART_IRQ_HANDLER_DEFINE(n)
#endif  /* !CONFIG_UART_INTERRUPT_DRIVEN */

/* Device init macro for UART instance. As multiple uart instances follow a
 * similar definition of data structures differing only in the instance
 * number.This macro makes adding instances simpler.
 */
#define UART_SEDI_DEVICE_INIT(n)				      \
	UART_IRQ_HANDLER_DECL(n);				      \
	static K_MUTEX_DEFINE(uart_##n##_mutex);		      \
	static K_SEM_DEFINE(uart_##n##_tx_sem, 1, 1);		      \
	static K_SEM_DEFINE(uart_##n##_rx_sem, 1, 1);		      \
	static K_SEM_DEFINE(uart_##n##_sync_read_sem, 0, 1);	      \
	static const struct uart_sedi_config_info config_info_##n = { \
		DEVICE_MMIO_ROM_INIT(DT_DRV_INST(n)),		      \
		.instance = DT_INST_PROP(n, peripheral_id),	      \
		.baud_rate = DT_INST_PROP(n, current_speed),	      \
		.hw_fc = DT_INST_PROP(n, hw_flow_control),	      \
		.line_ctrl = SEDI_UART_LC_8N1,			      \
		.mutex = &uart_##n##_mutex,			      \
		UART_CONFIG_IRQ_HANDLER_SET(n)			      \
	};							      \
								      \
	static struct uart_sedi_drv_data drv_data_##n;		      \
	PM_DEVICE_DT_DEFINE(DT_NODELABEL(uart##n),                    \
			    uart_sedi_pm_action);		      \
	DEVICE_DT_DEFINE(DT_NODELABEL(uart##n),		              \
		      &uart_sedi_init,				      \
		      PM_DEVICE_DT_GET(DT_NODELABEL(uart##n)),        \
		      &drv_data_##n, &config_info_##n,		      \
		      PRE_KERNEL_1,				      \
		      CONFIG_SERIAL_INIT_PRIORITY, &api);	      \
	UART_IRQ_HANDLER_DEFINE(n)



/* Convenient macro to get the controller instance. */
#define GET_CONTROLLER_INSTANCE(dev)		 \
	(((const struct uart_sedi_config_info *) \
	  dev->config)->instance)

#define GET_MUTEX(dev)				 \
	(((const struct uart_sedi_config_info *) \
	  dev->config)->mutex)

struct uart_sedi_config_info {
	DEVICE_MMIO_ROM;
	/* Specifies the uart instance for configuration. */
	sedi_uart_t instance;

	/* Specifies the baudrate for the uart instance. */
	uint32_t baud_rate;

	/* Specifies the port line control settings */
	sedi_uart_lc_t line_ctrl;

	struct k_mutex *mutex;

	/* Enable / disable hardware flow control for UART. */
	bool hw_fc;

	/* UART irq configuration function when supporting interrupt
	 * mode.
	 */
	uart_irq_config_func_t uart_irq_config_func;
};


static int uart_sedi_init(const struct device *dev);

struct uart_sedi_drv_data {
	DEVICE_MMIO_RAM;
	uart_irq_callback_user_data_t user_cb;
	void *unsol_rx_usr_cb_param;
	uint32_t sync_rx_len;
	uint32_t sync_rx_status;
	void *user_data;
	void *usr_rx_buff;
	uint32_t usr_rx_size;
	uint8_t iir_cache;
	uint8_t busy_count;
};

#ifdef CONFIG_UART_INTERRUPT_DRIVEN
static void uart_busy_set(const struct device *dev)
{

	struct uart_sedi_drv_data *context = dev->data;

	context->busy_count++;

	if (context->busy_count == 1) {
		pm_device_busy_set(dev);
	}
}

static void uart_busy_clear(const struct device *dev)
{

	struct uart_sedi_drv_data *context = dev->data;

	context->busy_count--;

	if (context->busy_count == 0) {
		pm_device_busy_clear(dev);
	}
}
#endif

#ifdef CONFIG_PM_DEVICE

#ifndef CONFIG_UART_CONSOLE

static int uart_suspend_device(const struct device *dev)
{
	const struct uart_sedi_config_info *config = dev->config;

	if (pm_device_is_busy(dev)) {
		return -EBUSY;
	}

	int ret = sedi_uart_set_power(config->instance, SEDI_POWER_SUSPEND);

	if (ret != SEDI_DRIVER_OK) {
		return -EIO;
	}

	return 0;
}

static int uart_resume_device_from_suspend(const struct device *dev)
{
	const struct uart_sedi_config_info *config = dev->config;
	int ret;

	ret = sedi_uart_set_power(config->instance, SEDI_POWER_FULL);
	if (ret != SEDI_DRIVER_OK) {
		return -EIO;
	}

	return 0;
}

static int uart_sedi_pm_action(const struct device *dev,
		enum pm_device_action action)
{
	int ret = 0;

	switch (action) {
	case PM_DEVICE_ACTION_SUSPEND:
		ret = uart_suspend_device(dev);
		break;
	case PM_DEVICE_ACTION_RESUME:
		ret = uart_resume_device_from_suspend(dev);
		break;

	default:
		ret = -ENOTSUP;
	}
	return ret;
}

#else

static int uart_sedi_pm_action(const struct device *dev,
		enum pm_device_action action)
{
	/* do nothing if using UART print log to avoid clock gating
	 * pm driver already handled power management for uart.
	 */
	return 0;
}

#endif /* CONFIG_UART_CONSOLE */

#endif /* CONFIG_PM_DEVICE */

static int uart_sedi_poll_in(const struct device *dev, unsigned char *data)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);
	uint32_t status;
	int ret = 0;

	sedi_uart_get_status(instance, (uint32_t *) &status);

	/* In order to check if there is any data to read from UART
	 * controller we should check if the SEDI_UART_RX_BUSY bit from
	 * 'status' is not set. This bit is set only if there is any
	 * pending character to read.
	 */
	if (!(status & SEDI_UART_RX_BUSY)) {
		ret = -1;
	} else {
		if (sedi_uart_read(instance, data, (uint32_t *)&status)) {
			ret = -1;
		}
	}
	return ret;
}

static void uart_sedi_poll_out(const struct device *dev,
			       unsigned char data)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	sedi_uart_write(instance, data);
}

#ifdef CONFIG_UART_LINE_CTRL
static int get_xfer_error(int bsp_err)
{
	int err;

	switch (bsp_err) {
	case SEDI_DRIVER_OK:
		err = 0;
		break;
	case SEDI_USART_ERROR_CANCELED:
		err = -ECANCELED;
		break;
	case SEDI_DRIVER_ERROR:
		err = -EIO;
		break;
	case SEDI_DRIVER_ERROR_PARAMETER:
		err = -EINVAL;
		break;
	case SEDI_DRIVER_ERROR_UNSUPPORTED:
		err = -ENOTSUP;
		break;
	default:
		err = -EFAULT;
	}
	return err;
}
#endif  /* CONFIG_UART_LINE_CTRL */

static int uart_sedi_err_check(const struct device *dev)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);
	uint32_t status;
	int ret_status = 0;

	sedi_uart_get_status(instance, (uint32_t *const)&status);
	if (status &  SEDI_UART_RX_OE) {
		ret_status = UART_ERROR_OVERRUN;
	}

	if (status & SEDI_UART_RX_PE) {
		ret_status = UART_ERROR_PARITY;
	}

	if (status & SEDI_UART_RX_FE) {
		ret_status = UART_ERROR_FRAMING;
	}

	if (status & SEDI_UART_RX_BI) {
		ret_status = UART_BREAK;
	}

	return ret_status;
}


#ifdef CONFIG_UART_INTERRUPT_DRIVEN

static int uart_sedi_fifo_fill(const struct device *dev, const uint8_t *tx_data,
			       int size)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	return sedi_uart_fifo_fill(instance, tx_data, size);
}

static int uart_sedi_fifo_read(const struct device *dev, uint8_t *rx_data,
			       const int size)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	return sedi_uart_fifo_read(instance, rx_data, size);
}

static void uart_sedi_irq_tx_enable(const struct device *dev)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	sedi_uart_irq_tx_enable(instance);
}

static void uart_sedi_irq_tx_disable(const struct device *dev)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	sedi_uart_irq_tx_disable(instance);
}

static int uart_sedi_irq_tx_ready(const struct device *dev)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	return sedi_uart_irq_tx_ready(instance);
}

static int uart_sedi_irq_tx_complete(const struct device *dev)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	return sedi_uart_is_tx_complete(instance);
}

static void uart_sedi_irq_rx_enable(const struct device *dev)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	uart_busy_set(dev);
	sedi_uart_irq_rx_enable(instance);
}

static void uart_sedi_irq_rx_disable(const struct device *dev)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	sedi_uart_irq_rx_disable(instance);
	uart_busy_clear(dev);
}

static int uart_sedi_irq_rx_ready(const struct device *dev)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	return sedi_uart_is_irq_rx_ready(instance);
}

static void uart_sedi_irq_err_enable(const struct device *dev)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	sedi_uart_irq_err_enable(instance);
}

static void uart_sedi_irq_err_disable(const struct device *dev)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	sedi_uart_irq_err_disable(instance);
}

static int uart_sedi_irq_is_pending(const struct device *dev)
{

	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	return sedi_uart_is_irq_pending(instance);
}

static int uart_sedi_irq_update(const struct device *dev)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);

	sedi_uart_update_irq_cache(instance);
	return 1;
}

static void uart_sedi_irq_callback_set(const struct device *dev,
				       uart_irq_callback_user_data_t cb,
				       void *user_data)
{
	struct uart_sedi_drv_data *drv_data = dev->data;

	drv_data->user_cb = cb;
	drv_data->user_data = user_data;

}

static void uart_sedi_isr(void *arg)
{
	struct device *dev = arg;
	struct uart_sedi_drv_data *drv_data = dev->data;

	if (drv_data->user_cb) {
		drv_data->user_cb(dev, drv_data->user_data);
	} else {
		uart_sedi_cb(dev);
	}
}

/* Called from generic callback of zephyr , set by set_cb. */
static void uart_sedi_cb(struct device *port)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(port);

	sedi_uart_isr_handler(instance);
}

#endif /* CONFIG_UART_INTERRUPT_DRIVEN */

#ifdef CONFIG_UART_LINE_CTRL
static int uart_sedi_line_ctrl_set(struct device *dev,
		uint32_t ctrl, uint32_t val)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);
	sedi_uart_config_t cfg;
	uint32_t mask;
	int ret;

	k_mutex_lock(GET_MUTEX(dev), K_FOREVER);
	switch (ctrl) {
	case UART_LINE_CTRL_BAUD_RATE:
		sedi_uart_get_config(instance, &cfg);
		cfg.baud_rate = val;
		ret = sedi_uart_set_config(instance, &cfg);
		break;

	default:
		ret = -ENODEV;
	}
	k_mutex_unlock(GET_MUTEX(dev));
	ret = get_xfer_error(ret);
	return ret;
}

static int uart_sedi_line_ctrl_get(struct device *dev,
		uint32_t ctrl, uint32_t *val)
{
	sedi_uart_t instance = GET_CONTROLLER_INSTANCE(dev);
	sedi_uart_config_t cfg;
	uint32_t mask;
	int ret;

	k_mutex_lock(GET_MUTEX(dev), K_FOREVER);
	switch (ctrl) {
	case UART_LINE_CTRL_BAUD_RATE:
		ret = sedi_uart_get_config(instance, &cfg);
		*val = cfg.baud_rate;
		break;

	case UART_LINE_CTRL_LOOPBACK:
		ret = sedi_uart_get_loopback_mode(instance, (uint32_t *)val);
		break;

	case UART_LINE_CTRL_AFCE:
		ret = sedi_uart_get_config(instance, &cfg);
		*val = cfg.hw_fc;
		break;

	case UART_LINE_CTRL_LINE_STATUS_REPORT_MASK:
		mask = 0;
		*val = 0;
		ret = sedi_get_ln_status_report_mask(instance,
						     (uint32_t *)&mask);
		*val |= ((mask & SEDI_UART_RX_OE) ? UART_ERROR_OVERRUN : 0);
		*val |= ((mask & SEDI_UART_RX_PE) ? UART_ERROR_PARITY : 0);
		*val |= ((mask & SEDI_UART_RX_FE) ? UART_ERROR_FRAMING : 0);
		*val |= ((mask & SEDI_UART_RX_BI) ? UART_BREAK : 0);
		break;

	case UART_LINE_CTRL_RTS:
		ret = sedi_uart_read_rts(instance, (uint32_t *)val);
		break;

	case UART_LINE_CTRL_CTS:
		ret = sedi_uart_read_cts(instance, (uint32_t *)val);
		break;


	default:
		ret = -ENODEV;
	}
	k_mutex_unlock(GET_MUTEX(dev));
	ret = get_xfer_error(ret);
	return ret;
}

#endif /* CONFIG_UART_LINE_CTRL */

static const struct uart_driver_api api = {
	.poll_in = uart_sedi_poll_in,
	.poll_out = uart_sedi_poll_out,
	.err_check = uart_sedi_err_check,
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
	.fifo_fill = uart_sedi_fifo_fill,
	.fifo_read = uart_sedi_fifo_read,
	.irq_tx_enable = uart_sedi_irq_tx_enable,
	.irq_tx_disable = uart_sedi_irq_tx_disable,
	.irq_tx_ready = uart_sedi_irq_tx_ready,
	.irq_tx_complete = uart_sedi_irq_tx_complete,
	.irq_rx_enable = uart_sedi_irq_rx_enable,
	.irq_rx_disable = uart_sedi_irq_rx_disable,
	.irq_rx_ready = uart_sedi_irq_rx_ready,
	.irq_err_enable = uart_sedi_irq_err_enable,
	.irq_err_disable = uart_sedi_irq_err_disable,
	.irq_is_pending = uart_sedi_irq_is_pending,
	.irq_update = uart_sedi_irq_update,
	.irq_callback_set = uart_sedi_irq_callback_set,
#endif  /* CONFIG_UART_INTERRUPT_DRIVEN */
#ifdef CONFIG_UART_LINE_CTRL
	.line_ctrl_set = uart_sedi_line_ctrl_set,
	.line_ctrl_get = uart_sedi_line_ctrl_get,
#endif  /* CONFIG_UART_LINE_CTRL */

};

static int uart_sedi_init(const struct device *dev)
{

	const struct uart_sedi_config_info *config = dev->config;
	sedi_uart_config_t cfg;

	DEVICE_MMIO_MAP(dev, K_MEM_CACHE_NONE);
	sedi_uart_init(config->instance, (void *)DEVICE_MMIO_GET(dev));

	cfg.line_control = config->line_ctrl;
	cfg.baud_rate = config->baud_rate;
	cfg.hw_fc = config->hw_fc;

	/* Setting to full power and enabling clk. */
	sedi_uart_set_power(config->instance, SEDI_POWER_FULL);

	sedi_uart_set_config(config->instance, &cfg);

#ifdef CONFIG_UART_INTERRUPT_DRIVEN
	config->uart_irq_config_func(dev);
#endif  /* CONFIG_UART_INTERRUPT_DRIVEN */

	return 0;
}

DT_INST_FOREACH_STATUS_OKAY(UART_SEDI_DEVICE_INIT)