/* * ======== Power_sleep ======== */ Power_Status Power_sleep(Power_SleepState sleepState, UArg arg0, UArg arg1) { Power_Status status = Power_SOK; UInt xosc_hf_active = FALSE; Power_Event postEventLate; UInt32 poweredDomains = 0; Bool exitNow = FALSE; Power_Event preEvent; Power_Event postEvent; UInt32 constraints; Bool retainCache = FALSE; UInt32 modeVIMS; UInt taskKey; UInt swiKey; UInt hwiKey; /* first validate the sleep code */ if ( sleepState != Power_STANDBY) { status = Power_EFAIL; } if (status == Power_SOK) { /* make sure Power is not still busy with a previous transition */ hwiKey = Hwi_disable(); if (Power_module->state == Power_ACTIVE) { /* set transition state to entering sleep */ Power_module->state = Power_ENTERING_SLEEP; } else { exitNow = TRUE; } Hwi_restore(hwiKey); if (exitNow == TRUE) { status = Power_EBUSY; } else { /* setup sleep vars */ if (sleepState == Power_STANDBY) { preEvent = Power_ENTERING_STANDBY; postEvent = Power_AWAKE_STANDBY; postEventLate = Power_AWAKE_STANDBY_LATE; } /* disable Task scheduling; allow Swis and Hwis for notifications */ taskKey = Task_disable(); /* signal all clients registered for pre-sleep notification */ status = Power_notify(preEvent); /* check for any error */ if (status != Power_SOK) { Power_module->state = Power_ACTIVE; Task_restore(taskKey); /* re-enable scheduler */ return (status); } /* now disable Swi scheduling */ swiKey = Swi_disable(); /* freeze the IOs on the boundary between MCU and AON */ AONIOCFreezeEnable(); /* if XOSC_HF is active, force it off */ if(OSCClockSourceGet(OSC_SRC_CLK_HF) == OSC_XOSC_HF) { xosc_hf_active = TRUE; ti_sysbios_family_arm_cc26xx_Power_XOSC_HF(DISABLE); } /* allow AUX to power down */ AONWUCAuxWakeupEvent(AONWUC_AUX_ALLOW_SLEEP); /* make sure writes take effect */ SysCtrlAonSync(); /* invoke specific sequences to activate sleep states... */ if (sleepState == Power_STANDBY) { /* query and save domain states before powering them off */ if (Power_getDependencyCount(DOMAIN_RFCORE)) { poweredDomains |= PRCM_DOMAIN_RFCORE; } if (Power_getDependencyCount(DOMAIN_SERIAL)){ poweredDomains |= PRCM_DOMAIN_SERIAL; } if (Power_getDependencyCount(DOMAIN_PERIPH)) { poweredDomains |= PRCM_DOMAIN_PERIPH; } /* gate running deep sleep clocks for Crypto and DMA */ if (Power_getDependencyCount(PERIPH_CRYPTO)) { PRCMPeripheralDeepSleepDisable( ti_sysbios_family_arm_cc26xx_Power_db[ PERIPH_CRYPTO].driverlibID); } if (Power_getDependencyCount(PERIPH_UDMA)) { PRCMPeripheralDeepSleepDisable( ti_sysbios_family_arm_cc26xx_Power_db[ PERIPH_UDMA].driverlibID); } /* make sure clock settings take effect */ PRCMLoadSet(); /* request power off of domains in the MCU voltage domain */ PRCMPowerDomainOff(poweredDomains | PRCM_DOMAIN_CPU); /* request uLDO during standby */ PRCMMcuUldoConfigure(true); /* query constraints to determine if cache should be retained */ constraints = Power_getConstraintInfo(); if ((constraints & Power_SB_VIMS_CACHE_RETAIN) != 0) { retainCache = TRUE; } /* if don't want retention in standby, disable it now ... */ if (retainCache == FALSE) { modeVIMS = VIMSModeGet(VIMS_BASE); /* wait if invalidate in progress... */ while (modeVIMS == VIMS_MODE_CHANGING) { modeVIMS = VIMSModeGet(VIMS_BASE); } PRCMCacheRetentionDisable(); VIMSModeSet(VIMS_BASE, VIMS_MODE_OFF); } /* setup recharge parameters */ SysCtrlSetRechargeBeforePowerDown(XoscInHighPowerMode); /* make sure all writes have taken effect */ SysCtrlAonSync(); /* invoke deep sleep to go to STANDBY */ PRCMDeepSleep(); /* if didn't retain cache in standby, re-enable retention now */ if (retainCache == FALSE) { VIMSModeSet(VIMS_BASE, modeVIMS); PRCMCacheRetentionEnable(); } /* force power on of AUX to keep it on when system is not * sleeping; this also counts as a write to the AON interface * ensuring that a following sync of the AON interface will * force an update of all registers */ AONWUCAuxWakeupEvent(AONWUC_AUX_WAKEUP); while(!(AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON)) {}; /* if XOSC_HF was forced off above, initiate switch back */ if (xosc_hf_active == TRUE) { ti_sysbios_family_arm_cc26xx_Power_XOSC_HF(ENABLE); } /* restore power domain states in effect before standby */ PRCMPowerDomainOn(poweredDomains); while (PRCMPowerDomainStatus(poweredDomains) != PRCM_DOMAIN_POWER_ON){}; /* restore deep sleep clocks of Crypto and DMA */ if (Power_getDependencyCount(PERIPH_CRYPTO)) { PRCMPeripheralDeepSleepEnable( ti_sysbios_family_arm_cc26xx_Power_db[ PERIPH_CRYPTO].driverlibID); } if (Power_getDependencyCount(PERIPH_UDMA)) { PRCMPeripheralDeepSleepEnable( ti_sysbios_family_arm_cc26xx_Power_db[ PERIPH_UDMA].driverlibID); } /* make sure clock settings take effect */ PRCMLoadSet(); } /* release request for uLDO */ PRCMMcuUldoConfigure(false); /* set transition state to EXITING_SLEEP */ Power_module->state = Power_EXITING_SLEEP; /* * signal clients registered for early post-sleep notification; * this should be used to initialize any timing critical or IO * dependent hardware */ status = Power_notify(postEvent); /* disable IO freeze and ensure RTC shadow value is updated */ AONIOCFreezeDisable(); SysCtrlAonSync(); /* re-enable interrupts */ CPUcpsie(); /* signal all clients registered for late post-sleep notification */ status = Power_notify(postEventLate); /* now clear the transition state before re-enabling scheduler */ Power_module->state = Power_ACTIVE; /* re-enable Swi scheduling */ Swi_restore(swiKey); /* adjust recharge parameters */ SysCtrlAdjustRechargeAfterPowerDown(); /* re-enable Task scheduling */ Task_restore(taskKey); /* check for any notification error */ if (status != Power_SOK) { return (status); } } } return (status); }
//***************************************************************************** // // Force the system in to low power modes. // //***************************************************************************** void PowerCtrlStateSet(uint32_t ui32Powerstate) { // // Check the arguments. // ASSERT((ui32Powerstate == PWRCTRL_STANDBY) || (ui32Powerstate == PWRCTRL_POWER_DOWN) || (ui32Powerstate == PWRCTRL_SHUTDOWN)); // // Configure the desired power state. // if(ui32Powerstate == PWRCTRL_STANDBY) { // // // Turn of all power domains in the MCU voltage domain. This is // necessary to conserve power before switching to the uLDO. // PRCMPowerDomainOff(PRCM_DOMAIN_RFCORE | PRCM_DOMAIN_SERIAL | PRCM_DOMAIN_PERIPH | PRCM_DOMAIN_CPU | PRCM_DOMAIN_VIMS); // // Make sure to request power off of the JTAG domain. // AONWUCJtagPowerOff(); // // Configuration of clock source for MCU and AUX in standby mode. // AONWUCMcuPowerDownConfig(AONWUC_CLOCK_SRC_LF); AONWUCAuxPowerDownConfig(AONWUC_CLOCK_SRC_LF); // // Configure the recharge controller and request the uLDO as power // source. // AONWUCRechargeCtrlConfigSet(true, 34, 2500, 5000); // // Enable AUX power down // This will tell the system that no HF source is needed and will // allow the system to use the low-leakage/effect power supply. // NB. This does not allow co-existence of an independent // Sensor Controller. // AUXWUCPowerCtrl(AUX_WUC_POWER_DOWN); while(AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON); // // Request the uLDO for standby power consumption. // PowerCtrlSourceSet(PWRCTRL_PWRSRC_ULDO); // // Sync the AON interface to ensure all writes have gone through // HWREG(AON_RTC_BASE + AON_RTC_O_SYNC); // // Enable transition to standby. // PRCMDeepSleep(); } else if(ui32Powerstate == PWRCTRL_POWER_DOWN) { // // Latch the current IO configuration before going to sleep to ensure // the IOs retain their value even after boot and reset of the // configuration. // AONIOCFreezeEnable(); // // Make sure retention on MCU SRAM is on - on pr. default. // AONWUCMcuSRamConfig(MCU_RAM0_RETENTION | MCU_RAM1_RETENTION | MCU_RAM2_RETENTION | MCU_RAM3_RETENTION); // // Allow power off on all domains in the MCU voltage domain. // This is necessary to conserve power before switching to the uLDO. // PRCMPowerDomainOff(PRCM_DOMAIN_RFCORE | PRCM_DOMAIN_SERIAL | PRCM_DOMAIN_PERIPH | PRCM_DOMAIN_CPU | PRCM_DOMAIN_VIMS); // // Turn off the MCU voltage domain. This will not take effect until System CPU // is in deep sleep. // PRCMMcuPowerOff(); // // Set the wake up mode - default value coming out of reset // AONWUCMcuWakeUpConfig(MCU_IMM_WAKE_UP); // // VIRTUAL POWER OFF DISABLE is the default value coming out of reset // AONWUCMcuPowerOffConfig(MCU_VIRT_PWOFF_DISABLE); // // Configure the recharge controller and request the uLDO as power // source. // Recommended maximum numbers for lowest power consumption // AdaptRate = 96 // MaxPeriod = 21440 // InitPeriod = 14816 // AONWUCRechargeCtrlConfigSet(true, 75, 5000, 7500); // // Enable AUX power down with LF clock source // Turn off JTAG domain and enable powerdown - values are default. // AONWUCAuxPowerDownConfig(AONWUC_CLOCK_SRC_LF); AUXWUCPowerCtrl(AUX_WUC_POWER_DOWN); AONWUCDomainPowerDownEnable(); while(AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON); // // Sync the AON interface to ensure all writes have gone through // HWREG(AON_RTC_BASE + AON_RTC_O_SYNC); // // Enable transition to power down. // PRCMDeepSleep(); } else { // // Latch the current IO configuration before going to sleep to ensure // the IOs retain their value even after boot and reset of the // configuration. // AONIOCFreezeEnable(); // // Turn of all power domains in the MCU voltage domain. // PRCMPowerDomainOff(PRCM_DOMAIN_RFCORE | PRCM_DOMAIN_SERIAL | PRCM_DOMAIN_PERIPH | PRCM_DOMAIN_CPU | PRCM_DOMAIN_VIMS); // // Turn off the MCU voltage domain. This will not take effect until System CPU // is in deep sleep. // PRCMMcuPowerOff(); // // Set the wake up mode of MCU to immediate // AONWUCMcuWakeUpConfig(MCU_IMM_WAKE_UP); AONWUCMcuPowerOffConfig(MCU_VIRT_PWOFF_DISABLE); // // Turn off the AUX domain and wait for power to be off. // // Is this required for shutdown mode? or will AUX automatically // power off. AUXWUCPowerCtrl(AUX_WUC_POWER_OFF); while(AONWUCPowerStatusGet() & AONWUC_AUX_POWER_ON) { } // // Latch the IOs in the padring before going to sleep to retain their // value even after boot and reset of the configuration. // PowerCtrlIOFreezeEnable(); // // Enable shutdown and make sure the AON interface is in sync on the // 32kHz clock. // AONWUCShutDownEnable(); // // Sync the AON interface to ensure all writes have gone through // HWREG(AON_RTC_BASE + AON_RTC_O_SYNC); // // Enable transition to shutdown. // PRCMDeepSleep(); } }