cfn_hal_uart.h

Go to the documentation of this file.

 
#ifndef CAFFEINE_HAL_HAL_UART_H
#define CAFFEINE_HAL_HAL_UART_H
 
#ifdef __cplusplus
extern "C"
{
#endif
 
/* Includes ---------------------------------------------------------*/
#include "cfn_hal.h"
#include "cfn_hal_base.h"
#include "cfn_hal_gpio.h"
#include "cfn_hal_types.h"
 
/* Defines ----------------------------------------------------------*/
 
/* Types Enums ------------------------------------------------------*/
 
typedef enum
{
    CFN_HAL_UART_EVENT_NONE        = 0,
    CFN_HAL_UART_EVENT_TX_COMPLETE = CFN_HAL_BIT(0), 
    CFN_HAL_UART_EVENT_RX_READY    = CFN_HAL_BIT(1), 
    CFN_HAL_UART_EVENT_BUS_IDLE    = CFN_HAL_BIT(2), 
    CFN_HAL_UART_EVENT_RX_BYTE     = CFN_HAL_BIT(3), 
} cfn_hal_uart_event_t;
 
#define CFN_HAL_UART_FLAG_CONTINUOUS_RX CFN_HAL_BIT(0)
 
typedef enum
{
    CFN_HAL_UART_ERROR_NONE    = 0,
    CFN_HAL_UART_ERROR_FRAMING = CFN_HAL_BIT(0), 
    CFN_HAL_UART_ERROR_PARITY  = CFN_HAL_BIT(1), 
    CFN_HAL_UART_ERROR_OVERRUN = CFN_HAL_BIT(2), 
    CFN_HAL_UART_ERROR_TIMEOUT = CFN_HAL_BIT(3), 
    CFN_HAL_UART_ERROR_GENERAL = CFN_HAL_BIT(4), 
} cfn_hal_uart_error_t;
 
typedef enum
{
    CFN_HAL_UART_CONFIG_PARITY_NONE, 
    CFN_HAL_UART_CONFIG_PARITY_EVEN, 
    CFN_HAL_UART_CONFIG_PARITY_ODD,  
    CFN_HAL_UART_CONFIG_PARITY_MAX
} cfn_hal_uart_config_parity_t;
 
typedef enum
{
    CFN_HAL_UART_CONFIG_STOP_ONE_BIT,  
    CFN_HAL_UART_CONFIG_STOP_TWO_BITS, 
    CFN_HAL_UART_CONFIG_STOP_MAX
} cfn_hal_uart_config_stop_bits_t;
 
typedef enum
{
    CFN_HAL_UART_CONFIG_DATA_LEN_5, 
    CFN_HAL_UART_CONFIG_DATA_LEN_6, 
    CFN_HAL_UART_CONFIG_DATA_LEN_7, 
    CFN_HAL_UART_CONFIG_DATA_LEN_8, 
    CFN_HAL_UART_CONFIG_DATA_LEN_9, 
    CFN_HAL_UART_CONFIG_DATA_LEN_MAX
} cfn_hal_uart_config_data_len_t;
 
typedef enum
{
    CFN_HAL_UART_CONFIG_FLOW_CTRL_NONE,    
    CFN_HAL_UART_CONFIG_FLOW_CTRL_CTS,     
    CFN_HAL_UART_CONFIG_FLOW_CTRL_RTS,     
    CFN_HAL_UART_CONFIG_FLOW_CTRL_RTS_CTS, 
    CFN_HAL_UART_CONFIG_FLOW_CTRL_MAX
} cfn_hal_uart_config_flow_ctrl_t;
 
typedef enum
{
    CFN_HAL_UART_CONFIG_MODE_NONE,      
    CFN_HAL_UART_CONFIG_MODE_BLOCKING,  
    CFN_HAL_UART_CONFIG_MODE_INTERRUPT, 
    CFN_HAL_UART_CONFIG_MODE_DMA,       
    CFN_HAL_UART_CONFIG_MODE_MAX
} cfn_hal_uart_config_mode_t;
 
typedef enum
{
    CFN_HAL_UART_CONFIG_DIRECTION_NONE,
    CFN_HAL_UART_CONFIG_DIRECTION_TX_ONLY,
    CFN_HAL_UART_CONFIG_DIRECTION_RX_ONLY,
    CFN_HAL_UART_CONFIG_DIRECTION_TX_RX,
 
    CFN_HAL_UART_CONFIG_DIRECTION_MAX
} cfn_hal_uart_config_direction_t;
/* Types Structs ----------------------------------------------------*/
 
typedef struct
{
    void                      *instance;  
    cfn_hal_gpio_pin_handle_t *tx;        
    cfn_hal_gpio_pin_handle_t *rx;        
    cfn_hal_gpio_pin_handle_t *cts;       
    cfn_hal_gpio_pin_handle_t *rts;       
    void                      *user_data; 
} cfn_hal_uart_phy_t;
 
typedef struct
{
    bool                            echo;       
    uint32_t                        baudrate;   
    cfn_hal_uart_config_mode_t      read_mode;  
    cfn_hal_uart_config_mode_t      write_mode; 
    cfn_hal_uart_config_data_len_t  data_len;   
    cfn_hal_uart_config_stop_bits_t stop_bits;  
    cfn_hal_uart_config_parity_t    parity;     
    cfn_hal_uart_config_flow_ctrl_t flow_ctrl;  
    cfn_hal_uart_config_direction_t direction;
    void                           *custom; 
} cfn_hal_uart_config_t;
 
typedef struct cfn_hal_uart_s     cfn_hal_uart_t;
typedef struct cfn_hal_uart_api_s cfn_hal_uart_api_t;
 
typedef void (*cfn_hal_uart_callback_t)(cfn_hal_uart_t *driver,
                                        uint32_t        event_mask,
                                        uint32_t        error_mask,
                                        uint8_t        *data,
                                        size_t          nbr_of_bytes,
                                        void           *user_arg);
 
struct cfn_hal_uart_api_s
{
    cfn_hal_api_base_t base;
 
    /* UART Specific Extensions */
    cfn_hal_error_code_t (*tx_irq)(cfn_hal_uart_t *driver, const uint8_t *data, size_t nbr_of_bytes);
    cfn_hal_error_code_t (*tx_irq_abort)(cfn_hal_uart_t *driver);
    cfn_hal_error_code_t (*rx_n_irq)(cfn_hal_uart_t *driver, uint8_t *data, size_t nbr_of_bytes);
    cfn_hal_error_code_t (*rx_irq)(cfn_hal_uart_t *driver);
    cfn_hal_error_code_t (*rx_irq_abort)(cfn_hal_uart_t *driver);
    cfn_hal_error_code_t (*tx_polling)(cfn_hal_uart_t *driver,
                                       const uint8_t  *data,
                                       size_t          nbr_of_bytes,
                                       uint32_t        timeout);
    cfn_hal_error_code_t (*rx_polling)(cfn_hal_uart_t *driver, uint8_t *data, size_t nbr_of_bytes, uint32_t timeout);
    cfn_hal_error_code_t (*rx_to_idle)(
        cfn_hal_uart_t *driver, uint8_t *data, size_t max_bytes, size_t *received_bytes, uint32_t timeout);
    cfn_hal_error_code_t (*tx_dma)(cfn_hal_uart_t *driver, const uint8_t *data, size_t nbr_of_bytes);
    cfn_hal_error_code_t (*rx_dma)(cfn_hal_uart_t *driver, uint8_t *data, size_t nbr_of_bytes);
};
 
CFN_HAL_VMT_CHECK(struct cfn_hal_uart_api_s);
 
CFN_HAL_CREATE_DRIVER_TYPE(
    uart, cfn_hal_uart_config_t, cfn_hal_uart_api_t, cfn_hal_uart_phy_t, cfn_hal_uart_callback_t);
/* Functions inline ------------------------------------------------- */
CFN_HAL_INLINE void cfn_hal_uart_populate(cfn_hal_uart_t              *driver,
                                          uint32_t                     peripheral_id,
                                          struct cfn_hal_clock_s      *clock,
                                          void                        *dependency,
                                          const cfn_hal_uart_api_t    *api,
                                          const cfn_hal_uart_phy_t    *phy,
                                          const cfn_hal_uart_config_t *config,
                                          cfn_hal_uart_callback_t      callback,
                                          void                        *user_arg)
{
    CFN_HAL_POPULATE_DRIVER(
        driver, CFN_HAL_PERIPHERAL_TYPE_UART, peripheral_id, clock, dependency, api, phy, config, callback, user_arg);
}
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_config_validate(const cfn_hal_uart_t        *driver,
                                                                 const cfn_hal_uart_config_t *config)
{
    if (driver == NULL || config == NULL)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
 
    if (config->read_mode >= CFN_HAL_UART_CONFIG_MODE_MAX || config->write_mode >= CFN_HAL_UART_CONFIG_MODE_MAX ||
        config->data_len >= CFN_HAL_UART_CONFIG_DATA_LEN_MAX || config->stop_bits >= CFN_HAL_UART_CONFIG_STOP_MAX ||
        config->parity >= CFN_HAL_UART_CONFIG_PARITY_MAX || config->flow_ctrl >= CFN_HAL_UART_CONFIG_FLOW_CTRL_MAX ||
        config->direction >= CFN_HAL_UART_CONFIG_DIRECTION_MAX)
    {
        return CFN_HAL_ERROR_BAD_CONFIG;
    }
 
    return cfn_hal_base_config_validate(&driver->base, CFN_HAL_PERIPHERAL_TYPE_UART, config);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_init(cfn_hal_uart_t *driver)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    driver->base.vmt           = (const struct cfn_hal_api_base_s *) driver->api;
    cfn_hal_error_code_t error = cfn_hal_uart_config_validate(driver, driver->config);
    if (error != CFN_HAL_ERROR_OK)
    {
        return error;
    }
    return cfn_hal_base_init(&driver->base, CFN_HAL_PERIPHERAL_TYPE_UART);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_deinit(cfn_hal_uart_t *driver)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    return cfn_hal_base_deinit(&driver->base, CFN_HAL_PERIPHERAL_TYPE_UART);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_config_set(cfn_hal_uart_t *driver, const cfn_hal_uart_config_t *config)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    cfn_hal_error_code_t error = cfn_hal_uart_config_validate(driver, config);
    if (error != CFN_HAL_ERROR_OK)
    {
        return error;
    }
    {
        driver->config = config;
    }
    return cfn_hal_base_config_set(&driver->base, CFN_HAL_PERIPHERAL_TYPE_UART, (const void *) config);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_config_get(cfn_hal_uart_t *driver, cfn_hal_uart_config_t *config)
{
    if (!driver || !config || !driver->config)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    *config = *(driver->config);
    return CFN_HAL_ERROR_OK;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_callback_register(cfn_hal_uart_t               *driver,
                                                                   const cfn_hal_uart_callback_t callback,
                                                                   void                         *user_arg)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    {
        driver->cb          = callback;
        driver->cb_user_arg = user_arg;
    }
    return cfn_hal_base_callback_register(
        &driver->base, CFN_HAL_PERIPHERAL_TYPE_UART, (cfn_hal_callback_t) callback, user_arg);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_power_state_set(cfn_hal_uart_t *driver, cfn_hal_power_state_t state)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    return cfn_hal_power_state_set(&driver->base, CFN_HAL_PERIPHERAL_TYPE_UART, state);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_event_enable(cfn_hal_uart_t *driver, uint32_t event_mask)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    return cfn_hal_base_event_enable(&driver->base, CFN_HAL_PERIPHERAL_TYPE_UART, event_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_event_disable(cfn_hal_uart_t *driver, uint32_t event_mask)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    return cfn_hal_base_event_disable(&driver->base, CFN_HAL_PERIPHERAL_TYPE_UART, event_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_event_get(cfn_hal_uart_t *driver, uint32_t *event_mask)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    return cfn_hal_base_event_get(&driver->base, CFN_HAL_PERIPHERAL_TYPE_UART, event_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_error_enable(cfn_hal_uart_t *driver, uint32_t error_mask)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    return cfn_hal_base_error_enable(&driver->base, CFN_HAL_PERIPHERAL_TYPE_UART, error_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_error_disable(cfn_hal_uart_t *driver, uint32_t error_mask)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    return cfn_hal_base_error_disable(&driver->base, CFN_HAL_PERIPHERAL_TYPE_UART, error_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_error_get(cfn_hal_uart_t *driver, uint32_t *error_mask)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    return cfn_hal_base_error_get(&driver->base, CFN_HAL_PERIPHERAL_TYPE_UART, error_mask);
}
 
/* UART Specific Functions ------------------------------------------ */
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_tx_irq(cfn_hal_uart_t *driver,
                                                        const uint8_t  *data,
                                                        size_t          nbr_of_bytes)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_UART, tx_irq, driver, error, data, nbr_of_bytes);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_tx_irq_abort(cfn_hal_uart_t *driver)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC(CFN_HAL_PERIPHERAL_TYPE_UART, tx_irq_abort, driver, error);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_rx_n_irq(cfn_hal_uart_t *driver, uint8_t *data, size_t nbr_of_bytes)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_UART, rx_n_irq, driver, error, data, nbr_of_bytes);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_rx_irq(cfn_hal_uart_t *driver)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC(CFN_HAL_PERIPHERAL_TYPE_UART, rx_irq, driver, error);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_rx_irq_abort(cfn_hal_uart_t *driver)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC(CFN_HAL_PERIPHERAL_TYPE_UART, rx_irq_abort, driver, error);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_tx_polling(cfn_hal_uart_t *driver,
                                                            const uint8_t  *data,
                                                            size_t          nbr_of_bytes,
                                                            uint32_t        timeout)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(
        CFN_HAL_PERIPHERAL_TYPE_UART, tx_polling, driver, error, data, nbr_of_bytes, timeout);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_rx_polling(cfn_hal_uart_t *driver,
                                                            uint8_t        *data,
                                                            size_t          nbr_of_bytes,
                                                            uint32_t        timeout)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(
        CFN_HAL_PERIPHERAL_TYPE_UART, rx_polling, driver, error, data, nbr_of_bytes, timeout);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_rx_to_idle(
    cfn_hal_uart_t *driver, uint8_t *data, size_t max_bytes, size_t *received_bytes, uint32_t timeout)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(
        CFN_HAL_PERIPHERAL_TYPE_UART, rx_to_idle, driver, error, data, max_bytes, received_bytes, timeout);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_tx_dma(cfn_hal_uart_t *driver,
                                                        const uint8_t  *data,
                                                        size_t          nbr_of_bytes)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_UART, tx_dma, driver, error, data, nbr_of_bytes);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_uart_rx_dma(cfn_hal_uart_t *driver, uint8_t *data, size_t nbr_of_bytes)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_UART, rx_dma, driver, error, data, nbr_of_bytes);
    return error;
}
cfn_hal_error_code_t cfn_hal_uart_construct(cfn_hal_uart_t              *driver,
                                            const cfn_hal_uart_config_t *config,
                                            const cfn_hal_uart_phy_t    *phy,
                                            struct cfn_hal_clock_s      *clock,
                                            void                        *dependency,
                                            cfn_hal_uart_callback_t      callback,
                                            void                        *user_arg);
cfn_hal_error_code_t cfn_hal_uart_destruct(cfn_hal_uart_t *driver);
#ifdef __cplusplus
}
#endif
 
#endif // CAFFEINE_HAL_HAL_UART_H