uart.h

浏览该文件的文档.

 
#ifndef UART_H
#define UART_H
 
#include <stdint.h>
#include <stddef.h>
#include "errcode.h"
#include "hal_uart.h"
#include "uart_porting.h"
 
#if !defined(CONFIG_UART_SUPPORT_TX) && !defined(CONFIG_UART_SUPPORT_RX)
#error UART must support TX or RX
#endif  /* !defined(CONFIG_UART_SUPPORT_TX) && !defined(CONFIG_UART_SUPPORT_RX) */
 
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
 
typedef hal_uart_pin_config_t uart_pin_config_t;
 
typedef hal_uart_data_bit_t uart_data_bit_t;
 
typedef hal_uart_parity_t uart_parity_t;
 
typedef hal_uart_stop_bit_t uart_stop_bit_t;
 
typedef hal_uart_attr_t uart_attr_t;
 
typedef hal_uart_extra_attr_t uart_extra_attr_t;
 
typedef hal_uart_flow_ctrl_t uart_flow_ctrl_t;
 
#if defined(CONFIG_UART_SUPPORT_TX) && defined(CONFIG_UART_SUPPORT_DMA)
typedef struct uart_write_dma_config {
    uint8_t src_width;          
    uint8_t dest_width;         
    uint8_t burst_length;       
    uint8_t priority;           
} uart_write_dma_config_t;
#endif  /* defined(CONFIG_UART_SUPPORT_TX) && defined(CONFIG_UART_SUPPORT_DMA) */
 
typedef struct uart_buffer_config {
    void *rx_buffer;            
    size_t rx_buffer_size;      
} uart_buffer_config_t;
 
#if defined(CONFIG_UART_SUPPORT_RX)
 
#define UART_RX_CONDITION_MASK_IDLE            1
#define UART_RX_CONDITION_MASK_SUFFICIENT_DATA 2
#define UART_RX_CONDITION_MASK_FULL            4
 
typedef enum uart_rx_condition {
    UART_RX_CONDITION_FULL_OR_IDLE = (UART_RX_CONDITION_MASK_FULL | UART_RX_CONDITION_MASK_IDLE),
    UART_RX_CONDITION_FULL_OR_SUFFICIENT_DATA = (UART_RX_CONDITION_MASK_FULL | UART_RX_CONDITION_MASK_SUFFICIENT_DATA),
 
    UART_RX_CONDITION_FULL_OR_SUFFICIENT_DATA_OR_IDLE = (UART_RX_CONDITION_MASK_FULL |
                                                         UART_RX_CONDITION_MASK_SUFFICIENT_DATA |
                                                         UART_RX_CONDITION_MASK_IDLE)
} uart_rx_condition_t;
 
typedef void (*uart_rx_callback_t)(const void *buffer, uint16_t length, bool error);
 
#if defined(CONFIG_UART_SUPPORT_INT_TRIGGER_DMA) && defined(CONFIG_UART_SUPPORT_DMA)
typedef void (*uart_rx_by_dma_callback_t)(uart_bus_t bus, const void *buffer, uint32_t length,
                                          uart_write_dma_config_t *dma_cfg);
#endif  /* defined(CONFIG_UART_SUPPORT_INT_TRIGGER_DMA) && defined(CONFIG_UART_SUPPORT_DMA) */
#endif  /* CONFIG_UART_SUPPORT_RX */
 
#if defined(CONFIG_UART_SUPPORT_TX)
typedef void (*uart_tx_callback_t)(const void *buffer, uint32_t length, const void *params);
#endif  /* CONFIG_UART_SUPPORT_TX */
 
typedef void (*uart_error_callback_t)(uint32_t *err_info, uint32_t len);
 
errcode_t uapi_uart_init(uart_bus_t bus, const uart_pin_config_t *pins,
                         const uart_attr_t *attr, const uart_extra_attr_t *extra_attr,
                         uart_buffer_config_t *uart_buffer_config);
 
errcode_t uapi_uart_deinit(uart_bus_t bus);
 
errcode_t uapi_uart_set_attr(uart_bus_t bus, const uart_attr_t *attr);
 
errcode_t uapi_uart_get_attr(uart_bus_t bus, const uart_attr_t *attr);
 
bool uapi_uart_has_pending_transmissions(uart_bus_t bus);
 
bool uapi_uart_rx_fifo_is_empty(uart_bus_t bus);
 
bool uapi_uart_tx_fifo_is_empty(uart_bus_t bus);
 
#if defined(CONFIG_UART_SUPPORT_RX)
errcode_t uapi_uart_register_rx_callback(uart_bus_t bus, uart_rx_condition_t condition,
                                         uint32_t size, uart_rx_callback_t callback);
 
void uapi_uart_unregister_rx_callback(uart_bus_t bus);
 
errcode_t uapi_uart_register_parity_error_callback(uart_bus_t bus, uart_error_callback_t callback);
 
errcode_t uapi_uart_register_frame_error_callback(uart_bus_t bus, uart_error_callback_t callback);
 
errcode_t uapi_uart_register_overrun_error_callback(uart_bus_t bus, uart_error_callback_t callback);
#endif  /* CONFIG_UART_SUPPORT_RX */
 
#if defined(CONFIG_UART_SUPPORT_TX)
int32_t uapi_uart_write(uart_bus_t bus, const uint8_t *buffer, uint32_t length, uint32_t timeout);
 
errcode_t uapi_uart_write_int(uart_bus_t bus, const uint8_t *buffer, uint32_t length,
                              void *params, uart_tx_callback_t finished_with_buffer_func);
 
#if defined(CONFIG_UART_SUPPORT_DMA)
int32_t uapi_uart_write_by_dma(uart_bus_t bus, const void *buffer, uint32_t length, uart_write_dma_config_t *dma_cfg);
 
int32_t uapi_uart_read_by_dma(uart_bus_t bus, const void *buffer, uint32_t length, uart_write_dma_config_t *dma_cfg);
 
#if defined(CONFIG_UART_SUPPORT_INT_TRIGGER_DMA)
errcode_t uapi_uart_register_read_by_dma_callback(uart_bus_t bus, uart_write_dma_config_t *dma_cfg);
 
void uapi_uart_unregister_read_by_dma_callback(uart_bus_t bus);
#endif  /* CONFIG_UART_SUPPORT_INT_TRIGGER_DMA */
#endif  /* CONFIG_UART_SUPPORT_DMA */
#endif  /* CONFIG_UART_SUPPORT_TX  */
 
#if defined(CONFIG_UART_SUPPORT_RX)
int32_t uapi_uart_read(uart_bus_t bus, const uint8_t *buffer, uint32_t length, uint32_t timeout);
 
errcode_t uapi_uart_flush_rx_data(uart_bus_t bus);
 
errcode_t uapi_uart_update_rx_buff(uart_bus_t bus, uint8_t *rx_buffer, uint16_t rx_buffer_size);
#endif  /* CONFIG_UART_SUPPORT_RX */
 
#if defined(CONFIG_UART_SUPPORT_LPM)
errcode_t uapi_uart_suspend(uintptr_t arg);
 
errcode_t uapi_uart_resume(uintptr_t arg);
#endif  /* CONFIG_UART_SUPPORT_LPM */
 
#ifdef __cplusplus
#if __cplusplus
}
#endif /* __cplusplus */
#endif /* __cplusplus */
 
#endif