cfn_hal_types.h

Go to the documentation of this file.

 
#ifndef CAFFEINE_HAL_HAL_TYPES_H
#define CAFFEINE_HAL_HAL_TYPES_H
 
#ifdef __cplusplus
extern "C"
{
#endif
 
/* Includes ---------------------------------------------------------*/
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
/* Defines ----------------------------------------------------------*/
 
/* Macro ------------------------------------------------------------*/
/* Types Enums ------------------------------------------------------*/
typedef enum
{
    CFN_HAL_CONFIG_PHASE_DEINIT = 0,
    CFN_HAL_CONFIG_PHASE_INIT
} cfn_hal_config_phase_t;
 
typedef enum cfn_hal_error_codes
{
    CFN_HAL_ERROR_OK   = 0x00,
 
    CFN_HAL_ERROR_FAIL = 0x01,
    CFN_HAL_ERROR_BAD_PARAM,
    CFN_HAL_ERROR_NOT_READY,
    CFN_HAL_ERROR_NOT_FOUND,
    CFN_HAL_ERROR_OUT_OF_BOUND,
    CFN_HAL_ERROR_NOT_SUPPORTED,
    CFN_HAL_ERROR_EXTERNAL,
    CFN_HAL_ERROR_BUSY,
    CFN_HAL_ERROR_BAD_CONFIG,
 
    CFN_HAL_ERROR_PERIPHERAL_FAIL = 0x40,
 
    CFN_HAL_ERROR_TIMING_TIMEOUT  = 0x80,
 
    CFN_HAL_ERROR_DRIVER_GENERAL  = 0xC0,
    CFN_HAL_ERROR_DRIVER_NOT_INIT,
    CFN_HAL_ERROR_DRIVER_ALREADY_INIT,
 
    CFN_HAL_ERROR_DATA_CRC = 0x100,
    CFN_HAL_ERROR_DATA_BAD_FORMAT,
    CFN_HAL_ERROR_DATA_MISMATCH,
 
    CFN_HAL_ERROR_MEMORY_NULL = 0x140,
    CFN_HAL_ERROR_MEMORY_FULL,
    CFN_HAL_ERROR_MEMORY_ALLOC,
    CFN_HAL_ERROR_MEMORY_EMPTY,
 
    CFN_HAL_ERROR_DEVICE_FAIL = 0x180,
    CFN_HAL_ERROR_DEVICE_NOT_FOUND,
 
    CFN_HAL_ERROR_UNKNOWN
} cfn_hal_error_code_t;
 
typedef uint32_t cfn_hal_peripheral_type_t;
 
struct cfn_hal_api_base_s;
 
typedef void (*cfn_hal_callback_t)(void);
 
// Macro to pack 4 characters into a 32-bit integer (FourCC)
// Note: This packs in Little-Endian order (a is LSB), ensuring
// debug readability in memory dumps on Little-Endian systems (e.g., ARM).
#define CFN_HAL_MAKE_TYPE(a, b, c, d)                                                                                  \
    (((uint32_t) (uint8_t) (a)) | ((uint32_t) (uint8_t) (b) << 8U) | ((uint32_t) (uint8_t) (c) << 16U) |               \
     ((uint32_t) (uint8_t) (d) << 24U))
 
#define CFN_HAL_PERIPHERAL_PREFIX 'A'
 
#define CFN_HAL_PERIPHERAL_TYPE(a, b, c) CFN_HAL_MAKE_TYPE(CFN_HAL_PERIPHERAL_PREFIX, a, b, c)
 
#define CFN_HAL_PERIPHERAL_TYPE_UNKNOWN 0
#define CFN_HAL_PERIPHERAL_TYPE_ADC     CFN_HAL_PERIPHERAL_TYPE('A', 'D', 'C')
#define CFN_HAL_PERIPHERAL_TYPE_CAN     CFN_HAL_PERIPHERAL_TYPE('C', 'A', 'N')
#define CFN_HAL_PERIPHERAL_TYPE_CLOCK   CFN_HAL_PERIPHERAL_TYPE('C', 'L', 'K')
#define CFN_HAL_PERIPHERAL_TYPE_DAC     CFN_HAL_PERIPHERAL_TYPE('D', 'A', 'C')
#define CFN_HAL_PERIPHERAL_TYPE_DMA     CFN_HAL_PERIPHERAL_TYPE('D', 'M', 'A')
#define CFN_HAL_PERIPHERAL_TYPE_GPIO    CFN_HAL_PERIPHERAL_TYPE('G', 'P', 'O')
#define CFN_HAL_PERIPHERAL_TYPE_I2C     CFN_HAL_PERIPHERAL_TYPE('I', '2', 'C')
#define CFN_HAL_PERIPHERAL_TYPE_PWM     CFN_HAL_PERIPHERAL_TYPE('P', 'W', 'M')
#define CFN_HAL_PERIPHERAL_TYPE_RTC     CFN_HAL_PERIPHERAL_TYPE('R', 'T', 'C')
#define CFN_HAL_PERIPHERAL_TYPE_SPI     CFN_HAL_PERIPHERAL_TYPE('S', 'P', 'I')
#define CFN_HAL_PERIPHERAL_TYPE_TIMER   CFN_HAL_PERIPHERAL_TYPE('T', 'I', 'M')
#define CFN_HAL_PERIPHERAL_TYPE_UART    CFN_HAL_PERIPHERAL_TYPE('U', 'R', 'T')
#define CFN_HAL_PERIPHERAL_TYPE_WDT     CFN_HAL_PERIPHERAL_TYPE('W', 'D', 'T')
#define CFN_HAL_PERIPHERAL_TYPE_IRQ     CFN_HAL_PERIPHERAL_TYPE('I', 'R', 'Q')
#define CFN_HAL_PERIPHERAL_TYPE_NVM     CFN_HAL_PERIPHERAL_TYPE('N', 'V', 'M')
#define CFN_HAL_PERIPHERAL_TYPE_I2S     CFN_HAL_PERIPHERAL_TYPE('I', '2', 'S')
#define CFN_HAL_PERIPHERAL_TYPE_QSPI    CFN_HAL_PERIPHERAL_TYPE('Q', 'S', 'P')
#define CFN_HAL_PERIPHERAL_TYPE_CRYPTO  CFN_HAL_PERIPHERAL_TYPE('C', 'R', 'Y')
#define CFN_HAL_PERIPHERAL_TYPE_SDIO    CFN_HAL_PERIPHERAL_TYPE('S', 'D', 'I')
#define CFN_HAL_PERIPHERAL_TYPE_USB     CFN_HAL_PERIPHERAL_TYPE('U', 'S', 'B')
#define CFN_HAL_PERIPHERAL_TYPE_ETH     CFN_HAL_PERIPHERAL_TYPE('E', 'T', 'H')
#define CFN_HAL_PERIPHERAL_TYPE_COMP    CFN_HAL_PERIPHERAL_TYPE('C', 'M', 'P')
 
typedef enum
{
    CFN_HAL_DRIVER_STATUS_UNKNOWN = 0, 
    CFN_HAL_DRIVER_STATUS_CONSTRUCTED, 
    CFN_HAL_DRIVER_STATUS_INITIALIZED, 
    CFN_HAL_DRIVER_STATUS_ERROR        
} cfn_hal_driver_status_t;
 
/* Types Structs ----------------------------------------------------*/
typedef enum
{
    CFN_HAL_POWER_STATE_UNKNOWN = 0,
    CFN_HAL_POWER_STATE_ON,        
    CFN_HAL_POWER_STATE_LOW_POWER, 
    CFN_HAL_POWER_STATE_OFF        
} cfn_hal_power_state_t;
 
struct cfn_hal_clock_s;
 
typedef struct cfn_hal_driver_s
{
    cfn_hal_peripheral_type_t type;        
    cfn_hal_driver_status_t   status;      
    cfn_hal_power_state_t     power_state; 
    struct cfn_hal_clock_s *clock_driver; 
#if (CFN_HAL_USE_LOCK == 1)
    void *lock_obj; 
#endif
 
    cfn_hal_error_code_t (*on_config)(struct cfn_hal_driver_s *base, void *user_arg, cfn_hal_config_phase_t phase);
 
    void *on_config_arg; 
    void *dependency; 
    void *extension;  
    uint32_t                         flags; 
    uint32_t                         peripheral_id;
    const struct cfn_hal_api_base_s *vmt; 
} cfn_hal_driver_t;
/* Functions prototypes ---------------------------------------------*/
 
#ifdef __cplusplus
}
#endif
 
#endif // CAFFEINE_HAL_HAL_TYPES_H