diff options
Diffstat (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/modules/nrfx/drivers/src/nrfx_uart.c')
| -rw-r--r-- | thirdparty/nRF5_SDK_15.0.0_a53641a/modules/nrfx/drivers/src/nrfx_uart.c | 649 |
1 files changed, 649 insertions, 0 deletions
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/modules/nrfx/drivers/src/nrfx_uart.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/modules/nrfx/drivers/src/nrfx_uart.c new file mode 100644 index 0000000..8c5f487 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/modules/nrfx/drivers/src/nrfx_uart.c @@ -0,0 +1,649 @@ +/** + * Copyright (c) 2015 - 2018, Nordic Semiconductor ASA + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. + * + * 3. Neither the name of Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include <nrfx.h> + +#if NRFX_CHECK(NRFX_UART_ENABLED) + +#if !NRFX_CHECK(NRFX_UART0_ENABLED) +#error "No enabled UART instances. Check <nrfx_config.h>." +#endif + +#include <nrfx_uart.h> +#include "prs/nrfx_prs.h" +#include <hal/nrf_gpio.h> + +#define NRFX_LOG_MODULE UART +#include <nrfx_log.h> + +#define EVT_TO_STR(event) \ + (event == NRF_UART_EVENT_ERROR ? "NRF_UART_EVENT_ERROR" : \ + "UNKNOWN EVENT") + + +#define TX_COUNTER_ABORT_REQ_VALUE UINT32_MAX + +typedef struct +{ + void * p_context; + nrfx_uart_event_handler_t handler; + uint8_t const * p_tx_buffer; + uint8_t * p_rx_buffer; + uint8_t * p_rx_secondary_buffer; + size_t tx_buffer_length; + size_t rx_buffer_length; + size_t rx_secondary_buffer_length; + volatile size_t tx_counter; + volatile size_t rx_counter; + volatile bool tx_abort; + bool rx_enabled; + nrfx_drv_state_t state; +} uart_control_block_t; +static uart_control_block_t m_cb[NRFX_UART_ENABLED_COUNT]; + +static void apply_config(nrfx_uart_t const * p_instance, + nrfx_uart_config_t const * p_config) +{ + if (p_config->pseltxd != NRF_UART_PSEL_DISCONNECTED) + { + nrf_gpio_pin_set(p_config->pseltxd); + nrf_gpio_cfg_output(p_config->pseltxd); + } + if (p_config->pselrxd != NRF_UART_PSEL_DISCONNECTED) + { + nrf_gpio_cfg_input(p_config->pselrxd, NRF_GPIO_PIN_NOPULL); + } + + nrf_uart_baudrate_set(p_instance->p_reg, p_config->baudrate); + nrf_uart_configure(p_instance->p_reg, p_config->parity, p_config->hwfc); + nrf_uart_txrx_pins_set(p_instance->p_reg, p_config->pseltxd, p_config->pselrxd); + if (p_config->hwfc == NRF_UART_HWFC_ENABLED) + { + if (p_config->pselcts != NRF_UART_PSEL_DISCONNECTED) + { + nrf_gpio_cfg_input(p_config->pselcts, NRF_GPIO_PIN_NOPULL); + } + if (p_config->pselrts != NRF_UART_PSEL_DISCONNECTED) + { + nrf_gpio_pin_set(p_config->pselrts); + nrf_gpio_cfg_output(p_config->pselrts); + } + nrf_uart_hwfc_pins_set(p_instance->p_reg, p_config->pselrts, p_config->pselcts); + } +} + +static void interrupts_enable(nrfx_uart_t const * p_instance, + uint8_t interrupt_priority) +{ + nrf_uart_event_clear(p_instance->p_reg, NRF_UART_EVENT_TXDRDY); + nrf_uart_event_clear(p_instance->p_reg, NRF_UART_EVENT_RXTO); + nrf_uart_int_enable(p_instance->p_reg, NRF_UART_INT_MASK_TXDRDY | + NRF_UART_INT_MASK_RXTO); + NRFX_IRQ_PRIORITY_SET(nrfx_get_irq_number((void *)p_instance->p_reg), + interrupt_priority); + NRFX_IRQ_ENABLE(nrfx_get_irq_number((void *)p_instance->p_reg)); +} + +static void interrupts_disable(nrfx_uart_t const * p_instance) +{ + nrf_uart_int_disable(p_instance->p_reg, NRF_UART_INT_MASK_RXDRDY | + NRF_UART_INT_MASK_TXDRDY | + NRF_UART_INT_MASK_ERROR | + NRF_UART_INT_MASK_RXTO); + NRFX_IRQ_DISABLE(nrfx_get_irq_number((void *)p_instance->p_reg)); +} + +static void pins_to_default(nrfx_uart_t const * p_instance) +{ + /* Reset pins to default states */ + uint32_t txd; + uint32_t rxd; + uint32_t rts; + uint32_t cts; + + txd = nrf_uart_tx_pin_get(p_instance->p_reg); + rxd = nrf_uart_rx_pin_get(p_instance->p_reg); + rts = nrf_uart_rts_pin_get(p_instance->p_reg); + cts = nrf_uart_cts_pin_get(p_instance->p_reg); + nrf_uart_txrx_pins_disconnect(p_instance->p_reg); + nrf_uart_hwfc_pins_disconnect(p_instance->p_reg); + + if (txd != NRF_UART_PSEL_DISCONNECTED) + { + nrf_gpio_cfg_default(txd); + } + if (rxd != NRF_UART_PSEL_DISCONNECTED) + { + nrf_gpio_cfg_default(rxd); + } + if (cts != NRF_UART_PSEL_DISCONNECTED) + { + nrf_gpio_cfg_default(cts); + } + if (rts != NRF_UART_PSEL_DISCONNECTED) + { + nrf_gpio_cfg_default(rts); + } +} + +nrfx_err_t nrfx_uart_init(nrfx_uart_t const * p_instance, + nrfx_uart_config_t const * p_config, + nrfx_uart_event_handler_t event_handler) +{ + NRFX_ASSERT(p_config); + uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx]; + nrfx_err_t err_code = NRFX_SUCCESS; + + if (p_cb->state != NRFX_DRV_STATE_UNINITIALIZED) + { + err_code = NRFX_ERROR_INVALID_STATE; + NRFX_LOG_WARNING("Function: %s, error code: %s.", + __func__, + NRFX_LOG_ERROR_STRING_GET(err_code)); + return err_code; + } + +#if NRFX_CHECK(NRFX_PRS_ENABLED) + static nrfx_irq_handler_t const irq_handlers[NRFX_UART_ENABLED_COUNT] = { + #if NRFX_CHECK(NRFX_UART0_ENABLED) + nrfx_uart_0_irq_handler, + #endif + }; + if (nrfx_prs_acquire(p_instance->p_reg, + irq_handlers[p_instance->drv_inst_idx]) != NRFX_SUCCESS) + { + err_code = NRFX_ERROR_BUSY; + NRFX_LOG_WARNING("Function: %s, error code: %s.", + __func__, + NRFX_LOG_ERROR_STRING_GET(err_code)); + return err_code; + } +#endif // NRFX_CHECK(NRFX_PRS_ENABLED) + + apply_config(p_instance, p_config); + + p_cb->handler = event_handler; + p_cb->p_context = p_config->p_context; + + if (p_cb->handler) + { + interrupts_enable(p_instance, p_config->interrupt_priority); + } + + nrf_uart_enable(p_instance->p_reg); + p_cb->rx_buffer_length = 0; + p_cb->rx_secondary_buffer_length = 0; + p_cb->rx_enabled = false; + p_cb->tx_buffer_length = 0; + p_cb->state = NRFX_DRV_STATE_INITIALIZED; + NRFX_LOG_WARNING("Function: %s, error code: %s.", + __func__, + NRFX_LOG_ERROR_STRING_GET(err_code)); + return err_code; +} + +void nrfx_uart_uninit(nrfx_uart_t const * p_instance) +{ + uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx]; + + nrf_uart_disable(p_instance->p_reg); + + if (p_cb->handler) + { + interrupts_disable(p_instance); + } + + pins_to_default(p_instance); + +#if NRFX_CHECK(NRFX_PRS_ENABLED) + nrfx_prs_release(p_instance->p_reg); +#endif + + p_cb->state = NRFX_DRV_STATE_UNINITIALIZED; + p_cb->handler = NULL; + NRFX_LOG_INFO("Instance uninitialized: %d.", p_instance->drv_inst_idx); +} + +static void tx_byte(NRF_UART_Type * p_uart, uart_control_block_t * p_cb) +{ + nrf_uart_event_clear(p_uart, NRF_UART_EVENT_TXDRDY); + uint8_t txd = p_cb->p_tx_buffer[p_cb->tx_counter]; + p_cb->tx_counter++; + nrf_uart_txd_set(p_uart, txd); +} + +static bool tx_blocking(NRF_UART_Type * p_uart, uart_control_block_t * p_cb) +{ + while (p_cb->tx_counter < p_cb->tx_buffer_length) + { + // Wait until the transmitter is ready to accept a new byte. + // Exit immediately if the transfer has been aborted. + while (!nrf_uart_event_check(p_uart, NRF_UART_EVENT_TXDRDY)) + { + if (p_cb->tx_abort) + { + return false; + } + } + + tx_byte(p_uart, p_cb); + } + + return true; +} + +nrfx_err_t nrfx_uart_tx(nrfx_uart_t const * p_instance, + uint8_t const * p_data, + size_t length) +{ + uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx]; + NRFX_ASSERT(p_cb->state == NRFX_DRV_STATE_INITIALIZED); + NRFX_ASSERT(p_data); + NRFX_ASSERT(length > 0); + + nrfx_err_t err_code; + + if (nrfx_uart_tx_in_progress(p_instance)) + { + err_code = NRFX_ERROR_BUSY; + NRFX_LOG_WARNING("Function: %s, error code: %s.", + __func__, + NRFX_LOG_ERROR_STRING_GET(err_code)); + return err_code; + } + p_cb->tx_buffer_length = length; + p_cb->p_tx_buffer = p_data; + p_cb->tx_counter = 0; + p_cb->tx_abort = false; + + NRFX_LOG_INFO("Transfer tx_len: %d.", p_cb->tx_buffer_length); + NRFX_LOG_DEBUG("Tx data:"); + NRFX_LOG_HEXDUMP_DEBUG(p_cb->p_tx_buffer, + p_cb->tx_buffer_length * sizeof(p_cb->p_tx_buffer[0])); + + err_code = NRFX_SUCCESS; + + nrf_uart_event_clear(p_instance->p_reg, NRF_UART_EVENT_TXDRDY); + nrf_uart_task_trigger(p_instance->p_reg, NRF_UART_TASK_STARTTX); + + tx_byte(p_instance->p_reg, p_cb); + + if (p_cb->handler == NULL) + { + if (!tx_blocking(p_instance->p_reg, p_cb)) + { + // The transfer has been aborted. + err_code = NRFX_ERROR_FORBIDDEN; + } + else + { + // Wait until the last byte is completely transmitted. + while (!nrf_uart_event_check(p_instance->p_reg, NRF_UART_EVENT_TXDRDY)) + {} + nrf_uart_task_trigger(p_instance->p_reg, NRF_UART_TASK_STOPTX); + } + p_cb->tx_buffer_length = 0; + } + + NRFX_LOG_INFO("Function: %s, error code: %s.", __func__, NRFX_LOG_ERROR_STRING_GET(err_code)); + return err_code; +} + +bool nrfx_uart_tx_in_progress(nrfx_uart_t const * p_instance) +{ + return (m_cb[p_instance->drv_inst_idx].tx_buffer_length != 0); +} + +static void rx_enable(nrfx_uart_t const * p_instance) +{ + nrf_uart_event_clear(p_instance->p_reg, NRF_UART_EVENT_ERROR); + nrf_uart_event_clear(p_instance->p_reg, NRF_UART_EVENT_RXDRDY); + nrf_uart_task_trigger(p_instance->p_reg, NRF_UART_TASK_STARTRX); +} + +static void rx_byte(NRF_UART_Type * p_uart, uart_control_block_t * p_cb) +{ + if (!p_cb->rx_buffer_length) + { + nrf_uart_event_clear(p_uart, NRF_UART_EVENT_RXDRDY); + // Byte received when buffer is not set - data lost. + (void) nrf_uart_rxd_get(p_uart); + return; + } + nrf_uart_event_clear(p_uart, NRF_UART_EVENT_RXDRDY); + p_cb->p_rx_buffer[p_cb->rx_counter] = nrf_uart_rxd_get(p_uart); + p_cb->rx_counter++; +} + +nrfx_err_t nrfx_uart_rx(nrfx_uart_t const * p_instance, + uint8_t * p_data, + size_t length) +{ + uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx]; + + NRFX_ASSERT(m_cb[p_instance->drv_inst_idx].state == NRFX_DRV_STATE_INITIALIZED); + NRFX_ASSERT(p_data); + NRFX_ASSERT(length > 0); + + nrfx_err_t err_code; + + bool second_buffer = false; + + if (p_cb->handler) + { + nrf_uart_int_disable(p_instance->p_reg, NRF_UART_INT_MASK_RXDRDY | + NRF_UART_INT_MASK_ERROR); + } + if (p_cb->rx_buffer_length != 0) + { + if (p_cb->rx_secondary_buffer_length != 0) + { + if (p_cb->handler) + { + nrf_uart_int_enable(p_instance->p_reg, NRF_UART_INT_MASK_RXDRDY | + NRF_UART_INT_MASK_ERROR); + } + err_code = NRFX_ERROR_BUSY; + NRFX_LOG_WARNING("Function: %s, error code: %s.", + __func__, + NRFX_LOG_ERROR_STRING_GET(err_code)); + return err_code; + } + second_buffer = true; + } + + if (!second_buffer) + { + p_cb->rx_buffer_length = length; + p_cb->p_rx_buffer = p_data; + p_cb->rx_counter = 0; + p_cb->rx_secondary_buffer_length = 0; + } + else + { + p_cb->p_rx_secondary_buffer = p_data; + p_cb->rx_secondary_buffer_length = length; + } + + NRFX_LOG_INFO("Transfer rx_len: %d.", length); + + if ((!p_cb->rx_enabled) && (!second_buffer)) + { + rx_enable(p_instance); + } + + if (p_cb->handler == NULL) + { + nrf_uart_event_clear(p_instance->p_reg, NRF_UART_EVENT_RXTO); + + bool rxrdy; + bool rxto; + bool error; + do + { + do + { + error = nrf_uart_event_check(p_instance->p_reg, NRF_UART_EVENT_ERROR); + rxrdy = nrf_uart_event_check(p_instance->p_reg, NRF_UART_EVENT_RXDRDY); + rxto = nrf_uart_event_check(p_instance->p_reg, NRF_UART_EVENT_RXTO); + } while ((!rxrdy) && (!rxto) && (!error)); + + if (error || rxto) + { + break; + } + rx_byte(p_instance->p_reg, p_cb); + } while (p_cb->rx_buffer_length > p_cb->rx_counter); + + p_cb->rx_buffer_length = 0; + if (error) + { + err_code = NRFX_ERROR_INTERNAL; + NRFX_LOG_WARNING("Function: %s, error code: %s.", + __func__, + NRFX_LOG_ERROR_STRING_GET(err_code)); + return err_code; + } + + if (rxto) + { + err_code = NRFX_ERROR_FORBIDDEN; + NRFX_LOG_WARNING("Function: %s, error code: %s.", + __func__, + NRFX_LOG_ERROR_STRING_GET(err_code)); + return err_code; + } + + if (p_cb->rx_enabled) + { + nrf_uart_task_trigger(p_instance->p_reg, NRF_UART_TASK_STARTRX); + } + else + { + // Skip stopping RX if driver is forced to be enabled. + nrf_uart_task_trigger(p_instance->p_reg, NRF_UART_TASK_STOPRX); + } + } + else + { + nrf_uart_int_enable(p_instance->p_reg, NRF_UART_INT_MASK_RXDRDY | + NRF_UART_INT_MASK_ERROR); + } + err_code = NRFX_SUCCESS; + NRFX_LOG_INFO("Function: %s, error code: %s.", __func__, NRFX_LOG_ERROR_STRING_GET(err_code)); + return err_code; +} + +bool nrfx_uart_rx_ready(nrfx_uart_t const * p_instance) +{ + return nrf_uart_event_check(p_instance->p_reg, NRF_UART_EVENT_RXDRDY); +} + +void nrfx_uart_rx_enable(nrfx_uart_t const * p_instance) +{ + if (!m_cb[p_instance->drv_inst_idx].rx_enabled) + { + rx_enable(p_instance); + m_cb[p_instance->drv_inst_idx].rx_enabled = true; + } +} + +void nrfx_uart_rx_disable(nrfx_uart_t const * p_instance) +{ + nrf_uart_task_trigger(p_instance->p_reg, NRF_UART_TASK_STOPRX); + m_cb[p_instance->drv_inst_idx].rx_enabled = false; +} + +uint32_t nrfx_uart_errorsrc_get(nrfx_uart_t const * p_instance) +{ + nrf_uart_event_clear(p_instance->p_reg, NRF_UART_EVENT_ERROR); + return nrf_uart_errorsrc_get_and_clear(p_instance->p_reg); +} + +static void rx_done_event(uart_control_block_t * p_cb, + size_t bytes, + uint8_t * p_data) +{ + nrfx_uart_event_t event; + + event.type = NRFX_UART_EVT_RX_DONE; + event.data.rxtx.bytes = bytes; + event.data.rxtx.p_data = p_data; + + p_cb->handler(&event, p_cb->p_context); +} + +static void tx_done_event(uart_control_block_t * p_cb, + size_t bytes) +{ + nrfx_uart_event_t event; + + event.type = NRFX_UART_EVT_TX_DONE; + event.data.rxtx.bytes = bytes; + event.data.rxtx.p_data = (uint8_t *)p_cb->p_tx_buffer; + + p_cb->tx_buffer_length = 0; + + p_cb->handler(&event, p_cb->p_context); +} + +void nrfx_uart_tx_abort(nrfx_uart_t const * p_instance) +{ + uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx]; + + p_cb->tx_abort = true; + nrf_uart_task_trigger(p_instance->p_reg, NRF_UART_TASK_STOPTX); + if (p_cb->handler) + { + tx_done_event(p_cb, p_cb->tx_counter); + } + + NRFX_LOG_INFO("TX transaction aborted."); +} + +void nrfx_uart_rx_abort(nrfx_uart_t const * p_instance) +{ + nrf_uart_int_disable(p_instance->p_reg, NRF_UART_INT_MASK_RXDRDY | + NRF_UART_INT_MASK_ERROR); + nrf_uart_task_trigger(p_instance->p_reg, NRF_UART_TASK_STOPRX); + + NRFX_LOG_INFO("RX transaction aborted."); +} + +static void uart_irq_handler(NRF_UART_Type * p_uart, + uart_control_block_t * p_cb) +{ + if (nrf_uart_int_enable_check(p_uart, NRF_UART_INT_MASK_ERROR) && + nrf_uart_event_check(p_uart, NRF_UART_EVENT_ERROR)) + { + nrfx_uart_event_t event; + nrf_uart_event_clear(p_uart, NRF_UART_EVENT_ERROR); + NRFX_LOG_DEBUG("Event: %s.", EVT_TO_STR(NRF_UART_EVENT_ERROR)); + nrf_uart_int_disable(p_uart, NRF_UART_INT_MASK_RXDRDY | + NRF_UART_INT_MASK_ERROR); + if (!p_cb->rx_enabled) + { + nrf_uart_task_trigger(p_uart, NRF_UART_TASK_STOPRX); + } + event.type = NRFX_UART_EVT_ERROR; + event.data.error.error_mask = nrf_uart_errorsrc_get_and_clear(p_uart); + event.data.error.rxtx.bytes = p_cb->rx_buffer_length; + event.data.error.rxtx.p_data = p_cb->p_rx_buffer; + + // Abort transfer. + p_cb->rx_buffer_length = 0; + p_cb->rx_secondary_buffer_length = 0; + + p_cb->handler(&event,p_cb->p_context); + } + else if (nrf_uart_int_enable_check(p_uart, NRF_UART_INT_MASK_RXDRDY) && + nrf_uart_event_check(p_uart, NRF_UART_EVENT_RXDRDY)) + { + rx_byte(p_uart, p_cb); + if (p_cb->rx_buffer_length == p_cb->rx_counter) + { + if (p_cb->rx_secondary_buffer_length) + { + uint8_t * p_data = p_cb->p_rx_buffer; + size_t rx_counter = p_cb->rx_counter; + + // Switch to secondary buffer. + p_cb->rx_buffer_length = p_cb->rx_secondary_buffer_length; + p_cb->p_rx_buffer = p_cb->p_rx_secondary_buffer; + p_cb->rx_secondary_buffer_length = 0; + p_cb->rx_counter = 0; + rx_done_event(p_cb, rx_counter, p_data); + } + else + { + if (!p_cb->rx_enabled) + { + nrf_uart_task_trigger(p_uart, NRF_UART_TASK_STOPRX); + } + nrf_uart_int_disable(p_uart, NRF_UART_INT_MASK_RXDRDY | + NRF_UART_INT_MASK_ERROR); + p_cb->rx_buffer_length = 0; + rx_done_event(p_cb, p_cb->rx_counter, p_cb->p_rx_buffer); + } + } + } + + if (nrf_uart_event_check(p_uart, NRF_UART_EVENT_TXDRDY)) + { + if (p_cb->tx_counter < p_cb->tx_buffer_length && + !p_cb->tx_abort) + { + tx_byte(p_uart, p_cb); + } + else + { + nrf_uart_event_clear(p_uart, NRF_UART_EVENT_TXDRDY); + if (p_cb->tx_buffer_length) + { + tx_done_event(p_cb, p_cb->tx_buffer_length); + } + } + } + + if (nrf_uart_event_check(p_uart, NRF_UART_EVENT_RXTO)) + { + nrf_uart_event_clear(p_uart, NRF_UART_EVENT_RXTO); + + // RXTO event may be triggered as a result of abort call. In th + if (p_cb->rx_enabled) + { + nrf_uart_task_trigger(p_uart, NRF_UART_TASK_STARTRX); + } + if (p_cb->rx_buffer_length) + { + p_cb->rx_buffer_length = 0; + rx_done_event(p_cb, p_cb->rx_counter, p_cb->p_rx_buffer); + } + } +} + +#if NRFX_CHECK(NRFX_UART0_ENABLED) +void nrfx_uart_0_irq_handler(void) +{ + uart_irq_handler(NRF_UART0, &m_cb[NRFX_UART0_INST_IDX]); +} +#endif + +#endif // NRFX_CHECK(NRFX_UART_ENABLED) |