| /* |
| * |
| * Copyright (c) 2022 Project CHIP Authors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @file |
| * Provides a glue layer between Matter and NXP-SDK Low Power |
| */ |
| |
| #if defined(cPWR_UsePowerDownMode) && (cPWR_UsePowerDownMode) |
| |
| #include <platform/CHIPDeviceLayer.h> |
| #include <platform/ThreadStackManager.h> |
| |
| #include "Keyboard.h" |
| #include "MacSched.h" |
| #include "OtaSupport.h" |
| #include "PWR_Configuration.h" |
| #include "PWR_Interface.h" |
| #include "RNG_Interface.h" |
| #include "app_dual_mode_low_power.h" |
| #include "app_dual_mode_switch.h" |
| #include "k32w0-chip-mbedtls-config.h" |
| #include <AppTask.h> // nogncheck |
| |
| #include "app_config.h" |
| #include "fsl_gpio.h" |
| #include "fsl_iocon.h" |
| #include "gpio_pins.h" |
| |
| using namespace ::chip; |
| using namespace ::chip::Inet; |
| using namespace ::chip::DeviceLayer; |
| |
| extern "C" void InitLowPower(); |
| |
| extern "C" void vMMAC_IntHandlerBbc(); |
| extern "C" void vMMAC_IntHandlerPhy(); |
| extern "C" void BOARD_SetClockForPowerMode(void); |
| extern "C" void stopM2(); |
| extern "C" void sched_enable(); |
| extern "C" uint64_t otPlatTimeGet(void); |
| |
| static void dm_switch_wakeupCallBack(void); |
| static void dm_switch_preSleepCallBack(void); |
| static void ThreadExitSleep(); |
| static void BOARD_SetClockForWakeup(void); |
| |
| typedef struct |
| { |
| bool_t bleAppRunning; |
| bool_t bleAppStopInprogress; |
| bool_t threadInitialized; |
| uint32_t threadWarmBootInitTime; |
| } sDualModeAppStates; |
| |
| typedef void * appCallbackParam_t; |
| typedef void (*appCallbackHandler_t)(appCallbackParam_t param); |
| |
| static sDualModeAppStates dualModeStates; |
| /* 15.4 warm time must be > 0, so this value will be |
| * updated when 15.4 is initialized for the first time |
| */ |
| constexpr uint16_t kThreadWarmNotInitializedValue = 0; |
| |
| extern "C" void otTaskletsSignalPending(otInstance * p_instance); |
| |
| #define ENABLE_LOW_POWER_LOGS 0 |
| |
| void InitLowPower() |
| { |
| PWR_Init(); |
| |
| /* Internal - MATTER-303: keep in retention the entire RAM1 for the moment */ |
| PWR_vAddRamRetention((uint32_t) 0x4020000, 0x10000); |
| |
| PWR_RegisterLowPowerExitCallback(dm_switch_wakeupCallBack); |
| PWR_RegisterLowPowerEnterCallback(dm_switch_preSleepCallBack); |
| |
| dualModeStates.threadWarmBootInitTime = kThreadWarmNotInitializedValue; |
| |
| dm_lp_init(); |
| } |
| |
| extern "C" void setThreadInitialized(bool isInitialized) |
| { |
| dualModeStates.threadInitialized = isInitialized; |
| } |
| |
| extern "C" bool isThreadInitialized() |
| { |
| return dualModeStates.threadInitialized; |
| } |
| |
| uint32_t dm_switch_get15_4InitWakeUpTime(void) |
| { |
| return dualModeStates.threadWarmBootInitTime; |
| } |
| |
| extern "C" bleResult_t App_PostCallbackMessage(appCallbackHandler_t handler, appCallbackParam_t param) |
| { |
| AppEvent event; |
| event.Type = AppEvent::kEventType_Lp; |
| event.Handler = handler; |
| event.param = param; |
| |
| #if ENABLE_LOW_POWER_LOGS |
| K32W_LOG("App_PostCallbackMessage %d", (uint32_t) param); |
| #endif |
| |
| GetAppTask().PostEvent(&event); |
| |
| return gBleSuccess_c; |
| } |
| |
| static void dm_switch_wakeupCallBack(void) |
| { |
| BOARD_SetClockForWakeup(); |
| SHA_ClkInit(SHA_INSTANCE); |
| CLOCK_EnableClock(kCLOCK_Aes); |
| |
| #if ENABLE_LOW_POWER_LOGS |
| K32W_LOG("dm_switch_wakeupCallBack"); |
| K32W_LOG("Warm up time actual value: %d", dualModeStates.threadWarmBootInitTime); |
| #endif |
| |
| RNG_Init(); |
| SecLib_Init(); |
| OTA_InitExternalMemory(); |
| |
| KBD_PrepareExitLowPower(); |
| |
| PWR_WakeupReason_t wakeReason = PWR_GetWakeupReason(); |
| if (wakeReason.Bits.FromBLE_LLTimer == 1) |
| { |
| #if ENABLE_LOW_POWER_LOGS |
| K32W_LOG("woken up from LL"); |
| #endif |
| } |
| else if (wakeReason.Bits.FromKeyBoard == 1) |
| { |
| #if ENABLE_LOW_POWER_LOGS |
| K32W_LOG("woken up from FromKeyBoard"); |
| #endif |
| } |
| else if (wakeReason.Bits.FromTMR == 1) |
| { |
| #if ENABLE_LOW_POWER_LOGS |
| K32W_LOG("woken up from TMR"); |
| #endif |
| } |
| dm_lp_wakeup(); |
| } |
| |
| void vOptimizeConsumption(uint32_t u32PIOvalue, uint32_t u32SkipIO) |
| { |
| uint8_t u8KeepFro32k, u8KeepIOclk, u8KeepXtal32M; |
| |
| u8KeepFro32k = u32SkipIO >> 31; |
| u8KeepIOclk = (u32SkipIO >> 30) & 0x1; |
| u8KeepXtal32M = (u32SkipIO >> 29) & 0x1; |
| const gpio_pin_config_t pin_config = { .pinDirection = kGPIO_DigitalInput, .outputLogic = 1U }; |
| |
| if (u32PIOvalue != 0) |
| { |
| for (int i = 0; i < 22; i++) |
| { |
| |
| if (((u32SkipIO >> i) & 0x1) != 1) |
| { |
| /* configure GPIOs to Input mode */ |
| GPIO_PinInit(GPIO, 0, i, &pin_config); |
| IOCON_PinMuxSet(IOCON, 0, i, u32PIOvalue); |
| } |
| } |
| } |
| |
| if (u8KeepIOclk == 0) |
| { |
| CLOCK_DisableClock(kCLOCK_Iocon); |
| CLOCK_DisableClock(kCLOCK_InputMux); |
| CLOCK_DisableClock(kCLOCK_Gpio0); |
| } |
| |
| if (u8KeepXtal32M == 0) |
| { |
| CLOCK_DisableClock(kCLOCK_Xtal32M); // Crystal 32MHz |
| } |
| |
| // Keep the 32K clock |
| if (u8KeepFro32k == 0) |
| { |
| CLOCK_DisableClock(kCLOCK_Fro32k); |
| } |
| } |
| |
| static void dm_switch_preSleepCallBack(void) |
| { |
| #if ENABLE_LOW_POWER_LOGS |
| K32W_LOG("dm_switch_preSleepCallBack"); |
| #endif |
| |
| if (dualModeStates.threadInitialized) |
| { |
| /* stop the internal MAC Scheduler timer */ |
| stopM2(); |
| /* disable the MAC scheduler */ |
| sched_disable(); |
| otPlatRadioDisable(NULL); |
| setThreadInitialized(FALSE); |
| } |
| /* Inform the low power dual mode module that we will sleep */ |
| dm_lp_preSleep(); |
| |
| EEPROM_DeInit(); |
| /* BUTTON2 change contact, BUTTON4 start adv/factoryreset */ |
| vOptimizeConsumption((IOCON_FUNC0 | (0x2 << 3) | IOCON_ANALOG_EN), |
| (1 << IOCON_USER_BUTTON1_PIN) | (1 << IOCON_USER_BUTTON2_PIN)); |
| |
| /* disable SHA clock */ |
| SHA_ClkDeinit(SHA_INSTANCE); |
| |
| /* disable the AES clock */ |
| CLOCK_DisableClock(kCLOCK_Aes); |
| |
| /* configure pins for power down mode */ |
| BOARD_SetPinsForPowerMode(); |
| /* DeInitialize application support for drivers */ |
| BOARD_DeInitAdc(); |
| /* DeInit the necessary clocks */ |
| BOARD_SetClockForPowerMode(); |
| } |
| |
| extern "C" void vDynStopAll(void) |
| { |
| vDynRequestState(E_DYN_SLAVE, E_DYN_STATE_OFF); |
| vDynRequestState(E_DYN_MASTER, E_DYN_STATE_OFF); |
| } |
| |
| void dm_switch_init15_4AfterWakeUp(void) |
| { |
| uint64_t tick1 = 0; |
| |
| if (dualModeStates.threadWarmBootInitTime == kThreadWarmNotInitializedValue) |
| { |
| /* Get a 32K tick */ |
| PWR_Start32kCounter(); |
| tick1 = otPlatTimeGet(); |
| } |
| |
| if (!dualModeStates.threadInitialized && ConnectivityMgr().IsThreadEnabled()) |
| { |
| OSA_InstallIntHandler(ZIGBEE_MAC_IRQn, vMMAC_IntHandlerBbc); |
| OSA_InstallIntHandler(ZIGBEE_MODEM_IRQn, vMMAC_IntHandlerPhy); |
| |
| /* Radio must be re-enabled after waking up from sleep. |
| * The module is completely disabled in power down mode */ |
| otPlatRadioEnable(NULL); |
| sched_enable(); |
| |
| if (dualModeStates.threadWarmBootInitTime == kThreadWarmNotInitializedValue) |
| { |
| dualModeStates.threadWarmBootInitTime = (uint32_t)(otPlatTimeGet() - tick1); |
| |
| /* Add a margin of 1 ms */ |
| dualModeStates.threadWarmBootInitTime += 1000; |
| |
| #if ENABLE_LOW_POWER_LOGS |
| K32W_LOG("Calibration: %d", dualModeStates.threadWarmBootInitTime); |
| #endif |
| } |
| |
| setThreadInitialized(TRUE); |
| |
| /* wake up the Thread stack and check if any processing needs to be done */ |
| otTaskletsSignalPending(NULL); |
| } |
| } |
| |
| extern "C" void App_NotifyWakeup(void) |
| { |
| if ((!dualModeStates.threadInitialized)) |
| { |
| |
| /* Notify the dual mode low power mode */ |
| (void) App_PostCallbackMessage(dm_lp_processEvent, (void *) e15_4WakeUpEnded); |
| } |
| } |
| |
| extern "C" void App_AllowDeviceToSleep() |
| { |
| PWR_PreventEnterLowPower(false); |
| } |
| |
| extern "C" void App_DisallowDeviceToSleep() |
| { |
| PWR_PreventEnterLowPower(true); |
| } |
| |
| static void BOARD_SetClockForWakeup(void) |
| { |
| /* Enables the clock for the I/O controller block. 0: Disable. 1: Enable.: 0x01u */ |
| CLOCK_EnableClock(kCLOCK_Iocon); |
| /* Enables the clock for the GPIO0 module */ |
| CLOCK_EnableClock(kCLOCK_Gpio0); |
| } |
| |
| #endif |