/* * * Copyright (c) 2020 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 the implementation of the Device Layer ConfigurationManager object * for Qorvo QPG platforms. */ /* this file behaves like a config.h, comes first */ #include #include #include #include #include #include #include #include namespace chip { namespace DeviceLayer { using namespace ::chip::DeviceLayer::Internal; ConfigurationManagerImpl & ConfigurationManagerImpl::GetDefaultInstance() { static ConfigurationManagerImpl sInstance; return sInstance; } CHIP_ERROR ConfigurationManagerImpl::Init() { CHIP_ERROR err; uint32_t rebootCount; qvResetReason_t qvRebootReason; BootReasonType bootReason; // Initialize the generic implementation base class. err = Internal::GenericConfigurationManagerImpl::Init(); SuccessOrExit(err); if (QPGConfig::ConfigValueExists(QPGConfig::kCounterKey_RebootCount)) { err = GetRebootCount(rebootCount); SuccessOrExit(err); // Do not increment reboot count if the value is going to overflow UINT16. err = StoreRebootCount(rebootCount < UINT16_MAX ? rebootCount + 1 : rebootCount); SuccessOrExit(err); } else { // The first boot after factory reset of the Node. err = StoreRebootCount(1); SuccessOrExit(err); } if (!QPGConfig::ConfigValueExists(QPGConfig::kCounterKey_TotalOperationalHours)) { err = StoreTotalOperationalHours(0); SuccessOrExit(err); } qvRebootReason = qvCHIP_GetResetReason(); switch (qvRebootReason) { case qvResetReason_HW_BrownOutDetected: { bootReason = BootReasonType::kBrownOutReset; break; } case qvResetReason_HW_Watchdog: { bootReason = BootReasonType::kHardwareWatchdogReset; break; } case qvResetReason_HW_Por: { bootReason = BootReasonType::kPowerOnReboot; break; } case qvResetReason_SW_Por: { bootReason = BootReasonType::kSoftwareReset; break; } default: bootReason = BootReasonType::kUnspecified; break; } err = StoreBootReason(to_underlying(bootReason)); SuccessOrExit(err); err = CHIP_NO_ERROR; exit: return err; } CHIP_ERROR ConfigurationManagerImpl::GetRebootCount(uint32_t & rebootCount) { return ReadConfigValue(QPGConfig::kCounterKey_RebootCount, rebootCount); } CHIP_ERROR ConfigurationManagerImpl::StoreRebootCount(uint32_t rebootCount) { return WriteConfigValue(QPGConfig::kCounterKey_RebootCount, rebootCount); } CHIP_ERROR ConfigurationManagerImpl::GetTotalOperationalHours(uint32_t & totalOperationalHours) { return QPGConfig::ReadConfigValue(QPGConfig::kCounterKey_TotalOperationalHours, totalOperationalHours); } CHIP_ERROR ConfigurationManagerImpl::StoreTotalOperationalHours(uint32_t totalOperationalHours) { return QPGConfig::WriteConfigValue(QPGConfig::kCounterKey_TotalOperationalHours, totalOperationalHours); } CHIP_ERROR ConfigurationManagerImpl::GetBootReason(uint32_t & bootReason) { return ReadConfigValue(QPGConfig::kCounterKey_BootReason, bootReason); } CHIP_ERROR ConfigurationManagerImpl::StoreBootReason(uint32_t bootReason) { return WriteConfigValue(QPGConfig::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; uintmax_t recordKey = persistedStorageKey + QPGConfig::kConfigKey_GroupKeyBase; VerifyOrExit(recordKey <= QPGConfig::kConfigKey_GroupKeyMax, err = CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); err = ReadConfigValue(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) { CHIP_ERROR err; uintmax_t recordKey = persistedStorageKey + QPGConfig::kConfigKey_GroupKeyBase; VerifyOrExit(recordKey <= QPGConfig::kConfigKey_GroupKeyMax, err = CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); err = WriteConfigValue(persistedStorageKey, value); SuccessOrExit(err); exit: return err; } CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, bool & val) { return QPGConfig::ReadConfigValue(key, val); } CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint32_t & val) { return QPGConfig::ReadConfigValue(key, val); } CHIP_ERROR ConfigurationManagerImpl::ReadConfigValue(Key key, uint64_t & val) { return QPGConfig::ReadConfigValue(key, val); } CHIP_ERROR ConfigurationManagerImpl::ReadConfigValueStr(Key key, char * buf, size_t bufSize, size_t & outLen) { return QPGConfig::ReadConfigValueStr(key, buf, bufSize, outLen); } CHIP_ERROR ConfigurationManagerImpl::ReadConfigValueBin(Key key, uint8_t * buf, size_t bufSize, size_t & outLen) { return QPGConfig::ReadConfigValueBin(key, buf, bufSize, outLen); } CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, bool val) { return QPGConfig::WriteConfigValue(key, val); } CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint32_t val) { return QPGConfig::WriteConfigValue(key, val); } CHIP_ERROR ConfigurationManagerImpl::WriteConfigValue(Key key, uint64_t val) { return QPGConfig::WriteConfigValue(key, val); } CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueStr(Key key, const char * str) { return QPGConfig::WriteConfigValueStr(key, str); } CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueStr(Key key, const char * str, size_t strLen) { return QPGConfig::WriteConfigValueStr(key, str, strLen); } CHIP_ERROR ConfigurationManagerImpl::WriteConfigValueBin(Key key, const uint8_t * data, size_t dataLen) { return QPGConfig::WriteConfigValueBin(key, data, dataLen); } void ConfigurationManagerImpl::RunConfigUnitTest(void) { QPGConfig::RunConfigUnitTest(); } void ConfigurationManagerImpl::DoFactoryReset(intptr_t arg) { CHIP_ERROR err; qvStatus_t qvErr; ChipLogProgress(DeviceLayer, "Performing factory reset"); err = QPGConfig::FactoryResetConfig(); if (err != CHIP_NO_ERROR) { ChipLogError(DeviceLayer, "FactoryResetConfig() failed: %s", ErrorStr(err)); } qvErr = qvCHIP_KvsErasePartition(); if (qvErr != QV_STATUS_NO_ERROR) { ChipLogError(DeviceLayer, "qvCHIP_KvsErasePartition() failed: %d", qvErr); } #if CHIP_DEVICE_CONFIG_ENABLE_THREAD ChipLogProgress(DeviceLayer, "Clearing Thread provision"); ThreadStackMgr().ErasePersistentInfo(); #endif // CHIP_DEVICE_CONFIG_ENABLE_THREAD // Restart the system. ChipLogProgress(DeviceLayer, "System restarting"); qvCHIP_ResetSystem(); } ConfigurationManager & ConfigurationMgrImpl() { return ConfigurationManagerImpl::GetDefaultInstance(); } } // namespace DeviceLayer } // namespace chip