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(struct uart_async_to_irq_data *data,
 const struct uart_async_to_irq_config *config);
 
/* @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_ */