530 lines
13 KiB
C
530 lines
13 KiB
C
/*
|
|
* Copyright (c) 2018 Diego Sueiro <diego.sueiro@gmail.com>
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
|
|
/**
|
|
* @brief Driver for UART on NXP IMX family processor.
|
|
*
|
|
* For full serial function, use the USART controller.
|
|
*
|
|
*/
|
|
|
|
#include <kernel.h>
|
|
#include <arch/cpu.h>
|
|
#include <misc/__assert.h>
|
|
#include <soc.h>
|
|
#include <init.h>
|
|
#include <uart.h>
|
|
#include <uart_imx.h>
|
|
|
|
#define DEV_CFG(dev) \
|
|
((const struct imx_uart_config *const)(dev)->config->config_info)
|
|
#define UART_STRUCT(dev) \
|
|
((UART_Type *)(DEV_CFG(dev))->base)
|
|
|
|
struct imx_uart_config {
|
|
UART_Type *base;
|
|
u32_t baud_rate;
|
|
u8_t modem_mode;
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
void (*irq_config_func)(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(struct device *dev)
|
|
{
|
|
UART_Type *uart = UART_STRUCT(dev);
|
|
const struct imx_uart_config *config = dev->config->config_info;
|
|
unsigned int old_level;
|
|
|
|
/* 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
|
|
};
|
|
|
|
/* Get current module clock frequency */
|
|
initConfig.clockRate = get_uart_clock_freq(uart);
|
|
|
|
UART_Init(uart, &initConfig);
|
|
|
|
/* Set UART build-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(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(struct device *dev, unsigned char *c)
|
|
{
|
|
UART_Type *uart = UART_STRUCT(dev);
|
|
|
|
while (!UART_GetStatusFlag(uart, uartStatusRxDataReady))
|
|
;
|
|
*c = UART_Getchar(uart);
|
|
|
|
if (UART_GetStatusFlag(uart, uartStatusRxOverrun)) {
|
|
UART_ClearStatusFlag(uart, uartStatusRxOverrun);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
|
|
static int uart_imx_fifo_fill(struct device *dev, const u8_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(struct device *dev, u8_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(struct device *dev)
|
|
{
|
|
UART_Type *uart = UART_STRUCT(dev);
|
|
|
|
UART_SetIntCmd(uart, uartIntTxReady, true);
|
|
}
|
|
|
|
static void uart_imx_irq_tx_disable(struct device *dev)
|
|
{
|
|
UART_Type *uart = UART_STRUCT(dev);
|
|
|
|
UART_SetIntCmd(uart, uartIntTxReady, false);
|
|
}
|
|
|
|
static int uart_imx_irq_tx_ready(struct device *dev)
|
|
{
|
|
UART_Type *uart = UART_STRUCT(dev);
|
|
|
|
return UART_GetStatusFlag(uart, uartStatusTxReady);
|
|
}
|
|
|
|
static void uart_imx_irq_rx_enable(struct device *dev)
|
|
{
|
|
UART_Type *uart = UART_STRUCT(dev);
|
|
|
|
UART_SetIntCmd(uart, uartIntRxReady, true);
|
|
}
|
|
|
|
static void uart_imx_irq_rx_disable(struct device *dev)
|
|
{
|
|
UART_Type *uart = UART_STRUCT(dev);
|
|
|
|
UART_SetIntCmd(uart, uartIntRxReady, false);
|
|
}
|
|
|
|
static int uart_imx_irq_rx_ready(struct device *dev)
|
|
{
|
|
UART_Type *uart = UART_STRUCT(dev);
|
|
|
|
return UART_GetStatusFlag(uart, uartStatusRxReady);
|
|
}
|
|
|
|
static void uart_imx_irq_err_enable(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(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(struct device *dev)
|
|
{
|
|
UART_Type *uart = UART_STRUCT(dev);
|
|
|
|
return UART_GetStatusFlag(uart, uartStatusRxReady) ||
|
|
UART_GetStatusFlag(uart, uartStatusTxReady);
|
|
}
|
|
|
|
static int uart_imx_irq_update(struct device *dev)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
static void uart_imx_irq_callback_set(struct device *dev,
|
|
uart_irq_callback_user_data_t cb,
|
|
void *cb_data)
|
|
{
|
|
struct imx_uart_data *data = dev->driver_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.
|
|
*
|
|
* @return N/A
|
|
*/
|
|
void uart_imx_isr(void *arg)
|
|
{
|
|
struct device *dev = arg;
|
|
struct imx_uart_data *data = dev->driver_data;
|
|
|
|
if (data->callback) {
|
|
data->callback(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 */
|
|
|
|
};
|
|
|
|
|
|
#ifdef CONFIG_UART_IMX_UART_1
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_1(struct device *port);
|
|
#endif
|
|
|
|
static const struct imx_uart_config imx_uart_1_config = {
|
|
.base = (UART_Type *) DT_UART_IMX_UART_1_BASE_ADDRESS,
|
|
.baud_rate = DT_UART_IMX_UART_1_BAUD_RATE,
|
|
.modem_mode = DT_UART_IMX_UART_1_MODEM_MODE,
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
.irq_config_func = irq_config_func_1,
|
|
#endif
|
|
};
|
|
|
|
static struct imx_uart_data imx_uart_1_data;
|
|
|
|
DEVICE_AND_API_INIT(uart_1, DT_UART_IMX_UART_1_NAME, &uart_imx_init,
|
|
&imx_uart_1_data, &imx_uart_1_config,
|
|
PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
|
|
&uart_imx_driver_api);
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_1(struct device *dev)
|
|
{
|
|
IRQ_CONNECT(DT_UART_IMX_UART_1_IRQ_NUM,
|
|
DT_UART_IMX_UART_1_IRQ_PRI,
|
|
uart_imx_isr, DEVICE_GET(uart_1),
|
|
0);
|
|
irq_enable(DT_UART_IMX_UART_1_IRQ_NUM);
|
|
}
|
|
#endif
|
|
|
|
#endif /* CONFIG_UART_IMX_UART_1 */
|
|
|
|
|
|
#ifdef CONFIG_UART_IMX_UART_2
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_2(struct device *port);
|
|
#endif
|
|
|
|
static const struct imx_uart_config imx_uart_2_config = {
|
|
.base = (UART_Type *) DT_UART_IMX_UART_2_BASE_ADDRESS,
|
|
.baud_rate = DT_UART_IMX_UART_2_BAUD_RATE,
|
|
.modem_mode = DT_UART_IMX_UART_2_MODEM_MODE,
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
.irq_config_func = irq_config_func_2,
|
|
#endif
|
|
};
|
|
|
|
static struct imx_uart_data imx_uart_2_data;
|
|
|
|
DEVICE_AND_API_INIT(uart_2, DT_UART_IMX_UART_2_NAME, &uart_imx_init,
|
|
&imx_uart_2_data, &imx_uart_2_config,
|
|
PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
|
|
&uart_imx_driver_api);
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_2(struct device *dev)
|
|
{
|
|
IRQ_CONNECT(DT_UART_IMX_UART_2_IRQ_NUM,
|
|
DT_UART_IMX_UART_2_IRQ_PRI,
|
|
uart_imx_isr, DEVICE_GET(uart_2),
|
|
0);
|
|
irq_enable(DT_UART_IMX_UART_2_IRQ_NUM);
|
|
}
|
|
#endif
|
|
|
|
#endif /* CONFIG_UART_IMX_UART_2 */
|
|
|
|
#ifdef CONFIG_UART_IMX_UART_3
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_3(struct device *port);
|
|
#endif
|
|
|
|
static const struct imx_uart_config imx_uart_3_config = {
|
|
.base = (UART_Type *) DT_UART_IMX_UART_3_BASE_ADDRESS,
|
|
.baud_rate = DT_UART_IMX_UART_3_BAUD_RATE,
|
|
.modem_mode = DT_UART_IMX_UART_3_MODEM_MODE,
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
.irq_config_func = irq_config_func_3,
|
|
#endif
|
|
};
|
|
|
|
static struct imx_uart_data imx_uart_3_data;
|
|
|
|
DEVICE_AND_API_INIT(uart_3, DT_UART_IMX_UART_3_NAME, &uart_imx_init,
|
|
&imx_uart_3_data, &imx_uart_3_config,
|
|
PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
|
|
&uart_imx_driver_api);
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_3(struct device *dev)
|
|
{
|
|
IRQ_CONNECT(DT_UART_IMX_UART_3_IRQ_NUM,
|
|
DT_UART_IMX_UART_3_IRQ_PRI,
|
|
uart_imx_isr, DEVICE_GET(uart_3),
|
|
0);
|
|
irq_enable(DT_UART_IMX_UART_3_IRQ_NUM);
|
|
}
|
|
#endif
|
|
|
|
#endif /* CONFIG_UART_IMX_UART_3 */
|
|
|
|
#ifdef CONFIG_UART_IMX_UART_4
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_4(struct device *port);
|
|
#endif
|
|
|
|
static const struct imx_uart_config imx_uart_4_config = {
|
|
.base = (UART_Type *) DT_UART_IMX_UART_4_BASE_ADDRESS,
|
|
.baud_rate = DT_UART_IMX_UART_4_BAUD_RATE,
|
|
.modem_mode = DT_UART_IMX_UART_4_MODEM_MODE,
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
.irq_config_func = irq_config_func_4,
|
|
#endif
|
|
};
|
|
|
|
static struct imx_uart_data imx_uart_4_data;
|
|
|
|
DEVICE_AND_API_INIT(uart_4, DT_UART_IMX_UART_4_NAME, &uart_imx_init,
|
|
&imx_uart_4_data, &imx_uart_4_config,
|
|
PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
|
|
&uart_imx_driver_api);
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_4(struct device *dev)
|
|
{
|
|
IRQ_CONNECT(DT_UART_IMX_UART_4_IRQ_NUM,
|
|
DT_UART_IMX_UART_4_IRQ_PRI,
|
|
uart_imx_isr, DEVICE_GET(uart_4),
|
|
0);
|
|
irq_enable(DT_UART_IMX_UART_4_IRQ_NUM);
|
|
}
|
|
#endif
|
|
|
|
#endif /* CONFIG_UART_IMX_UART_4 */
|
|
|
|
#ifdef CONFIG_UART_IMX_UART_5
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_5(struct device *port);
|
|
#endif
|
|
|
|
static const struct imx_uart_config imx_uart_5_config = {
|
|
.base = (UART_Type *) DT_UART_IMX_UART_5_BASE_ADDRESS,
|
|
.baud_rate = DT_UART_IMX_UART_5_BAUD_RATE,
|
|
.modem_mode = DT_UART_IMX_UART_5_MODEM_MODE,
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
.irq_config_func = irq_config_func_5,
|
|
#endif
|
|
};
|
|
|
|
static struct imx_uart_data imx_uart_5_data;
|
|
|
|
DEVICE_AND_API_INIT(uart_5, DT_UART_IMX_UART_5_NAME, &uart_imx_init,
|
|
&imx_uart_5_data, &imx_uart_5_config,
|
|
PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
|
|
&uart_imx_driver_api);
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_5(struct device *dev)
|
|
{
|
|
IRQ_CONNECT(DT_UART_IMX_UART_5_IRQ_NUM,
|
|
DT_UART_IMX_UART_5_IRQ_PRI,
|
|
uart_imx_isr, DEVICE_GET(uart_5),
|
|
0);
|
|
irq_enable(DT_UART_IMX_UART_5_IRQ_NUM);
|
|
}
|
|
#endif
|
|
|
|
#endif /* CONFIG_UART_IMX_UART_5 */
|
|
|
|
#ifdef CONFIG_UART_IMX_UART_6
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_6(struct device *port);
|
|
#endif
|
|
|
|
static const struct imx_uart_config imx_uart_6_config = {
|
|
.base = (UART_Type *) DT_UART_IMX_UART_6_BASE_ADDRESS,
|
|
.baud_rate = DT_UART_IMX_UART_6_BAUD_RATE,
|
|
.modem_mode = DT_UART_IMX_UART_6_MODEM_MODE,
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
.irq_config_func = irq_config_func_6,
|
|
#endif
|
|
};
|
|
|
|
static struct imx_uart_data imx_uart_6_data;
|
|
|
|
DEVICE_AND_API_INIT(uart_6, DT_UART_IMX_UART_6_NAME, &uart_imx_init,
|
|
&imx_uart_6_data, &imx_uart_6_config,
|
|
PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
|
|
&uart_imx_driver_api);
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_6(struct device *dev)
|
|
{
|
|
IRQ_CONNECT(DT_UART_IMX_UART_6_IRQ_NUM,
|
|
DT_UART_IMX_UART_6_IRQ_PRI,
|
|
uart_imx_isr, DEVICE_GET(uart_6),
|
|
0);
|
|
irq_enable(DT_UART_IMX_UART_6_IRQ_NUM);
|
|
}
|
|
#endif
|
|
|
|
#endif /* CONFIG_UART_IMX_UART_6 */
|
|
|
|
#ifdef CONFIG_UART_IMX_UART_7
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_7(struct device *port);
|
|
#endif
|
|
|
|
static const struct imx_uart_config imx_uart_7_config = {
|
|
.base = (UART_Type *) DT_UART_IMX_UART_7_BASE_ADDRESS,
|
|
.baud_rate = DT_UART_IMX_UART_7_BAUD_RATE,
|
|
.modem_mode = DT_UART_IMX_UART_7_MODEM_MODE,
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
.irq_config_func = irq_config_func_7,
|
|
#endif
|
|
};
|
|
|
|
static struct imx_uart_data imx_uart_7_data;
|
|
|
|
DEVICE_AND_API_INIT(uart_7, DT_UART_IMX_UART_7_NAME, &uart_imx_init,
|
|
&imx_uart_7_data, &imx_uart_7_config,
|
|
PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
|
|
&uart_imx_driver_api);
|
|
|
|
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
|
|
static void irq_config_func_7(struct device *dev)
|
|
{
|
|
IRQ_CONNECT(DT_UART_IMX_UART_7_IRQ_NUM,
|
|
DT_UART_IMX_UART_7_IRQ_PRI,
|
|
uart_imx_isr, DEVICE_GET(uart_7),
|
|
0);
|
|
irq_enable(DT_UART_IMX_UART_7_IRQ_NUM);
|
|
}
|
|
#endif
|
|
|
|
#endif /* CONFIG_UART_IMX_UART_7 */
|