michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers: serial: drop get_dev_data/get_dev_config usage

Browse source 
Replace all get_dev_data()/get_dev_config() accessor utilities with
dev->data and dev->config.

Signed-off-by: Gerard Marull-Paretas <gerard.marull@nordicsemi.no>
This commit is contained in:
Gerard Marull-Paretas 2022-01-19 16:16:23 +01:00 • committed by Carles Cufí
commit a6614968a8
4 changed files with 181 additions and 163 deletions
Download patch file Download diff file Expand all files Collapse all files

160
drivers/serial/uart_cc13xx_cc26xx.c
View file

@ -38,24 +38,16 @@ struct uart_cc13xx_cc26xx_data {
#endif #endif
}; };
static inline struct uart_cc13xx_cc26xx_data *get_dev_data(const struct device *dev)
{
return dev->data;
}
static inline const struct uart_device_config *get_dev_conf(const struct device *dev)
{
return dev->config;
}
static int uart_cc13xx_cc26xx_poll_in(const struct device *dev, static int uart_cc13xx_cc26xx_poll_in(const struct device *dev,
unsigned char *c) unsigned char *c)
{ {
if (!UARTCharsAvail(get_dev_conf(dev)->regs)) { const struct uart_device_config *config = dev->config;
if (!UARTCharsAvail(config->regs)) {
return -1; return -1;
} }
*c = UARTCharGetNonBlocking(get_dev_conf(dev)->regs); *c = UARTCharGetNonBlocking(config->regs);
return 0; return 0;
} }
@ -63,25 +55,29 @@ static int uart_cc13xx_cc26xx_poll_in(const struct device *dev,
static void uart_cc13xx_cc26xx_poll_out(const struct device *dev, static void uart_cc13xx_cc26xx_poll_out(const struct device *dev,
unsigned char c) unsigned char c)
{ {
UARTCharPut(get_dev_conf(dev)->regs, c); const struct uart_device_config *config = dev->config;
UARTCharPut(config->regs, c);
/* /*
* Need to wait for character to be transmitted to ensure cpu does not * Need to wait for character to be transmitted to ensure cpu does not
* enter standby when uart is busy * enter standby when uart is busy
*/ */
while (UARTBusy(get_dev_conf(dev)->regs) == true) { while (UARTBusy(config->regs) == true) {
} }
} }
static int uart_cc13xx_cc26xx_err_check(const struct device *dev) static int uart_cc13xx_cc26xx_err_check(const struct device *dev)
{ {
uint32_t flags = UARTRxErrorGet(get_dev_conf(dev)->regs); const struct uart_device_config *config = dev->config;
uint32_t flags = UARTRxErrorGet(config->regs);
int error = (flags & UART_RXERROR_FRAMING ? UART_ERROR_FRAMING : 0) | int error = (flags & UART_RXERROR_FRAMING ? UART_ERROR_FRAMING : 0) |
(flags & UART_RXERROR_PARITY ? UART_ERROR_PARITY : 0) | (flags & UART_RXERROR_PARITY ? UART_ERROR_PARITY : 0) |
(flags & UART_RXERROR_BREAK ? UART_BREAK : 0) | (flags & UART_RXERROR_BREAK ? UART_BREAK : 0) |
(flags & UART_RXERROR_OVERRUN ? UART_ERROR_OVERRUN : 0); (flags & UART_RXERROR_OVERRUN ? UART_ERROR_OVERRUN : 0);
UARTRxErrorClear(get_dev_conf(dev)->regs); UARTRxErrorClear(config->regs);
return error; return error;
} }
@ -89,6 +85,8 @@ static int uart_cc13xx_cc26xx_err_check(const struct device *dev)
static int uart_cc13xx_cc26xx_configure(const struct device *dev, static int uart_cc13xx_cc26xx_configure(const struct device *dev,
const struct uart_config *cfg) const struct uart_config *cfg)
{ {
const struct uart_device_config *config = dev->config;
struct uart_cc13xx_cc26xx_data *data = dev->data;
uint32_t line_ctrl = 0; uint32_t line_ctrl = 0;
bool flow_ctrl; bool flow_ctrl;
@ -157,29 +155,29 @@ static int uart_cc13xx_cc26xx_configure(const struct device *dev,
} }
/* Disables UART before setting control registers */ /* Disables UART before setting control registers */
UARTConfigSetExpClk(get_dev_conf(dev)->regs, UARTConfigSetExpClk(config->regs,
get_dev_conf(dev)->sys_clk_freq, cfg->baudrate, config->sys_clk_freq, cfg->baudrate,
line_ctrl); line_ctrl);
/* Clear all UART interrupts */ /* Clear all UART interrupts */
UARTIntClear(get_dev_conf(dev)->regs, UARTIntClear(config->regs,
UART_INT_OE | UART_INT_BE | UART_INT_PE | UART_INT_OE | UART_INT_BE | UART_INT_PE |
UART_INT_FE | UART_INT_RT | UART_INT_TX | UART_INT_FE | UART_INT_RT | UART_INT_TX |
UART_INT_RX | UART_INT_CTS); UART_INT_RX | UART_INT_CTS);
if (flow_ctrl) { if (flow_ctrl) {
UARTHwFlowControlEnable(get_dev_conf(dev)->regs); UARTHwFlowControlEnable(config->regs);
} else { } else {
UARTHwFlowControlDisable(get_dev_conf(dev)->regs); UARTHwFlowControlDisable(config->regs);
} }
/* Re-enable UART */ /* Re-enable UART */
UARTEnable(get_dev_conf(dev)->regs); UARTEnable(config->regs);
/* Disabled FIFOs act as 1-byte-deep holding registers (character mode) */ /* Disabled FIFOs act as 1-byte-deep holding registers (character mode) */
UARTFIFODisable(get_dev_conf(dev)->regs); UARTFIFODisable(config->regs);
get_dev_data(dev)->uart_config = *cfg; data->uart_config = *cfg;
return 0; return 0;
} }
@ -188,7 +186,9 @@ static int uart_cc13xx_cc26xx_configure(const struct device *dev,
static int uart_cc13xx_cc26xx_config_get(const struct device *dev, static int uart_cc13xx_cc26xx_config_get(const struct device *dev,
struct uart_config *cfg) struct uart_config *cfg)
{ {
*cfg = get_dev_data(dev)->uart_config; struct uart_cc13xx_cc26xx_data *data = dev->data;
*cfg = data->uart_config;
return 0; return 0;
} }
#endif /* CONFIG_UART_USE_RUNTIME_CONFIGURE */ #endif /* CONFIG_UART_USE_RUNTIME_CONFIGURE */
@ -199,10 +199,11 @@ static int uart_cc13xx_cc26xx_fifo_fill(const struct device *dev,
const uint8_t *buf, const uint8_t *buf,
int len) int len)
{ {
const struct uart_device_config *config = dev->config;
int n = 0; int n = 0;
while (n < len) { while (n < len) {
if (!UARTCharPutNonBlocking(get_dev_conf(dev)->regs, buf[n])) { if (!UARTCharPutNonBlocking(config->regs, buf[n])) {
break; break;
} }
n++; n++;
@ -215,11 +216,12 @@ static int uart_cc13xx_cc26xx_fifo_read(const struct device *dev,
uint8_t *buf, uint8_t *buf,
const int len) const int len)
{ {
const struct uart_device_config *config = dev->config;
int c, n; int c, n;
n = 0; n = 0;
while (n < len) { while (n < len) {
c = UARTCharGetNonBlocking(get_dev_conf(dev)->regs); c = UARTCharGetNonBlocking(config->regs);
if (c == -1) { if (c == -1) {
break; break;
} }
@ -231,8 +233,12 @@ static int uart_cc13xx_cc26xx_fifo_read(const struct device *dev,
static void uart_cc13xx_cc26xx_irq_tx_enable(const struct device *dev) static void uart_cc13xx_cc26xx_irq_tx_enable(const struct device *dev)
{ {
const struct uart_device_config *config = dev->config;
#ifdef CONFIG_PM #ifdef CONFIG_PM
if (!get_dev_data(dev)->tx_constrained) { struct uart_cc13xx_cc26xx_data *data = dev->data;
if (!data->tx_constrained) {
/* /*
* When tx irq is enabled, it is implicit that we are expecting * When tx irq is enabled, it is implicit that we are expecting
* to transmit using the uart, hence we should no longer go * to transmit using the uart, hence we should no longer go
@ -244,86 +250,109 @@ static void uart_cc13xx_cc26xx_irq_tx_enable(const struct device *dev)
* would interfere with a transfer. * would interfere with a transfer.
*/ */
pm_constraint_set(PM_STATE_STANDBY); pm_constraint_set(PM_STATE_STANDBY);
get_dev_data(dev)->tx_constrained = true; data->tx_constrained = true;
} }
#endif #endif
UARTIntEnable(get_dev_conf(dev)->regs, UART_INT_TX); UARTIntEnable(config->regs, UART_INT_TX);
} }
static void uart_cc13xx_cc26xx_irq_tx_disable(const struct device *dev) static void uart_cc13xx_cc26xx_irq_tx_disable(const struct device *dev)
{ {
UARTIntDisable(get_dev_conf(dev)->regs, UART_INT_TX); const struct uart_device_config *config = dev->config;
UARTIntDisable(config->regs, UART_INT_TX);
#ifdef CONFIG_PM #ifdef CONFIG_PM
if (get_dev_data(dev)->tx_constrained) { struct uart_cc13xx_cc26xx_data *data = dev->data;
if (data->tx_constrained) {
pm_constraint_release(PM_STATE_STANDBY); pm_constraint_release(PM_STATE_STANDBY);
get_dev_data(dev)->tx_constrained = false; data->tx_constrained = false;
} }
#endif #endif
} }
static int uart_cc13xx_cc26xx_irq_tx_ready(const struct device *dev) static int uart_cc13xx_cc26xx_irq_tx_ready(const struct device *dev)
{ {
return UARTSpaceAvail(get_dev_conf(dev)->regs) ? 1 : 0; const struct uart_device_config *config = dev->config;
return UARTSpaceAvail(config->regs) ? 1 : 0;
} }
static void uart_cc13xx_cc26xx_irq_rx_enable(const struct device *dev) static void uart_cc13xx_cc26xx_irq_rx_enable(const struct device *dev)
{ {
const struct uart_device_config *config = dev->config;
#ifdef CONFIG_PM #ifdef CONFIG_PM
struct uart_cc13xx_cc26xx_data *data = dev->data;
/* /*
* When rx is enabled, it is implicit that we are expecting * When rx is enabled, it is implicit that we are expecting
* to receive from the uart, hence we can no longer go into * to receive from the uart, hence we can no longer go into
* standby. * standby.
*/ */
if (!get_dev_data(dev)->rx_constrained) { if (!data->rx_constrained) {
pm_constraint_set(PM_STATE_STANDBY); pm_constraint_set(PM_STATE_STANDBY);
get_dev_data(dev)->rx_constrained = true; data->rx_constrained = true;
} }
#endif #endif
UARTIntEnable(get_dev_conf(dev)->regs, UART_INT_RX); UARTIntEnable(config->regs, UART_INT_RX);
} }
static void uart_cc13xx_cc26xx_irq_rx_disable(const struct device *dev) static void uart_cc13xx_cc26xx_irq_rx_disable(const struct device *dev)
{ {
const struct uart_device_config *config = dev->config;
#ifdef CONFIG_PM #ifdef CONFIG_PM
if (get_dev_data(dev)->rx_constrained) { struct uart_cc13xx_cc26xx_data *data = dev->data;
if (data->rx_constrained) {
pm_constraint_release(PM_STATE_STANDBY); pm_constraint_release(PM_STATE_STANDBY);
get_dev_data(dev)->rx_constrained = false; data->rx_constrained = false;
} }
#endif #endif
UARTIntDisable(get_dev_conf(dev)->regs, UART_INT_RX); UARTIntDisable(config->regs, UART_INT_RX);
} }
static int uart_cc13xx_cc26xx_irq_tx_complete(const struct device *dev) static int uart_cc13xx_cc26xx_irq_tx_complete(const struct device *dev)
{ {
return UARTBusy(get_dev_conf(dev)->regs) ? 0 : 1; const struct uart_device_config *config = dev->config;
return UARTBusy(config->regs) ? 0 : 1;
} }
static int uart_cc13xx_cc26xx_irq_rx_ready(const struct device *dev) static int uart_cc13xx_cc26xx_irq_rx_ready(const struct device *dev)
{ {
return UARTCharsAvail(get_dev_conf(dev)->regs) ? 1 : 0; const struct uart_device_config *config = dev->config;
return UARTCharsAvail(config->regs) ? 1 : 0;
} }
static void uart_cc13xx_cc26xx_irq_err_enable(const struct device *dev) static void uart_cc13xx_cc26xx_irq_err_enable(const struct device *dev)
{ {
return UARTIntEnable(get_dev_conf(dev)->regs, const struct uart_device_config *config = dev->config;
return UARTIntEnable(config->regs,
UART_INT_OE | UART_INT_BE | UART_INT_PE | UART_INT_OE | UART_INT_BE | UART_INT_PE |
UART_INT_FE); UART_INT_FE);
} }
static void uart_cc13xx_cc26xx_irq_err_disable(const struct device *dev) static void uart_cc13xx_cc26xx_irq_err_disable(const struct device *dev)
{ {
return UARTIntDisable(get_dev_conf(dev)->regs, const struct uart_device_config *config = dev->config;
return UARTIntDisable(config->regs,
UART_INT_OE | UART_INT_BE | UART_INT_PE | UART_INT_OE | UART_INT_BE | UART_INT_PE |
UART_INT_FE); UART_INT_FE);
} }
static int uart_cc13xx_cc26xx_irq_is_pending(const struct device *dev) static int uart_cc13xx_cc26xx_irq_is_pending(const struct device *dev)
{ {
uint32_t status = UARTIntStatus(get_dev_conf(dev)->regs, true); const struct uart_device_config *config = dev->config;
uint32_t status = UARTIntStatus(config->regs, true);
return status & (UART_INT_TX | UART_INT_RX) ? 1 : 0; return status & (UART_INT_TX | UART_INT_RX) ? 1 : 0;
} }
@ -338,7 +367,7 @@ static void uart_cc13xx_cc26xx_irq_callback_set(const struct device *dev,
uart_irq_callback_user_data_t cb, uart_irq_callback_user_data_t cb,
void *user_data) void *user_data)
{ {
struct uart_cc13xx_cc26xx_data *data = get_dev_data(dev); struct uart_cc13xx_cc26xx_data *data = dev->data;
data->callback = cb; data->callback = cb;
data->user_data = user_data; data->user_data = user_data;
@ -346,7 +375,7 @@ static void uart_cc13xx_cc26xx_irq_callback_set(const struct device *dev,
static void uart_cc13xx_cc26xx_isr(const struct device *dev) static void uart_cc13xx_cc26xx_isr(const struct device *dev)
{ {
struct uart_cc13xx_cc26xx_data *data = get_dev_data(dev); struct uart_cc13xx_cc26xx_data *data = dev->data;
if (data->callback) { if (data->callback) {
data->callback(dev, data->user_data); data->callback(dev, data->user_data);
@ -368,13 +397,14 @@ static int postNotifyFxn(unsigned int eventType, uintptr_t eventArg,
uintptr_t clientArg) uintptr_t clientArg)
{ {
const struct device *dev = (const struct device *)clientArg; const struct device *dev = (const struct device *)clientArg;
const struct uart_device_config *config = dev->config;
struct uart_cc13xx_cc26xx_data *data = dev->data;
int ret = Power_NOTIFYDONE; int ret = Power_NOTIFYDONE;
int16_t res_id; int16_t res_id;
/* Reconfigure the hardware if returning from standby */ /* Reconfigure the hardware if returning from standby */
if (eventType == PowerCC26XX_AWAKE_STANDBY) { if (eventType == PowerCC26XX_AWAKE_STANDBY) {
if (get_dev_conf(dev)->regs == if (config->regs == DT_INST_REG_ADDR(0)) {
DT_INST_REG_ADDR(0)) {
res_id = PowerCC26XX_PERIPH_UART0; res_id = PowerCC26XX_PERIPH_UART0;
} else { /* DT_INST_REG_ADDR(1) */ } else { /* DT_INST_REG_ADDR(1) */
res_id = PowerCC26X2_PERIPH_UART1; res_id = PowerCC26X2_PERIPH_UART1;
@ -386,7 +416,7 @@ static int postNotifyFxn(unsigned int eventType, uintptr_t eventArg,
* actively powered down * actively powered down
*/ */
if (uart_cc13xx_cc26xx_configure(dev, if (uart_cc13xx_cc26xx_configure(dev,
&get_dev_data(dev)->uart_config) != 0) { &data->uart_config) != 0) {
ret = Power_NOTIFYERROR; ret = Power_NOTIFYERROR;
} }
} }
@ -400,27 +430,27 @@ static int postNotifyFxn(unsigned int eventType, uintptr_t eventArg,
static int uart_cc13xx_cc26xx_pm_action(const struct device *dev, static int uart_cc13xx_cc26xx_pm_action(const struct device *dev,
enum pm_device_action action) enum pm_device_action action)
{ {
const struct uart_device_config *config = dev->config;
struct uart_cc13xx_cc26xx_data *data = dev->data;
int ret = 0; int ret = 0;
switch (action) { switch (action) {
case PM_DEVICE_ACTION_RESUME: case PM_DEVICE_ACTION_RESUME:
if (get_dev_conf(dev)->regs == DT_INST_REG_ADDR(0)) { if (config->regs == DT_INST_REG_ADDR(0)) {
Power_setDependency(PowerCC26XX_PERIPH_UART0); Power_setDependency(PowerCC26XX_PERIPH_UART0);
} else { } else {
Power_setDependency(PowerCC26X2_PERIPH_UART1); Power_setDependency(PowerCC26X2_PERIPH_UART1);
} }
/* Configure and enable UART */ /* Configure and enable UART */
ret = uart_cc13xx_cc26xx_configure(dev, ret = uart_cc13xx_cc26xx_configure(dev, &data->uart_config);
&get_dev_data(dev)->uart_config);
break; break;
case PM_DEVICE_ACTION_SUSPEND: case PM_DEVICE_ACTION_SUSPEND:
UARTDisable(get_dev_conf(dev)->regs); UARTDisable(config->regs);
/* /*
* Release power dependency - i.e. potentially power * Release power dependency - i.e. potentially power
* down serial domain. * down serial domain.
*/ */
if (get_dev_conf(dev)->regs == if (config->regs == DT_INST_REG_ADDR(0)) {
DT_INST_REG_ADDR(0)) {
Power_releaseDependency(PowerCC26XX_PERIPH_UART0); Power_releaseDependency(PowerCC26XX_PERIPH_UART0);
} else { } else {
Power_releaseDependency(PowerCC26X2_PERIPH_UART1); Power_releaseDependency(PowerCC26X2_PERIPH_UART1);
@ -463,8 +493,10 @@ static const struct uart_driver_api uart_cc13xx_cc26xx_driver_api = {
#ifdef CONFIG_PM #ifdef CONFIG_PM
#define UART_CC13XX_CC26XX_POWER_UART(n) \ #define UART_CC13XX_CC26XX_POWER_UART(n) \
do { \ do { \
get_dev_data(dev)->rx_constrained = false; \ struct uart_cc13xx_cc26xx_data *data = dev->data; \
get_dev_data(dev)->tx_constrained = false; \ \
data->rx_constrained = false; \
data->tx_constrained = false; \
\ \
/* Set Power dependencies */ \ /* Set Power dependencies */ \
if (DT_INST_REG_ADDR(n) == 0x40001000) { \ if (DT_INST_REG_ADDR(n) == 0x40001000) { \
@ -474,7 +506,7 @@ static const struct uart_driver_api uart_cc13xx_cc26xx_driver_api = {
} \ } \
\ \
/* Register notification function */ \ /* Register notification function */ \
Power_registerNotify(&get_dev_data(dev)->postNotify, \ Power_registerNotify(&data->postNotify, \
PowerCC26XX_AWAKE_STANDBY, \ PowerCC26XX_AWAKE_STANDBY, \
postNotifyFxn, (uintptr_t)dev); \ postNotifyFxn, (uintptr_t)dev); \
} while (0) } while (0)
@ -514,7 +546,9 @@ static const struct uart_driver_api uart_cc13xx_cc26xx_driver_api = {
#ifdef CONFIG_UART_INTERRUPT_DRIVEN #ifdef CONFIG_UART_INTERRUPT_DRIVEN
#define UART_CC13XX_CC26XX_IRQ_CFG(n) \ #define UART_CC13XX_CC26XX_IRQ_CFG(n) \
do { \ do { \
UARTIntClear(get_dev_conf(dev)->regs, UART_INT_RX); \ const struct uart_device_config *config = dev->config; \
\
UARTIntClear(config->regs, UART_INT_RX); \
\ \
IRQ_CONNECT(DT_INST_IRQN(n), \ IRQ_CONNECT(DT_INST_IRQN(n), \
DT_INST_IRQ(n, priority), \ DT_INST_IRQ(n, priority), \
@ -523,7 +557,7 @@ static const struct uart_driver_api uart_cc13xx_cc26xx_driver_api = {
0); \ 0); \
irq_enable(DT_INST_IRQN(n)); \ irq_enable(DT_INST_IRQN(n)); \
/* Causes an initial TX ready INT when TX INT enabled */\ /* Causes an initial TX ready INT when TX INT enabled */\
UARTCharPutNonBlocking(get_dev_conf(dev)->regs, '\0'); \ UARTCharPutNonBlocking(config->regs, '\0'); \
} while (0) } while (0)
#define UART_CC13XX_CC26XX_INT_FIELDS \ #define UART_CC13XX_CC26XX_INT_FIELDS \
@ -552,6 +586,7 @@ static const struct uart_driver_api uart_cc13xx_cc26xx_driver_api = {
#define UART_CC13XX_CC26XX_INIT_FUNC(n) \ #define UART_CC13XX_CC26XX_INIT_FUNC(n) \
static int uart_cc13xx_cc26xx_init_##n(const struct device *dev) \ static int uart_cc13xx_cc26xx_init_##n(const struct device *dev) \
{ \ { \
struct uart_cc13xx_cc26xx_data *data = dev->data; \
int ret; \ int ret; \
\ \
UART_CC13XX_CC26XX_POWER_UART(n); \ UART_CC13XX_CC26XX_POWER_UART(n); \
@ -563,8 +598,7 @@ static const struct uart_driver_api uart_cc13xx_cc26xx_driver_api = {
IOC_STD_INPUT); \ IOC_STD_INPUT); \
\ \
/* Configure and enable UART */ \ /* Configure and enable UART */ \
ret = uart_cc13xx_cc26xx_configure(dev, \ ret = uart_cc13xx_cc26xx_configure(dev, &data->uart_config);\
&get_dev_data(dev)->uart_config); \
\ \
/* Enable interrupts */ \ /* Enable interrupts */ \
UART_CC13XX_CC26XX_IRQ_CFG(n); \ UART_CC13XX_CC26XX_IRQ_CFG(n); \

27
drivers/serial/uart_nrfx_uart.c
View file

@ -61,17 +61,6 @@ struct uart_nrfx_data {
struct uart_config uart_config; struct uart_config uart_config;
}; };
static inline const struct uart_nrfx_config *get_dev_config(
const struct device *dev)
{
return dev->config;
}
static inline struct uart_nrfx_data *get_dev_data(const struct device *dev)
{
return dev->data;
}
#ifdef CONFIG_UART_0_ASYNC #ifdef CONFIG_UART_0_ASYNC
static struct { static struct {
uart_callback_t callback; uart_callback_t callback;
@ -117,7 +106,7 @@ static volatile bool disable_tx_irq;
#ifndef CONFIG_PINCTRL #ifndef CONFIG_PINCTRL
static void uart_nrfx_pins_configure(const struct device *dev, bool sleep) static void uart_nrfx_pins_configure(const struct device *dev, bool sleep)
{ {
const struct uart_nrfx_config *cfg = get_dev_config(dev); const struct uart_nrfx_config *cfg = dev->config;
if (!sleep) { if (!sleep) {
if (cfg->tx_pin != NRF_UART_PSEL_DISCONNECTED) { if (cfg->tx_pin != NRF_UART_PSEL_DISCONNECTED) {
@ -383,6 +372,7 @@ static int uart_nrfx_err_check(const struct device *dev)
static int uart_nrfx_configure(const struct device *dev, static int uart_nrfx_configure(const struct device *dev,
const struct uart_config *cfg) const struct uart_config *cfg)
{ {
struct uart_nrfx_data *data = dev->data;
nrf_uart_config_t uart_cfg; nrf_uart_config_t uart_cfg;
#if defined(UART_CONFIG_STOP_Msk) #if defined(UART_CONFIG_STOP_Msk)
@ -447,7 +437,7 @@ static int uart_nrfx_configure(const struct device *dev,
nrf_uart_configure(uart0_addr, &uart_cfg); nrf_uart_configure(uart0_addr, &uart_cfg);
get_dev_data(dev)->uart_config = *cfg; data->uart_config = *cfg;
return 0; return 0;
} }
@ -456,7 +446,9 @@ static int uart_nrfx_configure(const struct device *dev,
static int uart_nrfx_config_get(const struct device *dev, static int uart_nrfx_config_get(const struct device *dev,
struct uart_config *cfg) struct uart_config *cfg)
{ {
*cfg = get_dev_data(dev)->uart_config; struct uart_nrfx_data *data = dev->data;
*cfg = data->uart_config;
return 0; return 0;
} }
#endif /* CONFIG_UART_USE_RUNTIME_CONFIGURE */ #endif /* CONFIG_UART_USE_RUNTIME_CONFIGURE */
@ -1046,9 +1038,10 @@ static void uart_nrfx_isr(const struct device *dev)
*/ */
static int uart_nrfx_init(const struct device *dev) static int uart_nrfx_init(const struct device *dev)
{ {
struct uart_nrfx_data *data = dev->data;
int err; int err;
#ifdef CONFIG_PINCTRL #ifdef CONFIG_PINCTRL
const struct uart_nrfx_config *config = get_dev_config(dev); const struct uart_nrfx_config *config = dev->config;
#endif /* CONFIG_PINCTRL */ #endif /* CONFIG_PINCTRL */
nrf_uart_disable(uart0_addr); nrf_uart_disable(uart0_addr);
@ -1063,7 +1056,7 @@ static int uart_nrfx_init(const struct device *dev)
#endif /* CONFIG_PINCTRL */ #endif /* CONFIG_PINCTRL */
/* Set initial configuration */ /* Set initial configuration */
err = uart_nrfx_configure(dev, &get_dev_data(dev)->uart_config); err = uart_nrfx_configure(dev, &data->uart_config);
if (err) { if (err) {
return err; return err;
} }
@ -1148,7 +1141,7 @@ static int uart_nrfx_pm_action(const struct device *dev,
enum pm_device_action action) enum pm_device_action action)
{ {
#ifdef CONFIG_PINCTRL #ifdef CONFIG_PINCTRL
const struct uart_nrfx_config *config = get_dev_config(dev); const struct uart_nrfx_config *config = dev->config;
int ret; int ret;
#endif #endif

123
drivers/serial/uart_nrfx_uarte.c
View file

@ -171,19 +171,9 @@ struct uarte_nrfx_config {
#endif #endif
}; };
static inline struct uarte_nrfx_data *get_dev_data(const struct device *dev)
{
return dev->data;
}
static inline const struct uarte_nrfx_config *get_dev_config(const struct device *dev)
{
return dev->config;
}
static inline NRF_UARTE_Type *get_uarte_instance(const struct device *dev) static inline NRF_UARTE_Type *get_uarte_instance(const struct device *dev)
{ {
const struct uarte_nrfx_config *config = get_dev_config(dev); const struct uarte_nrfx_config *config = dev->config;
return config->uarte_regs; return config->uarte_regs;
} }
@ -191,7 +181,7 @@ static inline NRF_UARTE_Type *get_uarte_instance(const struct device *dev)
#ifndef CONFIG_PINCTRL #ifndef CONFIG_PINCTRL
static void uarte_nrfx_pins_configure(const struct device *dev, bool sleep) static void uarte_nrfx_pins_configure(const struct device *dev, bool sleep)
{ {
const struct uarte_nrfx_config *cfg = get_dev_config(dev); const struct uarte_nrfx_config *cfg = dev->config;
if (!sleep) { if (!sleep) {
if (cfg->tx_pin != NRF_UARTE_PSEL_DISCONNECTED) { if (cfg->tx_pin != NRF_UARTE_PSEL_DISCONNECTED) {
@ -266,6 +256,7 @@ static void endtx_isr(const struct device *dev)
static void uarte_nrfx_isr_int(void *arg) static void uarte_nrfx_isr_int(void *arg)
{ {
const struct device *dev = arg; const struct device *dev = arg;
const struct uarte_nrfx_config *config = dev->config;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
/* If interrupt driven and asynchronous APIs are disabled then UART /* If interrupt driven and asynchronous APIs are disabled then UART
@ -276,7 +267,7 @@ static void uarte_nrfx_isr_int(void *arg)
endtx_isr(dev); endtx_isr(dev);
} }
if (get_dev_config(dev)->flags & UARTE_CFG_FLAG_LOW_POWER) { if (config->flags & UARTE_CFG_FLAG_LOW_POWER) {
int key = irq_lock(); int key = irq_lock();
if (nrf_uarte_event_check(uarte, NRF_UARTE_EVENT_TXSTOPPED)) { if (nrf_uarte_event_check(uarte, NRF_UARTE_EVENT_TXSTOPPED)) {
@ -284,7 +275,7 @@ static void uarte_nrfx_isr_int(void *arg)
} }
#ifdef UARTE_INTERRUPT_DRIVEN #ifdef UARTE_INTERRUPT_DRIVEN
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
if (!data->int_driven || data->int_driven->fifo_fill_lock == 0) if (!data->int_driven || data->int_driven->fifo_fill_lock == 0)
#endif #endif
@ -297,7 +288,7 @@ static void uarte_nrfx_isr_int(void *arg)
} }
#ifdef UARTE_INTERRUPT_DRIVEN #ifdef UARTE_INTERRUPT_DRIVEN
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
if (!data->int_driven) { if (!data->int_driven) {
return; return;
@ -416,6 +407,7 @@ static int baudrate_set(const struct device *dev, uint32_t baudrate)
static int uarte_nrfx_configure(const struct device *dev, static int uarte_nrfx_configure(const struct device *dev,
const struct uart_config *cfg) const struct uart_config *cfg)
{ {
struct uarte_nrfx_data *data = dev->data;
nrf_uarte_config_t uarte_cfg; nrf_uarte_config_t uarte_cfg;
#if defined(UARTE_CONFIG_STOP_Msk) #if defined(UARTE_CONFIG_STOP_Msk)
@ -476,7 +468,7 @@ static int uarte_nrfx_configure(const struct device *dev,
nrf_uarte_configure(get_uarte_instance(dev), &uarte_cfg); nrf_uarte_configure(get_uarte_instance(dev), &uarte_cfg);
get_dev_data(dev)->uart_config = *cfg; data->uart_config = *cfg;
return 0; return 0;
} }
@ -485,7 +477,9 @@ static int uarte_nrfx_configure(const struct device *dev,
static int uarte_nrfx_config_get(const struct device *dev, static int uarte_nrfx_config_get(const struct device *dev,
struct uart_config *cfg) struct uart_config *cfg)
{ {
*cfg = get_dev_data(dev)->uart_config; struct uarte_nrfx_data *data = dev->data;
*cfg = data->uart_config;
return 0; return 0;
} }
#endif /* CONFIG_UART_USE_RUNTIME_CONFIGURE */ #endif /* CONFIG_UART_USE_RUNTIME_CONFIGURE */
@ -504,8 +498,9 @@ static int uarte_nrfx_err_check(const struct device *dev)
*/ */
static bool is_tx_ready(const struct device *dev) static bool is_tx_ready(const struct device *dev)
{ {
const struct uarte_nrfx_config *config = dev->config;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
bool ppi_endtx = get_dev_config(dev)->flags & UARTE_CFG_FLAG_PPI_ENDTX; bool ppi_endtx = config->flags & UARTE_CFG_FLAG_PPI_ENDTX;
return nrf_uarte_event_check(uarte, NRF_UARTE_EVENT_TXSTOPPED) || return nrf_uarte_event_check(uarte, NRF_UARTE_EVENT_TXSTOPPED) ||
(!ppi_endtx ? (!ppi_endtx ?
@ -556,14 +551,15 @@ static inline bool hw_rx_counting_enabled(struct uarte_nrfx_data *data)
static void uarte_enable(const struct device *dev, uint32_t mask) static void uarte_enable(const struct device *dev, uint32_t mask)
{ {
#ifdef CONFIG_UART_ASYNC_API #ifdef CONFIG_UART_ASYNC_API
struct uarte_nrfx_data *data = get_dev_data(dev); const struct uarte_nrfx_config *config = dev->config;
struct uarte_nrfx_data *data = dev->data;
if (data->async) { if (data->async) {
bool disabled = data->async->low_power_mask == 0; bool disabled = data->async->low_power_mask == 0;
data->async->low_power_mask |= mask; data->async->low_power_mask |= mask;
if (hw_rx_counting_enabled(data) && disabled) { if (hw_rx_counting_enabled(data) && disabled) {
const nrfx_timer_t *timer = &get_dev_config(dev)->timer; const nrfx_timer_t *timer = &config->timer;
nrfx_timer_enable(timer); nrfx_timer_enable(timer);
@ -581,6 +577,7 @@ static void uarte_enable(const struct device *dev, uint32_t mask)
*/ */
static void tx_start(const struct device *dev, const uint8_t *buf, size_t len) static void tx_start(const struct device *dev, const uint8_t *buf, size_t len)
{ {
const struct uarte_nrfx_config *config = dev->config;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
#if CONFIG_PM_DEVICE #if CONFIG_PM_DEVICE
@ -595,7 +592,7 @@ static void tx_start(const struct device *dev, const uint8_t *buf, size_t len)
nrf_uarte_event_clear(uarte, NRF_UARTE_EVENT_ENDTX); nrf_uarte_event_clear(uarte, NRF_UARTE_EVENT_ENDTX);
nrf_uarte_event_clear(uarte, NRF_UARTE_EVENT_TXSTOPPED); nrf_uarte_event_clear(uarte, NRF_UARTE_EVENT_TXSTOPPED);
if (get_dev_config(dev)->flags & UARTE_CFG_FLAG_LOW_POWER) { if (config->flags & UARTE_CFG_FLAG_LOW_POWER) {
uarte_enable(dev, UARTE_LOW_POWER_TX); uarte_enable(dev, UARTE_LOW_POWER_TX);
nrf_uarte_int_enable(uarte, NRF_UARTE_INT_TXSTOPPED_MASK); nrf_uarte_int_enable(uarte, NRF_UARTE_INT_TXSTOPPED_MASK);
} }
@ -607,10 +604,11 @@ static void tx_start(const struct device *dev, const uint8_t *buf, size_t len)
static void uart_disable(const struct device *dev) static void uart_disable(const struct device *dev)
{ {
#ifdef CONFIG_UART_ASYNC_API #ifdef CONFIG_UART_ASYNC_API
struct uarte_nrfx_data *data = get_dev_data(dev); const struct uarte_nrfx_config *config = dev->config;
struct uarte_nrfx_data *data = dev->data;
if (data->async && hw_rx_counting_enabled(data)) { if (data->async && hw_rx_counting_enabled(data)) {
nrfx_timer_disable(&get_dev_config(dev)->timer); nrfx_timer_disable(&config->timer);
/* Timer/counter value is reset when disabled. */ /* Timer/counter value is reset when disabled. */
data->async->rx_total_byte_cnt = 0; data->async->rx_total_byte_cnt = 0;
data->async->rx_total_user_byte_cnt = 0; data->async->rx_total_user_byte_cnt = 0;
@ -629,8 +627,8 @@ static void tx_timeout(struct k_timer *timer);
static int uarte_nrfx_rx_counting_init(const struct device *dev) static int uarte_nrfx_rx_counting_init(const struct device *dev)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
const struct uarte_nrfx_config *cfg = get_dev_config(dev); const struct uarte_nrfx_config *cfg = dev->config;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
int ret; int ret;
@ -696,7 +694,7 @@ static int uarte_nrfx_rx_counting_init(const struct device *dev)
static int uarte_nrfx_init(const struct device *dev) static int uarte_nrfx_init(const struct device *dev)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
int ret = uarte_nrfx_rx_counting_init(dev); int ret = uarte_nrfx_rx_counting_init(dev);
@ -741,7 +739,7 @@ static int uarte_nrfx_tx(const struct device *dev, const uint8_t *buf,
size_t len, size_t len,
int32_t timeout) int32_t timeout)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
if (!nrfx_is_in_ram(buf)) { if (!nrfx_is_in_ram(buf)) {
@ -779,7 +777,7 @@ static int uarte_nrfx_tx(const struct device *dev, const uint8_t *buf,
static int uarte_nrfx_tx_abort(const struct device *dev) static int uarte_nrfx_tx_abort(const struct device *dev)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
if (data->async->tx_buf == NULL) { if (data->async->tx_buf == NULL) {
@ -793,7 +791,7 @@ static int uarte_nrfx_tx_abort(const struct device *dev)
static void user_callback(const struct device *dev, struct uart_event *evt) static void user_callback(const struct device *dev, struct uart_event *evt)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
if (data->async->user_callback) { if (data->async->user_callback) {
data->async->user_callback(dev, evt, data->async->user_data); data->async->user_callback(dev, evt, data->async->user_data);
@ -802,7 +800,7 @@ static void user_callback(const struct device *dev, struct uart_event *evt)
static void notify_uart_rx_rdy(const struct device *dev, size_t len) static void notify_uart_rx_rdy(const struct device *dev, size_t len)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
struct uart_event evt = { struct uart_event evt = {
.type = UART_RX_RDY, .type = UART_RX_RDY,
.data.rx.buf = data->async->rx_buf, .data.rx.buf = data->async->rx_buf,
@ -842,8 +840,8 @@ static int uarte_nrfx_rx_enable(const struct device *dev, uint8_t *buf,
size_t len, size_t len,
int32_t timeout) int32_t timeout)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
const struct uarte_nrfx_config *cfg = get_dev_config(dev); const struct uarte_nrfx_config *cfg = dev->config;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
if (cfg->disable_rx) { if (cfg->disable_rx) {
@ -872,7 +870,7 @@ static int uarte_nrfx_rx_enable(const struct device *dev, uint8_t *buf,
data->async->rx_next_buf = NULL; data->async->rx_next_buf = NULL;
data->async->rx_next_buf_len = 0; data->async->rx_next_buf_len = 0;
if (get_dev_config(dev)->flags & UARTE_CFG_FLAG_LOW_POWER) { if (cfg->flags & UARTE_CFG_FLAG_LOW_POWER) {
if (data->async->rx_flush_cnt) { if (data->async->rx_flush_cnt) {
int cpy_len = MIN(len, data->async->rx_flush_cnt); int cpy_len = MIN(len, data->async->rx_flush_cnt);
@ -900,7 +898,7 @@ static int uarte_nrfx_rx_enable(const struct device *dev, uint8_t *buf,
nrf_uarte_event_clear(uarte, NRF_UARTE_EVENT_RXSTARTED); nrf_uarte_event_clear(uarte, NRF_UARTE_EVENT_RXSTARTED);
data->async->rx_enabled = true; data->async->rx_enabled = true;
if (get_dev_config(dev)->flags & UARTE_CFG_FLAG_LOW_POWER) { if (cfg->flags & UARTE_CFG_FLAG_LOW_POWER) {
int key = irq_lock(); int key = irq_lock();
uarte_enable(dev, UARTE_LOW_POWER_RX); uarte_enable(dev, UARTE_LOW_POWER_RX);
@ -915,7 +913,7 @@ static int uarte_nrfx_rx_enable(const struct device *dev, uint8_t *buf,
static int uarte_nrfx_rx_buf_rsp(const struct device *dev, uint8_t *buf, static int uarte_nrfx_rx_buf_rsp(const struct device *dev, uint8_t *buf,
size_t len) size_t len)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
int err; int err;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
int key = irq_lock(); int key = irq_lock();
@ -941,7 +939,7 @@ static int uarte_nrfx_callback_set(const struct device *dev,
uart_callback_t callback, uart_callback_t callback,
void *user_data) void *user_data)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
if (!data->async) { if (!data->async) {
return -ENOTSUP; return -ENOTSUP;
@ -955,7 +953,7 @@ static int uarte_nrfx_callback_set(const struct device *dev,
static int uarte_nrfx_rx_disable(const struct device *dev) static int uarte_nrfx_rx_disable(const struct device *dev)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
if (data->async->rx_buf == NULL) { if (data->async->rx_buf == NULL) {
@ -992,7 +990,7 @@ static void rx_timeout(struct k_timer *timer)
{ {
struct uarte_nrfx_data *data = k_timer_user_data_get(timer); struct uarte_nrfx_data *data = k_timer_user_data_get(timer);
const struct device *dev = data->dev; const struct device *dev = data->dev;
const struct uarte_nrfx_config *cfg = get_dev_config(dev); const struct uarte_nrfx_config *cfg = dev->config;
uint32_t read; uint32_t read;
if (data->async->is_in_irq) { if (data->async->is_in_irq) {
@ -1095,7 +1093,7 @@ static void error_isr(const struct device *dev)
static void rxstarted_isr(const struct device *dev) static void rxstarted_isr(const struct device *dev)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
struct uart_event evt = { struct uart_event evt = {
.type = UART_RX_BUF_REQUEST, .type = UART_RX_BUF_REQUEST,
}; };
@ -1110,7 +1108,7 @@ static void rxstarted_isr(const struct device *dev)
static void endrx_isr(const struct device *dev) static void endrx_isr(const struct device *dev)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
data->async->is_in_irq = true; data->async->is_in_irq = true;
@ -1261,7 +1259,7 @@ static uint8_t rx_flush(const struct device *dev, uint8_t *buf, uint32_t len)
static void async_uart_release(const struct device *dev, uint32_t dir_mask) static void async_uart_release(const struct device *dev, uint32_t dir_mask)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
int key = irq_lock(); int key = irq_lock();
data->async->low_power_mask &= ~dir_mask; data->async->low_power_mask &= ~dir_mask;
@ -1283,7 +1281,8 @@ static void async_uart_release(const struct device *dev, uint32_t dir_mask)
*/ */
static void rxto_isr(const struct device *dev) static void rxto_isr(const struct device *dev)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); const struct uarte_nrfx_config *config = dev->config;
struct uarte_nrfx_data *data = dev->data;
notify_rx_buf_release(dev, &data->async->rx_buf, true); notify_rx_buf_release(dev, &data->async->rx_buf, true);
notify_rx_buf_release(dev, &data->async->rx_next_buf, true); notify_rx_buf_release(dev, &data->async->rx_next_buf, true);
@ -1292,7 +1291,7 @@ static void rxto_isr(const struct device *dev)
(void)rx_flush(dev, NULL, 0); (void)rx_flush(dev, NULL, 0);
} }
if (get_dev_config(dev)->flags & UARTE_CFG_FLAG_LOW_POWER) { if (config->flags & UARTE_CFG_FLAG_LOW_POWER) {
async_uart_release(dev, UARTE_LOW_POWER_RX); async_uart_release(dev, UARTE_LOW_POWER_RX);
} }
@ -1301,11 +1300,12 @@ static void rxto_isr(const struct device *dev)
static void txstopped_isr(const struct device *dev) static void txstopped_isr(const struct device *dev)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); const struct uarte_nrfx_config *config = dev->config;
struct uarte_nrfx_data *data = dev->data;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
int key; int key;
if (get_dev_config(dev)->flags & UARTE_CFG_FLAG_LOW_POWER) { if (config->flags & UARTE_CFG_FLAG_LOW_POWER) {
nrf_uarte_int_disable(uarte, NRF_UARTE_INT_TXSTOPPED_MASK); nrf_uarte_int_disable(uarte, NRF_UARTE_INT_TXSTOPPED_MASK);
async_uart_release(dev, UARTE_LOW_POWER_TX); async_uart_release(dev, UARTE_LOW_POWER_TX);
@ -1364,7 +1364,7 @@ static void txstopped_isr(const struct device *dev)
static void uarte_nrfx_isr_async(const struct device *dev) static void uarte_nrfx_isr_async(const struct device *dev)
{ {
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
if (!hw_rx_counting_enabled(data) if (!hw_rx_counting_enabled(data)
&& nrf_uarte_event_check(uarte, NRF_UARTE_EVENT_RXDRDY)) { && nrf_uarte_event_check(uarte, NRF_UARTE_EVENT_RXDRDY)) {
@ -1434,7 +1434,7 @@ static void uarte_nrfx_isr_async(const struct device *dev)
static int uarte_nrfx_poll_in(const struct device *dev, unsigned char *c) static int uarte_nrfx_poll_in(const struct device *dev, unsigned char *c)
{ {
const struct uarte_nrfx_data *data = get_dev_data(dev); const struct uarte_nrfx_data *data = dev->data;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
#ifdef CONFIG_UART_ASYNC_API #ifdef CONFIG_UART_ASYNC_API
@ -1464,7 +1464,7 @@ static int uarte_nrfx_poll_in(const struct device *dev, unsigned char *c)
*/ */
static void uarte_nrfx_poll_out(const struct device *dev, unsigned char c) static void uarte_nrfx_poll_out(const struct device *dev, unsigned char c)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
bool isr_mode = k_is_in_isr() || k_is_pre_kernel(); bool isr_mode = k_is_in_isr() || k_is_pre_kernel();
int key; int key;
@ -1502,7 +1502,7 @@ static int uarte_nrfx_fifo_fill(const struct device *dev,
const uint8_t *tx_data, const uint8_t *tx_data,
int len) int len)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
len = MIN(len, data->int_driven->tx_buff_size); len = MIN(len, data->int_driven->tx_buff_size);
if (!atomic_cas(&data->int_driven->fifo_fill_lock, 0, 1)) { if (!atomic_cas(&data->int_driven->fifo_fill_lock, 0, 1)) {
@ -1535,7 +1535,7 @@ static int uarte_nrfx_fifo_read(const struct device *dev,
{ {
int num_rx = 0; int num_rx = 0;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
const struct uarte_nrfx_data *data = get_dev_data(dev); const struct uarte_nrfx_data *data = dev->data;
if (size > 0 && nrf_uarte_event_check(uarte, NRF_UARTE_EVENT_ENDRX)) { if (size > 0 && nrf_uarte_event_check(uarte, NRF_UARTE_EVENT_ENDRX)) {
/* Clear the interrupt */ /* Clear the interrupt */
@ -1554,7 +1554,7 @@ static int uarte_nrfx_fifo_read(const struct device *dev,
static void uarte_nrfx_irq_tx_enable(const struct device *dev) static void uarte_nrfx_irq_tx_enable(const struct device *dev)
{ {
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
int key = irq_lock(); int key = irq_lock();
data->int_driven->disable_tx_irq = false; data->int_driven->disable_tx_irq = false;
@ -1566,7 +1566,7 @@ static void uarte_nrfx_irq_tx_enable(const struct device *dev)
/** Interrupt driven transfer disabling function */ /** Interrupt driven transfer disabling function */
static void uarte_nrfx_irq_tx_disable(const struct device *dev) static void uarte_nrfx_irq_tx_disable(const struct device *dev)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
/* TX IRQ will be disabled after current transmission is finished */ /* TX IRQ will be disabled after current transmission is finished */
data->int_driven->disable_tx_irq = true; data->int_driven->disable_tx_irq = true;
} }
@ -1575,7 +1575,7 @@ static void uarte_nrfx_irq_tx_disable(const struct device *dev)
static int uarte_nrfx_irq_tx_ready_complete(const struct device *dev) static int uarte_nrfx_irq_tx_ready_complete(const struct device *dev)
{ {
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
/* ENDTX flag is always on so that ISR is called when we enable TX IRQ. /* ENDTX flag is always on so that ISR is called when we enable TX IRQ.
* Because of that we have to explicitly check if ENDTX interrupt is * Because of that we have to explicitly check if ENDTX interrupt is
@ -1658,7 +1658,7 @@ static void uarte_nrfx_irq_callback_set(const struct device *dev,
uart_irq_callback_user_data_t cb, uart_irq_callback_user_data_t cb,
void *cb_data) void *cb_data)
{ {
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
data->int_driven->cb = cb; data->int_driven->cb = cb;
data->int_driven->cb_data = cb_data; data->int_driven->cb_data = cb_data;
@ -1723,8 +1723,8 @@ static int uarte_instance_init(const struct device *dev,
{ {
int err; int err;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
const struct uarte_nrfx_config *cfg = get_dev_config(dev); const struct uarte_nrfx_config *cfg = dev->config;
nrf_uarte_disable(uarte); nrf_uarte_disable(uarte);
@ -1739,7 +1739,7 @@ static int uarte_instance_init(const struct device *dev,
uarte_nrfx_pins_configure(dev, false); uarte_nrfx_pins_configure(dev, false);
#endif /* CONFIG_PINCTRL */ #endif /* CONFIG_PINCTRL */
err = uarte_nrfx_configure(dev, &get_dev_data(dev)->uart_config); err = uarte_nrfx_configure(dev, &data->uart_config);
if (err) { if (err) {
return err; return err;
} }
@ -1803,7 +1803,8 @@ static int uarte_instance_init(const struct device *dev,
*/ */
static void wait_for_tx_stopped(const struct device *dev) static void wait_for_tx_stopped(const struct device *dev)
{ {
bool ppi_endtx = get_dev_config(dev)->flags & UARTE_CFG_FLAG_PPI_ENDTX; const struct uarte_nrfx_config *config = dev->config;
bool ppi_endtx = config->flags & UARTE_CFG_FLAG_PPI_ENDTX;
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
bool res; bool res;
@ -1835,9 +1836,9 @@ static int uarte_nrfx_pm_action(const struct device *dev,
{ {
NRF_UARTE_Type *uarte = get_uarte_instance(dev); NRF_UARTE_Type *uarte = get_uarte_instance(dev);
#if defined(CONFIG_UART_ASYNC_API) || defined(UARTE_INTERRUPT_DRIVEN) #if defined(CONFIG_UART_ASYNC_API) || defined(UARTE_INTERRUPT_DRIVEN)
struct uarte_nrfx_data *data = get_dev_data(dev); struct uarte_nrfx_data *data = dev->data;
#endif #endif
const struct uarte_nrfx_config *cfg = get_dev_config(dev); const struct uarte_nrfx_config *cfg = dev->config;
#ifdef CONFIG_PINCTRL #ifdef CONFIG_PINCTRL
int ret; int ret;
#endif #endif
@ -1860,7 +1861,7 @@ static int uarte_nrfx_pm_action(const struct device *dev,
#ifdef CONFIG_UART_ASYNC_API #ifdef CONFIG_UART_ASYNC_API
if (hw_rx_counting_enabled(data)) { if (hw_rx_counting_enabled(data)) {
nrfx_timer_enable(&get_dev_config(dev)->timer); nrfx_timer_enable(&cfg->timer);
} }
if (data->async) { if (data->async) {
return 0; return 0;

34
drivers/serial/uart_rtt.c
View file

@ -24,18 +24,6 @@ struct uart_rtt_data {
#endif /* CONFIG_UART_ASYNC_API */ #endif /* CONFIG_UART_ASYNC_API */
}; };
static inline
const struct uart_rtt_config *get_dev_config(const struct device *dev)
{
return dev->config;
}
static inline
struct uart_rtt_data *get_dev_data(const struct device *dev)
{
return dev->data;
}
static int uart_rtt_init(const struct device *dev) static int uart_rtt_init(const struct device *dev)
{ {
/* /*
@ -43,8 +31,8 @@ static int uart_rtt_init(const struct device *dev)
* it is configured in correct, non-blocking mode. Other channels * it is configured in correct, non-blocking mode. Other channels
* need to be configured at run-time. * need to be configured at run-time.
*/ */
if (get_dev_config(dev)) { if (dev->config) {
const struct uart_rtt_config *cfg = get_dev_config(dev); const struct uart_rtt_config *cfg = dev->config;
SEGGER_RTT_ConfigUpBuffer(cfg->channel, dev->name, SEGGER_RTT_ConfigUpBuffer(cfg->channel, dev->name,
cfg->up_buffer, cfg->up_size, cfg->up_buffer, cfg->up_size,
@ -67,8 +55,8 @@ static int uart_rtt_init(const struct device *dev)
static int uart_rtt_poll_in(const struct device *dev, unsigned char *c) static int uart_rtt_poll_in(const struct device *dev, unsigned char *c)
{ {
unsigned int ch = const struct uart_rtt_config *config = dev->config;
get_dev_config(dev) ? get_dev_config(dev)->channel : 0; unsigned int ch = config ? config->channel : 0;
unsigned int ret = SEGGER_RTT_Read(ch, c, 1); unsigned int ret = SEGGER_RTT_Read(ch, c, 1);
return ret ? 0 : -1; return ret ? 0 : -1;
@ -82,8 +70,8 @@ static int uart_rtt_poll_in(const struct device *dev, unsigned char *c)
*/ */
static void uart_rtt_poll_out(const struct device *dev, unsigned char c) static void uart_rtt_poll_out(const struct device *dev, unsigned char c)
{ {
unsigned int ch = const struct uart_rtt_config *config = dev->config;
get_dev_config(dev) ? get_dev_config(dev)->channel : 0; unsigned int ch = config ? config->channel : 0;
SEGGER_RTT_Write(ch, &c, 1); SEGGER_RTT_Write(ch, &c, 1);
} }
@ -93,16 +81,18 @@ static void uart_rtt_poll_out(const struct device *dev, unsigned char c)
static int uart_rtt_callback_set(const struct device *dev, static int uart_rtt_callback_set(const struct device *dev,
uart_callback_t callback, void *user_data) uart_callback_t callback, void *user_data)
{ {
get_dev_data(dev)->callback = callback; struct uart_rtt_data *data = dev->data;
get_dev_data(dev)->user_data = user_data;
data->callback = callback;
data->user_data = user_data;
return 0; return 0;
} }
static int uart_rtt_tx(const struct device *dev, static int uart_rtt_tx(const struct device *dev,
const uint8_t *buf, size_t len, int32_t timeout) const uint8_t *buf, size_t len, int32_t timeout)
{ {
const struct uart_rtt_config *cfg = get_dev_config(dev); const struct uart_rtt_config *cfg = dev->config;
struct uart_rtt_data *data = get_dev_data(dev); struct uart_rtt_data *data = dev->data;
unsigned int ch = cfg ? cfg->channel : 0; unsigned int ch = cfg ? cfg->channel : 0;
ARG_UNUSED(timeout); ARG_UNUSED(timeout);