blob: 6f61d4120edcdab4610706676ff14c57d2c11f9e [file] [log] [blame]
/*
* Copyright (c) 2018 Diego Sueiro <diego.sueiro@gmail.com>
*
* SPDX-License-Identifier: Apache-2.0
*/
#define DT_DRV_COMPAT nxp_imx_uart
/**
* @brief Driver for UART on NXP IMX family processor.
*
* For full serial function, use the USART controller.
*
*/
#include <zephyr/kernel.h>
#include <zephyr/arch/cpu.h>
#include <zephyr/sys/__assert.h>
#include <soc.h>
#include <zephyr/init.h>
#include <zephyr/drivers/uart.h>
#include <uart_imx.h>
#include <zephyr/drivers/pinctrl.h>
#define UART_STRUCT(dev) \
((UART_Type *)((const struct imx_uart_config *const)(dev)->config)->base)
struct imx_uart_config {
UART_Type *base;
uint32_t baud_rate;
uint8_t modem_mode;
const struct pinctrl_dev_config *pincfg;
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
void (*irq_config_func)(const struct device *dev);
#endif
};
struct imx_uart_data {
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
uart_irq_callback_user_data_t callback;
void *cb_data;
#endif
};
/**
* @brief Initialize UART channel
*
* This routine is called to reset the chip in a quiescent state.
* It is assumed that this function is called only once per UART.
*
* @param dev UART device struct
*
* @return 0
*/
static int uart_imx_init(const struct device *dev)
{
UART_Type *uart = UART_STRUCT(dev);
const struct imx_uart_config *config = dev->config;
unsigned int old_level;
int err;
/* disable interrupts */
old_level = irq_lock();
/* Setup UART init structure */
uart_init_config_t initConfig = {
.baudRate = config->baud_rate,
.wordLength = uartWordLength8Bits,
.stopBitNum = uartStopBitNumOne,
.parity = uartParityDisable,
.direction = uartDirectionTxRx
};
err = pinctrl_apply_state(config->pincfg, PINCTRL_STATE_DEFAULT);
if (err) {
return err;
}
/* Get current module clock frequency */
initConfig.clockRate = get_uart_clock_freq(uart);
UART_Init(uart, &initConfig);
/* Set UART built-in hardware FIFO Watermark. */
UART_SetTxFifoWatermark(uart, 2);
UART_SetRxFifoWatermark(uart, 1);
/* restore interrupt state */
irq_unlock(old_level);
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
config->irq_config_func(dev);
#endif
/* Set UART modem mode */
UART_SetModemMode(uart, config->modem_mode);
/* Finally, enable the UART module */
UART_Enable(uart);
return 0;
}
static void uart_imx_poll_out(const struct device *dev, unsigned char c)
{
UART_Type *uart = UART_STRUCT(dev);
while (!UART_GetStatusFlag(uart, uartStatusTxReady)) {
}
UART_Putchar(uart, c);
}
static int uart_imx_poll_in(const struct device *dev, unsigned char *c)
{
UART_Type *uart = UART_STRUCT(dev);
int ret = -1;
if (UART_GetStatusFlag(uart, uartStatusRxDataReady)) {
*c = UART_Getchar(uart);
if (UART_GetStatusFlag(uart, uartStatusRxOverrun)) {
UART_ClearStatusFlag(uart, uartStatusRxOverrun);
}
ret = 0;
}
return ret;
}
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
static int uart_imx_fifo_fill(const struct device *dev,
const uint8_t *tx_data,
int size)
{
UART_Type *uart = UART_STRUCT(dev);
unsigned int num_tx = 0U;
while (((size - num_tx) > 0) &&
UART_GetStatusFlag(uart, uartStatusTxReady)) {
/* Send a character */
UART_Putchar(uart, tx_data[num_tx]);
num_tx++;
}
return (int)num_tx;
}
static int uart_imx_fifo_read(const struct device *dev, uint8_t *rx_data,
const int size)
{
UART_Type *uart = UART_STRUCT(dev);
unsigned int num_rx = 0U;
while (((size - num_rx) > 0) &&
UART_GetStatusFlag(uart, uartStatusRxReady)) {
/* Receive a character */
rx_data[num_rx++] = UART_Getchar(uart);
}
if (UART_GetStatusFlag(uart, uartStatusRxOverrun)) {
UART_ClearStatusFlag(uart, uartStatusRxOverrun);
}
return num_rx;
}
static void uart_imx_irq_tx_enable(const struct device *dev)
{
UART_Type *uart = UART_STRUCT(dev);
UART_SetIntCmd(uart, uartIntTxReady, true);
}
static void uart_imx_irq_tx_disable(const struct device *dev)
{
UART_Type *uart = UART_STRUCT(dev);
UART_SetIntCmd(uart, uartIntTxReady, false);
}
static int uart_imx_irq_tx_ready(const struct device *dev)
{
UART_Type *uart = UART_STRUCT(dev);
return UART_GetStatusFlag(uart, uartStatusTxReady);
}
static void uart_imx_irq_rx_enable(const struct device *dev)
{
UART_Type *uart = UART_STRUCT(dev);
UART_SetIntCmd(uart, uartIntRxReady, true);
}
static void uart_imx_irq_rx_disable(const struct device *dev)
{
UART_Type *uart = UART_STRUCT(dev);
UART_SetIntCmd(uart, uartIntRxReady, false);
}
static int uart_imx_irq_rx_ready(const struct device *dev)
{
UART_Type *uart = UART_STRUCT(dev);
return UART_GetStatusFlag(uart, uartStatusRxReady);
}
static void uart_imx_irq_err_enable(const struct device *dev)
{
UART_Type *uart = UART_STRUCT(dev);
UART_SetIntCmd(uart, uartIntParityError, true);
UART_SetIntCmd(uart, uartIntFrameError, true);
}
static void uart_imx_irq_err_disable(const struct device *dev)
{
UART_Type *uart = UART_STRUCT(dev);
UART_SetIntCmd(uart, uartIntParityError, false);
UART_SetIntCmd(uart, uartIntFrameError, false);
}
static int uart_imx_irq_is_pending(const struct device *dev)
{
UART_Type *uart = UART_STRUCT(dev);
return UART_GetStatusFlag(uart, uartStatusRxReady) ||
UART_GetStatusFlag(uart, uartStatusTxReady);
}
static int uart_imx_irq_update(const struct device *dev)
{
return 1;
}
static void uart_imx_irq_callback_set(const struct device *dev,
uart_irq_callback_user_data_t cb,
void *cb_data)
{
struct imx_uart_data *data = dev->data;
data->callback = cb;
data->cb_data = cb_data;
}
/**
* @brief Interrupt service routine.
*
* This simply calls the callback function, if one exists.
*
* Note: imx UART Tx interrupts when ready to send; Rx interrupts when char
* received.
*
* @param arg Argument to ISR.
*/
void uart_imx_isr(const struct device *dev)
{
struct imx_uart_data *data = dev->data;
if (data->callback) {
data->callback(dev, data->cb_data);
}
}
#endif /* CONFIG_UART_INTERRUPT_DRIVEN */
static const struct uart_driver_api uart_imx_driver_api = {
.poll_in = uart_imx_poll_in,
.poll_out = uart_imx_poll_out,
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
.fifo_fill = uart_imx_fifo_fill,
.fifo_read = uart_imx_fifo_read,
.irq_tx_enable = uart_imx_irq_tx_enable,
.irq_tx_disable = uart_imx_irq_tx_disable,
.irq_tx_ready = uart_imx_irq_tx_ready,
.irq_rx_enable = uart_imx_irq_rx_enable,
.irq_rx_disable = uart_imx_irq_rx_disable,
.irq_rx_ready = uart_imx_irq_rx_ready,
.irq_err_enable = uart_imx_irq_err_enable,
.irq_err_disable = uart_imx_irq_err_disable,
.irq_is_pending = uart_imx_irq_is_pending,
.irq_update = uart_imx_irq_update,
.irq_callback_set = uart_imx_irq_callback_set,
#endif /* CONFIG_UART_INTERRUPT_DRIVEN */
};
#define UART_IMX_DECLARE_CFG(n, IRQ_FUNC_INIT) \
static const struct imx_uart_config imx_uart_##n##_config = { \
.base = (UART_Type *) DT_INST_REG_ADDR(n), \
.baud_rate = DT_INST_PROP(n, current_speed), \
.modem_mode = DT_INST_PROP(n, modem_mode), \
.pincfg = PINCTRL_DT_INST_DEV_CONFIG_GET(n), \
IRQ_FUNC_INIT \
}
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
#define UART_IMX_CONFIG_FUNC(n) \
static void irq_config_func_##n(const struct device *dev) \
{ \
IRQ_CONNECT(DT_INST_IRQN(n), \
DT_INST_IRQ(n, priority), \
uart_imx_isr, \
DEVICE_DT_INST_GET(n), 0); \
irq_enable(DT_INST_IRQN(n)); \
}
#define UART_IMX_IRQ_CFG_FUNC_INIT(n) \
.irq_config_func = irq_config_func_##n
#define UART_IMX_INIT_CFG(n) \
UART_IMX_DECLARE_CFG(n, UART_IMX_IRQ_CFG_FUNC_INIT(n))
#else
#define UART_IMX_CONFIG_FUNC(n)
#define UART_IMX_IRQ_CFG_FUNC_INIT
#define UART_IMX_INIT_CFG(n) \
UART_IMX_DECLARE_CFG(n, UART_IMX_IRQ_CFG_FUNC_INIT)
#endif
#define UART_IMX_INIT(n) \
static struct imx_uart_data imx_uart_##n##_data; \
\
static const struct imx_uart_config imx_uart_##n##_config; \
\
PINCTRL_DT_INST_DEFINE(n); \
\
DEVICE_DT_INST_DEFINE(n, &uart_imx_init, NULL, \
&imx_uart_##n##_data, &imx_uart_##n##_config, \
PRE_KERNEL_1, \
CONFIG_SERIAL_INIT_PRIORITY, \
&uart_imx_driver_api); \
\
UART_IMX_CONFIG_FUNC(n) \
\
UART_IMX_INIT_CFG(n);
DT_INST_FOREACH_STATUS_OKAY(UART_IMX_INIT)