#include "platform.h"
#include "hal_common.h"
#include "hal_wfi.h"

/**
* @brief        WFI时钟使能配置
* @details      使能/关闭WFI模式下的时钟
* @param[in]    wfi_clk_en_s：wfi_clk_en_bmp_enum 中的项目（多项逻辑或）
* @param[in]    en：ENABLE/DISABLE
* @return       none
* @note         none
*/
void wfi_clk_en_config(wfi_clk_en_t clk_en, uint32_t en)
{
    hal_assert(0 == (clk_en & (~(
                                   WFI_CLK_EN_PSRAM |
                                   WFI_CLK_EN_MEM   |
                                   WFI_CLK_EN_HST   |
                                   WFI_CLK_EN_DEV   |
                                   WFI_CLK_EN_RAM7  |
                                   WFI_CLK_EN_RAM6  |
                                   WFI_CLK_EN_RAM5  |
                                   WFI_CLK_EN_RAM4  |
                                   WFI_CLK_EN_RAM3  |
                                   WFI_CLK_EN_RAM2  |
                                   WFI_CLK_EN_RAM1  |
                                   WFI_CLK_EN_RAM0  |
                                   WFI_CLK_EN_CACHE |
                                   WFI_CLK_EN_NORC  |
                                   WFI_CLK_EN_SYS   |
                                   WFI_CLK_EN_CPU))));
    hal_assert((en == DISABLE) || (en == ENABLE));

    if (en)
    {
        DEV_WFI->CTL |= clk_en;
    }
    else
    {
        DEV_WFI->CTL &= ~clk_en;
    }
}

/**
* @brief        获取WFI时钟使能配置
* @details      获取WFI模式下的时钟使能/关闭状态
* @param[in]    none
* @return       wfi_clk_en_bmp_enum 中的项目（多项逻辑或）
* @note         none
*/
uint32_t wfi_get_clk_en_config(void)
{
    return DEV_WFI->CTL;
}

/**
* @brief        WFI中断唤醒MASK0配置
* @details      WFI中断唤醒MASK0配置
* @param[in]    wfi_mask0_s：wfi_mask0_bmp_enum 中的项目（多项逻辑或）
* @param[in]    en：ENABLE/DISABLE
* @return       none
* @note         none
*/
void wfi_mask0_config(wfi_mask0_t wfi_mask0, uint32_t en)
{
    hal_assert(0 == (wfi_mask0 & (~(
                                      WFI_MASK0_TRAP  |
                                      WFI_MASK0_WDOG  |
                                      WFI_MASK0_PMU   |
                                      WFI_MASK0_LRADC |
                                      WFI_MASK0_ADUI  |
                                      WFI_MASK0_UDSP  |
                                      WFI_MASK0_NPU_TAB   |
                                      WFI_MASK0_NPU_RES   |
                                      WFI_MASK0_TIMER0    |
                                      WFI_MASK0_TIMER1    |
                                      WFI_MASK0_TIMER2    |
                                      WFI_MASK0_TIMER3    |
                                      WFI_MASK0_CAPTURE0  |
                                      WFI_MASK0_CAPTURE1  |
                                      WFI_MASK0_CAPTURE2  |
                                      WFI_MASK0_CAPTURE3  |
                                      WFI_MASK0_IRRX  |
                                      WFI_MASK0_IRTX  |
                                      WFI_MASK0_SPI0  |
                                      WFI_MASK0_SPI1  |
                                      WFI_MASK0_SDC   |
                                      WFI_MASK0_ADC   |
                                      WFI_MASK0_DAC   |
                                      WFI_MASK0_SRC   |
                                      WFI_MASK0_DMA   |
                                      WFI_MASK0_MMU   |
                                      WFI_MASK0_NORC  |
                                      WFI_MASK0_UART0 |
                                      WFI_MASK0_UART1 |
                                      WFI_MASK0_UART2 |
                                      WFI_MASK0_I2C0  |
                                      WFI_MASK0_I2C1))));
    hal_assert((en == DISABLE) || (en == ENABLE));

    if (en)
    {
        DEV_WFI->MASK0 |= wfi_mask0;
    }
    else
    {
        DEV_WFI->MASK0 &= ~wfi_mask0;
    }
}

/**
* @brief        获取WFI中断唤醒MASK0配置
* @details      获取WFI中断唤醒MASK0配置
* @param[in]    none
* @return       wfi_mask0_bmp_enum 中的项目（多项逻辑或）
* @note         none
*/
uint32_t wfi_get_mask0_config(void)
{
    return DEV_WFI->MASK0;
}

/**
* @brief        WFI中断唤醒MASK1配置
* @details      WFI中断唤醒MASK1配置
* @param[in]    wfi_mask1_s：wfi_mask1_bmp_enum 中的项目（多项逻辑或）
* @param[in]    en：ENABLE/DISABLE
* @return       none
* @note         none
*/
void wfi_mask1_config(wfi_mask1_t wfi_mask1, uint32_t en)
{
    hal_assert(0 == (wfi_mask1 & (~(
                                      WFI_MASK1_ASI0  |
                                      WFI_MASK1_ASI1  |
                                      WFI_MASK1_USB_MAC   |
                                      WFI_MASK1_USB_DMA   |
                                      WFI_MASK1_GPIO0 |
                                      WFI_MASK1_GPIO1 |
                                      WFI_MASK1_PWM   |
                                      WFI_MASK1_CAMERA    |
                                      WFI_MASK1_UART3 |
                                      WFI_MASK1_PSRAM |
                                      WFI_MASK1_MPU))));
    hal_assert((en == DISABLE) || (en == ENABLE));

    if (en)
    {
        DEV_WFI->MASK1 |= wfi_mask1;
    }
    else
    {
        DEV_WFI->MASK1 &= ~wfi_mask1;
    }
}

/**
* @brief        获取WFI中断唤醒MASK1配置
* @details      获取WFI中断唤醒MASK1配置
* @param[in]    none
* @return       wfi_mask1_bmp_enum 中的项目（多项逻辑或）
* @note         none
*/
uint32_t wfi_get_mask1_config(void)
{
    return DEV_WFI->MASK1;
}

/**
* @brief        获取WFI中断唤醒状态STA0
* @details      获取WFI中断唤醒状态STA0
* @param[in]    none
* @return       wfi_mask0_bmp_enum 中的项目（多项逻辑或）
* @note         none
*/
uint32_t wfi_get_status0(void)
{
    return DEV_WFI->STA0;
}

/**
* @brief        获取WFI中断唤醒状态STA1
* @details      获取WFI中断唤醒状态STA1
* @param[in]    none
* @return       wfi_mask1_bmp_enum 中的项目（多项逻辑或）
* @note         none
*/
uint32_t wfi_get_status1(void)
{
    return DEV_WFI->STA1;
}

/**
* @brief        WFI NMI中断唤醒MASK0配置
* @details      WFI NMI中断唤醒MASK0配置
* @param[in]    wfi_nmi_mask0_s：wfi_nmi_mask0_bmp_enum 中的项目（多项逻辑或）
* @param[in]    en：ENABLE/DISABLE
* @return       none
* @note         none
*/
void wfi_nmi_mask0_config(wfi_nmi_mask0_t wfi_nmi_mask0, uint32_t en)
{
    hal_assert(0 == (wfi_nmi_mask0 & (~(
                                          WFI_NMI_MASK0_TRAP  |
                                          WFI_NMI_MASK0_WDOG  |
                                          WFI_NMI_MASK0_PMU   |
                                          WFI_NMI_MASK0_LRADC |
                                          WFI_NMI_MASK0_ADUI  |
                                          WFI_NMI_MASK0_UDSP  |
                                          WFI_NMI_MASK0_NPU_TAB   |
                                          WFI_NMI_MASK0_NPU_RES   |
                                          WFI_NMI_MASK0_TIMER0    |
                                          WFI_NMI_MASK0_TIMER1    |
                                          WFI_NMI_MASK0_TIMER2    |
                                          WFI_NMI_MASK0_TIMER3    |
                                          WFI_NMI_MASK0_CAPTURE0  |
                                          WFI_NMI_MASK0_CAPTURE1  |
                                          WFI_NMI_MASK0_CAPTURE2  |
                                          WFI_NMI_MASK0_CAPTURE3  |
                                          WFI_NMI_MASK0_IRRX  |
                                          WFI_NMI_MASK0_IRTX  |
                                          WFI_NMI_MASK0_SPI0  |
                                          WFI_NMI_MASK0_SPI1  |
                                          WFI_NMI_MASK0_SDC   |
                                          WFI_NMI_MASK0_ADC   |
                                          WFI_NMI_MASK0_DAC   |
                                          WFI_NMI_MASK0_SRC   |
                                          WFI_NMI_MASK0_DMA   |
                                          WFI_NMI_MASK0_MMU   |
                                          WFI_NMI_MASK0_NORC  |
                                          WFI_NMI_MASK0_UART0 |
                                          WFI_NMI_MASK0_UART1 |
                                          WFI_NMI_MASK0_UART2 |
                                          WFI_NMI_MASK0_I2C0  |
                                          WFI_NMI_MASK0_I2C1))));
    hal_assert((en == DISABLE) || (en == ENABLE));

    if (en)
    {
        DEV_WFI->NMI_MASK0 |= wfi_nmi_mask0;
    }
    else
    {
        DEV_WFI->NMI_MASK0 &= ~wfi_nmi_mask0;
    }
}

/**
* @brief        获取WFI NMI中断唤醒MASK0配置
* @details      获取WFI NMI中断唤醒MASK0配置
* @param[in]    none
* @return       wfi_nmi_mask0_bmp_enum 中的项目（多项逻辑或）
* @note         none
*/
uint32_t wfi_nmi_get_mask0_config(void)
{
    return DEV_WFI->NMI_MASK0;
}

/**
* @brief        WFI NMI中断唤醒MASK1配置
* @details      WFI NMI中断唤醒MASK1配置
* @param[in]    wfi_nmi_mask1_s：wfi_nmi_mask1_bmp_enum 中的项目（多项逻辑或）
* @param[in]    en：ENABLE/DISABLE
* @return       none
* @note         none
*/
void wfi_nmi_mask1_config(wfi_nmi_mask1_t wfi_nmi_mask1, uint32_t en)
{
    hal_assert(0 == (wfi_nmi_mask1 & (~(
                                          WFI_NMI_MASK1_ASI0  |
                                          WFI_NMI_MASK1_ASI1  |
                                          WFI_NMI_MASK1_USB_MAC   |
                                          WFI_NMI_MASK1_USB_DMA   |
                                          WFI_NMI_MASK1_GPIO0 |
                                          WFI_NMI_MASK1_GPIO1 |
                                          WFI_NMI_MASK1_PWM   |
                                          WFI_NMI_MASK1_CAMERA    |
                                          WFI_NMI_MASK1_UART3 |
                                          WFI_NMI_MASK1_PSRAM |
                                          WFI_NMI_MASK1_MPU))));
    hal_assert((en == DISABLE) || (en == ENABLE));

    if (en)
    {
        DEV_WFI->NMI_MASK1 |= wfi_nmi_mask1;
    }
    else
    {
        DEV_WFI->NMI_MASK1 &= ~wfi_nmi_mask1;
    }
}

/**
* @brief        获取WFI NMI中断唤醒MASK1配置
* @details      获取WFI NMI中断唤醒MASK1配置
* @param[in]    none
* @return       wfi_nmi_mask1_bmp_enum 中的项目（多项逻辑或）
* @note         none
*/
uint32_t wfi_nmi_get_mask1_config(void)
{
    return DEV_WFI->NMI_MASK1;
}

/**
* @brief        获取WFI NMI中断唤醒状态STA0
* @details      获取WFI NMI中断唤醒状态STA0
* @param[in]    none
* @return       wfi_nmi_mask0_bmp_enum 中的项目（多项逻辑或）
* @note         none
*/
uint32_t wfi_get_nmi_status0(void)
{
    return DEV_WFI->NMI_STA0;
}

/**
* @brief        获取WFI NMI中断唤醒状态STA1
* @details      获取WFI NMI中断唤醒状态STA1
* @param[in]    none
* @return       wfi_nmi_mask1_bmp_enum 中的项目（多项逻辑或）
* @note         none
*/
uint32_t wfi_get_nmi_status1(void)
{
    return DEV_WFI->NMI_STA1;
}
