cfn_hal_i2c.h

Go to the documentation of this file.

 
#ifndef CAFFEINE_HAL_HAL_I2C_H
#define CAFFEINE_HAL_HAL_I2C_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_I2C_EVENT_NONE        = 0,
    CFN_HAL_I2C_EVENT_TX_COMPLETE = CFN_HAL_BIT(0), 
    CFN_HAL_I2C_EVENT_RX_READY    = CFN_HAL_BIT(1), 
    CFN_HAL_I2C_EVENT_START_SENT  = CFN_HAL_BIT(2), 
    CFN_HAL_I2C_EVENT_ADDR_SENT   = CFN_HAL_BIT(3), 
    CFN_HAL_I2C_EVENT_HEADER_SENT = CFN_HAL_BIT(4), 
    CFN_HAL_I2C_EVENT_DATA_SENT   = CFN_HAL_BIT(5), 
    CFN_HAL_I2C_EVENT_STOP_DET    = CFN_HAL_BIT(6), 
} cfn_hal_i2c_event_t;
 
typedef enum
{
    CFN_HAL_I2C_ERROR_NONE        = 0,
    CFN_HAL_I2C_ERROR_ARBITRATION = CFN_HAL_BIT(0), 
    CFN_HAL_I2C_ERROR_ACK         = CFN_HAL_BIT(1), 
    CFN_HAL_I2C_ERROR_OVERRUN     = CFN_HAL_BIT(2), 
    CFN_HAL_I2C_ERROR_PEC         = CFN_HAL_BIT(3), 
    CFN_HAL_I2C_ERROR_TIMEOUT     = CFN_HAL_BIT(4), 
    CFN_HAL_I2C_ERROR_SMB         = CFN_HAL_BIT(5), 
    CFN_HAL_I2C_ERROR_GENERAL     = CFN_HAL_BIT(6), 
} cfn_hal_i2c_error_t;
 
typedef enum
{
    CFN_HAL_I2C_CONFIG_SPEED_100KHZ,  
    CFN_HAL_I2C_CONFIG_SPEED_400KHZ,  
    CFN_HAL_I2C_CONFIG_SPEED_1000KHZ, 
    CFN_HAL_I2C_CONFIG_SPEED_3330KHZ, 
    CFN_HAL_I2C_CONFIG_SPEED_3400KHZ, 
    CFN_HAL_I2C_CONFIG_SPEED_5000KHZ, 
    CFN_HAL_I2C_CONFIG_SPEED_CUSTOM,  
    CFN_HAL_I2C_CONFIG_SPEED_MAX
} cfn_hal_i2c_config_speed_t;
 
/* Types Structs ----------------------------------------------------*/
 
typedef struct
{
    void                      *instance; 
    cfn_hal_gpio_pin_handle_t *sda;      
    cfn_hal_gpio_pin_handle_t *scl;      
    cfn_hal_gpio_pin_handle_t *irq;      
    void                      *user_arg; 
} cfn_hal_i2c_phy_t;
 
typedef struct cfn_hal_i2c_config_s
{
    cfn_hal_i2c_config_speed_t speed;  
    void                      *custom; 
} cfn_hal_i2c_config_t;
 
typedef struct
{
    uint16_t       slave_address;   
    const uint8_t *tx_payload;      
    size_t         nbr_of_tx_bytes; 
    uint8_t       *rx_payload;      
    size_t         nbr_of_rx_bytes; 
} cfn_hal_i2c_transaction_t;
 
typedef struct
{
    uint16_t dev_addr;      
    uint16_t mem_addr;      
    uint8_t  mem_addr_size; 
    uint8_t *data;          
    size_t   size;          
} cfn_hal_i2c_mem_transaction_t;
 
typedef struct cfn_hal_i2c_s cfn_hal_i2c_t;
 
typedef struct
{
    cfn_hal_i2c_t *i2c;     
    uint16_t       address; 
} cfn_hal_i2c_device_t;
 
typedef struct cfn_hal_i2c_api_s cfn_hal_i2c_api_t;
 
typedef void (*cfn_hal_i2c_callback_t)(cfn_hal_i2c_t *driver,
                                       uint32_t       event_mask,
                                       uint32_t       error_mask,
                                       uint8_t       *payload,
                                       size_t         nbr_of_bytes,
                                       void          *user_arg);
 
struct cfn_hal_i2c_api_s
{
    cfn_hal_api_base_t base;
 
    /* I2C Specific Extensions */
    cfn_hal_error_code_t (*xfr_irq)(cfn_hal_i2c_t *driver, const cfn_hal_i2c_transaction_t *xfr);
    cfn_hal_error_code_t (*xfr_irq_abort)(cfn_hal_i2c_t *driver);
    cfn_hal_error_code_t (*xfr_polling)(cfn_hal_i2c_t *driver, const cfn_hal_i2c_transaction_t *xfr, uint32_t timeout);
    cfn_hal_error_code_t (*mem_read)(cfn_hal_i2c_t                       *driver,
                                     const cfn_hal_i2c_mem_transaction_t *mem_xfr,
                                     uint32_t                             timeout);
    cfn_hal_error_code_t (*mem_write)(cfn_hal_i2c_t                       *driver,
                                      const cfn_hal_i2c_mem_transaction_t *mem_xfr,
                                      uint32_t                             timeout);
    cfn_hal_error_code_t (*xfr_dma)(cfn_hal_i2c_t *driver, const cfn_hal_i2c_transaction_t *xfr);
};
 
CFN_HAL_VMT_CHECK(struct cfn_hal_i2c_api_s);
 
CFN_HAL_CREATE_DRIVER_TYPE(i2c, cfn_hal_i2c_config_t, cfn_hal_i2c_api_t, cfn_hal_i2c_phy_t, cfn_hal_i2c_callback_t);
 
/* Functions inline ------------------------------------------------- */
CFN_HAL_INLINE void cfn_hal_i2c_populate(cfn_hal_i2c_t              *driver,
                                         uint32_t                    peripheral_id,
                                         struct cfn_hal_clock_s     *clock,
                                         void                       *dependency,
                                         const cfn_hal_i2c_api_t    *api,
                                         const cfn_hal_i2c_phy_t    *phy,
                                         const cfn_hal_i2c_config_t *config,
                                         cfn_hal_i2c_callback_t      callback,
                                         void                       *user_arg)
{
    CFN_HAL_POPULATE_DRIVER(
        driver, CFN_HAL_PERIPHERAL_TYPE_I2C, peripheral_id, clock, dependency, api, phy, config, callback, user_arg);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_config_validate(const cfn_hal_i2c_t        *driver,
                                                                const cfn_hal_i2c_config_t *config)
{
    if (driver == NULL || config == NULL)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
 
    if (config->speed >= CFN_HAL_I2C_CONFIG_SPEED_MAX)
    {
        return CFN_HAL_ERROR_BAD_CONFIG;
    }
 
    return cfn_hal_base_config_validate(&driver->base, CFN_HAL_PERIPHERAL_TYPE_I2C, config);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_init(cfn_hal_i2c_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_i2c_config_validate(driver, driver->config);
    if (error != CFN_HAL_ERROR_OK)
    {
        return error;
    }
    return cfn_hal_base_init(&driver->base, CFN_HAL_PERIPHERAL_TYPE_I2C);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_deinit(cfn_hal_i2c_t *driver)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    return cfn_hal_base_deinit(&driver->base, CFN_HAL_PERIPHERAL_TYPE_I2C);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_config_set(cfn_hal_i2c_t *driver, const cfn_hal_i2c_config_t *config)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    cfn_hal_error_code_t error = cfn_hal_i2c_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_I2C, (const void *) config);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_config_get(cfn_hal_i2c_t *driver, cfn_hal_i2c_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_i2c_callback_register(cfn_hal_i2c_t               *driver,
                                                                  const cfn_hal_i2c_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_I2C, (cfn_hal_callback_t) callback, user_arg);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_power_state_set(cfn_hal_i2c_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_I2C, state);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_event_enable(cfn_hal_i2c_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_I2C, event_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_event_disable(cfn_hal_i2c_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_I2C, event_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_event_get(cfn_hal_i2c_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_I2C, event_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_error_enable(cfn_hal_i2c_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_I2C, error_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_error_disable(cfn_hal_i2c_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_I2C, error_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_error_get(cfn_hal_i2c_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_I2C, error_mask);
}
 
/* I2C Specific Functions ------------------------------------------- */
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_xfr_irq(cfn_hal_i2c_t *driver, const cfn_hal_i2c_transaction_t *xfr)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_I2C, xfr_irq, driver, error, xfr);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_xfr_irq_abort(cfn_hal_i2c_t *driver)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC(CFN_HAL_PERIPHERAL_TYPE_I2C, xfr_irq_abort, driver, error);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_xfr_polling(cfn_hal_i2c_t                   *driver,
                                                            const cfn_hal_i2c_transaction_t *xfr,
                                                            uint32_t                         timeout)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_I2C, xfr_polling, driver, error, xfr, timeout);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_mem_read(cfn_hal_i2c_t                       *driver,
                                                         const cfn_hal_i2c_mem_transaction_t *mem_xfr,
                                                         uint32_t                             timeout)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_I2C, mem_read, driver, error, mem_xfr, timeout);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_mem_write(cfn_hal_i2c_t                       *driver,
                                                          const cfn_hal_i2c_mem_transaction_t *mem_xfr,
                                                          uint32_t                             timeout)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_I2C, mem_write, driver, error, mem_xfr, timeout);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_i2c_xfr_dma(cfn_hal_i2c_t *driver, const cfn_hal_i2c_transaction_t *xfr)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_I2C, xfr_dma, driver, error, xfr);
    return error;
}
cfn_hal_error_code_t cfn_hal_i2c_construct(cfn_hal_i2c_t              *driver,
                                           const cfn_hal_i2c_config_t *config,
                                           const cfn_hal_i2c_phy_t    *phy,
                                           struct cfn_hal_clock_s     *clock,
                                           void                       *dependency,
                                           cfn_hal_i2c_callback_t      callback,
                                           void                       *user_arg);
cfn_hal_error_code_t cfn_hal_i2c_destruct(cfn_hal_i2c_t *driver);
#ifdef __cplusplus
}
#endif
 
#endif // CAFFEINE_HAL_HAL_I2C_H