hw_gpio.h

Go to the documentation of this file.

 
#ifndef HW_GPIO_H_
#define HW_GPIO_H_
 
#if dg_configUSE_HW_GPIO
 
#include <stdbool.h>
#include <stdint.h>
#include "sdk_defs.h"
 
#define HW_GPIO_SET_PIN_FUNCTION(X)     hw_gpio_set_pin_function(X##_PORT, X##_PIN, X##_MODE, X##_FUNC);
#define HW_GPIO_PAD_LATCH_ENABLE(X)     hw_gpio_pad_latch_enable(X##_PORT, X##_PIN);
#define HW_GPIO_PAD_LATCH_DISABLE(X)    hw_gpio_pad_latch_disable(X##_PORT, X##_PIN);
/* GPIO layout definitions */
 
#define HW_GPIO_NUM_PORTS       (2)
 
#define HW_GPIO_NUM_PINS        (HW_GPIO_PORT_0_NUM_PINS + HW_GPIO_PORT_1_NUM_PINS)
 
#define HW_GPIO_PIN_BITS        (4)
 
#define HW_GPIO_PORT_0_NUM_PINS (16)
 
#define HW_GPIO_PORT_1_NUM_PINS (16)
 
#define HW_GPIO_PORT_NONE       (HW_GPIO_PORT_MAX)
 
#define HW_GPIO_PIN_NONE        (HW_GPIO_PIN_MAX)
 
#define HW_GPIO_MODE_NONE       (HW_GPIO_MODE_INVALID)
 
extern const uint8_t hw_gpio_port_num_pins[HW_GPIO_NUM_PORTS];
 
typedef enum {
        HW_GPIO_MODE_INPUT = 0,                 
        HW_GPIO_MODE_INPUT_PULLUP = 0x100,      
        HW_GPIO_MODE_INPUT_PULLDOWN = 0x200,    
        HW_GPIO_MODE_OUTPUT = 0x300,            
        HW_GPIO_MODE_OUTPUT_PUSH_PULL = 0x300,  
        HW_GPIO_MODE_OUTPUT_OPEN_DRAIN = 0x700, 
        HW_GPIO_MODE_INVALID = 0xFFF,           
} HW_GPIO_MODE;
 
typedef enum {
        HW_GPIO_PORT_0 = 0,     
        HW_GPIO_PORT_1 = 1,     
        HW_GPIO_PORT_MAX        
} HW_GPIO_PORT;
 
typedef enum {
        HW_GPIO_PIN_0 = 0,      
        HW_GPIO_PIN_1 = 1,      
        HW_GPIO_PIN_2 = 2,      
        HW_GPIO_PIN_3 = 3,      
        HW_GPIO_PIN_4 = 4,      
        HW_GPIO_PIN_5 = 5,      
        HW_GPIO_PIN_6 = 6,      
        HW_GPIO_PIN_7 = 7,      
        HW_GPIO_PIN_8 = 8,      
        HW_GPIO_PIN_9 = 9,      
        HW_GPIO_PIN_10 = 10,    
        HW_GPIO_PIN_11 = 11,    
        HW_GPIO_PIN_12 = 12,    
        HW_GPIO_PIN_13 = 13,    
        HW_GPIO_PIN_14 = 14,    
        HW_GPIO_PIN_15 = 15,    
        HW_GPIO_PIN_MAX         
} HW_GPIO_PIN;
 
typedef enum {
        HW_GPIO_FUNC_GPIO = 0,                  
        HW_GPIO_FUNC_UART_RX = 1,               
        HW_GPIO_FUNC_UART_TX = 2,               
        HW_GPIO_FUNC_UART2_RX = 3,              
        HW_GPIO_FUNC_UART2_TX = 4,              
        HW_GPIO_FUNC_UART2_CTSN = 5,            
        HW_GPIO_FUNC_UART2_RTSN = 6,            
        HW_GPIO_FUNC_ISO_CLK = 7,               
        HW_GPIO_FUNC_ISO_DATA = 8,              
        HW_GPIO_FUNC_SPI_DI = 9,                
        HW_GPIO_FUNC_SPI_DO = 10,               
        HW_GPIO_FUNC_SPI_CLK = 11,              
        HW_GPIO_FUNC_SPI_EN = 12,               
        HW_GPIO_FUNC_SPI_EN2 = 13,              
        HW_GPIO_FUNC_I2C_SCL = 14,              
        HW_GPIO_FUNC_I2C_SDA = 15,              
        HW_GPIO_FUNC_ADC = 16,                  
        HW_GPIO_FUNC_PCM_DI = 17,               
        HW_GPIO_FUNC_PCM_DO = 18,               
        HW_GPIO_FUNC_PCM_FSC = 19,              
        HW_GPIO_FUNC_PCM_CLK = 20,              
        HW_GPIO_FUNC_PDM_DATA = 21,             
        HW_GPIO_FUNC_PDM_CLK = 22,              
        HW_GPIO_FUNC_CLOCK = 23,                
        HW_GPIO_FUNC_TIM_PWM = 24,              
        HW_GPIO_FUNC_TIM2_PWM = 25,             
        HW_GPIO_FUNC_TIM_1SHOT = 26,            
        HW_GPIO_FUNC_TIM2_1SHOT = 27,           
        HW_GPIO_FUNC_TIM3_PWM = 28,             
        HW_GPIO_FUNC_TIM4_PWM = 29,             
        HW_GPIO_FUNC_COEX_EXT_ACT = 30,         
        HW_GPIO_FUNC_COEX_SMART_ACT = 31,       
        HW_GPIO_FUNC_COEX_SMART_PRI = 32,       
        HW_GPIO_FUNC_PORT0_DCF = 33,            
        HW_GPIO_FUNC_PORT1_DCF = 34,            
        HW_GPIO_FUNC_PORT2_DCF = 35,            
        HW_GPIO_FUNC_PORT3_DCF = 36,            
        HW_GPIO_FUNC_PORT4_DCF = 37,            
        HW_GPIO_FUNC_CMAC_DIAG0 = 38,           
        HW_GPIO_FUNC_CMAC_DIAG1 = 39,           
        HW_GPIO_FUNC_CMAC_DIAG2 = 40,           
        HW_GPIO_FUNC_CMAC_DIAG3 = 41,           
        HW_GPIO_FUNC_CMAC_DIAG4 = 42,           
        HW_GPIO_FUNC_CMAC_DIAG5 = 43,           
        HW_GPIO_FUNC_CMAC_DIAG6 = 44,           
        HW_GPIO_FUNC_CMAC_DIAG7 = 45,           
        HW_GPIO_FUNC_CMAC_DIAG8 = 46,           
        HW_GPIO_FUNC_CMAC_DIAG9 = 47,           
        HW_GPIO_FUNC_CMAC_DIAG10 = 48,          
        HW_GPIO_FUNC_CMAC_DIAG11 = 49,          
        HW_GPIO_FUNC_CMAC_DIAG12 = 50,          
        HW_GPIO_FUNC_CMAC_DIAG13 = 51,          
        HW_GPIO_FUNC_CMAC_DIAG14 = 52,          
        HW_GPIO_FUNC_CMAC_DIAG15 = 53,          
        HW_GPIO_FUNC_LAST,
} HW_GPIO_FUNC;
 
typedef enum {
        HW_GPIO_CLK_XTAL32K = 0,
        HW_GPIO_CLK_RCLP = 1,
        HW_GPIO_CLK_RCX = 2,
        HW_GPIO_CLK_XTAL32M = 3,
        HW_GPIO_CLK_RC32M = 4,
        HW_GPIO_CLK_DIVN = 5,
        HW_GPIO_CLK_LAST,
} HW_GPIO_CLK;
 
typedef __PACKED_STRUCT {
        uint8_t         pin;     
        HW_GPIO_MODE    mode;    
        HW_GPIO_FUNC    func;    
        bool            high;    
        bool            reserve; /*<< true if pin should be also reserved */
} gpio_config;
 
typedef enum {
        HW_GPIO_DRIVE_STRENGTH_NORMAL = 0, 
        HW_GPIO_DRIVE_STRENGTH_WEAK,       
} HW_GPIO_DRIVE_STRENGTH;
 
#define HW_GPIO_PINCONFIG(xport, xpin, xmode, xfunc, xhigh) \
        {                                               \
                .pin = (xport << HW_GPIO_PIN_BITS) | (xpin & ((1 << HW_GPIO_PIN_BITS) - 1)),    \
                .mode = HW_GPIO_MODE_ ## xmode,         \
                .func = HW_GPIO_FUNC_ ## xfunc,         \
                .high = xhigh,                          \
                .reserve = false,                       \
        }
 
#define HW_GPIO_PINCONFIG_RESERVE(xport, xpin, xmode, xfunc, xhigh) \
        {                                               \
                .pin = (xport << HW_GPIO_PIN_BITS) | (xpin & ((1 << HW_GPIO_PIN_BITS) - 1)),    \
                .mode = HW_GPIO_MODE_ ## xmode,         \
                .func = HW_GPIO_FUNC_ ## xfunc,         \
                .high = xhigh,                          \
                .reserve = true,                        \
        }
 
#define HW_GPIO_PINCONFIG_END \
        {                       \
                .pin = 0xFF,    \
        }
 
void hw_gpio_configure(const gpio_config cfg[]);
 
bool hw_gpio_reserve_pin(HW_GPIO_PORT port, HW_GPIO_PIN pin);
 
bool hw_gpio_reserve_and_configure_pin(HW_GPIO_PORT port, HW_GPIO_PIN pin, HW_GPIO_MODE mode,
                                                                HW_GPIO_FUNC function, bool high);
 
void hw_gpio_unreserve_pin(HW_GPIO_PORT port, HW_GPIO_PIN pin);
 
#if (DEBUG_GPIO_ALLOC_MONITOR_ENABLED == 1)
 
#define RESERVE_GPIO(name, port, pin, func)                                                     \
        do {                                                                                    \
                if (!hw_gpio_reserve_pin((port), (pin))) {                                      \
                        /* If debugger stops at this line, there is configuration problem */    \
                        /* pin is used without being reserved first */                          \
                        __BKPT(0); /* this pin has not been previously reserved! */             \
                }                                                                               \
        } while (0)
 
#else
 
#define RESERVE_GPIO( name, port, pin, func )   \
        do {                                    \
                                                \
        } while (0)
 
#endif // (DEBUG_GPIO_ALLOC_MONITOR_ENABLED == 1)
 
void hw_gpio_set_pin_function(HW_GPIO_PORT port, HW_GPIO_PIN pin, HW_GPIO_MODE mode,
                                                                        HW_GPIO_FUNC function);
 
void hw_gpio_get_pin_function(HW_GPIO_PORT port, HW_GPIO_PIN pin, HW_GPIO_MODE* mode,
                                                                        HW_GPIO_FUNC* function);
 
void hw_gpio_set_pin_drive_strength(HW_GPIO_PORT port, HW_GPIO_PIN pin, HW_GPIO_DRIVE_STRENGTH strength);
 
HW_GPIO_DRIVE_STRENGTH hw_gpio_get_pin_drive_strength(HW_GPIO_PORT port, HW_GPIO_PIN pin);
 
void hw_gpio_configure_pin(HW_GPIO_PORT port, HW_GPIO_PIN pin, HW_GPIO_MODE mode,
                                                        HW_GPIO_FUNC function, const bool high);
 
 
void hw_gpio_set_active(HW_GPIO_PORT port, HW_GPIO_PIN pin);
 
void hw_gpio_set_inactive(HW_GPIO_PORT port, HW_GPIO_PIN pin);
 
bool hw_gpio_get_pin_status(HW_GPIO_PORT port, HW_GPIO_PIN pin);
 
void hw_gpio_toggle(HW_GPIO_PORT port, HW_GPIO_PIN pin);
 
int hw_gpio_get_pins_with_function(HW_GPIO_FUNC func, uint8_t *buf, int buf_size);
 
__STATIC_FORCEINLINE void hw_gpio_pad_latch_disable_all(void)
{
        GLOBAL_INT_DISABLE();
        REG_SETF(CRG_TOP, P0_RESET_PAD_LATCH_REG, P0_RESET_LATCH_EN, CRG_TOP_P0_RESET_PAD_LATCH_REG_P0_RESET_LATCH_EN_Msk);
        REG_SETF(CRG_TOP, P1_RESET_PAD_LATCH_REG, P1_RESET_LATCH_EN, CRG_TOP_P1_RESET_PAD_LATCH_REG_P1_RESET_LATCH_EN_Msk);
        GLOBAL_INT_RESTORE();
}
 
__STATIC_FORCEINLINE void hw_gpio_pad_latch_enable_all(void)
{
        GLOBAL_INT_DISABLE();
        REG_SETF(CRG_TOP, P0_SET_PAD_LATCH_REG, P0_SET_LATCH_EN, CRG_TOP_P0_SET_PAD_LATCH_REG_P0_SET_LATCH_EN_Msk);
        REG_SETF(CRG_TOP, P1_SET_PAD_LATCH_REG, P1_SET_LATCH_EN, CRG_TOP_P1_SET_PAD_LATCH_REG_P1_SET_LATCH_EN_Msk);
        GLOBAL_INT_RESTORE();
}
 
__STATIC_FORCEINLINE void hw_gpio_pad_latch_enable(HW_GPIO_PORT port, HW_GPIO_PIN pin)
{
        ASSERT_WARNING((port == HW_GPIO_PORT_0) || (port == HW_GPIO_PORT_1));
 
        if (port == HW_GPIO_PORT_0) {
                ASSERT_WARNING(pin < HW_GPIO_PORT_0_NUM_PINS);
                CRG_TOP->P0_SET_PAD_LATCH_REG = 1 << pin;
        } else if (port == HW_GPIO_PORT_1) {
                ASSERT_WARNING(pin < HW_GPIO_PORT_1_NUM_PINS);
                CRG_TOP->P1_SET_PAD_LATCH_REG = 1 << pin;
        }
}
 
__STATIC_FORCEINLINE void hw_gpio_pad_latch_disable(HW_GPIO_PORT port, HW_GPIO_PIN pin)
{
        ASSERT_WARNING((port == HW_GPIO_PORT_0) || (port == HW_GPIO_PORT_1));
 
        if (port == HW_GPIO_PORT_0) {
                ASSERT_WARNING(pin < HW_GPIO_PORT_0_NUM_PINS);
                CRG_TOP->P0_RESET_PAD_LATCH_REG = 1 << pin;
        } else if (port == HW_GPIO_PORT_1) {
                ASSERT_WARNING(pin < HW_GPIO_PORT_1_NUM_PINS);
                CRG_TOP->P1_RESET_PAD_LATCH_REG = 1 << pin;
        }
}
 
__STATIC_FORCEINLINE bool hw_gpio_pad_latch_is_enabled(HW_GPIO_PORT port, HW_GPIO_PIN pin)
{
        ASSERT_WARNING((port == HW_GPIO_PORT_0) || (port == HW_GPIO_PORT_1));
 
        if (port == HW_GPIO_PORT_0) {
                ASSERT_WARNING(pin < HW_GPIO_PORT_0_NUM_PINS);
                return (CRG_TOP->P0_PAD_LATCH_REG & (1 << pin));
        } else if (port == HW_GPIO_PORT_1) {
                ASSERT_WARNING(pin < HW_GPIO_PORT_1_NUM_PINS);
                return (CRG_TOP->P1_PAD_LATCH_REG & (1 << pin));
        }
 
        return false;
}
 
bool hw_gpio_get_pin_with_function(HW_GPIO_FUNC func, HW_GPIO_PORT* port, HW_GPIO_PIN* pin);
 
 
__STATIC_INLINE void hw_gpio_clk_output_enable(HW_GPIO_CLK clk)
{
        switch (clk) {
        case HW_GPIO_CLK_XTAL32M:
                REG_SET_BIT(GPIO, GPIO_CLK_SEL_REG, XTAL32M_OUTPUT_EN);
                break;
        case HW_GPIO_CLK_RC32M:
                REG_SET_BIT(GPIO, GPIO_CLK_SEL_REG, RC32M_OUTPUT_EN);
                break;
        case HW_GPIO_CLK_DIVN:
                REG_SET_BIT(GPIO, GPIO_CLK_SEL_REG, DIVN_OUTPUT_EN);
                break;
        default:
                ASSERT_WARNING(0);
                break;
        }
}
 
__STATIC_INLINE void hw_gpio_clk_output_disable(HW_GPIO_CLK clk)
{
        switch (clk) {
        case HW_GPIO_CLK_XTAL32M:
                REG_CLR_BIT(GPIO, GPIO_CLK_SEL_REG, XTAL32M_OUTPUT_EN);
                break;
        case HW_GPIO_CLK_RC32M:
                REG_CLR_BIT(GPIO, GPIO_CLK_SEL_REG, RC32M_OUTPUT_EN);
                break;
        case HW_GPIO_CLK_DIVN:
                REG_CLR_BIT(GPIO, GPIO_CLK_SEL_REG, DIVN_OUTPUT_EN);
                break;
        default:
                ASSERT_WARNING(0);
                break;
        }
}
 
__STATIC_INLINE void hw_gpio_clk_func_enable(void)
{
        REG_SET_BIT(GPIO, GPIO_CLK_SEL_REG, FUNC_CLOCK_EN);
}
 
__STATIC_INLINE void hw_gpio_clk_func_disable(void)
{
        REG_CLR_BIT(GPIO, GPIO_CLK_SEL_REG, FUNC_CLOCK_EN);
}
 
__STATIC_INLINE void hw_gpio_clk_func_sel(HW_GPIO_CLK clk_src)
{
        REG_SETF(GPIO, GPIO_CLK_SEL_REG, FUNC_CLOCK_SEL, clk_src);
}
 
__STATIC_INLINE void hw_gpio_configure_por_pin(HW_GPIO_PORT port, HW_GPIO_PIN pin, bool polarity)
{
        uint8_t  pin_select = REG_MSK(CRG_TOP, POR_PIN_REG, POR_PIN_SELECT);
        if (port == HW_GPIO_PORT_0) {
                if (pin < HW_GPIO_PORT_0_NUM_PINS) {
                        pin_select = pin;
                }
        } else if (port == HW_GPIO_PORT_1) {
                if (pin < HW_GPIO_PORT_1_NUM_PINS) {
                        pin_select = HW_GPIO_PORT_0_NUM_PINS + pin;
                }
        }
        CRG_TOP->POR_PIN_REG = BITS32(CRG_TOP, POR_PIN_REG, POR_PIN_POLARITY, polarity) |
                               BITS32(CRG_TOP, POR_PIN_REG, POR_PIN_SELECT, pin_select);
}
#endif /* dg_configUSE_HW_GPIO */
#endif /* HW_GPIO_H_ */