SPC.h

 
#ifndef MCXA153_2E3411A1_6370_44BE_84E2_32D911539D8F
#define MCXA153_2E3411A1_6370_44BE_84E2_32D911539D8F
 
/* ***************************************************************************************
 * Include
 */
#include "mframe.h"
 
//----------------------------------------------------------------------------------------
#include "./../Processor.h"
#include "./../spc/ActiveModeCoreLdoOption.h"
#include "./../spc/ActiveModeRegulatorsConfig.h"
#include "./../spc/AnalogModuleControl.h"
#include "./../spc/BandgapMode.h"
#include "./../spc/CoreLdoDriveStrength.h"
#include "./../spc/CoreLdoVoltageLevel.h"
#include "./../spc/CoreVoltageDetectConfig.h"
#include "./../spc/Count.h"
#include "./../spc/LowPowerModeCoreLdoOption.h"
#include "./../spc/LowPowerModeRegulatorsConfig.h"
#include "./../spc/LowPowerRequestConfig.h"
#include "./../spc/LowPowerRequestOutputOverride.h"
#include "./../spc/LowPowerRequestPinPolarity.h"
#include "./../spc/LowVoltageLevelSelect.h"
#include "./../spc/Mask.h"
#include "./../spc/PowerDomainID.h"
#include "./../spc/PowerDomainLowPowerMode.h"
#include "./../spc/PowerDomains.h"
#include "./../spc/Register.h"
#include "./../spc/Shift.h"
#include "./../spc/SramOperateVoltage.h"
#include "./../spc/SramVoltageConfig.h"
#include "./../spc/Status.h"
#include "./../spc/SystemVoltageDetectConfig.h"
#include "./../spc/VoltageDetectFlag.h"
#include "./../spc/VoltageDetectOption.h"
 
//----------------------------------------------------------------------------------------
 
/* ***************************************************************************************
 * Namespace
 */
namespace mcxa153::chip::spc {
  class SPC;
  Register* const SPC0 =
      reinterpret_cast<Register*>(mcxa153::chip::Processor::BASE_SPC0);
 
  Register* const SPC[] = {SPC0};
}  // namespace mcxa153::chip::spc
 
/* ***************************************************************************************
 * Class/Interface/Struct/Enum
 */
class mcxa153::chip::spc::SPC final : public ufm::lang::NonInstantiable {
  /* *************************************************************************************
   * Variable
   */
 
  /* *************************************************************************************
   * Abstract Method
   */
 
  /* *************************************************************************************
   * Construct Method
   */
 protected:
  virtual ~SPC(void) override = default;
 
  /* *************************************************************************************
   * Operator Method
   */
 
  /* *************************************************************************************
   * Override Method
   */
 
  /* *************************************************************************************
   * Public Method
   */
 
  /* *************************************************************************************
   * Protected Method
   */
 
  /* *************************************************************************************
   * Private Method
   */
 
  /* *************************************************************************************
   * Static Variable
   */
 
  /* *************************************************************************************
   * Static Method
   */
 public:
  static uint8 getPeriphIOIsolationStatus(Register* base);
 
  static inline void clearPeriphIOIsolationFlag(Register* base) {
    base->sc |= +mcxa153::chip::spc::Mask::SC_ISO_CLR;
  }
 
  static inline bool getBusyStatusFlag(Register* base) {
    return ((base->sc & +mcxa153::chip::spc::Mask::SC_BUSY) != 0UL);
  }
 
  static inline bool checkLowPowerReqest(Register* base) {
    return ((base->sc & +mcxa153::chip::spc::Mask::SC_SPC_LP_REQ) ==
            +mcxa153::chip::spc::Mask::SC_SPC_LP_REQ);
  }
 
  static inline void clearLowPowerRequest(Register* base) {
    base->sc |= +mcxa153::chip::spc::Mask::SC_SPC_LP_REQ;
  }
 
  static inline bool checkSwitchState(Register* base) {
    return ((base->sc & +mcxa153::chip::spc::Mask::SC_SWITCH_STATE) != 0UL);
  }
 
  static PowerDomainLowPowerMode getPowerDomainLowPowerMode(Register*     base,
                                                            PowerDomainID powerDomainId);
 
  static inline bool checkPowerDomainLowPowerRequest(Register*     base,
                                                     PowerDomainID powerDomainId) {
    return ((base->pd_status[+powerDomainId] &
             +mcxa153::chip::spc::Mask::PD_STATUS_PWR_REQ_STATUS) ==
            +mcxa153::chip::spc::Mask::PD_STATUS_PWR_REQ_STATUS);
  }
 
  static inline void clearPowerDomainLowPowerRequestFlag(Register*     base,
                                                         PowerDomainID powerDomainId) {
    base->pd_status[+powerDomainId] |= +mcxa153::chip::spc::Mask::PD_STATUS_PD_LP_REQ;
  }
 
  static inline void trimSRAMLdoRefVoltage(Register* base, uint8 trimValue) {
    base->sramretldo_reftrim = ((base->sramretldo_reftrim &
                                ~+mcxa153::chip::spc::Mask::SRAMRETLDO_REFTRIM_REFTRIM) |
                               SPC::SRAMRETLDO_REFTRIM_REFTRIM(trimValue));
  }
 
  static inline void enableSRAMLdo(Register* base, bool enable) {
    if (enable) {
      base->sramretldo_cntrl |= +mcxa153::chip::spc::Mask::SRAMRETLDO_CNTRL_SRAMLDO_ON;
    } else {
      base->sramretldo_cntrl &= ~+mcxa153::chip::spc::Mask::SRAMRETLDO_CNTRL_SRAMLDO_ON;
    }
  }
 
  static inline void retainSRAMArray(Register* base, uint8 mask) {
    base->sramretldo_cntrl |= SPC::SRAMRETLDO_CNTRL_SRAM_RET_EN(mask);
  }
 
  static void setLowPowerRequestConfig(Register*                    base,
                                       const LowPowerRequestConfig& config);
 
  static inline void enableIntegratedPowerSwitchManually(Register* base, bool enable) {
    if (enable) {
      base->cfg |= (+Mask::CFG_INTG_PWSWTCH_SLEEP_ACTIVE_EN |
                   +Mask::CFG_INTG_PWSWTCH_WKUP_ACTIVE_EN);
    } else {
      base->cfg &= ~(+Mask::CFG_INTG_PWSWTCH_SLEEP_ACTIVE_EN |
                    +Mask::CFG_INTG_PWSWTCH_WKUP_ACTIVE_EN);
    }
  }
 
  static inline void enableIntegratedPowerSwitchAutomatically(Register* base,
                                                              bool      sleepGate,
                                                              bool      wakeupUngate) {
    uint32 tmp32 =
        ((base->cfg) &
         ~(+Mask::CFG_INTG_PWSWTCH_SLEEP_EN | +Mask::CFG_INTG_PWSWTCH_WKUP_EN));
 
    tmp32 |= SPC::CFG_INTG_PWSWTCH_SLEEP_EN(sleepGate) |
        SPC::CFG_INTG_PWSWTCH_WKUP_EN(wakeupUngate);
 
    base->cfg = tmp32;
  }
 
  static void setSRAMOperateVoltage(Register* base, const SramVoltageConfig& config);
 
  static inline BandgapMode getActiveModeBandgapMode(Register* base) {
    return static_cast<mcxa153::chip::spc::BandgapMode>(
        (base->active_cfg & +Mask::ACTIVE_CFG_BGMODE) >> +Shift::ACTIVE_CFG_BGMODE);
  }
 
  static inline uint32 getActiveModeVoltageDetectStatus(Register* base) {
    uint32 state;
    state = base->active_cfg &
        (+Mask::ACTIVE_CFG_SYS_HVDE | +Mask::ACTIVE_CFG_SYS_LVDE |
         +Mask::ACTIVE_CFG_CORE_LVDE);
    return state;
  }
 
  static mcxa153::chip::spc::Status setActiveModeBandgapModeConfig(
      Register* base, mcxa153::chip::spc::BandgapMode mode);
 
  static inline void setActiveModeVoltageTrimDelay(Register* base, uint16 delay) {
    base->active_vdelay = SPC::ACTIVE_VDELAY_ACTIVE_VDELAY(delay);
  }
 
  static mcxa153::chip::spc::Status setActiveModeRegulatorsConfig(
      Register* base, const ActiveModeRegulatorsConfig& config);
 
  static inline void enableActiveModeAnalogModules(Register* base, uint32 maskValue) {
    base->active_cfg1 |= SPC::ACTIVE_CFG1_SOC_CNTRL(maskValue);
  }
 
  static inline void disableActiveModeAnalogModules(Register* base, uint32 maskValue) {
    base->active_cfg1 &= ~SPC::ACTIVE_CFG1_SOC_CNTRL(maskValue);
  }
 
  static inline uint32 getActiveModeEnabledAnalogModules(Register* base) {
    return base->active_cfg1;
  }
 
  static inline mcxa153::chip::spc::BandgapMode getLowPowerModeBandgapMode(
      Register* base) {
    return static_cast<mcxa153::chip::spc::BandgapMode>(
        (base->lp_cfg & +Mask::LP_CFG_BGMODE) >> +Shift::LP_CFG_BGMODE);
  }
 
  static inline uint32 getLowPowerModeVoltageDetectStatus(Register* base) {
    uint32 state;
    state = base->lp_cfg &
        (+Mask::LP_CFG_SYS_HVDE | +Mask::LP_CFG_SYS_LVDE | +Mask::LP_CFG_CORE_LVDE);
    return state;
  }
 
  static inline void enableLowPowerModeLowPowerIREF(Register* base, bool enable) {
    if (enable) {
      base->lp_cfg |= +Mask::LP_CFG_LP_IREFEN;
    } else {
      base->lp_cfg &= ~+Mask::LP_CFG_LP_IREFEN;
    }
  }
 
  static mcxa153::chip::spc::Status setLowPowerModeBandgapmodeConfig(
      Register* base, mcxa153::chip::spc::BandgapMode mode);
 
  static inline void enableSRAMLdOLowPowerModeIREF(Register* base, bool enable) {
    if (enable) {
      base->lp_cfg |= +Mask::LP_CFG_SRAMLDO_DPD_ON;
    } else {
      base->lp_cfg &= ~+Mask::LP_CFG_SRAMLDO_DPD_ON;
    }
  }
 
  static inline void setLowPowerWakeUpDelay(Register* base, uint16 delay) {
    base->lpwkup_delay = SPC::LPWKUP_DELAY_LPWKUP_DELAY(delay);
  }
 
  static mcxa153::chip::spc::Status setLowPowerModeRegulatorsConfig(
      Register* base, const LowPowerModeRegulatorsConfig* config);
 
  static inline void enableLowPowerModeAnalogModules(Register* base, uint32 maskValue) {
    base->lp_cfg1 |= SPC::LP_CFG1_SOC_CNTRL(maskValue);
  }
 
  static inline void disableLowPowerModeAnalogModules(Register* base, uint32 maskValue) {
    base->lp_cfg1 &= ~SPC::LP_CFG1_SOC_CNTRL(maskValue);
  }
 
  static inline uint32 getLowPowerModeEnabledAnalogModules(Register* base) {
    return base->lp_cfg1;
  }
 
  static inline uint8 getVoltageDetectStatusFlag(Register* base) {
    return static_cast<uint8>(base->vd_stat);
  }
 
  static inline void clearVoltageDetectStatusFlag(Register* base, uint8 mask) {
    base->vd_stat |= mask;
  }
 
  static void setCoreVoltageDetectConfig(Register*                      base,
                                         const CoreVoltageDetectConfig& config);
 
  static inline void lockCoreVoltageDetectResetSetting(Register* base) {
    base->vd_core_cfg |= +Mask::VD_CORE_CFG_LOCK;
  }
 
  static inline void unlockCoreVoltageDetectResetSetting(Register* base) {
    base->vd_core_cfg &= ~+Mask::VD_CORE_CFG_LOCK;
  }
 
  static mcxa153::chip::spc::Status enableActiveModeCoreLowVoltageDetect(Register* base,
                                                                         bool enable);
 
  static mcxa153::chip::spc::Status enableLowPowerModeCoreLowVoltageDetect(Register* base,
                                                                           bool enable);
 
  static void setSystemVDDLowVoltageLevel(Register* base, LowVoltageLevelSelect level);
 
  static void setSystemVoltageDetectConfig(Register*                        base,
                                           const SystemVoltageDetectConfig& config);
 
  static inline void lockSystemVoltageDetectResetSetting(Register* base) {
    base->vd_sys_cfg |= +Mask::VD_SYS_CFG_LOCK;
  }
 
  static inline void unlockSystemVoltageDetectResetSetting(Register* base) {
    base->vd_sys_cfg &= ~+Mask::VD_SYS_CFG_LOCK;
  }
 
  static mcxa153::chip::spc::Status enableActiveModeSystemHighVoltageDetect(
      Register* base, bool enable);
 
  static mcxa153::chip::spc::Status enableActiveModeSystemLowVoltageDetect(Register* base,
                                                                           bool enable);
 
  static mcxa153::chip::spc::Status enableLowPowerModeSystemHighVoltageDetect(
      Register* base, bool enable);
 
  static mcxa153::chip::spc::Status enableLowPowerModeSystemLowVoltageDetect(
      Register* base, bool enable);
 
  static void setExternalVoltageDomainsConfig(Register* base,
                                              uint8     lowPowerIsoMask,
                                              uint8     IsoMask);
 
  static inline uint8 getExternalDomainsStatus(Register* base) {
    return static_cast<uint8>(base->evd_cfg >> +Shift::EVD_CFG_REG_EVDSTAT);
  }
 
  static mcxa153::chip::spc::Status setActiveModeCoreLDORegulatorConfig(
      Register* base, const ActiveModeCoreLdoOption& option);
 
  static mcxa153::chip::spc::Status setActiveModeCoreLDORegulatorVoltageLevel(
      Register* base, CoreLdoVoltageLevel voltageLevel);
 
  static inline CoreLdoVoltageLevel getActiveModeCoreLDOVDDVoltageLevel(Register* base) {
    return static_cast<CoreLdoVoltageLevel>(
        (base->active_cfg & +Mask::ACTIVE_CFG_CORELDO_VDD_LVL) >>
        +Shift::ACTIVE_CFG_CORELDO_VDD_LVL);
  }
 
  static mcxa153::chip::spc::Status setActiveModeCoreLDORegulatorDriveStrength(
      Register* base, CoreLdoDriveStrength driveStrength);
 
  static inline CoreLdoDriveStrength getActiveModeCoreLDODriveStrength(Register* base) {
    return static_cast<CoreLdoDriveStrength>(
        (base->active_cfg & +Mask::ACTIVE_CFG_CORELDO_VDD_DS) >>
        +Shift::ACTIVE_CFG_CORELDO_VDD_DS);
  }
 
  static mcxa153::chip::spc::Status setLowPowerModeCoreLDORegulatorConfig(
      Register* base, const LowPowerModeCoreLdoOption& option);
 
  static mcxa153::chip::spc::Status setLowPowerModeCoreLDORegulatorVoltageLevel(
      Register* base, CoreLdoVoltageLevel voltageLevel);
 
  static inline CoreLdoVoltageLevel getLowPowerCoreLDOVDDVoltageLevel(Register* base) {
    return static_cast<CoreLdoVoltageLevel>(
        ((base->lp_cfg & +Mask::LP_CFG_CORELDO_VDD_LVL) >> +Mask::LP_CFG_CORELDO_VDD_LVL));
  }
 
  static mcxa153::chip::spc::Status setLowPowerModeCoreLDORegulatorDriveStrength(
      Register* base, CoreLdoDriveStrength driveStrength);
 
  static inline CoreLdoDriveStrength getLowPowerCoreLDOVDDDriveStrength(Register* base) {
    return static_cast<CoreLdoDriveStrength>(
        (base->lp_cfg & +Mask::LP_CFG_CORELDO_VDD_DS) >> +Shift::LP_CFG_CORELDO_VDD_DS);
  }
 
  static inline constexpr uint32 VERID_FEATURE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VERID_FEATURE) &
            +mcxa153::chip::spc::Mask::VERID_FEATURE);
  }
 
  static inline constexpr uint32 VERID_MINOR(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VERID_MINOR) &
            +mcxa153::chip::spc::Mask::VERID_MINOR);
  }
 
  static inline constexpr uint32 VERID_MAJOR(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VERID_MAJOR) &
            +mcxa153::chip::spc::Mask::VERID_MAJOR);
  }
 
  static inline constexpr uint32 SC_BUSY(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::SC_BUSY) &
            +mcxa153::chip::spc::Mask::SC_BUSY);
  }
 
  static inline constexpr uint32 SC_SPC_LP_REQ(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::SC_SPC_LP_REQ) &
            +mcxa153::chip::spc::Mask::SC_SPC_LP_REQ);
  }
 
  static inline constexpr uint32 SC_SPC_LP_MODE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::SC_SPC_LP_MODE) &
            +mcxa153::chip::spc::Mask::SC_SPC_LP_MODE);
  }
 
  static inline constexpr uint32 SC_ISO_CLR(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::SC_ISO_CLR) &
            +mcxa153::chip::spc::Mask::SC_ISO_CLR);
  }
 
  static inline constexpr uint32 SC_SWITCH_STATE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::SC_SWITCH_STATE) &
            +mcxa153::chip::spc::Mask::SC_SWITCH_STATE);
  }
 
  static inline constexpr uint32 LPREQ_CFG_LPREQOE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LPREQ_CFG_LPREQOE) &
            +mcxa153::chip::spc::Mask::LPREQ_CFG_LPREQOE);
  }
 
  static inline constexpr uint32 LPREQ_CFG_LPREQPOL(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LPREQ_CFG_LPREQPOL) &
            +mcxa153::chip::spc::Mask::LPREQ_CFG_LPREQPOL);
  }
 
  static inline constexpr uint32 LPREQ_CFG_LPREQOV(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LPREQ_CFG_LPREQOV) &
            +mcxa153::chip::spc::Mask::LPREQ_CFG_LPREQOV);
  }
 
  static inline constexpr uint32 CFG_INTG_PWSWTCH_SLEEP_EN(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::CFG_INTG_PWSWTCH_SLEEP_EN) &
            +mcxa153::chip::spc::Mask::CFG_INTG_PWSWTCH_SLEEP_EN);
  }
 
  static inline constexpr uint32 CFG_INTG_PWSWTCH_WKUP_EN(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::CFG_INTG_PWSWTCH_WKUP_EN) &
            +mcxa153::chip::spc::Mask::CFG_INTG_PWSWTCH_WKUP_EN);
  }
 
  static inline constexpr uint32 CFG_INTG_PWSWTCH_SLEEP_ACTIVE_EN(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::CFG_INTG_PWSWTCH_SLEEP_ACTIVE_EN) &
            +mcxa153::chip::spc::Mask::CFG_INTG_PWSWTCH_SLEEP_ACTIVE_EN);
  }
 
  static inline constexpr uint32 CFG_INTG_PWSWTCH_WKUP_ACTIVE_EN(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::CFG_INTG_PWSWTCH_WKUP_ACTIVE_EN) &
            +mcxa153::chip::spc::Mask::CFG_INTG_PWSWTCH_WKUP_ACTIVE_EN);
  }
 
  static inline constexpr uint32 PD_STATUS_PWR_REQ_STATUS(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::PD_STATUS_PWR_REQ_STATUS) &
            +mcxa153::chip::spc::Mask::PD_STATUS_PWR_REQ_STATUS);
  }
 
  static inline constexpr uint32 PD_STATUS_PD_LP_REQ(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::PD_STATUS_PD_LP_REQ) &
            +mcxa153::chip::spc::Mask::PD_STATUS_PD_LP_REQ);
  }
 
  static inline constexpr uint32 PD_STATUS_LP_MODE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::PD_STATUS_LP_MODE) &
            +mcxa153::chip::spc::Mask::PD_STATUS_LP_MODE);
  }
 
  static inline constexpr uint32 SRAMCTL_VSM(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::SRAMCTL_VSM) &
            +mcxa153::chip::spc::Mask::SRAMCTL_VSM);
  }
 
  static inline constexpr uint32 SRAMCTL_REQ(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::SRAMCTL_REQ) &
            +mcxa153::chip::spc::Mask::SRAMCTL_REQ);
  }
 
  static inline constexpr uint32 SRAMCTL_ACK(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::SRAMCTL_ACK) &
            +mcxa153::chip::spc::Mask::SRAMCTL_ACK);
  }
 
  static inline constexpr uint32 SRAMRETLDO_REFTRIM_REFTRIM(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::SRAMRETLDO_REFTRIM_REFTRIM) &
            +mcxa153::chip::spc::Mask::SRAMRETLDO_REFTRIM_REFTRIM);
  }
 
  static inline constexpr uint32 SRAMRETLDO_CNTRL_SRAMLDO_ON(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::SRAMRETLDO_CNTRL_SRAMLDO_ON) &
            +mcxa153::chip::spc::Mask::SRAMRETLDO_CNTRL_SRAMLDO_ON);
  }
 
  static inline constexpr uint32 SRAMRETLDO_CNTRL_SRAM_RET_EN(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::SRAMRETLDO_CNTRL_SRAM_RET_EN) &
            +mcxa153::chip::spc::Mask::SRAMRETLDO_CNTRL_SRAM_RET_EN);
  }
 
  static inline constexpr uint32 ACTIVE_CFG_CORELDO_VDD_DS(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::ACTIVE_CFG_CORELDO_VDD_DS) &
            +mcxa153::chip::spc::Mask::ACTIVE_CFG_CORELDO_VDD_DS);
  }
 
  static inline constexpr uint32 ACTIVE_CFG_CORELDO_VDD_LVL(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::ACTIVE_CFG_CORELDO_VDD_LVL) &
            +mcxa153::chip::spc::Mask::ACTIVE_CFG_CORELDO_VDD_LVL);
  }
 
  static inline constexpr uint32 ACTIVE_CFG_BGMODE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::ACTIVE_CFG_BGMODE) &
            +mcxa153::chip::spc::Mask::ACTIVE_CFG_BGMODE);
  }
 
  static inline constexpr uint32 ACTIVE_CFG_VDD_VD_DISABLE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::ACTIVE_CFG_VDD_VD_DISABLE) &
            +mcxa153::chip::spc::Mask::ACTIVE_CFG_VDD_VD_DISABLE);
  }
 
  static inline constexpr uint32 ACTIVE_CFG_CORE_LVDE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::ACTIVE_CFG_CORE_LVDE) &
            +mcxa153::chip::spc::Mask::ACTIVE_CFG_CORE_LVDE);
  }
 
  static inline constexpr uint32 ACTIVE_CFG_SYS_LVDE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::ACTIVE_CFG_SYS_LVDE) &
            +mcxa153::chip::spc::Mask::ACTIVE_CFG_SYS_LVDE);
  }
 
  static inline constexpr uint32 ACTIVE_CFG_SYS_HVDE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::ACTIVE_CFG_SYS_HVDE) &
            +mcxa153::chip::spc::Mask::ACTIVE_CFG_SYS_HVDE);
  }
 
  static inline constexpr uint32 ACTIVE_CFG1_SOC_CNTRL(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::ACTIVE_CFG1_SOC_CNTRL) &
            +mcxa153::chip::spc::Mask::ACTIVE_CFG1_SOC_CNTRL);
  }
 
  static inline constexpr uint32 LP_CFG_CORELDO_VDD_DS(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LP_CFG_CORELDO_VDD_DS) &
            +mcxa153::chip::spc::Mask::LP_CFG_CORELDO_VDD_DS);
  }
 
  static inline constexpr uint32 LP_CFG_CORELDO_VDD_LVL(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LP_CFG_CORELDO_VDD_LVL) &
            +mcxa153::chip::spc::Mask::LP_CFG_CORELDO_VDD_LVL);
  }
 
  static inline constexpr uint32 LP_CFG_SRAMLDO_DPD_ON(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LP_CFG_SRAMLDO_DPD_ON) &
            +mcxa153::chip::spc::Mask::LP_CFG_SRAMLDO_DPD_ON);
  }
 
  static inline constexpr uint32 LP_CFG_BGMODE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LP_CFG_BGMODE) &
            +mcxa153::chip::spc::Mask::LP_CFG_BGMODE);
  }
 
  static inline constexpr uint32 LP_CFG_LP_IREFEN(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LP_CFG_LP_IREFEN) &
            +mcxa153::chip::spc::Mask::LP_CFG_LP_IREFEN);
  }
 
  static inline constexpr uint32 LP_CFG_CORE_LVDE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LP_CFG_CORE_LVDE) &
            +mcxa153::chip::spc::Mask::LP_CFG_CORE_LVDE);
  }
 
  static inline constexpr uint32 LP_CFG_SYS_LVDE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LP_CFG_SYS_LVDE) &
            +mcxa153::chip::spc::Mask::LP_CFG_SYS_LVDE);
  }
 
  static inline constexpr uint32 LP_CFG_SYS_HVDE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LP_CFG_SYS_HVDE) &
            +mcxa153::chip::spc::Mask::LP_CFG_SYS_HVDE);
  }
 
  static inline constexpr uint32 LP_CFG1_SOC_CNTRL(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LP_CFG1_SOC_CNTRL) &
            +mcxa153::chip::spc::Mask::LP_CFG1_SOC_CNTRL);
  }
 
  static inline constexpr uint32 LPWKUP_DELAY_LPWKUP_DELAY(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::LPWKUP_DELAY_LPWKUP_DELAY) &
            +mcxa153::chip::spc::Mask::LPWKUP_DELAY_LPWKUP_DELAY);
  }
 
  static inline constexpr uint32 ACTIVE_VDELAY_ACTIVE_VDELAY(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::ACTIVE_VDELAY_ACTIVE_VDELAY) &
            +mcxa153::chip::spc::Mask::ACTIVE_VDELAY_ACTIVE_VDELAY);
  }
 
  static inline constexpr uint32 VD_STAT_COREVDD_LVDF(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VD_STAT_COREVDD_LVDF) &
            +mcxa153::chip::spc::Mask::VD_STAT_COREVDD_LVDF);
  }
 
  static inline constexpr uint32 VD_STAT_SYSVDD_LVDF(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VD_STAT_SYSVDD_LVDF) &
            +mcxa153::chip::spc::Mask::VD_STAT_SYSVDD_LVDF);
  }
 
  static inline constexpr uint32 VD_STAT_SYSVDD_HVDF(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VD_STAT_SYSVDD_HVDF) &
            +mcxa153::chip::spc::Mask::VD_STAT_SYSVDD_HVDF);
  }
 
  static inline constexpr uint32 VD_CORE_CFG_LVDRE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VD_CORE_CFG_LVDRE) &
            +mcxa153::chip::spc::Mask::VD_CORE_CFG_LVDRE);
  }
 
  static inline constexpr uint32 VD_CORE_CFG_LVDIE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VD_CORE_CFG_LVDIE) &
            +mcxa153::chip::spc::Mask::VD_CORE_CFG_LVDIE);
  }
 
  static inline constexpr uint32 VD_CORE_CFG_LOCK(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VD_CORE_CFG_LOCK) &
            +mcxa153::chip::spc::Mask::VD_CORE_CFG_LOCK);
  }
 
  static inline constexpr uint32 VD_SYS_CFG_LVDRE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VD_SYS_CFG_LVDRE) &
            +mcxa153::chip::spc::Mask::VD_SYS_CFG_LVDRE);
  }
 
  static inline constexpr uint32 VD_SYS_CFG_LVDIE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VD_SYS_CFG_LVDIE) &
            +mcxa153::chip::spc::Mask::VD_SYS_CFG_LVDIE);
  }
 
  static inline constexpr uint32 VD_SYS_CFG_HVDRE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VD_SYS_CFG_HVDRE) &
            +mcxa153::chip::spc::Mask::VD_SYS_CFG_HVDRE);
  }
 
  static inline constexpr uint32 VD_SYS_CFG_HVDIE(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VD_SYS_CFG_HVDIE) &
            +mcxa153::chip::spc::Mask::VD_SYS_CFG_HVDIE);
  }
 
  static inline constexpr uint32 VD_SYS_CFG_LVSEL(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VD_SYS_CFG_LVSEL) &
            +mcxa153::chip::spc::Mask::VD_SYS_CFG_LVSEL);
  }
 
  static inline constexpr uint32 VD_SYS_CFG_LOCK(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::VD_SYS_CFG_LOCK) &
            +mcxa153::chip::spc::Mask::VD_SYS_CFG_LOCK);
  }
 
  static inline constexpr uint32 EVD_CFG_EVDISO(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::EVD_CFG_EVDISO) &
            +mcxa153::chip::spc::Mask::EVD_CFG_EVDISO);
  }
 
  static inline constexpr uint32 EVD_CFG_EVDLPISO(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::EVD_CFG_EVDLPISO) &
            +mcxa153::chip::spc::Mask::EVD_CFG_EVDLPISO);
  }
 
  static inline constexpr uint32 EVD_CFG_EVDSTAT(uint32 value) {
    return ((value << +mcxa153::chip::spc::Shift::EVD_CFG_EVDSTAT) &
            +mcxa153::chip::spc::Mask::EVD_CFG_EVDSTAT);
  }
 
  static inline constexpr uint32 EVD_CFG_REG_EVDISO(uint32 value) {
    return value << +Shift::EVD_CFG_REG_EVDISO;
  }
 
  static inline constexpr uint32 EVD_CFG_REG_EVDLPISO(uint32 value) {
    return value << +Shift::EVD_CFG_REG_EVDLPISO;
  }
 
  static inline constexpr uint32 EVD_CFG_REG_EVDSTAT(uint32 value) {
    return value << +Shift::EVD_CFG_REG_EVDSTAT;
  }
};
 
/* ***************************************************************************************
 * End of file
 */
 
#endif /* MCXA153_2E3411A1_6370_44BE_84E2_32D911539D8F */