uart_async_to_irq.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_DRIVERS_SERIAL_UART_ASYNC_TO_IRQ_H_
#define ZEPHYR_DRIVERS_SERIAL_UART_ASYNC_TO_IRQ_H_
 
#include <zephyr/drivers/uart.h>
#include <zephyr/logging/log.h>
#include <zephyr/spinlock.h>
#include <zephyr/sys/util.h>
#include <zephyr/drivers/serial/uart_async_rx.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Forward declarations. */
 
struct uart_async_to_irq_data;
 
struct uart_async_to_irq_config;
 
/* @brief Function that triggers trampoline to the interrupt context.
 *
 * This context is used to call user UART interrupt handler. It is to used to
 * fulfill the requirement that UART interrupt driven API shall be called from
 * the UART interrupt. Trampoline context shall have the same priority as UART.
 *
 * One option may be to use k_timer configured to expire immediately.
 */
typedef void (*uart_async_to_irq_trampoline)(const struct device *dev);
 
void uart_async_to_irq_trampoline_cb(const struct device *dev);
 
#define UART_ASYNC_TO_IRQ_API_INIT()                            \
        .fifo_fill        = z_uart_async_to_irq_fifo_fill,      \
        .fifo_read        = z_uart_async_to_irq_fifo_read,      \
        .irq_tx_enable    = z_uart_async_to_irq_irq_tx_enable,  \
        .irq_tx_disable   = z_uart_async_to_irq_irq_tx_disable, \
        .irq_tx_ready     = z_uart_async_to_irq_irq_tx_ready,   \
        .irq_rx_enable    = z_uart_async_to_irq_irq_rx_enable,  \
        .irq_rx_disable   = z_uart_async_to_irq_irq_rx_disable, \
        .irq_tx_complete  = z_uart_async_to_irq_irq_tx_complete,\
        .irq_rx_ready     = z_uart_async_to_irq_irq_rx_ready,   \
        .irq_err_enable   = z_uart_async_to_irq_irq_err_enable, \
        .irq_err_disable  = z_uart_async_to_irq_irq_err_disable,\
        .irq_is_pending   = z_uart_async_to_irq_irq_is_pending, \
        .irq_update       = z_uart_async_to_irq_irq_update,     \
        .irq_callback_set = z_uart_async_to_irq_irq_callback_set
 
#define UART_ASYNC_TO_IRQ_API_CONFIG_INITIALIZER(_api, _trampoline, _baudrate, _tx_buf,         \
                                                 _tx_len, _rx_buf, _rx_len, _rx_cnt, _log)      \
        {                                                                                       \
                .tx_buf = _tx_buf,                                                              \
                .tx_len = _tx_len,                                                              \
                .async_rx = {                                                                   \
                        .buffer = _rx_buf,                                                      \
                        .length = _rx_len,                                                      \
                        .buf_cnt = _rx_cnt                                                      \
                },                                                                              \
                .api = _api,                                                                    \
                .trampoline = _trampoline,                                                      \
                .baudrate = _baudrate,                                                          \
                LOG_OBJECT_PTR_INIT(log,                                                        \
                                COND_CODE_1(IS_EMPTY(_log),                                     \
                                            (LOG_OBJECT_PTR(UART_ASYNC_TO_IRQ_LOG_NAME)),       \
                                            (_log)                                              \
                                           )                                                    \
                                   )                                                            \
        }
 
int uart_async_to_irq_init(const struct device *dev);
 
/* @brief Enable RX for interrupt driven API.
 *
 * @param dev UART device. Device must support asynchronous API.
 *
 * @retval 0 on successful operation.
 * @retval -EINVAL if adaption layer has wrong configuration.
 * @retval negative value Error reported by the UART API.
 */
int uart_async_to_irq_rx_enable(const struct device *dev);
 
/* @brief Disable RX for interrupt driven API.
 *
 * @param dev UART device. Device must support asynchronous API.
 *
 * @retval 0 on successful operation.
 * @retval -EINVAL if adaption layer has wrong configuration.
 * @retval negative value Error reported by the UART API.
 */
int uart_async_to_irq_rx_disable(const struct device *dev);
 
/* Starting from here API is internal only. */
 
struct uart_async_to_irq_config {
        uint8_t *tx_buf;
 
        size_t tx_len;
 
        struct uart_async_rx_config async_rx;
 
        const struct uart_async_to_irq_async_api *api;
 
        uart_async_to_irq_trampoline trampoline;
 
        uint32_t baudrate;
 
        LOG_INSTANCE_PTR_DECLARE(log);
};
 
struct uart_async_to_irq_async_api {
        int (*callback_set)(const struct device *dev,
                            uart_callback_t callback,
                            void *user_data);
 
        int (*tx)(const struct device *dev, const uint8_t *buf, size_t len,
                  int32_t timeout);
        int (*tx_abort)(const struct device *dev);
 
        int (*rx_enable)(const struct device *dev, uint8_t *buf, size_t len,
                         int32_t timeout);
        int (*rx_buf_rsp)(const struct device *dev, uint8_t *buf, size_t len);
        int (*rx_disable)(const struct device *dev);
};
 
struct uart_async_to_irq_rx_data {
        struct uart_async_rx async_rx;
 
        struct k_sem sem;
 
        atomic_t pending_buf_req;
};
 
struct uart_async_to_irq_tx_data {
        uint8_t *buf;
 
        size_t len;
};
 
struct uart_async_to_irq_data {
        uart_irq_callback_user_data_t callback;
 
        void *user_data;
 
        atomic_t irq_req;
 
        struct uart_async_to_irq_rx_data rx;
 
        struct uart_async_to_irq_tx_data tx;
 
        struct k_spinlock lock;
 
        atomic_t flags;
};
 
int z_uart_async_to_irq_fifo_fill(const struct device *dev,
                                  const uint8_t *buf,
                                  int len);
 
int z_uart_async_to_irq_fifo_read(const struct device *dev,
                                  uint8_t *buf,
                                  const int len);
 
void z_uart_async_to_irq_irq_tx_enable(const struct device *dev);
 
void z_uart_async_to_irq_irq_tx_disable(const struct device *dev);
 
int z_uart_async_to_irq_irq_tx_ready(const struct device *dev);
 
void z_uart_async_to_irq_irq_rx_enable(const struct device *dev);
 
void z_uart_async_to_irq_irq_rx_disable(const struct device *dev);
 
int z_uart_async_to_irq_irq_tx_complete(const struct device *dev);
 
int z_uart_async_to_irq_irq_rx_ready(const struct device *dev);
 
void z_uart_async_to_irq_irq_err_enable(const struct device *dev);
 
void z_uart_async_to_irq_irq_err_disable(const struct device *dev);
 
int z_uart_async_to_irq_irq_is_pending(const struct device *dev);
 
int z_uart_async_to_irq_irq_update(const struct device *dev);
 
void z_uart_async_to_irq_irq_callback_set(const struct device *dev,
                         uart_irq_callback_user_data_t cb,
                         void *user_data);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_DRIVERS_SERIAL_UART_ASYNC_TO_IRQ_H_ */