defined vendor_name, product_name, hardware_version_string and softwa…

…re_version_string config variables in all platforms

examples/platform/linux/CommissionableInit.cpp

@@ -20,7 +20,6 @@
 #include <lib/support/CodeUtils.h>
 #include <lib/support/logging/CHIPLogging.h>
 #include <platform/TestOnlyCommissionableDataProvider.h>
-#include <stdio.h>
 
 #include "CommissionableInit.h"
 
@@ -102,30 +101,30 @@ CHIP_ERROR InitConfigurationManager(ConfigurationManagerImpl & configManager, Li
 
  if (options.vendorName.HasValue())
  {
- chip::Span<const char> vendor_name(options.vendorName.Value().c_str(), options.vendorName.Value().size());
+ CharSpan vendor_name(options.vendorName.Value().c_str(), options.vendorName.Value().size());
  VerifyOrDie(configManager.StoreVendorName(vendor_name) == CHIP_NO_ERROR);
  }
  if (options.productName.HasValue())
  {
- chip::Span<const char> product_name(options.productName.Value().c_str(), options.productName.Value().size());
+ CharSpan product_name(options.productName.Value().c_str(), options.productName.Value().size());
  VerifyOrDie(configManager.StoreProductName(product_name) == CHIP_NO_ERROR);
  }
  if (options.hardwareVersionString.HasValue())
  {
- chip::Span<const char> hardware_version_string(options.hardwareVersionString.Value().c_str(),
-  options.hardwareVersionString.Value().size());
+ CharSpan hardware_version_string(options.hardwareVersionString.Value().c_str(),
+ options.hardwareVersionString.Value().size());
  VerifyOrDie(configManager.StoreHardwareVersionString(hardware_version_string) == CHIP_NO_ERROR);
  }
  if (options.softwareVersionString.HasValue())
  {
- chip::Span<const char> software_version_string(options.softwareVersionString.Value().c_str(),
-  options.softwareVersionString.Value().size());
+ CharSpan software_version_string(options.softwareVersionString.Value().c_str(),
+ options.softwareVersionString.Value().size());
  VerifyOrDie(configManager.StoreSoftwareVersionString(software_version_string) == CHIP_NO_ERROR);
  }
 
  if (options.serialNumber.HasValue())
  {
- chip::Span<const char> serial_number(options.serialNumber.Value().c_str(), options.serialNumber.Value().size());
+ CharSpan serial_number(options.serialNumber.Value().c_str(), options.serialNumber.Value().size());
  VerifyOrDie(configManager.StoreSerialNumber(serial_number) == CHIP_NO_ERROR);
  }
 

examples/platform/linux/Options.cpp

@@ -222,10 +222,10 @@ const char * sDeviceOptionHelp =
  " The product name specified by vendor.\n"
  "\n"
  " --hardware-version-string <string>\n"
- " The hardware version string specified by vendor.\n"
+ " The HardwareVersionString to use in the basic information cluster.\n"
  "\n"
  " --software-version-string <string>\n"
- " The software version string specified by vendor.\n"
+ " The SoftwareVersionString to use in the basic information cluster.\n"
  "\n"
  " --serial-number <serial_number>\n"
  " The serial number specified by vendor.\n"

examples/platform/linux/Options.h

@@ -80,9 +80,8 @@ struct LinuxDeviceOptions
  chip::Optional<std::string> productName;
  chip::Optional<std::string> hardwareVersionString;
  chip::Optional<std::string> softwareVersionString;
-#if defined(CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER)
  chip::Optional<std::string> serialNumber;
-#endif
+
  static LinuxDeviceOptions & GetInstance();
 };
 

src/include/platform/ConfigurationManager.h

@@ -132,11 +132,11 @@ class ConfigurationManager
  virtual CHIP_ERROR SetFailSafeArmed(bool val) = 0;
 
  virtual CHIP_ERROR GetBLEDeviceIdentificationInfo(Ble::ChipBLEDeviceIdentificationInfo & deviceIdInfo) = 0;
- virtual CHIP_ERROR StoreSerialNumber(chip::Span<const char> serialNumber) = 0;
- virtual CHIP_ERROR StoreVendorName(chip::Span<const char> vendorName) = 0;
- virtual CHIP_ERROR StoreProductName(chip::Span<const char> productName) = 0;
- virtual CHIP_ERROR StoreHardwareVersionString(chip::Span<const char> hardwareVersionString) = 0;
- virtual CHIP_ERROR StoreSoftwareVersionString(chip::Span<const char> softwareVersionString) = 0;
+ virtual CHIP_ERROR StoreSerialNumber(CharSpan serialNumber)  = 0;
+ virtual CHIP_ERROR StoreVendorName(CharSpan vendorName)  = 0;
+ virtual CHIP_ERROR StoreProductName(CharSpan productName)  = 0;
+ virtual CHIP_ERROR StoreHardwareVersionString(CharSpan hardwareVersionString)  = 0;
+ virtual CHIP_ERROR StoreSoftwareVersionString(CharSpan softwareVersionString)  = 0;
 
 #if CHIP_CONFIG_TEST
  virtual void RunUnitTests() = 0;

src/include/platform/internal/GenericConfigurationManagerImpl.h

@@ -68,7 +68,7 @@ class GenericConfigurationManagerImpl : public ConfigurationManager
  CHIP_ERROR StoreSoftwareVersion(uint32_t softwareVer) override;
  CHIP_ERROR GetFirmwareBuildChipEpochTime(System::Clock::Seconds32 & buildTime) override;
  CHIP_ERROR SetFirmwareBuildChipEpochTime(System::Clock::Seconds32 buildTime) override;
- CHIP_ERROR StoreSerialNumber(chip::Span<const char> serialNumber) override;
+ CHIP_ERROR StoreSerialNumber(CharSpan serialNumber) override;
  CHIP_ERROR GetPrimaryMACAddress(MutableByteSpan buf) override;
  CHIP_ERROR GetPrimaryWiFiMACAddress(uint8_t * buf) override;
  CHIP_ERROR GetPrimary802154MACAddress(uint8_t * buf) override;
@@ -104,10 +104,10 @@ class GenericConfigurationManagerImpl : public ConfigurationManager
  CHIP_ERROR StoreUniqueId(const char * uniqueId, size_t uniqueIdLen) override;
  CHIP_ERROR GenerateUniqueId(char * buf, size_t bufSize) override;
 
- CHIP_ERROR StoreVendorName(chip::Span<const char> vendorName) override;
- CHIP_ERROR StoreProductName(chip::Span<const char> productName) override;
- CHIP_ERROR StoreHardwareVersionString(chip::Span<const char> hardwareVersionString) override;
- CHIP_ERROR StoreSoftwareVersionString(chip::Span<const char> softwareVersionString) override;
+ CHIP_ERROR StoreVendorName(CharSpan vendorName) override;
+ CHIP_ERROR StoreProductName(CharSpan productName) override;
+ CHIP_ERROR StoreHardwareVersionString(CharSpan hardwareVersionString) override;
+ CHIP_ERROR StoreSoftwareVersionString(CharSpan softwareVersionString) override;
 #if CHIP_CONFIG_TEST
  void RunUnitTests() override;
 #endif

src/include/platform/internal/GenericConfigurationManagerImpl.ipp

@@ -351,51 +351,47 @@ CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetSecondaryPairingHint
 template <class ConfigClass>
 CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetSoftwareVersionString(char * buf, size_t bufSize)
 {
- ChipError err  = CHIP_NO_ERROR;
+ CHIP_ERROR err = CHIP_NO_ERROR;
  size_t softwareVersionStringLen = 0; // without counting null-terminator
 
  err = ReadConfigValueStr(ConfigClass::kConfigKey_SoftwareVersionString, buf, bufSize, softwareVersionStringLen);
 
- if (CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING[0] != 0 && err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
+ if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
  {
  ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
  memcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING, sizeof(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING));
- softwareVersionStringLen = sizeof(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING) - 1;
- err = CHIP_NO_ERROR;
+
+ return CHIP_NO_ERROR;
  }
 
  VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
-
- ReturnErrorCodeIf(softwareVersionStringLen >= bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
- ReturnErrorCodeIf(buf[softwareVersionStringLen] != 0, CHIP_ERROR_INVALID_STRING_LENGTH);
-
  return err;
 }
 
 template <class ConfigClass>
-CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSerialNumber(chip::Span<const char> serialNumber)
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSerialNumber(CharSpan serialNumber)
 {
  return WriteConfigValueStr(ConfigClass::kConfigKey_SerialNum, serialNumber.data(), serialNumber.size());
 }
 template <class ConfigClass>
-CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreVendorName(chip::Span<const char> vendorName)
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreVendorName(CharSpan vendorName)
 {
 
  return WriteConfigValueStr(ConfigClass::kConfigKey_VendorName, vendorName.data(), vendorName.size());
 }
 template <class ConfigClass>
-CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreProductName(chip::Span<const char> productName)
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreProductName(CharSpan productName)
 {
  return WriteConfigValueStr(ConfigClass::kConfigKey_ProductName, productName.data(), productName.size());
 }
 template <class ConfigClass>
-CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreHardwareVersionString(chip::Span<const char> hardwareVersionString)
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreHardwareVersionString(CharSpan hardwareVersionString)
 {
  return WriteConfigValueStr(ConfigClass::kConfigKey_HardwareVersionString, hardwareVersionString.data(),
  hardwareVersionString.size());
 }
 template <class ConfigClass>
-CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSoftwareVersionString(chip::Span<const char> softwareVersionString)
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSoftwareVersionString(CharSpan softwareVersionString)
 {
  return WriteConfigValueStr(ConfigClass::kConfigKey_SoftwareVersionString, softwareVersionString.data(),
  softwareVersionString.size());

src/include/platform/internal/GenericDeviceInstanceInfoProvider.ipp

@@ -42,19 +42,15 @@ CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetVendorName(char *
  size_t vendorNameLen = 0; // without counting null-terminator
 
  err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_VendorName, buf, bufSize, vendorNameLen);
-#ifdef CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME
- if (CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME[0] != 0 && err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
+
+ if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
  {
  ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
  memcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME, sizeof(CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME));
- vendorNameLen = sizeof(CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME) - 1;
- err = CHIP_NO_ERROR;
+ err = CHIP_NO_ERROR;
  }
-#endif
- ReturnErrorOnFailure(err);
 
- ReturnErrorCodeIf(vendorNameLen >= bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
- ReturnErrorCodeIf(buf[vendorNameLen] != 0, CHIP_ERROR_INVALID_STRING_LENGTH);
+ VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
 
  return err;
 }
@@ -67,19 +63,14 @@ CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetProductName(char *
 
  err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_ProductName, buf, bufSize, productNameLen);
 
-#ifdef CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME
- if (CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME[0] != 0 && err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
+ if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
  {
  ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
  memcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME, sizeof(CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME));
- productNameLen = sizeof(CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME) - 1;
- err = CHIP_NO_ERROR;
+ err = CHIP_NO_ERROR;
  }
-#endif
- ReturnErrorOnFailure(err);
 
- ReturnErrorCodeIf(productNameLen >= bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
- ReturnErrorCodeIf(buf[productNameLen] != 0, CHIP_ERROR_INVALID_STRING_LENGTH);
+ VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
 
  return err;
 }
@@ -128,19 +119,15 @@ CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetSerialNumber(char
 
  err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_SerialNum, buf, bufSize, serialNumLen);
 
-#ifdef CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER
- if (CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER[0] != 0 && err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
+ if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
  {
  ReturnErrorCodeIf(sizeof(CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER) > bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
  memcpy(buf, CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER, sizeof(CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER));
- serialNumLen = sizeof(CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER) - 1;
- err  = CHIP_NO_ERROR;
+
+ err = CHIP_NO_ERROR;
  }
-#endif // CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER
- ReturnErrorOnFailure(err);
 
- ReturnErrorCodeIf(serialNumLen >= bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
- ReturnErrorCodeIf(buf[serialNumLen] != 0, CHIP_ERROR_INVALID_STRING_LENGTH);
+ VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
 
  return err;
 }
@@ -214,20 +201,15 @@ CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetHardwareVersionStr
  err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_HardwareVersionString, buf, bufSize,
  hardwareVersionStringLen);
 
-#ifdef CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING
- if (CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING[0] != 0 && err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
+ if (err == CHIP_DEVICE_ERROR_CONFIG_NOT_FOUND)
  {
  ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
  memcpy(buf, CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING,
  sizeof(CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING));
- hardwareVersionStringLen = sizeof(CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING) - 1;
- err = CHIP_NO_ERROR;
+ err = CHIP_NO_ERROR;
  }
-#endif
- ReturnErrorOnFailure(err);
 
- ReturnErrorCodeIf(hardwareVersionStringLen >= bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
- ReturnErrorCodeIf(buf[hardwareVersionStringLen] != 0, CHIP_ERROR_INVALID_STRING_LENGTH);
+ VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
 
  return err;
 }

src/platform/ASR/ASRConfig.h

@@ -91,6 +91,11 @@ class ASRConfig
  static const Key kCounterKey_UpTime;
  static const Key kCounterKey_TotalOperationalHours;
 
+ static const Key kConfigKey_VendorName;
+ static const Key kConfigKey_ProductName;
+ static const Key kConfigKey_HardwareVersionString;
+ static const Key kConfigKey_SoftwareVersionString;
+
  // Config value accessors.
  static CHIP_ERROR ReadConfigValue(Key key, bool & val);
  static CHIP_ERROR ReadConfigValue(Key key, uint32_t & val);

src/platform/Ameba/AmebaConfig.h

@@ -74,6 +74,11 @@ class AmebaConfig
  static const Key kCounterKey_TotalOperationalHours;
  static const Key kCounterKey_BootReason;
 
+ static const Key kConfigKey_VendorName;
+ static const Key kConfigKey_ProductName;
+ static const Key kConfigKey_HardwareVersionString;
+ static const Key kConfigKey_SoftwareVersionString;
+
  // Config value accessors.
  static CHIP_ERROR ReadConfigValue(Key key, bool & val);
  static CHIP_ERROR ReadConfigValue(Key key, uint32_t & val);

src/platform/Beken/BekenConfig.h

@@ -74,6 +74,11 @@ class BekenConfig
  static const Key kCounterKey_TotalOperationalHours;
  static const Key kCounterKey_BootReason;
 
+ static const Key kConfigKey_VendorName;
+ static const Key kConfigKey_ProductName;
+ static const Key kConfigKey_HardwareVersionString;
+ static const Key kConfigKey_SoftwareVersionString;
+
  static const char kGroupKeyNamePrefix[];
 
  // Config value accessors.

src/platform/Infineon/PSOC6/P6Config.h

@@ -89,6 +89,11 @@ class P6Config
  static const Key kConfigKey_YearDaySchedules;
  static const Key kConfigKey_HolidaySchedules;
 
+ static const Key kConfigKey_VendorName;
+ static const Key kConfigKey_ProductName;
+ static const Key kConfigKey_HardwareVersionString;
+ static const Key kConfigKey_SoftwareVersionString;
+
  // CHIP Counter keys
  static const Key kCounterKey_RebootCount;
  static const Key kCounterKey_UpTime;

src/platform/Zephyr/ZephyrConfig.cpp

@@ -73,6 +73,11 @@ const ZephyrConfig::Key ZephyrConfig::kConfigKey_RegulatoryLocation = CONFIG_KEY
 const ZephyrConfig::Key ZephyrConfig::kConfigKey_CountryCode = CONFIG_KEY(NAMESPACE_CONFIG "country-code");
 const ZephyrConfig::Key ZephyrConfig::kConfigKey_UniqueId = CONFIG_KEY(NAMESPACE_CONFIG "unique-id");
 
+const ZephyrConfig::Key ZephyrConfig::kConfigKey_VendorName = CONFIG_KEY(NAMESPACE_CONFIG "vendor-name");
+const ZephyrConfig::Key ZephyrConfig::kConfigKey_ProductName = CONFIG_KEY(NAMESPACE_CONFIG "product-name");
+const ZephyrConfig::Key ZephyrConfig::kConfigKey_HardwareVersionString = CONFIG_KEY(NAMESPACE_CONFIG "hardware-version-string");
+const ZephyrConfig::Key ZephyrConfig::kConfigKey_SoftwareVersionString = CONFIG_KEY(NAMESPACE_CONFIG "software-version-string");
+
 // Keys stored in the counters namespace
 const ZephyrConfig::Key ZephyrConfig::kCounterKey_RebootCount = CONFIG_KEY(NAMESPACE_COUNTERS "reboot-count");
 const ZephyrConfig::Key ZephyrConfig::kCounterKey_BootReason = CONFIG_KEY(NAMESPACE_COUNTERS "boot-reason");

src/platform/Zephyr/ZephyrConfig.h

@@ -66,6 +66,11 @@ class ZephyrConfig
  static const Key kConfigKey_Spake2pVerifier;
  static const Key kConfigKey_CertificationDeclaration;
 
+ static const Key kConfigKey_VendorName;
+ static const Key kConfigKey_ProductName;
+ static const Key kConfigKey_HardwareVersionString;
+ static const Key kConfigKey_SoftwareVersionString;
+
  static const Key kCounterKey_RebootCount;
  static const Key kCounterKey_BootReason;
  static const Key kCounterKey_TotalOperationalHours;

src/platform/bouffalolab/common/BLConfig.h

@@ -77,6 +77,11 @@ class BLConfig
 
  static constexpr char kBLKey_factoryResetFlag[] = ("__factory_reset_pending");
 
+ static const Key kConfigKey_VendorName;
+ static const Key kConfigKey_ProductName;
+ static const Key kConfigKey_HardwareVersionString;
+ static const Key kConfigKey_SoftwareVersionString;
+
  static void Init(void);
 
  // Config value accessors.

src/platform/cc13xx_26xx/CC13XX_26XXConfig.h

@@ -82,6 +82,11 @@ class CC13XX_26XXConfig
  static const Key kConfigKey_TotalOperationalHours;
  static const Key kConfigKey_LifeTimeCounter;
 
+ static const Key kConfigKey_VendorName;
+ static const Key kConfigKey_ProductName;
+ static const Key kConfigKey_HardwareVersionString;
+ static const Key kConfigKey_SoftwareVersionString;
+
  static CHIP_ERROR Init(void);
 
  // Config value accessors.

src/platform/cc32xx/CC32XXConfig.h

@@ -57,6 +57,11 @@ class CC32XXConfig
  static const Key kConfigKey_Breadcrumb;
  static const Key kConfigKey_UniqueId;
 
+ static const Key kConfigKey_VendorName;
+ static const Key kConfigKey_ProductName;
+ static const Key kConfigKey_HardwareVersionString;
+ static const Key kConfigKey_SoftwareVersionString;
+
  static const Key kConfigKey_Spake2pIterationCount;
  static const Key kConfigKey_Spake2pSalt;
  static const Key kConfigKey_Spake2pVerifier;

src/platform/fake/ConfigurationManagerImpl.h

@@ -49,7 +49,7 @@ class ConfigurationManagerImpl : public ConfigurationManager
  }
  CHIP_ERROR GetSoftwareVersion(uint32_t & softwareVer) override { return CHIP_ERROR_NOT_IMPLEMENTED; }
  CHIP_ERROR StoreSoftwareVersion(uint32_t softwareVer) override { return CHIP_ERROR_NOT_IMPLEMENTED; }
- CHIP_ERROR StoreSerialNumber(chip::Span<const char> serialNumber) override { return CHIP_ERROR_NOT_IMPLEMENTED; }
+ CHIP_ERROR StoreSerialNumber(CharSpan serialNumber) override { return CHIP_ERROR_NOT_IMPLEMENTED; }
  CHIP_ERROR GetPrimaryMACAddress(MutableByteSpan buf) override { return CHIP_ERROR_NOT_IMPLEMENTED; }
  CHIP_ERROR GetPrimaryWiFiMACAddress(uint8_t * buf) override { return CHIP_ERROR_NOT_IMPLEMENTED; }
  CHIP_ERROR GetPrimary802154MACAddress(uint8_t * buf) override { return CHIP_ERROR_NOT_IMPLEMENTED; }