| /* |
| * |
| * Copyright (c) 2020 Project CHIP Authors |
| * Copyright (c) 2020 Nest Labs, Inc. |
| * All rights reserved. |
| * |
| * 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 the implementation of the Device Layer ConfigurationManager object |
| * for K32W platforms using the NXP SDK. |
| */ |
| |
| /* this file behaves like a config.h, comes first */ |
| #include <platform/internal/CHIPDeviceLayerInternal.h> |
| |
| #include <platform/ConfigurationManager.h> |
| #include <platform/DiagnosticDataProvider.h> |
| #include <platform/internal/GenericConfigurationManagerImpl.ipp> |
| #include <platform/nxp/k32w/k32w1/K32W1Config.h> |
| #if defined(USE_SMU2_DYNAMIC) |
| #include <src/platform/nxp/k32w/k32w1/SMU2Manager.h> |
| #endif |
| |
| // #include <openthread/platform/misc.h> |
| #include "fsl_cmc.h" |
| #include "fsl_device_registers.h" |
| |
| namespace chip { |
| namespace DeviceLayer { |
| |
| using namespace ::chip::DeviceLayer::Internal; |
| |
| // TODO: Define a Singleton instance of CHIP Group Key Store here |
| |
| ConfigurationManagerImpl & ConfigurationManagerImpl::GetDefaultInstance() |
| { |
| static ConfigurationManagerImpl sInstance; |
| return sInstance; |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::Init() |
| { |
| CHIP_ERROR err; |
| uint32_t rebootCount = 0; |
| |
| if (K32WConfig::ConfigValueExists(K32WConfig::kCounterKey_RebootCount)) |
| { |
| err = GetRebootCount(rebootCount); |
| SuccessOrExit(err); |
| |
| err = StoreRebootCount(rebootCount + 1); |
| SuccessOrExit(err); |
| } |
| else |
| { |
| // The first boot after factory reset of the Node. |
| err = StoreRebootCount(0); |
| SuccessOrExit(err); |
| } |
| |
| if (!K32WConfig::ConfigValueExists(K32WConfig::kCounterKey_TotalOperationalHours)) |
| { |
| err = StoreTotalOperationalHours(0); |
| SuccessOrExit(err); |
| } |
| |
| if (!K32WConfig::ConfigValueExists(K32WConfig::kCounterKey_BootReason)) |
| { |
| err = StoreBootReason(to_underlying(BootReasonType::kUnspecified)); |
| SuccessOrExit(err); |
| } |
| |
| // Initialize the generic implementation base class. |
| err = Internal::GenericConfigurationManagerImpl<K32WConfig>::Init(); |
| SuccessOrExit(err); |
| |
| // TODO: Initialize the global GroupKeyStore object here |
| |
| err = CHIP_NO_ERROR; |
| |
| exit: |
| return err; |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::StoreSoftwareUpdateCompleted() |
| { |
| /* Empty implementation*/ |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::GetRebootCount(uint32_t & rebootCount) |
| { |
| return ReadConfigValue(K32WConfig::kCounterKey_RebootCount, rebootCount); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::StoreRebootCount(uint32_t rebootCount) |
| { |
| return WriteConfigValue(K32WConfig::kCounterKey_RebootCount, rebootCount); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::GetTotalOperationalHours(uint32_t & totalOperationalHours) |
| { |
| return ReadConfigValue(K32WConfig::kCounterKey_TotalOperationalHours, totalOperationalHours); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::StoreTotalOperationalHours(uint32_t totalOperationalHours) |
| { |
| return WriteConfigValue(K32WConfig::kCounterKey_TotalOperationalHours, totalOperationalHours); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::GetBootReason(uint32_t & bootReason) |
| { |
| bootReason = to_underlying(BootReasonType::kUnspecified); |
| |
| uint32_t reason = CMC_GetSystemResetStatus(CMC0); |
| |
| if ((reason & CMC_SRS_POR_MASK) || (reason & CMC_SRS_PIN_MASK)) |
| { |
| bootReason = to_underlying(BootReasonType::kPowerOnReboot); |
| } |
| else if (reason & CMC_SRS_SW_MASK) |
| { |
| bootReason = to_underlying(BootReasonType::kSoftwareReset); |
| } |
| else if ((reason & CMC_SRS_WDOG0_MASK) || (reason & CMC_SRS_WDOG1_MASK)) |
| { |
| bootReason = to_underlying(BootReasonType::kSoftwareWatchdogReset); |
| } |
| else |
| { |
| bootReason = to_underlying(BootReasonType::kUnspecified); |
| } |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::StoreBootReason(uint32_t bootReason) |
| { |
| return WriteConfigValue(K32WConfig::kCounterKey_BootReason, bootReason); |
| } |
| |
| bool ConfigurationManagerImpl::CanFactoryReset() |
| { |
| // TODO: query the application to determine if factory reset is allowed. |
| return true; |
| } |
| |
| void ConfigurationManagerImpl::InitiateFactoryReset() |
| { |
| PlatformMgr().ScheduleWork(DoFactoryReset); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::ReadPersistedStorageValue(::chip::Platform::PersistedStorage::Key persistedStorageKey, |
| uint32_t & value) |
| { |
| CHIP_ERROR err; |
| |
| err = K32WConfig::ReadConfigValueCounter(persistedStorageKey, value); |
| if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND) |
| { |
| err = CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND; |
| } |
| SuccessOrExit(err); |
| |
| exit: |
| return err; |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::WritePersistedStorageValue(::chip::Platform::PersistedStorage::Key persistedStorageKey, |
| uint32_t value) |
| { |
| // This method reads Chip Persisted Counter type nvm3 objects. |
| // (where persistedStorageKey represents an index to the counter). |
| CHIP_ERROR err; |
| |
| err = K32WConfig::WriteConfigValueCounter(persistedStorageKey, value); |
| if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND) |
| { |
| err = CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND; |
| } |
| SuccessOrExit(err); |
| |
| exit: |
| return err; |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, bool & val) |
| { |
| return K32WConfig::ReadConfigValue(key, val); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint32_t & val) |
| { |
| return K32WConfig::ReadConfigValue(key, val); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint64_t & val) |
| { |
| return K32WConfig::ReadConfigValue(key, val); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::ReadConfigValueStr(Key key, char * buf, size_t bufSize, size_t & outLen) |
| { |
| return K32WConfig::ReadConfigValueStr(key, buf, bufSize, outLen); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::ReadConfigValueBin(Key key, uint8_t * buf, size_t bufSize, size_t & outLen) |
| { |
| return K32WConfig::ReadConfigValueBin(key, buf, bufSize, outLen); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, bool val) |
| { |
| return K32WConfig::WriteConfigValue(key, val); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint32_t val) |
| { |
| return K32WConfig::WriteConfigValue(key, val); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint64_t val) |
| { |
| return K32WConfig::WriteConfigValue(key, val); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueStr(Key key, const char * str) |
| { |
| return K32WConfig::WriteConfigValueStr(key, str); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueStr(Key key, const char * str, size_t strLen) |
| { |
| return K32WConfig::WriteConfigValueStr(key, str, strLen); |
| } |
| |
| CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueBin(Key key, const uint8_t * data, size_t dataLen) |
| { |
| return K32WConfig::WriteConfigValueBin(key, data, dataLen); |
| } |
| |
| void ConfigurationManagerImpl::RunConfigUnitTest(void) |
| { |
| K32WConfig::RunConfigUnitTest(); |
| } |
| |
| void ConfigurationManagerImpl::DoFactoryReset(intptr_t arg) |
| { |
| CHIP_ERROR err; |
| |
| ChipLogProgress(DeviceLayer, "Performing factory reset"); |
| |
| err = K32WConfig::FactoryResetConfig(); |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(DeviceLayer, "FactoryResetConfig() failed: %s", ErrorStr(err)); |
| } |
| |
| #if CHIP_DEVICE_CONFIG_ENABLE_THREAD |
| |
| ThreadStackMgr().ErasePersistentInfo(); |
| |
| #if defined(USE_SMU2_DYNAMIC) |
| SMU2::Deactivate(); |
| #endif |
| #endif |
| |
| // Restart the system. |
| ChipLogProgress(DeviceLayer, "System restarting"); |
| |
| NVIC_SystemReset(); |
| |
| while (1) |
| { |
| } |
| } |
| |
| ConfigurationManager & ConfigurationMgrImpl() |
| { |
| return ConfigurationManagerImpl::GetDefaultInstance(); |
| } |
| |
| } // namespace DeviceLayer |
| } // namespace chip |