hw_wkup_v2.h

Go to the documentation of this file.

 
#ifndef HW_WKUP_V2_H_
#define HW_WKUP_V2_H_
 
 
#if dg_configUSE_HW_WKUP
 
#include <stdbool.h>
#include <stdint.h>
#include "sdk_defs.h"
#include "hw_gpio.h"
 
#define HW_WKUP_POL_P0_BASE_REG            (volatile uint32_t *)(&WAKEUP->WKUP_POL_P0_REG)
#define HW_WKUP_SELECT_KEY_P0_BASE_REG     (volatile uint32_t *)(&WAKEUP->WKUP_SELECT_P0_REG)
#define HW_WKUP_SELECT_GPIO_P0_BASE_REG    (volatile uint32_t *)(&WAKEUP->WKUP_SEL_GPIO_P0_REG)
#define HW_WKUP_SELECT1_GPIO_P0_BASE_REG   (volatile uint32_t *)(&WAKEUP->WKUP_SEL1_GPIO_P0_REG)
 
#define HW_WKUP_REG_FIELD_MASK(reg, field) \
                (WAKEUP_WKUP_##reg##_REG_##field##_Msk)
 
#define HW_WKUP_REG_FIELD_POS(reg, field) \
                (WAKEUP_WKUP_##reg##_REG_##field##_Pos)
 
#define HW_WKUP_REG_GETF(reg, field) \
                ((WAKEUP->WKUP_##reg##_REG & (WAKEUP_WKUP_##reg##_REG_##field##_Msk)) >> (WAKEUP_WKUP_##reg##_REG_##field##_Pos))
 
#define HW_WKUP_REG_SETF(reg, field, new_val) \
               WAKEUP->WKUP_##reg##_REG = ((WAKEUP->WKUP_##reg##_REG & ~(WAKEUP_WKUP_##reg##_REG_##field##_Msk)) | \
                        ((WAKEUP_WKUP_##reg##_REG_##field##_Msk) & ((new_val) << (WAKEUP_WKUP_##reg##_REG_##field##_Pos))))
 
typedef enum {
        HW_WKUP_TRIG_DISABLED,          
        HW_WKUP_TRIG_LEVEL_HI_DEB,      
        HW_WKUP_TRIG_LEVEL_LO_DEB,      
        HW_WKUP_TRIG_LEVEL_HI,          
        HW_WKUP_TRIG_LEVEL_LO,          
        HW_WKUP_TRIG_EDGE_HI,           
        HW_WKUP_TRIG_EDGE_LO            
} HW_WKUP_TRIGGER;
 
typedef struct {
        uint8_t debounce;                              
        uint32_t pin_wkup_state[HW_GPIO_PORT_MAX];     
        uint32_t pin_gpio_state[HW_GPIO_PORT_MAX];     
        uint32_t pin_trigger[HW_GPIO_PORT_MAX];        
        uint32_t gpio_sense[HW_GPIO_PORT_MAX];         
} wkup_config;
 
typedef enum {
        HW_WKUP_HIBERN_PIN_NONE = 0,    
        HW_WKUP_HIBERN_P0_14_ONLY,      
        HW_WKUP_HIBERN_P1_04_ONLY,      
        HW_WKUP_HIBERN_BOTH_PINS,       
} HW_WKUP_HIBERN_PIN;
 
typedef enum {
        HW_WKUP_HIBERN_BOTH_PINS_ACTIVE_HIGH = 0,       
        HW_WKUP_HIBERN_P0_14_ACTIVE_LOW_ONLY,           
        HW_WKUP_HIBERN_P1_04_ACTIVE_LOW_ONLY,           
        HW_WKUP_HIBERN_BOTH_PINS_ACTIVE_LOW,            
} HW_WKUP_HIBERN_POLARITY;
 
void hw_wkup_configure_hibernation(HW_WKUP_HIBERN_PIN pin, HW_WKUP_HIBERN_POLARITY pol);
 
typedef void (*hw_wkup_interrupt_cb)(void);
 
void hw_wkup_init(const wkup_config *cfg);
 
void hw_wkup_configure(const wkup_config *cfg);
 
void hw_wkup_register_key_interrupt(hw_wkup_interrupt_cb cb, uint32_t prio);
 
void hw_wkup_register_gpio_p0_interrupt(hw_wkup_interrupt_cb cb, uint32_t prio);
 
void hw_wkup_register_gpio_p1_interrupt(hw_wkup_interrupt_cb cb, uint32_t prio);
 
 
void hw_wkup_unregister_interrupts(void);
 
__STATIC_INLINE void hw_wkup_reset_key_interrupt(void)
{
        WAKEUP->WKUP_RESET_IRQ_REG = 1;
}
 
void hw_wkup_handler(void);
 
__STATIC_INLINE void hw_wkup_set_key_debounce_time(uint8_t time_ms)
{
        ASSERT_WARNING(time_ms <= 63);
        HW_WKUP_REG_SETF(CTRL, WKUP_DEB_VALUE, time_ms);
}
 
__STATIC_INLINE uint8_t hw_wkup_get_key_debounce_time(void)
{
        return HW_WKUP_REG_GETF(CTRL, WKUP_DEB_VALUE);
}
 
void hw_wkup_set_trigger(HW_GPIO_PORT port, HW_GPIO_PIN pin, HW_WKUP_TRIGGER trigger);
 
__STATIC_INLINE HW_WKUP_TRIGGER hw_wkup_get_trigger(HW_GPIO_PORT port, HW_GPIO_PIN pin)
{
        uint32_t polarity  = (*(HW_WKUP_POL_P0_BASE_REG + port) & (0x1 << pin)) >> pin;
        uint32_t key_enabled = (*(HW_WKUP_SELECT_KEY_P0_BASE_REG + port) & (0x1 << pin)) >> pin;
        uint32_t gpio_enabled = (*(HW_WKUP_SELECT_GPIO_P0_BASE_REG + port) & (0x1 << pin)) >> pin;
 
        if (key_enabled) {
                return polarity ? HW_WKUP_TRIG_LEVEL_LO_DEB : HW_WKUP_TRIG_LEVEL_HI_DEB;
        }
        else if (gpio_enabled) {
                if ((*(HW_WKUP_SELECT1_GPIO_P0_BASE_REG + port) & (0x1 << pin)) >> pin) {
                        return polarity ? HW_WKUP_TRIG_EDGE_LO : HW_WKUP_TRIG_EDGE_HI;
                }
                return polarity ? HW_WKUP_TRIG_LEVEL_LO : HW_WKUP_TRIG_LEVEL_HI;
        }
        else {
                return HW_WKUP_TRIG_DISABLED;
        }
}
 
__STATIC_INLINE void hw_wkup_emulate_key_hit(void)
{
        HW_WKUP_REG_SETF(CTRL, WKUP_SFT_KEYHIT, 1);
        HW_WKUP_REG_SETF(CTRL, WKUP_SFT_KEYHIT, 0);
}
 
__STATIC_INLINE void hw_wkup_enable_key_irq(void)
{
        HW_WKUP_REG_SETF(CTRL, WKUP_ENABLE_IRQ, 1);
}
 
__STATIC_INLINE void hw_wkup_disable_key_irq(void)
{
        HW_WKUP_REG_SETF(CTRL, WKUP_ENABLE_IRQ, 0);
}
 
__STATIC_INLINE void hw_wkup_freeze_key_timer(void)
{
        GPREG->SET_FREEZE_REG = GPREG_SET_FREEZE_REG_FRZ_WKUPTIM_Msk;
}
 
__STATIC_INLINE void hw_wkup_unfreeze_key_timer(void)
{
        GPREG->RESET_FREEZE_REG = GPREG_RESET_FREEZE_REG_FRZ_WKUPTIM_Msk;
}
 
__STATIC_INLINE uint32_t hw_wkup_get_gpio_status(HW_GPIO_PORT port)
{
        switch (port) {
        case HW_GPIO_PORT_0:
                return HW_WKUP_REG_GETF(STATUS_P0, WKUP_STAT_P0);
        case HW_GPIO_PORT_1:
                return HW_WKUP_REG_GETF(STATUS_P1, WKUP_STAT_P1);
        default:
                ASSERT_WARNING(0);// Invalid argument
                return 0;         // Should never reach here
        }
}
 
__STATIC_INLINE void hw_wkup_clear_gpio_status(HW_GPIO_PORT port, uint32_t status)
{
        switch (port) {
        case HW_GPIO_PORT_0:
                HW_WKUP_REG_SETF(CLEAR_P0, WKUP_CLEAR_P0, status);
                break;
        case HW_GPIO_PORT_1:
                HW_WKUP_REG_SETF(CLEAR_P1, WKUP_CLEAR_P1, status);
                break;
        default:
                ASSERT_WARNING(0);//Invalid argument
        }
}
 
 
 
#endif /* dg_configUSE_HW_WKUP */
#endif /* HW_WKUP_V2_H_ */