cfn_hal_gpio.h

Go to the documentation of this file.

 
#ifndef CAFFEINE_HAL_HAL_GPIO_H
#define CAFFEINE_HAL_HAL_GPIO_H
 
#ifdef __cplusplus
extern "C"
{
#endif
 
/* Includes ---------------------------------------------------------*/
#include "cfn_hal.h"
#include "cfn_hal_base.h"
#include "cfn_hal_types.h"
 
/* Defines ----------------------------------------------------------*/
 
/* Types Enums ------------------------------------------------------*/
 
typedef enum
{
    CFN_HAL_GPIO_EVENT_NONE    = 0,
    CFN_HAL_GPIO_EVENT_RISING  = CFN_HAL_BIT(0), 
    CFN_HAL_GPIO_EVENT_FALLING = CFN_HAL_BIT(1), 
} cfn_hal_gpio_event_t;
 
typedef enum
{
    CFN_HAL_GPIO_ERROR_NONE    = 0,
    CFN_HAL_GPIO_ERROR_GENERAL = CFN_HAL_BIT(0), 
} cfn_hal_gpio_error_t;
 
typedef enum
{
    CFN_HAL_GPIO_STATE_LOW = 0,
    CFN_HAL_GPIO_STATE_HIGH,
 
    CFN_HAL_GPIO_STATE_MAX
} cfn_hal_gpio_state_t;
 
typedef enum
{
    CFN_HAL_GPIO_CONFIG_MODE_ANALOG,
    CFN_HAL_GPIO_CONFIG_MODE_INPUT,
    CFN_HAL_GPIO_CONFIG_MODE_OUTPUT_PP,
    CFN_HAL_GPIO_CONFIG_MODE_OUTPUT_OD,
    CFN_HAL_GPIO_CONFIG_MODE_ALTERNATE_PP,
    CFN_HAL_GPIO_CONFIG_MODE_ALTERNATE_OD,
 
    CFN_HAL_GPIO_CONFIG_MODE_MAX
} cfn_hal_gpio_config_mode_t;
 
typedef enum
{
    CFN_HAL_GPIO_CONFIG_PULL_NOPULL,
    CFN_HAL_GPIO_CONFIG_PULL_PULLUP,
    CFN_HAL_GPIO_CONFIG_PULL_PULLDOWN,
 
    CFN_HAL_GPIO_CONFIG_PULL_MAX
} cfn_hal_gpio_config_pull_t;
 
typedef enum
{
    CFN_HAL_GPIO_CONFIG_SPEED_LOW,       
    CFN_HAL_GPIO_CONFIG_SPEED_MEDIUM,    
    CFN_HAL_GPIO_CONFIG_SPEED_HIGH,      
    CFN_HAL_GPIO_CONFIG_SPEED_VERY_HIGH, 
    CFN_HAL_GPIO_CONFIG_SPEED_MAX
} cfn_hal_gpio_config_speed_t;
 
typedef enum
{
    CFN_HAL_GPIO_CONFIG_STRENGTH_LOW,    
    CFN_HAL_GPIO_CONFIG_STRENGTH_MEDIUM, 
    CFN_HAL_GPIO_CONFIG_STRENGTH_HIGH,   
    CFN_HAL_GPIO_CONFIG_STRENGTH_MAX
} cfn_hal_gpio_config_strength_t;
 
typedef uint32_t cfn_hal_gpio_pin_t;
 
#define CFN_HAL_GPIO_PIN_0  CFN_HAL_BIT(0)
#define CFN_HAL_GPIO_PIN_1  CFN_HAL_BIT(1)
#define CFN_HAL_GPIO_PIN_2  CFN_HAL_BIT(2)
#define CFN_HAL_GPIO_PIN_3  CFN_HAL_BIT(3)
#define CFN_HAL_GPIO_PIN_4  CFN_HAL_BIT(4)
#define CFN_HAL_GPIO_PIN_5  CFN_HAL_BIT(5)
#define CFN_HAL_GPIO_PIN_6  CFN_HAL_BIT(6)
#define CFN_HAL_GPIO_PIN_7  CFN_HAL_BIT(7)
#define CFN_HAL_GPIO_PIN_8  CFN_HAL_BIT(8)
#define CFN_HAL_GPIO_PIN_9  CFN_HAL_BIT(9)
#define CFN_HAL_GPIO_PIN_10 CFN_HAL_BIT(10)
#define CFN_HAL_GPIO_PIN_11 CFN_HAL_BIT(11)
#define CFN_HAL_GPIO_PIN_12 CFN_HAL_BIT(12)
#define CFN_HAL_GPIO_PIN_13 CFN_HAL_BIT(13)
#define CFN_HAL_GPIO_PIN_14 CFN_HAL_BIT(14)
#define CFN_HAL_GPIO_PIN_15 CFN_HAL_BIT(15)
#define CFN_HAL_GPIO_PIN_16 CFN_HAL_BIT(16)
#define CFN_HAL_GPIO_PIN_17 CFN_HAL_BIT(17)
#define CFN_HAL_GPIO_PIN_18 CFN_HAL_BIT(18)
#define CFN_HAL_GPIO_PIN_19 CFN_HAL_BIT(19)
#define CFN_HAL_GPIO_PIN_20 CFN_HAL_BIT(20)
#define CFN_HAL_GPIO_PIN_21 CFN_HAL_BIT(21)
#define CFN_HAL_GPIO_PIN_22 CFN_HAL_BIT(22)
#define CFN_HAL_GPIO_PIN_23 CFN_HAL_BIT(23)
#define CFN_HAL_GPIO_PIN_24 CFN_HAL_BIT(24)
#define CFN_HAL_GPIO_PIN_25 CFN_HAL_BIT(25)
#define CFN_HAL_GPIO_PIN_26 CFN_HAL_BIT(26)
#define CFN_HAL_GPIO_PIN_27 CFN_HAL_BIT(27)
#define CFN_HAL_GPIO_PIN_28 CFN_HAL_BIT(28)
#define CFN_HAL_GPIO_PIN_29 CFN_HAL_BIT(29)
#define CFN_HAL_GPIO_PIN_30 CFN_HAL_BIT(30)
#define CFN_HAL_GPIO_PIN_31 CFN_HAL_BIT(31)
 
/* Types Structs ----------------------------------------------------*/
 
typedef struct
{
    void *port;
    void *user_arg;
} cfn_hal_gpio_phy_t;
 
typedef struct
{
    cfn_hal_gpio_pin_t             pin_mask; 
    cfn_hal_gpio_config_mode_t     mode;
    cfn_hal_gpio_config_pull_t     pull;
    cfn_hal_gpio_config_speed_t    speed;
    cfn_hal_gpio_config_strength_t strength;
    cfn_hal_gpio_state_t           default_state;
    void                          *alternate;
    void                          *custom;
} cfn_hal_gpio_pin_config_t;
 
typedef struct cfn_hal_gpio_s     cfn_hal_gpio_t;
typedef struct cfn_hal_gpio_api_s cfn_hal_gpio_api_t;
 
typedef struct
{
    cfn_hal_gpio_t    *port; 
    cfn_hal_gpio_pin_t pin;  
} cfn_hal_gpio_pin_handle_t;
 
typedef void (*cfn_hal_gpio_callback_t)(cfn_hal_gpio_t *port, uint32_t event_mask, uint32_t error_mask, void *user_arg);
 
struct cfn_hal_gpio_api_s
{
    cfn_hal_api_base_t base; 
    /* GPIO Specific Extensions */
    cfn_hal_error_code_t (*pin_config)(cfn_hal_gpio_t *port, const cfn_hal_gpio_pin_config_t *pin_cfg);
 
    cfn_hal_error_code_t (*pin_read)(cfn_hal_gpio_t *port, cfn_hal_gpio_pin_t pin, cfn_hal_gpio_state_t *state);
    cfn_hal_error_code_t (*pin_write)(cfn_hal_gpio_t *port, cfn_hal_gpio_pin_t pin, cfn_hal_gpio_state_t state);
    cfn_hal_error_code_t (*pin_toggle)(cfn_hal_gpio_t *port, cfn_hal_gpio_pin_t pin);
 
    cfn_hal_error_code_t (*port_read)(cfn_hal_gpio_t *port, uint32_t *port_value);
    cfn_hal_error_code_t (*port_write)(cfn_hal_gpio_t *port, uint32_t pin_mask, uint32_t port_value);
};
 
CFN_HAL_VMT_CHECK(struct cfn_hal_gpio_api_s);
 
/* Note: 'void' is used for config_type because the port driver does not have a
 * global config state */
CFN_HAL_CREATE_DRIVER_TYPE(gpio, void, cfn_hal_gpio_api_t, cfn_hal_gpio_phy_t, cfn_hal_gpio_callback_t);
 
/* Functions inline ------------------------------------------------- */
CFN_HAL_INLINE void cfn_hal_gpio_populate(cfn_hal_gpio_t           *driver,
                                          uint32_t                  peripheral_id,
                                          struct cfn_hal_clock_s   *clock,
                                          void                     *dependency,
                                          const cfn_hal_gpio_api_t *api,
                                          const cfn_hal_gpio_phy_t *phy,
                                          cfn_hal_gpio_callback_t   callback,
                                          void                     *user_arg)
{
    CFN_HAL_POPULATE_DRIVER(
        driver, CFN_HAL_PERIPHERAL_TYPE_GPIO, peripheral_id, clock, dependency, api, phy, NULL, callback, user_arg);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_pin_config_validate(const cfn_hal_gpio_t            *driver,
                                                                     const cfn_hal_gpio_pin_config_t *pin_cfg)
{
    if (driver == NULL || pin_cfg == NULL)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
 
    if (pin_cfg->mode >= CFN_HAL_GPIO_CONFIG_MODE_MAX || pin_cfg->pull >= CFN_HAL_GPIO_CONFIG_PULL_MAX ||
        pin_cfg->speed >= CFN_HAL_GPIO_CONFIG_SPEED_MAX || pin_cfg->strength >= CFN_HAL_GPIO_CONFIG_STRENGTH_MAX ||
        pin_cfg->default_state >= CFN_HAL_GPIO_STATE_MAX)
    {
        return CFN_HAL_ERROR_BAD_CONFIG;
    }
 
    return cfn_hal_base_config_validate(&driver->base, CFN_HAL_PERIPHERAL_TYPE_GPIO, pin_cfg);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_init(cfn_hal_gpio_t *driver)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    driver->base.vmt = (const struct cfn_hal_api_base_s *) driver->api;
    return cfn_hal_base_init(&driver->base, CFN_HAL_PERIPHERAL_TYPE_GPIO);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_deinit(cfn_hal_gpio_t *driver)
{
    if (!driver)
    {
        return CFN_HAL_ERROR_BAD_PARAM;
    }
    return cfn_hal_base_deinit(&driver->base, CFN_HAL_PERIPHERAL_TYPE_GPIO);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_callback_register(cfn_hal_gpio_t               *driver,
                                                                   const cfn_hal_gpio_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_GPIO, (cfn_hal_callback_t) callback, user_arg);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_power_state_set(cfn_hal_gpio_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_GPIO, state);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_event_enable(cfn_hal_gpio_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_GPIO, event_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_event_disable(cfn_hal_gpio_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_GPIO, event_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_event_get(cfn_hal_gpio_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_GPIO, event_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_error_enable(cfn_hal_gpio_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_GPIO, error_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_error_disable(cfn_hal_gpio_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_GPIO, error_mask);
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_error_get(cfn_hal_gpio_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_GPIO, error_mask);
}
 
/* GPIO Specific Functions ------------------------------------------ */
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_pin_config(cfn_hal_gpio_t                  *port,
                                                            const cfn_hal_gpio_pin_config_t *pin_cfg)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_GPIO, pin_config, port, error, pin_cfg);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_pin_read(cfn_hal_gpio_t       *port,
                                                          cfn_hal_gpio_pin_t    pin,
                                                          cfn_hal_gpio_state_t *state)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_GPIO, pin_read, port, error, pin, state);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_pin_write(cfn_hal_gpio_t      *port,
                                                           cfn_hal_gpio_pin_t   pin,
                                                           cfn_hal_gpio_state_t state)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_GPIO, pin_write, port, error, pin, state);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_pin_toggle(cfn_hal_gpio_t *port, cfn_hal_gpio_pin_t pin)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_GPIO, pin_toggle, port, error, pin);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_port_read(cfn_hal_gpio_t *port, uint32_t *port_value)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_GPIO, port_read, port, error, port_value);
    return error;
}
 
CFN_HAL_INLINE cfn_hal_error_code_t cfn_hal_gpio_port_write(cfn_hal_gpio_t *port,
                                                            uint32_t        pin_mask,
                                                            uint32_t        port_value)
{
    cfn_hal_error_code_t error = CFN_HAL_ERROR_OK;
    CFN_HAL_CHECK_AND_CALL_FUNC_VARG(CFN_HAL_PERIPHERAL_TYPE_GPIO, port_write, port, error, pin_mask, port_value);
    return error;
}
 
cfn_hal_error_code_t cfn_hal_gpio_construct(cfn_hal_gpio_t           *driver,
                                            const cfn_hal_gpio_phy_t *phy,
                                            struct cfn_hal_clock_s   *clock,
                                            void                     *dependency,
                                            cfn_hal_gpio_callback_t   callback,
                                            void                     *user_arg);
cfn_hal_error_code_t cfn_hal_gpio_destruct(cfn_hal_gpio_t *driver);
#ifdef __cplusplus
}
#endif
 
#endif // CAFFEINE_HAL_HAL_GPIO_H