src/adaptations/device-layer/EFR32/EFR32Config.cpp - third_party/openweave-core - Git at Google

 /*
  *
  *    Copyright (c) 2019 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
  *          Utilities for accessing persisted device configuration on
  *          platforms based on the Silicon Labs SDK.
  */

 #include <Weave/DeviceLayer/internal/WeaveDeviceLayerInternal.h>
 #include <Weave/DeviceLayer/EFR32/EFR32Config.h>
 #include <Weave/Core/WeaveEncoding.h>
 #include <Weave/DeviceLayer/internal/testing/ConfigUnitTest.h>

 #include "nvm3.h"
 #include "nvm3_hal_flash.h"
 #include "FreeRTOS.h"

 namespace nl {
 namespace Weave {
 namespace DeviceLayer {
 namespace Internal {

 // Two macros are provided to support the creation of the Silicon Labs NVM3 area and
 // initialization data- NVM3_DEFINE_SECTION_STATIC_DATA() and NVM3_DEFINE_SECTION_INIT_DATA().
 // A linker section called 'name'_section is defined by NVM3_DEFINE_SECTION_STATIC_DATA().
 // The NVM3 area is placed at the top of the device FLASH section by the linker
 // script file: openweave-efr32-bringup-MG12P.ld. An error is returned
 // by nvm3_open() on alignment or size violation.

 // Local version of SDK macro (avoids uninitialized var compile error).
 #define WEAVE_NVM3_DEFINE_SECTION_STATIC_DATA(name, nvmSize, cacheSize) \
     static nvm3_CacheEntry_t name##_cache[cacheSize];                   \
     static uint8_t           name##_nvm[nvmSize] SL_ATTRIBUTE_SECTION(STRINGIZE(name##_section))

 // Local version of SDK macro (allows Weave to configure the maximum nvm3 object size and headroom).
 #define WEAVE_NVM3_DEFINE_SECTION_INIT_DATA(name, maxObjectSize, repackHeadroom) \
     static nvm3_Init_t name = {                                                  \
         (nvm3_HalPtr_t)name##_nvm,                                               \
         sizeof(name##_nvm),                                                      \
         name##_cache,                                                            \
         sizeof(name##_cache) / sizeof(nvm3_CacheEntry_t),                        \
         maxObjectSize,                                                           \
         repackHeadroom,                                                          \
         &nvm3_halFlashHandle,                                                    \
     }

 #define WEAVE_NVM3_REPACK_HEADROOM 64 // Threshold for User non-forced nvm3 flash repacking.

 static nvm3_Handle_t handle;

 // Declare NVM3 data area and cache.

 WEAVE_NVM3_DEFINE_SECTION_STATIC_DATA(weaveNvm3,
                                       WEAVE_DEVICE_CONFIG_NVM3_NUM_FLASH_PAGES_FOR_STORAGE *FLASH_PAGE_SIZE,
                                       WEAVE_DEVICE_CONFIG_NVM3_MAX_NUM_OBJECTS);

 WEAVE_NVM3_DEFINE_SECTION_INIT_DATA(weaveNvm3, WEAVE_DEVICE_CONFIG_NVM3_MAX_OBJECT_SIZE, WEAVE_NVM3_REPACK_HEADROOM);

 WEAVE_ERROR EFR32Config::Init()
 {
     WEAVE_ERROR err;
     bool        needClose = false;

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }

     return err;
 }

 WEAVE_ERROR EFR32Config::ReadConfigValue(Key key, bool &val)
 {
     WEAVE_ERROR err;
     bool        needClose = false;
     uint32_t    objectType;
     size_t      dataLen;
     bool        tmpVal;

     VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     // Get nvm3 object info.
     err = MapNvm3Error(nvm3_getObjectInfo(&handle, key, &objectType, &dataLen));
     SuccessOrExit(err);

     // Read nvm3 bytes into tmp.
     err = MapNvm3Error(nvm3_readData(&handle, key, &tmpVal, dataLen));
     SuccessOrExit(err);
     val = tmpVal;

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return err;
 }

 WEAVE_ERROR EFR32Config::ReadConfigValue(Key key, uint32_t &val)
 {
     WEAVE_ERROR err;
     bool        needClose = false;
     uint32_t    objectType;
     size_t      dataLen;
     uint32_t    tmpVal;

     VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     // Get nvm3 object info.
     err = MapNvm3Error(nvm3_getObjectInfo(&handle, key, &objectType, &dataLen));
     SuccessOrExit(err);

     // Read nvm3 bytes into tmp.
     err = MapNvm3Error(nvm3_readData(&handle, key, &tmpVal, dataLen));
     SuccessOrExit(err);
     val = tmpVal;

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return err;
 }

 WEAVE_ERROR EFR32Config::ReadConfigValue(Key key, uint64_t &val)
 {
     WEAVE_ERROR err;
     bool        needClose = false;
     uint32_t    objectType;
     size_t      dataLen;
     uint64_t    tmpVal;

     VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     // Get nvm3 object info.
     err = MapNvm3Error(nvm3_getObjectInfo(&handle, key, &objectType, &dataLen));
     SuccessOrExit(err);

     // Read nvm3 bytes into tmp.
     err = MapNvm3Error(nvm3_readData(&handle, key, &tmpVal, dataLen));
     SuccessOrExit(err);
     val = tmpVal;

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return err;
 }

 WEAVE_ERROR EFR32Config::ReadConfigValueStr(Key key, char *buf, size_t bufSize, size_t &outLen)
 {
     WEAVE_ERROR err;
     bool        needClose = false;
     uint32_t    objectType;
     size_t      dataLen;

     outLen = 0;

     VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     // Get nvm3 object info.
     err = MapNvm3Error(nvm3_getObjectInfo(&handle, key, &objectType, &dataLen));
     SuccessOrExit(err);
     VerifyOrExit(dataLen > 0, err = WEAVE_ERROR_INVALID_STRING_LENGTH);

     if (buf != NULL)
     {
         // Read nvm3 bytes directly into the output buffer- check buffer is
         // long enough to take the string (nvm3 string does not include the
         // terminator char).
         VerifyOrExit((bufSize > dataLen), err = WEAVE_ERROR_BUFFER_TOO_SMALL);

         err = MapNvm3Error(nvm3_readData(&handle, key, buf, dataLen));
         SuccessOrExit(err);

         outLen      = ((dataLen == 1) && (buf[0] == 0)) ? 0 : dataLen;
         buf[outLen] = 0; // Add the terminator char.
     }
     else
     {
         if (dataLen > 1)
         {
             outLen = dataLen;
         }
         else
         {
             // Read the first byte of the nvm3 string into a tmp var.
             char firstByte;
             err = MapNvm3Error(nvm3_readData(&handle, key, &firstByte, 1));
             SuccessOrExit(err);

             outLen = (firstByte == 0) ? 0 : dataLen;
         }
     }

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return err;
 }

 WEAVE_ERROR EFR32Config::ReadConfigValueBin(Key key, uint8_t *buf, size_t bufSize, size_t &outLen)
 {
     WEAVE_ERROR err;
     bool        needClose = false;
     uint32_t    objectType;
     size_t      dataLen;

     outLen = 0;

     VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     // Get nvm3 object info.
     err = MapNvm3Error(nvm3_getObjectInfo(&handle, key, &objectType, &dataLen));
     SuccessOrExit(err);
     VerifyOrExit(dataLen > 0, err = WEAVE_ERROR_INVALID_STRING_LENGTH);

     if (buf != NULL)
     {
         // Read nvm3 bytes directly into output buffer- check buffer is long
         // enough to take the data.
         VerifyOrExit((bufSize >= dataLen), err = WEAVE_ERROR_BUFFER_TOO_SMALL);

         err = MapNvm3Error(nvm3_readData(&handle, key, buf, dataLen));
         SuccessOrExit(err);
     }

     outLen = dataLen;

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return err;
 }

 WEAVE_ERROR EFR32Config::ReadConfigValueCounter(uint8_t counterIdx, uint32_t &val)
 {
     WEAVE_ERROR err;
     bool        needClose = false;
     uint32_t    tmpVal;

     Key key = kMinConfigKey_WeaveCounter + counterIdx;
     VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     // Read bytes into tmp.
     err = MapNvm3Error(nvm3_readCounter(&handle, key, &tmpVal));
     SuccessOrExit(err);
     val = tmpVal;

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return err;
 }

 WEAVE_ERROR EFR32Config::WriteConfigValue(Key key, bool val)
 {
     WEAVE_ERROR err;
     bool        needClose = false;

     VerifyOrExit(ValidConfigKey(key), err = WEAVE_ERROR_INVALID_ARGUMENT); // Verify key id.

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     err = MapNvm3Error(nvm3_writeData(&handle, key, &val, sizeof(val)));
     SuccessOrExit(err);

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return err;
 }

 WEAVE_ERROR EFR32Config::WriteConfigValue(Key key, uint32_t val)
 {
     WEAVE_ERROR err;
     bool        needClose = false;

     VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     err = MapNvm3Error(nvm3_writeData(&handle, key, &val, sizeof(val)));
     SuccessOrExit(err);

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return err;
 }

 WEAVE_ERROR EFR32Config::WriteConfigValue(Key key, uint64_t val)
 {
     WEAVE_ERROR err;
     bool        needClose = false;

     VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     err = MapNvm3Error(nvm3_writeData(&handle, key, &val, sizeof(val)));
     SuccessOrExit(err);

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return err;
 }

 WEAVE_ERROR EFR32Config::WriteConfigValueStr(Key key, const char *str)
 {
     return WriteConfigValueStr(key, str, (str != NULL) ? strlen(str) : 0);
 }

 WEAVE_ERROR EFR32Config::WriteConfigValueStr(Key key, const char *str, size_t strLen)
 {
     WEAVE_ERROR err;
     bool        needClose = false;

     VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     if (str != NULL)
     {
         // Write the string to nvm3 without the terminator char (apart from
         // empty strings where only the terminator char is stored in nvm3).
         err = MapNvm3Error(nvm3_writeData(&handle, key, str, (strLen > 0) ? strLen : 1));
         SuccessOrExit(err);
     }
     else
     {
         nvm3_deleteObject(&handle, key); // no error checking here.
     }

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }

     return err;
 }

 WEAVE_ERROR EFR32Config::WriteConfigValueBin(Key key, const uint8_t *data, size_t dataLen)
 {
     WEAVE_ERROR err;
     bool        needClose = false;

     VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     if (data != NULL)
     {
         if (dataLen > 0)
         {
             // Write the binary data to nvm3.
             err = MapNvm3Error(nvm3_writeData(&handle, key, data, dataLen));
             SuccessOrExit(err);
         }
     }
     else
     {
         nvm3_deleteObject(&handle, key); // no error checking here.
     }

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return err;
 }

 WEAVE_ERROR EFR32Config::WriteConfigValueCounter(uint8_t counterIdx, uint32_t val)
 {
     WEAVE_ERROR err;
     bool        needClose = false;

     Key key = kMinConfigKey_WeaveCounter + counterIdx;
     VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     err = MapNvm3Error(nvm3_writeCounter(&handle, key, val));
     SuccessOrExit(err);

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return err;
 }

 WEAVE_ERROR EFR32Config::ClearConfigValue(Key key)
 {
     WEAVE_ERROR err;
     bool        needClose = false;

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     // Delete the nvm3 object with the given key id.
     err = MapNvm3Error(nvm3_deleteObject(&handle, key));
     SuccessOrExit(err);

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return err;
 }

 bool EFR32Config::ConfigValueExists(Key key)
 {
     WEAVE_ERROR err;
     bool        needClose = false;
     uint32_t    objectType;
     size_t      dataLen;

     err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
     SuccessOrExit(err);
     needClose = true;

     // Find object with key id.
     err = MapNvm3Error(nvm3_getObjectInfo(&handle, key, &objectType, &dataLen));

 exit:
     if (needClose)
     {
         nvm3_close(&handle);
     }
     return (err == WEAVE_NO_ERROR);
 }

 WEAVE_ERROR EFR32Config::FactoryResetConfig(void)
 {
     // Deletes all nvm3 'Config' type objects.
     // Note- 'Factory' and 'Counter' type nvm3 objects are NOT deleted.

     WEAVE_ERROR err;

     // Iterate over all the Weave Config nvm3 records and delete each one...
     err = ForEachRecord(kMinConfigKey_WeaveConfig, kMaxConfigKey_WeaveConfig, false,
                         [](const Key &nvm3Key, const size_t &length) -> WEAVE_ERROR {
                             WEAVE_ERROR err2;

                             err2 = ClearConfigValue(nvm3Key);
                             SuccessOrExit(err2);

                         exit:
                             return err2;
                         });

     // Return success at end of iterations.
     if (err == WEAVE_END_OF_INPUT)
     {
         err = WEAVE_NO_ERROR;
     }

     return err;
 }

 WEAVE_ERROR EFR32Config::MapNvm3Error(Ecode_t nvm3Res)
 {
     WEAVE_ERROR err;

     switch (nvm3Res)
     {
     case ECODE_NVM3_OK:
         err = WEAVE_NO_ERROR;
         break;
     case ECODE_NVM3_ERR_KEY_NOT_FOUND:
         err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND;
         break;
     default:
         err = (nvm3Res & 0xFF) + WEAVE_DEVICE_CONFIG_EFR32_NVM3_ERROR_MIN;
         break;
     }

     return err;
 }

 WEAVE_ERROR EFR32Config::ForEachRecord(Key firstNvm3Key, Key lastNvm3Key, bool addNewRecord, ForEachRecordFunct funct)
 {
     // Iterates through the specified range of nvm3 object key ids.
     // Invokes the callers CB function when appropriate.

     WEAVE_ERROR err = WEAVE_NO_ERROR;

     for (Key nvm3Key = firstNvm3Key; nvm3Key <= lastNvm3Key; ++nvm3Key)
     {
         Ecode_t  nvm3Res;
         uint32_t objectType;
         size_t   dataLen;

         // Open nvm3 handle for reading on each iteration.
         err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
         SuccessOrExit(err);

         // Find nvm3 object with current nvm3 iteration key.
         nvm3Res = nvm3_getObjectInfo(&handle, nvm3Key, &objectType, &dataLen);
         switch (nvm3Res)
         {
         case ECODE_NVM3_OK:
             if (!addNewRecord)
             {
                 // Invoke the caller's function
                 // (for retrieve,store,delete,enumerate GroupKey operations).
                 err = funct(nvm3Key, dataLen);
             }
             break;
         case ECODE_NVM3_ERR_KEY_NOT_FOUND:
             if (addNewRecord)
             {
                 // Invoke caller's function
                 // (for add GroupKey operation).
                 err = funct(nvm3Key, dataLen);
             }
             break;
         default:
             err = MapNvm3Error(nvm3Res);
             break;
         }

         SuccessOrExit(err);
     }

 exit:
     // Always close handle.
     nvm3_close(&handle);

     return err;
 }

 bool EFR32Config::ValidConfigKey(Key key)
 {
     // Returns true if the key is in the valid Weave Config nvm3 key range.

     if ((key >= kMinConfigKey_WeaveFactory) && (key <= kMaxConfigKey_WeaveCounter))
     {
         return true;
     }

     return false;
 }

 void EFR32Config::RunConfigUnitTest()
 {
     // Run common unit test.
     ::nl::Weave::DeviceLayer::Internal::RunConfigUnitTest<EFR32Config>();
 }

 void EFR32Config::RepackNvm3Flash(void)
 {
     // Repack nvm3 flash if nvm3 space < headroom threshold.
     // Note- checking periodically during idle periods should prevent
     // forced repack events on any write operation.
     nvm3_repack(&handle);
 }

 } // namespace Internal
 } // namespace DeviceLayer
 } // namespace Weave
 } // namespace nl
	/*
	*
	* Copyright (c) 2019 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
	* Utilities for accessing persisted device configuration on
	* platforms based on the Silicon Labs SDK.
	*/

	#include <Weave/DeviceLayer/internal/WeaveDeviceLayerInternal.h>
	#include <Weave/DeviceLayer/EFR32/EFR32Config.h>
	#include <Weave/Core/WeaveEncoding.h>
	#include <Weave/DeviceLayer/internal/testing/ConfigUnitTest.h>

	#include "nvm3.h"
	#include "nvm3_hal_flash.h"
	#include "FreeRTOS.h"

	namespace nl {
	namespace Weave {
	namespace DeviceLayer {
	namespace Internal {

	// Two macros are provided to support the creation of the Silicon Labs NVM3 area and
	// initialization data- NVM3_DEFINE_SECTION_STATIC_DATA() and NVM3_DEFINE_SECTION_INIT_DATA().
	// A linker section called 'name'_section is defined by NVM3_DEFINE_SECTION_STATIC_DATA().
	// The NVM3 area is placed at the top of the device FLASH section by the linker
	// script file: openweave-efr32-bringup-MG12P.ld. An error is returned
	// by nvm3_open() on alignment or size violation.

	// Local version of SDK macro (avoids uninitialized var compile error).
	#define WEAVE_NVM3_DEFINE_SECTION_STATIC_DATA(name, nvmSize, cacheSize) \
	static nvm3_CacheEntry_t name##_cache[cacheSize]; \
	static uint8_t name##_nvm[nvmSize] SL_ATTRIBUTE_SECTION(STRINGIZE(name##_section))

	// Local version of SDK macro (allows Weave to configure the maximum nvm3 object size and headroom).
	#define WEAVE_NVM3_DEFINE_SECTION_INIT_DATA(name, maxObjectSize, repackHeadroom) \
	static nvm3_Init_t name = { \
	(nvm3_HalPtr_t)name##_nvm, \
	sizeof(name##_nvm), \
	name##_cache, \
	sizeof(name##_cache) / sizeof(nvm3_CacheEntry_t), \
	maxObjectSize, \
	repackHeadroom, \
	&nvm3_halFlashHandle, \
	}

	#define WEAVE_NVM3_REPACK_HEADROOM 64 // Threshold for User non-forced nvm3 flash repacking.

	static nvm3_Handle_t handle;

	// Declare NVM3 data area and cache.

	WEAVE_NVM3_DEFINE_SECTION_STATIC_DATA(weaveNvm3,
	WEAVE_DEVICE_CONFIG_NVM3_NUM_FLASH_PAGES_FOR_STORAGE *FLASH_PAGE_SIZE,
	WEAVE_DEVICE_CONFIG_NVM3_MAX_NUM_OBJECTS);

	WEAVE_NVM3_DEFINE_SECTION_INIT_DATA(weaveNvm3, WEAVE_DEVICE_CONFIG_NVM3_MAX_OBJECT_SIZE, WEAVE_NVM3_REPACK_HEADROOM);

	WEAVE_ERROR EFR32Config::Init()
	{
	WEAVE_ERROR err;
	bool needClose = false;

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}

	return err;
	}

	WEAVE_ERROR EFR32Config::ReadConfigValue(Key key, bool &val)
	{
	WEAVE_ERROR err;
	bool needClose = false;
	uint32_t objectType;
	size_t dataLen;
	bool tmpVal;

	VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	// Get nvm3 object info.
	err = MapNvm3Error(nvm3_getObjectInfo(&handle, key, &objectType, &dataLen));
	SuccessOrExit(err);

	// Read nvm3 bytes into tmp.
	err = MapNvm3Error(nvm3_readData(&handle, key, &tmpVal, dataLen));
	SuccessOrExit(err);
	val = tmpVal;

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return err;
	}

	WEAVE_ERROR EFR32Config::ReadConfigValue(Key key, uint32_t &val)
	{
	WEAVE_ERROR err;
	bool needClose = false;
	uint32_t objectType;
	size_t dataLen;
	uint32_t tmpVal;

	VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	// Get nvm3 object info.
	err = MapNvm3Error(nvm3_getObjectInfo(&handle, key, &objectType, &dataLen));
	SuccessOrExit(err);

	// Read nvm3 bytes into tmp.
	err = MapNvm3Error(nvm3_readData(&handle, key, &tmpVal, dataLen));
	SuccessOrExit(err);
	val = tmpVal;

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return err;
	}

	WEAVE_ERROR EFR32Config::ReadConfigValue(Key key, uint64_t &val)
	{
	WEAVE_ERROR err;
	bool needClose = false;
	uint32_t objectType;
	size_t dataLen;
	uint64_t tmpVal;

	VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	// Get nvm3 object info.
	err = MapNvm3Error(nvm3_getObjectInfo(&handle, key, &objectType, &dataLen));
	SuccessOrExit(err);

	// Read nvm3 bytes into tmp.
	err = MapNvm3Error(nvm3_readData(&handle, key, &tmpVal, dataLen));
	SuccessOrExit(err);
	val = tmpVal;

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return err;
	}

	WEAVE_ERROR EFR32Config::ReadConfigValueStr(Key key, char *buf, size_t bufSize, size_t &outLen)
	{
	WEAVE_ERROR err;
	bool needClose = false;
	uint32_t objectType;
	size_t dataLen;

	outLen = 0;

	VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	// Get nvm3 object info.
	err = MapNvm3Error(nvm3_getObjectInfo(&handle, key, &objectType, &dataLen));
	SuccessOrExit(err);
	VerifyOrExit(dataLen > 0, err = WEAVE_ERROR_INVALID_STRING_LENGTH);

	if (buf != NULL)
	{
	// Read nvm3 bytes directly into the output buffer- check buffer is
	// long enough to take the string (nvm3 string does not include the
	// terminator char).
	VerifyOrExit((bufSize > dataLen), err = WEAVE_ERROR_BUFFER_TOO_SMALL);

	err = MapNvm3Error(nvm3_readData(&handle, key, buf, dataLen));
	SuccessOrExit(err);

	outLen = ((dataLen == 1) && (buf[0] == 0)) ? 0 : dataLen;
	buf[outLen] = 0; // Add the terminator char.
	}
	else
	{
	if (dataLen > 1)
	{
	outLen = dataLen;
	}
	else
	{
	// Read the first byte of the nvm3 string into a tmp var.
	char firstByte;
	err = MapNvm3Error(nvm3_readData(&handle, key, &firstByte, 1));
	SuccessOrExit(err);

	outLen = (firstByte == 0) ? 0 : dataLen;
	}
	}

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return err;
	}

	WEAVE_ERROR EFR32Config::ReadConfigValueBin(Key key, uint8_t *buf, size_t bufSize, size_t &outLen)
	{
	WEAVE_ERROR err;
	bool needClose = false;
	uint32_t objectType;
	size_t dataLen;

	outLen = 0;

	VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	// Get nvm3 object info.
	err = MapNvm3Error(nvm3_getObjectInfo(&handle, key, &objectType, &dataLen));
	SuccessOrExit(err);
	VerifyOrExit(dataLen > 0, err = WEAVE_ERROR_INVALID_STRING_LENGTH);

	if (buf != NULL)
	{
	// Read nvm3 bytes directly into output buffer- check buffer is long
	// enough to take the data.
	VerifyOrExit((bufSize >= dataLen), err = WEAVE_ERROR_BUFFER_TOO_SMALL);

	err = MapNvm3Error(nvm3_readData(&handle, key, buf, dataLen));
	SuccessOrExit(err);
	}

	outLen = dataLen;

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return err;
	}

	WEAVE_ERROR EFR32Config::ReadConfigValueCounter(uint8_t counterIdx, uint32_t &val)
	{
	WEAVE_ERROR err;
	bool needClose = false;
	uint32_t tmpVal;

	Key key = kMinConfigKey_WeaveCounter + counterIdx;
	VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	// Read bytes into tmp.
	err = MapNvm3Error(nvm3_readCounter(&handle, key, &tmpVal));
	SuccessOrExit(err);
	val = tmpVal;

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return err;
	}

	WEAVE_ERROR EFR32Config::WriteConfigValue(Key key, bool val)
	{
	WEAVE_ERROR err;
	bool needClose = false;

	VerifyOrExit(ValidConfigKey(key), err = WEAVE_ERROR_INVALID_ARGUMENT); // Verify key id.

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	err = MapNvm3Error(nvm3_writeData(&handle, key, &val, sizeof(val)));
	SuccessOrExit(err);

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return err;
	}

	WEAVE_ERROR EFR32Config::WriteConfigValue(Key key, uint32_t val)
	{
	WEAVE_ERROR err;
	bool needClose = false;

	VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	err = MapNvm3Error(nvm3_writeData(&handle, key, &val, sizeof(val)));
	SuccessOrExit(err);

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return err;
	}

	WEAVE_ERROR EFR32Config::WriteConfigValue(Key key, uint64_t val)
	{
	WEAVE_ERROR err;
	bool needClose = false;

	VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	err = MapNvm3Error(nvm3_writeData(&handle, key, &val, sizeof(val)));
	SuccessOrExit(err);

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return err;
	}

	WEAVE_ERROR EFR32Config::WriteConfigValueStr(Key key, const char *str)
	{
	return WriteConfigValueStr(key, str, (str != NULL) ? strlen(str) : 0);
	}

	WEAVE_ERROR EFR32Config::WriteConfigValueStr(Key key, const char *str, size_t strLen)
	{
	WEAVE_ERROR err;
	bool needClose = false;

	VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	if (str != NULL)
	{
	// Write the string to nvm3 without the terminator char (apart from
	// empty strings where only the terminator char is stored in nvm3).
	err = MapNvm3Error(nvm3_writeData(&handle, key, str, (strLen > 0) ? strLen : 1));
	SuccessOrExit(err);
	}
	else
	{
	nvm3_deleteObject(&handle, key); // no error checking here.
	}

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}

	return err;
	}

	WEAVE_ERROR EFR32Config::WriteConfigValueBin(Key key, const uint8_t *data, size_t dataLen)
	{
	WEAVE_ERROR err;
	bool needClose = false;

	VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	if (data != NULL)
	{
	if (dataLen > 0)
	{
	// Write the binary data to nvm3.
	err = MapNvm3Error(nvm3_writeData(&handle, key, data, dataLen));
	SuccessOrExit(err);
	}
	}
	else
	{
	nvm3_deleteObject(&handle, key); // no error checking here.
	}

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return err;
	}

	WEAVE_ERROR EFR32Config::WriteConfigValueCounter(uint8_t counterIdx, uint32_t val)
	{
	WEAVE_ERROR err;
	bool needClose = false;

	Key key = kMinConfigKey_WeaveCounter + counterIdx;
	VerifyOrExit(ValidConfigKey(key), err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND); // Verify key id.

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	err = MapNvm3Error(nvm3_writeCounter(&handle, key, val));
	SuccessOrExit(err);

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return err;
	}

	WEAVE_ERROR EFR32Config::ClearConfigValue(Key key)
	{
	WEAVE_ERROR err;
	bool needClose = false;

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	// Delete the nvm3 object with the given key id.
	err = MapNvm3Error(nvm3_deleteObject(&handle, key));
	SuccessOrExit(err);

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return err;
	}

	bool EFR32Config::ConfigValueExists(Key key)
	{
	WEAVE_ERROR err;
	bool needClose = false;
	uint32_t objectType;
	size_t dataLen;

	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);
	needClose = true;

	// Find object with key id.
	err = MapNvm3Error(nvm3_getObjectInfo(&handle, key, &objectType, &dataLen));

	exit:
	if (needClose)
	{
	nvm3_close(&handle);
	}
	return (err == WEAVE_NO_ERROR);
	}

	WEAVE_ERROR EFR32Config::FactoryResetConfig(void)
	{
	// Deletes all nvm3 'Config' type objects.
	// Note- 'Factory' and 'Counter' type nvm3 objects are NOT deleted.

	WEAVE_ERROR err;

	// Iterate over all the Weave Config nvm3 records and delete each one...
	err = ForEachRecord(kMinConfigKey_WeaveConfig, kMaxConfigKey_WeaveConfig, false,
	[](const Key &nvm3Key, const size_t &length) -> WEAVE_ERROR {
	WEAVE_ERROR err2;

	err2 = ClearConfigValue(nvm3Key);
	SuccessOrExit(err2);

	exit:
	return err2;
	});

	// Return success at end of iterations.
	if (err == WEAVE_END_OF_INPUT)
	{
	err = WEAVE_NO_ERROR;
	}

	return err;
	}

	WEAVE_ERROR EFR32Config::MapNvm3Error(Ecode_t nvm3Res)
	{
	WEAVE_ERROR err;

	switch (nvm3Res)
	{
	case ECODE_NVM3_OK:
	err = WEAVE_NO_ERROR;
	break;
	case ECODE_NVM3_ERR_KEY_NOT_FOUND:
	err = WEAVE_DEVICE_ERROR_CONFIG_NOT_FOUND;
	break;
	default:
	err = (nvm3Res & 0xFF) + WEAVE_DEVICE_CONFIG_EFR32_NVM3_ERROR_MIN;
	break;
	}

	return err;
	}

	WEAVE_ERROR EFR32Config::ForEachRecord(Key firstNvm3Key, Key lastNvm3Key, bool addNewRecord, ForEachRecordFunct funct)
	{
	// Iterates through the specified range of nvm3 object key ids.
	// Invokes the callers CB function when appropriate.

	WEAVE_ERROR err = WEAVE_NO_ERROR;

	for (Key nvm3Key = firstNvm3Key; nvm3Key <= lastNvm3Key; ++nvm3Key)
	{
	Ecode_t nvm3Res;
	uint32_t objectType;
	size_t dataLen;

	// Open nvm3 handle for reading on each iteration.
	err = MapNvm3Error(nvm3_open(&handle, &weaveNvm3));
	SuccessOrExit(err);

	// Find nvm3 object with current nvm3 iteration key.
	nvm3Res = nvm3_getObjectInfo(&handle, nvm3Key, &objectType, &dataLen);
	switch (nvm3Res)
	{
	case ECODE_NVM3_OK:
	if (!addNewRecord)
	{
	// Invoke the caller's function
	// (for retrieve,store,delete,enumerate GroupKey operations).
	err = funct(nvm3Key, dataLen);
	}
	break;
	case ECODE_NVM3_ERR_KEY_NOT_FOUND:
	if (addNewRecord)
	{
	// Invoke caller's function
	// (for add GroupKey operation).
	err = funct(nvm3Key, dataLen);
	}
	break;
	default:
	err = MapNvm3Error(nvm3Res);
	break;
	}

	SuccessOrExit(err);
	}

	exit:
	// Always close handle.
	nvm3_close(&handle);

	return err;
	}

	bool EFR32Config::ValidConfigKey(Key key)
	{
	// Returns true if the key is in the valid Weave Config nvm3 key range.

	if ((key >= kMinConfigKey_WeaveFactory) && (key <= kMaxConfigKey_WeaveCounter))
	{
	return true;
	}

	return false;
	}

	void EFR32Config::RunConfigUnitTest()
	{
	// Run common unit test.
	::nl::Weave::DeviceLayer::Internal::RunConfigUnitTest<EFR32Config>();
	}

	void EFR32Config::RepackNvm3Flash(void)
	{
	// Repack nvm3 flash if nvm3 space < headroom threshold.
	// Note- checking periodically during idle periods should prevent
	// forced repack events on any write operation.
	nvm3_repack(&handle);
	}

	} // namespace Internal
	} // namespace DeviceLayer
	} // namespace Weave
	} // namespace nl