cfn_hal_sdio.h

Go to the documentation of this file.

 
#ifndef CAFFEINE_HAL_HAL_SDIO_H
#define CAFFEINE_HAL_HAL_SDIO_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_SDIO_EVENT_NONE        = 0,
    CFN_HAL_SDIO_EVENT_TX_COMPLETE = CFN_HAL_BIT(0), 
    CFN_HAL_SDIO_EVENT_RX_READY    = CFN_HAL_BIT(1), 
    CFN_HAL_SDIO_EVENT_CMD_SENT    = CFN_HAL_BIT(2), 
} cfn_hal_sdio_event_t;
 
typedef enum
{
    CFN_HAL_SDIO_ERROR_NONE    = 0,
    CFN_HAL_SDIO_ERROR_CRC     = CFN_HAL_BIT(0), 
    CFN_HAL_SDIO_ERROR_TIMEOUT = CFN_HAL_BIT(1), 
    CFN_HAL_SDIO_ERROR_GENERAL = CFN_HAL_BIT(2), 
} cfn_hal_sdio_error_t;
 
/* Types Structs ----------------------------------------------------*/
 
typedef struct
{
    uint32_t arg;           
    uint32_t cmd_index;     
    uint32_t response_type; 
    uint32_t wait_type;     
} cfn_hal_sdio_cmd_t;
 
typedef struct
{
    uint32_t card_type;     
    uint32_t card_version;  
    uint32_t speed_class;   
    uint32_t rel_card_addr; 
    uint32_t block_count;   
    uint32_t block_size;    
    uint32_t log_block_count;
    uint32_t log_block_size;
} cfn_hal_sdio_card_info_t;
 
typedef struct
{
    uint32_t bus_wide;   
    uint32_t clock_freq; 
    void    *custom;     
} cfn_hal_sdio_config_t;
 
typedef struct
{
    void                      *instance; 
    cfn_hal_gpio_pin_handle_t *ck;       
    cfn_hal_gpio_pin_handle_t *cmd;      
    cfn_hal_gpio_pin_handle_t *d0;       
    cfn_hal_gpio_pin_handle_t *d1;       
    cfn_hal_gpio_pin_handle_t *d2;       
    cfn_hal_gpio_pin_handle_t *d3;       
    void                      *user_arg; 
} cfn_hal_sdio_phy_t;
 
typedef struct cfn_hal_sdio_s     cfn_hal_sdio_t;
typedef struct cfn_hal_sdio_api_s cfn_hal_sdio_api_t;
 
typedef void (*cfn_hal_sdio_callback_t)(cfn_hal_sdio_t *driver,
                                        uint32_t        event_mask,
                                        uint32_t        error_mask,
                                        void           *user_arg);
 
struct cfn_hal_sdio_api_s
{
    cfn_hal_api_base_t base;
 
    /* SDIO Specific Extensions */
    cfn_hal_error_code_t (*send_command)(cfn_hal_sdio_t *driver, const cfn_hal_sdio_cmd_t *cmd, uint32_t *response);
    cfn_hal_error_code_t (*read_blocks)(
        cfn_hal_sdio_t *driver, uint8_t *buffer, uint32_t block_addr, uint32_t nbr_of_blocks, uint32_t timeout);
    cfn_hal_error_code_t (*write_blocks)(
        cfn_hal_sdio_t *driver, const uint8_t *data, uint32_t block_addr, uint32_t nbr_of_blocks, uint32_t timeout);
    cfn_hal_error_code_t (*get_card_info)(cfn_hal_sdio_t *driver, cfn_hal_sdio_card_info_t *info);
    cfn_hal_error_code_t (*wait_card_ready)(cfn_hal_sdio_t *driver, uint32_t timeout);
};
CFN_HAL_VMT_CHECK(struct cfn_hal_sdio_api_s);
 
CFN_HAL_CREATE_DRIVER_TYPE(
    sdio, cfn_hal_sdio_config_t, cfn_hal_sdio_api_t, cfn_hal_sdio_phy_t, cfn_hal_sdio_callback_t);
 
/* Functions inline ------------------------------------------------- */
CFN_HAL_INLINE void cfn_hal_sdio_populate(cfn_hal_sdio_t              *driver,
                                          uint32_t                     peripheral_id,
                                          struct cfn_hal_clock_s      *clock,
                                          void                        *dependency,
                                          const cfn_hal_sdio_api_t    *api,
                                          const cfn_hal_sdio_phy_t    *phy,
                                          const cfn_hal_sdio_config_t *config,
                                          cfn_hal_sdio_callback_t      callback,
                                          void                        *user_arg)
{
    CFN_HAL_POPULATE_DRIVER(
        driver, CFN_HAL_PERIPHERAL_TYPE_SDIO, peripheral_id, clock, dependency, api, phy, config, callback, user_arg);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_config_validate(const cfn_hal_sdio_t        *driver,
                                                                 const cfn_hal_sdio_config_t *config)
{
    if (driver == NULL || config == NULL)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
 
    return cfn_hal_base_config_validate(&driver->base, CFN_HAL_PERIPHERAL_TYPE_SDIO, config);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_init(cfn_hal_sdio_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_sdio_config_validate(driver, driver->config);
    if (error != CFN_HAL_ERROR_OK)
    {
        return error;
    }
    return cfn_hal_base_init(&driver->base, CFN_HAL_PERIPHERAL_TYPE_SDIO);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_deinit(cfn_hal_sdio_t *driver)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    return cfn_hal_base_deinit(&driver->base, CFN_HAL_PERIPHERAL_TYPE_SDIO);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_config_set(cfn_hal_sdio_t *driver, const cfn_hal_sdio_config_t *config)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    cfn_hal_error_code_t error = cfn_hal_sdio_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_SDIO, (const void *) config);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_config_get(cfn_hal_sdio_t *driver, cfn_hal_sdio_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_sdio_callback_register(cfn_hal_sdio_t               *driver,
                                                                   const cfn_hal_sdio_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_SDIO, (cfn_hal_callback_t) callback, user_arg);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_power_state_set(cfn_hal_sdio_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_SDIO, state);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_event_enable(cfn_hal_sdio_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_SDIO, event_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_event_disable(cfn_hal_sdio_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_SDIO, event_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_event_get(cfn_hal_sdio_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_SDIO, event_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_error_enable(cfn_hal_sdio_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_SDIO, error_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_error_disable(cfn_hal_sdio_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_SDIO, error_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_error_get(cfn_hal_sdio_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_SDIO, error_mask);
}
 
/* SDIO Specific Functions ------------------------------------------ */
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_send_command(cfn_hal_sdio_t           *driver,
                                                              const cfn_hal_sdio_cmd_t *cmd,
                                                              uint32_t                 *response)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_SDIO, send_command, driver, error, cmd, response);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_read_blocks(
    cfn_hal_sdio_t *driver, uint8_t *buffer, uint32_t block_addr, uint32_t nbr_of_blocks, uint32_t timeout)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(
        CFN_HAL_PERIPHERAL_TYPE_SDIO, read_blocks, driver, error, buffer, block_addr, nbr_of_blocks, timeout);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_write_blocks(
    cfn_hal_sdio_t *driver, const uint8_t *data, uint32_t block_addr, uint32_t nbr_of_blocks, uint32_t timeout)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(
        CFN_HAL_PERIPHERAL_TYPE_SDIO, write_blocks, driver, error, data, block_addr, nbr_of_blocks, timeout);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_get_card_info(cfn_hal_sdio_t *driver, cfn_hal_sdio_card_info_t *info)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_SDIO, get_card_info, driver, error, info);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_sdio_wait_card_ready(cfn_hal_sdio_t *driver, uint32_t timeout)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_SDIO, wait_card_ready, driver, error, timeout);
    return error;
}
cfn_hal_error_code_t cfn_hal_sdio_construct(cfn_hal_sdio_t              *driver,
                                            const cfn_hal_sdio_config_t *config,
                                            const cfn_hal_sdio_phy_t    *phy,
                                            struct cfn_hal_clock_s      *clock,
                                            void                        *dependency,
                                            cfn_hal_sdio_callback_t      callback,
                                            void                        *user_arg);
cfn_hal_error_code_t cfn_hal_sdio_destruct(cfn_hal_sdio_t *driver);
#ifdef __cplusplus
}
#endif
 
#endif // CAFFEINE_HAL_HAL_SDIO_H