uart.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2019 Nordic Semiconductor ASA
 * Copyright (c) 2015 Wind River Systems, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_UART_H_
#define ZEPHYR_INCLUDE_DRIVERS_UART_H_
 
#include <stddef.h>
 
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum uart_line_ctrl {
        UART_LINE_CTRL_BAUD_RATE = BIT(0), 
        UART_LINE_CTRL_RTS = BIT(1),       
        UART_LINE_CTRL_DTR = BIT(2),       
        UART_LINE_CTRL_DCD = BIT(3),       
        UART_LINE_CTRL_DSR = BIT(4),       
};
 
enum uart_rx_stop_reason {
        UART_ERROR_OVERRUN = (1 << 0),
        UART_ERROR_PARITY  = (1 << 1),
        UART_ERROR_FRAMING = (1 << 2),
        UART_BREAK = (1 << 3),
        UART_ERROR_COLLISION = (1 << 4),
        UART_ERROR_NOISE = (1 << 5),
};
 
enum uart_config_parity {
        UART_CFG_PARITY_NONE,   
        UART_CFG_PARITY_ODD,    
        UART_CFG_PARITY_EVEN,   
        UART_CFG_PARITY_MARK,   
        UART_CFG_PARITY_SPACE,  
};
 
enum uart_config_stop_bits {
        UART_CFG_STOP_BITS_0_5,  
        UART_CFG_STOP_BITS_1,    
        UART_CFG_STOP_BITS_1_5,  
        UART_CFG_STOP_BITS_2,    
};
 
enum uart_config_data_bits {
        UART_CFG_DATA_BITS_5,    
        UART_CFG_DATA_BITS_6,    
        UART_CFG_DATA_BITS_7,    
        UART_CFG_DATA_BITS_8,    
        UART_CFG_DATA_BITS_9,    
};
 
enum uart_config_flow_control {
        UART_CFG_FLOW_CTRL_NONE,     
        UART_CFG_FLOW_CTRL_RTS_CTS,  
        UART_CFG_FLOW_CTRL_DTR_DSR,  
        UART_CFG_FLOW_CTRL_RS485,    
};
 
struct uart_config {
        uint32_t baudrate;  
        uint8_t parity;     
        uint8_t stop_bits;  
        uint8_t data_bits;  
        uint8_t flow_ctrl;  
};
 
typedef void (*uart_irq_callback_user_data_t)(const struct device *dev,
                                              void *user_data);
 
enum uart_event_type {
        UART_TX_DONE,
        UART_TX_ABORTED,
        UART_RX_RDY,
        UART_RX_BUF_REQUEST,
        UART_RX_BUF_RELEASED,
        UART_RX_DISABLED,
        UART_RX_STOPPED,
};
 
struct uart_event_tx {
        const uint8_t *buf;
        size_t len;
};
 
struct uart_event_rx {
        uint8_t *buf;
        size_t offset;
        size_t len;
};
 
struct uart_event_rx_buf {
        uint8_t *buf;
};
 
struct uart_event_rx_stop {
        enum uart_rx_stop_reason reason;
        struct uart_event_rx data;
};
 
struct uart_event {
        enum uart_event_type type;
        union uart_event_data {
                struct uart_event_tx tx;
                struct uart_event_rx rx;
                struct uart_event_rx_buf rx_buf;
                struct uart_event_rx_stop rx_stop;
        } data;
};
 
typedef void (*uart_callback_t)(const struct device *dev,
                                struct uart_event *evt, void *user_data);
 
__syscall int uart_err_check(const struct device *dev);
 
__syscall int uart_poll_in(const struct device *dev, unsigned char *p_char);
 
__syscall int uart_poll_in_u16(const struct device *dev, uint16_t *p_u16);
 
__syscall void uart_poll_out(const struct device *dev,
                             unsigned char out_char);
 
__syscall void uart_poll_out_u16(const struct device *dev, uint16_t out_u16);
 
__syscall int uart_configure(const struct device *dev,
                             const struct uart_config *cfg);
 
__syscall int uart_config_get(const struct device *dev,
                              struct uart_config *cfg);
 
static inline int uart_fifo_fill(const struct device *dev, const uint8_t *tx_data, int size);
 
static inline int uart_fifo_fill_u16(const struct device *dev, const uint16_t *tx_data, int size);
 
static inline int uart_fifo_read(const struct device *dev, uint8_t *rx_data, const int size);
 
static inline int uart_fifo_read_u16(const struct device *dev, uint16_t *rx_data, const int size);
 
__syscall void uart_irq_tx_enable(const struct device *dev);
 
__syscall void uart_irq_tx_disable(const struct device *dev);
 
static inline int uart_irq_tx_ready(const struct device *dev);
 
__syscall void uart_irq_rx_enable(const struct device *dev);
 
__syscall void uart_irq_rx_disable(const struct device *dev);
 
static inline int uart_irq_tx_complete(const struct device *dev);
 
static inline int uart_irq_rx_ready(const struct device *dev);
 
__syscall void uart_irq_err_enable(const struct device *dev);
 
__syscall void uart_irq_err_disable(const struct device *dev);
 
__syscall int uart_irq_is_pending(const struct device *dev);
 
__syscall int uart_irq_update(const struct device *dev);
 
static inline int uart_irq_callback_user_data_set(const struct device *dev,
                                                  uart_irq_callback_user_data_t cb,
                                                  void *user_data);
 
static inline int uart_irq_callback_set(const struct device *dev,
                                         uart_irq_callback_user_data_t cb);
 
static inline int uart_callback_set(const struct device *dev,
                                    uart_callback_t callback,
                                    void *user_data);
 
__syscall int uart_tx(const struct device *dev, const uint8_t *buf,
                      size_t len,
                      int32_t timeout);
 
__syscall int uart_tx_u16(const struct device *dev, const uint16_t *buf,
                          size_t len, int32_t timeout);
 
__syscall int uart_tx_abort(const struct device *dev);
 
__syscall int uart_rx_enable(const struct device *dev, uint8_t *buf,
                             size_t len,
                             int32_t timeout);
 
__syscall int uart_rx_enable_u16(const struct device *dev, uint16_t *buf,
                                 size_t len, int32_t timeout);
 
static inline int uart_rx_buf_rsp(const struct device *dev, uint8_t *buf,
                                  size_t len);
 
static inline int uart_rx_buf_rsp_u16(const struct device *dev, uint16_t *buf,
                                      size_t len);
 
__syscall int uart_rx_disable(const struct device *dev);
 
__syscall int uart_line_ctrl_set(const struct device *dev,
                                 uint32_t ctrl, uint32_t val);
 
__syscall int uart_line_ctrl_get(const struct device *dev, uint32_t ctrl,
                                 uint32_t *val);
 
__syscall int uart_drv_cmd(const struct device *dev, uint32_t cmd, uint32_t p);
 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/drivers/uart/uart_internal.h>
#include <zephyr/syscalls/uart.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_UART_H_ */