patrick/zephyr
1
0
Fork 0
Code Issues Pull requests Actions 7 Packages Projects Releases Wiki Activity

drivers: serial: Rename lpc usart shim driver

Browse source 
Renames the lpc usart shim driver to more accurately reflect the
flexcomm hardware IP and to prepare for instantiating it on an SoC
outside the LPC family.

Signed-off-by: Maureen Helm <maureen.helm@nxp.com>
This commit is contained in:
Maureen Helm 2019-12-04 18:11:48 -06:00 committed by Ioannis Glaropoulos
parent 612984e09c
commit 72e0080e56
13 changed files with 94 additions and 94 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
boards/arm/lpcxpresso54114/Kconfig.defconfig
View file

@ -9,12 +9,12 @@ config BOARD
default "lpcxpresso54114_m4" if BOARD_LPCXPRESSO54114_M4
default "lpcxpresso54114_m0" if BOARD_LPCXPRESSO54114_M0
if USART_MCUX_LPC
if UART_MCUX_FLEXCOMM
config USART_MCUX_LPC_0
config UART_MCUX_FLEXCOMM_0
default y if UART_CONSOLE
endif # USART_MCUX_LPC
endif # UART_MCUX_FLEXCOMM
if PINMUX_MCUX_LPC

2
boards/arm/lpcxpresso54114/pinmux.c
View file

@ -23,7 +23,7 @@ static int lpcxpresso_54114_pinmux_init(struct device *dev)
device_get_binding(CONFIG_PINMUX_MCUX_LPC_PORT1_NAME);
#endif
#ifdef CONFIG_USART_MCUX_LPC_0
#ifdef CONFIG_UART_MCUX_FLEXCOMM_0
/* USART0 RX, TX */
const u32_t port0_pin0_config = (
IOCON_PIO_FUNC1 |

6
boards/arm/lpcxpresso55s69/Kconfig.defconfig
View file

@ -9,12 +9,12 @@ config BOARD
default "lpcxpresso55S69_cpu0" if BOARD_LPCXPRESSO55S69_CPU0
default "lpcxpresso55S69_cpu1" if BOARD_LPCXPRESSO55S69_CPU1
if USART_MCUX_LPC
if UART_MCUX_FLEXCOMM
config USART_MCUX_LPC_0
config UART_MCUX_FLEXCOMM_0
default y if UART_CONSOLE
endif # USART_MCUX_LPC
endif # UART_MCUX_FLEXCOMM
if PINMUX_MCUX_LPC

2
boards/arm/lpcxpresso55s69/pinmux.c
View file

@ -23,7 +23,7 @@ static int lpcxpresso_55s69_pinmux_init(struct device *dev)
device_get_binding(CONFIG_PINMUX_MCUX_LPC_PORT1_NAME);
#endif
#ifdef CONFIG_USART_MCUX_LPC_0
#ifdef CONFIG_UART_MCUX_FLEXCOMM_0
/* USART0 RX, TX */
const u32_t port0_pin29_config = (
IOCON_PIO_FUNC1 |

2
drivers/serial/CMakeLists.txt
View file

@ -11,6 +11,7 @@ zephyr_library_sources_if_kconfig(uart_sifive.c)
zephyr_library_sources_if_kconfig(uart_gecko.c)
zephyr_library_sources_if_kconfig(leuart_gecko.c)
zephyr_library_sources_if_kconfig(uart_mcux.c)
zephyr_library_sources_if_kconfig(uart_mcux_flexcomm.c)
zephyr_library_sources_if_kconfig(uart_mcux_lpuart.c)
zephyr_library_sources_if_kconfig(uart_mcux_lpsci.c)
zephyr_library_sources_if_kconfig(uart_miv.c)
@ -23,7 +24,6 @@ zephyr_library_sources_if_kconfig(usart_sam.c)
zephyr_library_sources_if_kconfig(uart_stellaris.c)
zephyr_library_sources_if_kconfig(uart_stm32.c)
zephyr_library_sources_if_kconfig(uart_sam0.c)
zephyr_library_sources_if_kconfig(usart_mcux_lpc.c)
zephyr_library_sources_if_kconfig(uart_psoc6.c)
zephyr_library_sources_if_kconfig(uart_pl011.c)
zephyr_library_sources_if_kconfig(uart_rv32m1_lpuart.c)

2
drivers/serial/Kconfig
View file

@ -68,7 +68,7 @@ source "drivers/serial/Kconfig.ns16550"
source "drivers/serial/Kconfig.mcux"
source "drivers/serial/Kconfig.mcux_lpc_usart"
source "drivers/serial/Kconfig.mcux_flexcomm"
source "drivers/serial/Kconfig.mcux_lpsci"

12
drivers/serial/Kconfig.mcux_lpc_usart → drivers/serial/Kconfig.mcux_flexcomm
View file

@ -3,19 +3,19 @@
# Copyright 2017, NXP
# SPDX-License-Identifier: Apache-2.0
menuconfig USART_MCUX_LPC
bool "MCUX USART driver"
depends on HAS_MCUX
menuconfig UART_MCUX_FLEXCOMM
bool "MCUX FLEXCOMM UART driver"
depends on HAS_MCUX_FLEXCOMM
select SERIAL_HAS_DRIVER
select SERIAL_SUPPORT_INTERRUPT
help
Enable the MCUX USART driver.
if USART_MCUX_LPC
if UART_MCUX_FLEXCOMM
config USART_MCUX_LPC_0
config UART_MCUX_FLEXCOMM_0
bool "USART 0"
help
Enable USART 0.
endif # USART_MCUX_LPC
endif # UART_MCUX_FLEXCOMM

146
drivers/serial/usart_mcux_lpc.c → drivers/serial/uart_mcux_flexcomm.c
View file

@ -20,7 +20,7 @@
#include <soc.h>
#include <fsl_device_registers.h>
struct usart_mcux_lpc_config {
struct mcux_flexcomm_config {
USART_Type *base;
u32_t clock_source;
u32_t baud_rate;
@ -29,16 +29,16 @@ struct usart_mcux_lpc_config {
#endif
};
struct usart_mcux_lpc_data {
struct mcux_flexcomm_data {
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
uart_irq_callback_user_data_t callback;
void *cb_data;
#endif
};
static int usart_mcux_lpc_poll_in(struct device *dev, unsigned char *c)
static int mcux_flexcomm_poll_in(struct device *dev, unsigned char *c)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u32_t flags = USART_GetStatusFlags(config->base);
int ret = -1;
@ -50,10 +50,10 @@ static int usart_mcux_lpc_poll_in(struct device *dev, unsigned char *c)
return ret;
}
static void usart_mcux_lpc_poll_out(struct device *dev,
static void mcux_flexcomm_poll_out(struct device *dev,
unsigned char c)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
/* Wait until space is available in TX FIFO */
while (!(USART_GetStatusFlags(config->base) & kUSART_TxFifoEmptyFlag)) {
@ -62,9 +62,9 @@ static void usart_mcux_lpc_poll_out(struct device *dev,
USART_WriteByte(config->base, c);
}
static int usart_mcux_lpc_err_check(struct device *dev)
static int mcux_flexcomm_err_check(struct device *dev)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u32_t flags = USART_GetStatusFlags(config->base);
int err = 0;
@ -89,10 +89,10 @@ static int usart_mcux_lpc_err_check(struct device *dev)
}
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
static int usart_mcux_lpc_fifo_fill(struct device *dev, const u8_t *tx_data,
static int mcux_flexcomm_fifo_fill(struct device *dev, const u8_t *tx_data,
int len)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u8_t num_tx = 0U;
while ((len - num_tx > 0) &&
@ -105,10 +105,10 @@ static int usart_mcux_lpc_fifo_fill(struct device *dev, const u8_t *tx_data,
return num_tx;
}
static int usart_mcux_lpc_fifo_read(struct device *dev, u8_t *rx_data,
static int mcux_flexcomm_fifo_read(struct device *dev, u8_t *rx_data,
const int len)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u8_t num_rx = 0U;
while ((len - num_rx > 0) &&
@ -121,75 +121,75 @@ static int usart_mcux_lpc_fifo_read(struct device *dev, u8_t *rx_data,
return num_rx;
}
static void usart_mcux_lpc_irq_tx_enable(struct device *dev)
static void mcux_flexcomm_irq_tx_enable(struct device *dev)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u32_t mask = kUSART_TxLevelInterruptEnable;
USART_EnableInterrupts(config->base, mask);
}
static void usart_mcux_lpc_irq_tx_disable(struct device *dev)
static void mcux_flexcomm_irq_tx_disable(struct device *dev)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u32_t mask = kUSART_TxLevelInterruptEnable;
USART_DisableInterrupts(config->base, mask);
}
static int usart_mcux_lpc_irq_tx_complete(struct device *dev)
static int mcux_flexcomm_irq_tx_complete(struct device *dev)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u32_t flags = USART_GetStatusFlags(config->base);
return (flags & kUSART_TxFifoEmptyFlag) != 0U;
}
static int usart_mcux_lpc_irq_tx_ready(struct device *dev)
static int mcux_flexcomm_irq_tx_ready(struct device *dev)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u32_t mask = kUSART_TxLevelInterruptEnable;
return (USART_GetEnabledInterrupts(config->base) & mask)
&& usart_mcux_lpc_irq_tx_complete(dev);
&& mcux_flexcomm_irq_tx_complete(dev);
}
static void usart_mcux_lpc_irq_rx_enable(struct device *dev)
static void mcux_flexcomm_irq_rx_enable(struct device *dev)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u32_t mask = kUSART_RxLevelInterruptEnable;
USART_EnableInterrupts(config->base, mask);
}
static void usart_mcux_lpc_irq_rx_disable(struct device *dev)
static void mcux_flexcomm_irq_rx_disable(struct device *dev)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u32_t mask = kUSART_RxLevelInterruptEnable;
USART_DisableInterrupts(config->base, mask);
}
static int usart_mcux_lpc_irq_rx_full(struct device *dev)
static int mcux_flexcomm_irq_rx_full(struct device *dev)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u32_t flags = USART_GetStatusFlags(config->base);
return (flags & kUSART_RxFifoNotEmptyFlag) != 0U;
}
static int usart_mcux_lpc_irq_rx_ready(struct device *dev)
static int mcux_flexcomm_irq_rx_ready(struct device *dev)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u32_t mask = kUSART_RxLevelInterruptEnable;
return (USART_GetEnabledInterrupts(config->base) & mask)
&& usart_mcux_lpc_irq_rx_full(dev);
&& mcux_flexcomm_irq_rx_full(dev);
}
static void usart_mcux_lpc_irq_err_enable(struct device *dev)
static void mcux_flexcomm_irq_err_enable(struct device *dev)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u32_t mask = kStatus_USART_NoiseError |
kStatus_USART_FramingError |
kStatus_USART_ParityError;
@ -197,9 +197,9 @@ static void usart_mcux_lpc_irq_err_enable(struct device *dev)
USART_EnableInterrupts(config->base, mask);
}
static void usart_mcux_lpc_irq_err_disable(struct device *dev)
static void mcux_flexcomm_irq_err_disable(struct device *dev)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
u32_t mask = kStatus_USART_NoiseError |
kStatus_USART_FramingError |
kStatus_USART_ParityError;
@ -207,31 +207,31 @@ static void usart_mcux_lpc_irq_err_disable(struct device *dev)
USART_DisableInterrupts(config->base, mask);
}
static int usart_mcux_lpc_irq_is_pending(struct device *dev)
static int mcux_flexcomm_irq_is_pending(struct device *dev)
{
return (usart_mcux_lpc_irq_tx_ready(dev)
|| usart_mcux_lpc_irq_rx_ready(dev));
return (mcux_flexcomm_irq_tx_ready(dev)
|| mcux_flexcomm_irq_rx_ready(dev));
}
static int usart_mcux_lpc_irq_update(struct device *dev)
static int mcux_flexcomm_irq_update(struct device *dev)
{
return 1;
}
static void usart_mcux_lpc_irq_callback_set(struct device *dev,
static void mcux_flexcomm_irq_callback_set(struct device *dev,
uart_irq_callback_user_data_t cb,
void *cb_data)
{
struct usart_mcux_lpc_data *data = dev->driver_data;
struct mcux_flexcomm_data *data = dev->driver_data;
data->callback = cb;
data->cb_data = cb_data;
}
static void usart_mcux_lpc_isr(void *arg)
static void mcux_flexcomm_isr(void *arg)
{
struct device *dev = arg;
struct usart_mcux_lpc_data *data = dev->driver_data;
struct mcux_flexcomm_data *data = dev->driver_data;
if (data->callback) {
data->callback(data->cb_data);
@ -240,9 +240,9 @@ static void usart_mcux_lpc_isr(void *arg)
#endif /* CONFIG_UART_INTERRUPT_DRIVEN */
static int usart_mcux_lpc_init(struct device *dev)
static int mcux_flexcomm_init(struct device *dev)
{
const struct usart_mcux_lpc_config *config = dev->config->config_info;
const struct mcux_flexcomm_config *config = dev->config->config_info;
usart_config_t usart_config;
u32_t clock_freq;
@ -262,59 +262,59 @@ static int usart_mcux_lpc_init(struct device *dev)
return 0;
}
static const struct uart_driver_api usart_mcux_lpc_driver_api = {
.poll_in = usart_mcux_lpc_poll_in,
.poll_out = usart_mcux_lpc_poll_out,
.err_check = usart_mcux_lpc_err_check,
static const struct uart_driver_api mcux_flexcomm_driver_api = {
.poll_in = mcux_flexcomm_poll_in,
.poll_out = mcux_flexcomm_poll_out,
.err_check = mcux_flexcomm_err_check,
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
.fifo_fill = usart_mcux_lpc_fifo_fill,
.fifo_read = usart_mcux_lpc_fifo_read,
.irq_tx_enable = usart_mcux_lpc_irq_tx_enable,
.irq_tx_disable = usart_mcux_lpc_irq_tx_disable,
.irq_tx_complete = usart_mcux_lpc_irq_tx_complete,
.irq_tx_ready = usart_mcux_lpc_irq_tx_ready,
.irq_rx_enable = usart_mcux_lpc_irq_rx_enable,
.irq_rx_disable = usart_mcux_lpc_irq_rx_disable,
.irq_rx_ready = usart_mcux_lpc_irq_rx_ready,
.irq_err_enable = usart_mcux_lpc_irq_err_enable,
.irq_err_disable = usart_mcux_lpc_irq_err_disable,
.irq_is_pending = usart_mcux_lpc_irq_is_pending,
.irq_update = usart_mcux_lpc_irq_update,
.irq_callback_set = usart_mcux_lpc_irq_callback_set,
.fifo_fill = mcux_flexcomm_fifo_fill,
.fifo_read = mcux_flexcomm_fifo_read,
.irq_tx_enable = mcux_flexcomm_irq_tx_enable,
.irq_tx_disable = mcux_flexcomm_irq_tx_disable,
.irq_tx_complete = mcux_flexcomm_irq_tx_complete,
.irq_tx_ready = mcux_flexcomm_irq_tx_ready,
.irq_rx_enable = mcux_flexcomm_irq_rx_enable,
.irq_rx_disable = mcux_flexcomm_irq_rx_disable,
.irq_rx_ready = mcux_flexcomm_irq_rx_ready,
.irq_err_enable = mcux_flexcomm_irq_err_enable,
.irq_err_disable = mcux_flexcomm_irq_err_disable,
.irq_is_pending = mcux_flexcomm_irq_is_pending,
.irq_update = mcux_flexcomm_irq_update,
.irq_callback_set = mcux_flexcomm_irq_callback_set,
#endif
};
#ifdef CONFIG_USART_MCUX_LPC_0
#ifdef CONFIG_UART_MCUX_FLEXCOMM_0
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
static void usart_mcux_lpc_config_func_0(struct device *dev);
static void mcux_flexcomm_config_func_0(struct device *dev);
#endif
static const struct usart_mcux_lpc_config usart_mcux_lpc_0_config = {
static const struct mcux_flexcomm_config mcux_flexcomm_0_config = {
.base = (USART_Type *)DT_USART_MCUX_LPC_0_BASE_ADDRESS,
.clock_source = 0,
.baud_rate = DT_USART_MCUX_LPC_0_BAUD_RATE,
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
.irq_config_func = usart_mcux_lpc_config_func_0,
.irq_config_func = mcux_flexcomm_config_func_0,
#endif
};
static struct usart_mcux_lpc_data usart_mcux_lpc_0_data;
static struct mcux_flexcomm_data mcux_flexcomm_0_data;
DEVICE_AND_API_INIT(usart_0, DT_USART_MCUX_LPC_0_NAME,
&usart_mcux_lpc_init,
&usart_mcux_lpc_0_data, &usart_mcux_lpc_0_config,
&mcux_flexcomm_init,
&mcux_flexcomm_0_data, &mcux_flexcomm_0_config,
PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
&usart_mcux_lpc_driver_api);
&mcux_flexcomm_driver_api);
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
static void usart_mcux_lpc_config_func_0(struct device *dev)
static void mcux_flexcomm_config_func_0(struct device *dev)
{
IRQ_CONNECT(DT_USART_MCUX_LPC_0_IRQ,
DT_USART_MCUX_LPC_0_IRQ_PRI,
usart_mcux_lpc_isr, DEVICE_GET(usart_0), 0);
mcux_flexcomm_isr, DEVICE_GET(usart_0), 0);
irq_enable(DT_USART_MCUX_LPC_0_IRQ);
}
#endif
#endif /* CONFIG_USART_MCUX_LPC_0 */
#endif /* CONFIG_UART_MCUX_FLEXCOMM_0 */

2
soc/arm/nxp_lpc/lpc54xxx/Kconfig.defconfig.lpc54114_m0
View file

@ -27,7 +27,7 @@ endif # GPIO
if SERIAL
config USART_MCUX_LPC
config UART_MCUX_FLEXCOMM
default n
endif # SERIAL

2
soc/arm/nxp_lpc/lpc54xxx/Kconfig.defconfig.lpc54114_m4
View file

@ -24,7 +24,7 @@ endif # GPIO
if SERIAL
config USART_MCUX_LPC
config UART_MCUX_FLEXCOMM
default y
endif # SERIAL

2
soc/arm/nxp_lpc/lpc55xxx/Kconfig.defconfig.lpc55S69_cpu0
View file

@ -24,7 +24,7 @@ endif # GPIO
if SERIAL
config USART_MCUX_LPC
config UART_MCUX_FLEXCOMM
default y
endif # SERIAL

2
soc/arm/nxp_lpc/lpc55xxx/Kconfig.defconfig.lpc55S69_cpu1
View file

@ -27,7 +27,7 @@ endif # GPIO
if SERIAL
config USART_MCUX_LPC
config UART_MCUX_FLEXCOMM
default n
endif # SERIAL

2
west.yml
View file

@ -83,7 +83,7 @@ manifest:
revision: 00dd4fab1a00f2f6e995ef3f2e7c3814689f8885
path: modules/fs/nffs
- name: hal_nxp
revision: c6ce9b7e8ddb501ca6d54e927e1602cb5f7a7183
revision: ef000ff5d902c938e3d4763155b0511b043017c8
path: modules/hal/nxp
- name: open-amp
revision: 9b591b289e1f37339bd038b5a1f0e6c8ad39c63a