fsl_pgmc.h

/*
 * Copyright 2019-2021, NXP
 * All rights reserved.
 *
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_PGMC_H_
#define _FSL_PGMC_H_
 
#include "fsl_common.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
#define FSL_PGMC_RIVER_VERSION (MAKE_VERSION(2, 1, 1))
enum
{
    kPGMC_SetPoint0  = 1UL << 0UL,  
    kPGMC_SetPoint1  = 1UL << 1UL,  
    kPGMC_SetPoint2  = 1UL << 2UL,  
    kPGMC_SetPoint3  = 1UL << 3UL,  
    kPGMC_SetPoint4  = 1UL << 4UL,  
    kPGMC_SetPoint5  = 1UL << 5UL,  
    kPGMC_SetPoint6  = 1UL << 6UL,  
    kPGMC_SetPoint7  = 1UL << 7UL,  
    kPGMC_SetPoint8  = 1UL << 8UL,  
    kPGMC_SetPoint9  = 1UL << 9UL,  
    kPGMC_SetPoint10 = 1UL << 10UL, 
    kPGMC_SetPoint11 = 1UL << 11UL, 
    kPGMC_SetPoint12 = 1UL << 12UL, 
    kPGMC_SetPoint13 = 1UL << 13UL, 
    kPGMC_SetPoint14 = 1UL << 14UL, 
    kPGMC_SetPoint15 = 1UL << 15UL, 
};
 
enum _pgmc_mif_signal_behaviour
{
    kPGMC_AssertSleepSignal               = 1U << 0U,  
    kPGMC_AssertInputGateSignal           = 1U << 1U,  
    kPGMC_AssetLowSpeedSignal             = 1U << 2U,  
    kPGMC_AssertHighSpeedSignal           = 1U << 3U,  
    kPGMC_AssertStandbySignal             = 1U << 4U,  
    kPGMC_AssertArrayPowerDownSignal      = 1U << 5U,  
    kPGMC_AssertPeripheralPowerDownSignal = 1U << 6U,  
    kPGMC_AssertInitnSignal               = 1U << 7U,  
    kPGMC_AssertSwitch1OffSignal          = 1U << 8U,  
    kPGMC_AssertSwitch2OffSignal          = 1U << 9U,  
    kPGMC_AssertIsoSignal                 = 1U << 10U, 
};
 
typedef enum _pgmc_bpc_assign_domain
{
    kPGMC_CM7Core = 0U, 
    kPGMC_CM4Core = 1U  
} pgmc_bpc_assign_domain_t;
 
typedef enum _pgmc_cpu_mode
{
    kPGMC_RunMode     = 0x0UL, 
    kPGMC_WaitMode    = 0x1UL, 
    kPGMC_StopMode    = 0x2UL, 
    kPGMC_SuspendMode = 0x3UL, 
} pgmc_cpu_mode_t;
 
typedef enum _pgmc_control_mode
{
    kPGMC_DisableLowPowerControl   = 0UL,
    kPGMC_ControlledByCpuPowerMode = 1UL,
    kPGMC_ControlledBySetPoint     = 2UL,
} pgmc_control_mode_t;
 
typedef enum _pgmc_memory_low_power_level
{
    kPGMC_MLPLHighSpeed    = 1U,  
    kPGMC_MLPLNormal       = 3U,  
    kPGMC_MLPLLowSpeed     = 4U,  
    kPGMC_MLPLInputGating  = 5U,  
    kPGMC_MLPLStandby      = 6U,  
    kPGMC_MLPLSleep        = 8U,  
    kPGMC_MLPLArrOnPerOff  = 9U,  
    kPGMC_MLPLArrOffPerOn  = 10U, 
    kPGMC_MLPLArrOffPerOff = 11U, 
    kPGMC_MLPLSw2          = 13U, 
    kPGMC_MLPLSw2PerOff    = 14U, 
    kPGMC_MLPLSw1PerOff    = 15U, 
} pgmc_memory_low_power_level_t;
 
typedef enum _pgmc_mif_signal
{
    kPGMC_SleepSignal               = 0U,  
    kPGMC_InputGateSignal           = 1U,  
    kPGMC_LowSpeedSignal            = 2U,  
    kPGMC_HighSpeedSignal           = 3U,  
    kPGMC_StandbySignal             = 4U,  
    kPGMC_ArrayPowerDownSignal      = 5U,  
    kPGMC_PeripheralPowerDownSignal = 6U,  
    kPGMC_InitnSignal               = 7U,  
    kPGMC_Switch1OffSignal          = 8U,  
    kPGMC_Switch2OffSignal          = 9U,  
    kPGMC_IsoSignal                 = 10U, 
} pgmc_mif_signal_t;
 
typedef struct _pgmc_bpc_cpu_power_mode_option
{
    pgmc_bpc_assign_domain_t assignDomain; 
    bool stateSave; 
    bool powerOff;  
} pgmc_bpc_cpu_power_mode_option_t;
 
typedef struct _pgmc_bpc_setpoint_mode_option
{
    bool stateSave; 
    bool powerOff;  
} pgmc_bpc_setpoint_mode_option_t;
 
/*******************************************************************************
 * API
 ******************************************************************************/
#if defined(__cplusplus)
extern "C" {
#endif
 
void PGMC_BPC_ControlPowerDomainByCpuPowerMode(PGMC_BPC_Type *base,
                                               pgmc_cpu_mode_t mode,
                                               const pgmc_bpc_cpu_power_mode_option_t *option);
 
void PGMC_BPC_ControlPowerDomainBySetPointMode(PGMC_BPC_Type *base,
                                               uint32_t setPointMap,
                                               const pgmc_bpc_setpoint_mode_option_t *option);
 
void PGMC_BPC_ControlPowerDomainBySoftwareMode(PGMC_BPC_Type *base, bool powerOff);
 
static inline void PGMC_BPC_DisableLowPower(PGMC_BPC_Type *base)
{
    base->BPC_MODE = PGMC_BPC_BPC_MODE_CTRL_MODE(kPGMC_DisableLowPowerControl);
}
 
static inline void PGMC_BPC_RequestStateRestoreAtRunMode(PGMC_BPC_Type *base)
{
    base->BPC_SSAR_RESTORE_CTRL |= PGMC_BPC_BPC_SSAR_RESTORE_CTRL_RESTORE_AT_RUN_MASK;
}
 
static inline void PGMC_BPC_RequestStateRestoreAtSetPoint(PGMC_BPC_Type *base, uint32_t setPointMap)
{
    base->BPC_SSAR_RESTORE_CTRL |= PGMC_BPC_BPC_SSAR_RESTORE_CTRL_RESTORE_AT_SP(setPointMap & 0xFFFFU);
}
 
static inline void PGMC_BPC_AllowUserModeAccess(PGMC_BPC_Type *base, bool enable)
{
    if (enable)
    {
        base->BPC_AUTHEN_CTRL |= PGMC_BPC_BPC_AUTHEN_CTRL_USER_MASK;
    }
    else
    {
        base->BPC_AUTHEN_CTRL &= ~PGMC_BPC_BPC_AUTHEN_CTRL_USER_MASK;
    }
}
 
static inline void PGMC_BPC_AllowNonSecureModeAccess(PGMC_BPC_Type *base, bool enable)
{
    if (enable)
    {
        base->BPC_AUTHEN_CTRL |= PGMC_BPC_BPC_AUTHEN_CTRL_NONSECURE_MASK;
    }
    else
    {
        base->BPC_AUTHEN_CTRL &= ~PGMC_BPC_BPC_AUTHEN_CTRL_NONSECURE_MASK;
    }
}
 
static inline void PGMC_BPC_LockAccessSetting(PGMC_BPC_Type *base)
{
    base->BPC_AUTHEN_CTRL |= PGMC_BPC_BPC_AUTHEN_CTRL_LOCK_SETTING_MASK;
}
 
static inline void PGMC_BPC_SetDomainIdWhiteList(PGMC_BPC_Type *base, uint8_t domainId)
{
    base->BPC_AUTHEN_CTRL = (base->BPC_AUTHEN_CTRL & (~PGMC_BPC_BPC_AUTHEN_CTRL_WHITE_LIST_MASK)) |
                            PGMC_BPC_BPC_AUTHEN_CTRL_WHITE_LIST(domainId);
}
 
static inline void PGMC_BPC_LockDomainIDWhiteList(PGMC_BPC_Type *base)
{
    base->BPC_AUTHEN_CTRL |= PGMC_BPC_BPC_AUTHEN_CTRL_LOCK_LIST_MASK;
}
 
static inline void PGMC_BPC_LockLowPowerConfigurationFields(PGMC_BPC_Type *base)
{
    base->BPC_AUTHEN_CTRL |= PGMC_BPC_BPC_AUTHEN_CTRL_LOCK_CFG_MASK;
}
 
void PGMC_CPC_CORE_PowerOffByCpuPowerMode(PGMC_CPC_Type *base, pgmc_cpu_mode_t mode);
 
static inline void PGMC_CPC_CORE_PowerOffBySoftwareMode(PGMC_CPC_Type *base, bool powerOff)
{
    if (powerOff)
    {
        base->CPC_CORE_POWER_CTRL |=
            (PGMC_CPC_CPC_CORE_POWER_CTRL_PSW_OFF_SOFT_MASK | PGMC_CPC_CPC_CORE_POWER_CTRL_ISO_ON_SOFT_MASK);
    }
    else
    {
        base->CPC_CORE_POWER_CTRL |=
            (PGMC_CPC_CPC_CORE_POWER_CTRL_ISO_OFF_SOFT_MASK | PGMC_CPC_CPC_CORE_POWER_CTRL_PSW_ON_SOFT_MASK);
    }
}
 
static inline void PGMC_CPC_CORE_DisableLowPower(PGMC_CPC_Type *base)
{
    base->CPC_CORE_MODE = PGMC_CPC_CPC_CORE_MODE_CTRL_MODE(kPGMC_DisableLowPowerControl);
}
 
void PGMC_CPC_CACHE_ControlByCpuPowerMode(PGMC_CPC_Type *base,
                                          pgmc_cpu_mode_t mode,
                                          pgmc_memory_low_power_level_t memoryLowPowerLevel);
 
void PGMC_CPC_CACHE_ControlBySetPointMode(PGMC_CPC_Type *base,
                                          uint32_t setPointMap,
                                          pgmc_memory_low_power_level_t memoryLowPowerLevel);
 
static inline void PGMC_CPC_CACHE_DisableLowPower(PGMC_CPC_Type *base)
{
    base->CPC_CACHE_MODE = PGMC_CPC_CPC_CACHE_MODE_CTRL_MODE(kPGMC_DisableLowPowerControl);
}
 
void PGMC_CPC_CACHE_TriggerMLPLSoftwareChange(PGMC_CPC_Type *base);
 
void PGMC_CPC_LMEM_ControlByCpuPowerMode(PGMC_CPC_Type *base,
                                         pgmc_cpu_mode_t mode,
                                         pgmc_memory_low_power_level_t memoryLowPowerLevel);
 
void PGMC_CPC_LMEM_ControlBySetPointMode(PGMC_CPC_Type *base,
                                         uint32_t setPointMap,
                                         pgmc_memory_low_power_level_t memoryLowPowerLevel);
 
static inline void PGMC_CPC_LMEM_DisableLowPower(PGMC_CPC_Type *base)
{
    base->CPC_LMEM_MODE = PGMC_CPC_CPC_LMEM_MODE_CTRL_MODE(kPGMC_DisableLowPowerControl);
}
 
void PGMC_CPC_LMEM_TriggerMLPLSoftwareChange(PGMC_CPC_Type *base);
 
static inline void PGMC_CPC_AllowUserModeAccess(PGMC_CPC_Type *base, bool enable)
{
    if (enable)
    {
        base->CPC_AUTHEN_CTRL |= PGMC_CPC_CPC_AUTHEN_CTRL_USER_MASK;
    }
    else
    {
        base->CPC_AUTHEN_CTRL &= ~PGMC_CPC_CPC_AUTHEN_CTRL_USER_MASK;
    }
}
 
static inline void PGMC_CPC_AllowNonSecureModeAccess(PGMC_CPC_Type *base, bool enable)
{
    if (enable)
    {
        base->CPC_AUTHEN_CTRL |= PGMC_CPC_CPC_AUTHEN_CTRL_NONSECURE_MASK;
    }
    else
    {
        base->CPC_AUTHEN_CTRL &= ~PGMC_CPC_CPC_AUTHEN_CTRL_NONSECURE_MASK;
    }
}
 
static inline void PGMC_CPC_LockAccessSetting(PGMC_CPC_Type *base)
{
    base->CPC_AUTHEN_CTRL |= PGMC_CPC_CPC_AUTHEN_CTRL_LOCK_SETTING_MASK;
}
 
static inline void PGMC_CPC_SetDomainIdWhiteList(PGMC_CPC_Type *base, uint8_t domainId)
{
    base->CPC_AUTHEN_CTRL = (base->CPC_AUTHEN_CTRL & (~PGMC_CPC_CPC_AUTHEN_CTRL_WHITE_LIST_MASK)) |
                            PGMC_CPC_CPC_AUTHEN_CTRL_WHITE_LIST(domainId);
}
 
static inline void PGMC_CPC_LockDomainIDWhiteList(PGMC_CPC_Type *base)
{
    base->CPC_AUTHEN_CTRL |= PGMC_CPC_CPC_AUTHEN_CTRL_LOCK_LIST_MASK;
}
 
static inline void PGMC_CPC_LockLowPowerConfigurationFields(PGMC_CPC_Type *base)
{
    base->CPC_AUTHEN_CTRL |= PGMC_CPC_CPC_AUTHEN_CTRL_LOCK_CFG_MASK;
}
 
void PGMC_MIF_SetSignalBehaviour(PGMC_MIF_Type *base, pgmc_memory_low_power_level_t memoryLevel, uint32_t mask);
 
static inline void PGMC_MIF_LockLowPowerConfigurationFields(PGMC_MIF_Type *base)
{
    base->MIF_AUTHEN_CTRL |= PGMC_MIF_MIF_AUTHEN_CTRL_LOCK_CFG_MASK;
}
 
static inline void PGMC_PPC_TriggerPMICStandbySoftMode(PGMC_PPC_Type *base, bool enable)
{
    if (enable)
    {
        PGMC_PPC0->PPC_STBY_CM_CTRL |= PGMC_PPC_PPC_STBY_CM_CTRL_STBY_ON_SOFT_MASK;
    }
    else
    {
        PGMC_PPC0->PPC_STBY_CM_CTRL |= PGMC_PPC_PPC_STBY_CM_CTRL_STBY_OFF_SOFT_MASK;
    }
}
 
void PGMC_PPC_ControlByCpuPowerMode(PGMC_PPC_Type *base, pgmc_cpu_mode_t mode);
 
void PGMC_PPC_ControlBySetPointMode(PGMC_PPC_Type *base, uint32_t setPointMap, bool enableStandby);
 
static inline void PGMC_PPC_DisableLowPower(PGMC_PPC_Type *base)
{
    base->PPC_MODE = PGMC_PPC_PPC_MODE_CTRL_MODE(kPGMC_DisableLowPowerControl);
}
 
static inline void PGMC_PPC_AllowUserModeAccess(PGMC_PPC_Type *base, bool enable)
{
    if (enable)
    {
        base->PPC_AUTHEN_CTRL |= PGMC_PPC_PPC_AUTHEN_CTRL_USER_MASK;
    }
    else
    {
        base->PPC_AUTHEN_CTRL &= ~PGMC_PPC_PPC_AUTHEN_CTRL_USER_MASK;
    }
}
 
static inline void PGMC_PPC_AllowNonSecureModeAccess(PGMC_PPC_Type *base, bool enable)
{
    if (enable)
    {
        base->PPC_AUTHEN_CTRL |= PGMC_PPC_PPC_AUTHEN_CTRL_NONSECURE_MASK;
    }
    else
    {
        base->PPC_AUTHEN_CTRL &= ~PGMC_PPC_PPC_AUTHEN_CTRL_NONSECURE_MASK;
    }
}
 
static inline void PGMC_PPC_LockAccessSetting(PGMC_PPC_Type *base)
{
    base->PPC_AUTHEN_CTRL |= PGMC_PPC_PPC_AUTHEN_CTRL_LOCK_SETTING_MASK;
}
 
static inline void PGMC_PPC_SetDomainIdWhiteList(PGMC_PPC_Type *base, uint8_t domainId)
{
    base->PPC_AUTHEN_CTRL = (base->PPC_AUTHEN_CTRL & (~PGMC_PPC_PPC_AUTHEN_CTRL_WHITE_LIST_MASK)) |
                            PGMC_PPC_PPC_AUTHEN_CTRL_WHITE_LIST(domainId);
}
 
static inline void PGMC_PPC_LockDomainIDWhiteList(PGMC_PPC_Type *base)
{
    base->PPC_AUTHEN_CTRL |= PGMC_PPC_PPC_AUTHEN_CTRL_LOCK_LIST_MASK;
}
 
static inline void PGMC_PPC_LockLowPowerConfigurationFields(PGMC_PPC_Type *base)
{
    base->PPC_AUTHEN_CTRL |= PGMC_PPC_PPC_AUTHEN_CTRL_LOCK_CFG_MASK;
}
 
#if defined(__cplusplus)
}
#endif
#endif /* _FSL_PGMC_H_ */