add add some basic information cluster attributes to cmd line args to the reference app

examples/platform/linux/CommissionableInit.cpp

@@ -99,6 +99,35 @@ CHIP_ERROR InitConfigurationManager(ConfigurationManagerImpl & configManager, Li
         configManager.StoreProductId(options.payload.productID);
     }
 
+    if (options.vendorName.HasValue())
+    {
+        CharSpan vendor_name(options.vendorName.Value().c_str(), options.vendorName.Value().size());
+        VerifyOrDie(configManager.StoreVendorName(vendor_name) == CHIP_NO_ERROR);
+    }
+    if (options.productName.HasValue())
+    {
+        CharSpan product_name(options.productName.Value().c_str(), options.productName.Value().size());
+        VerifyOrDie(configManager.StoreProductName(product_name) == CHIP_NO_ERROR);
+    }
+    if (options.hardwareVersionString.HasValue())
+    {
+        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())
+    {
+        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())
+    {
+        CharSpan serial_number(options.serialNumber.Value().c_str(), options.serialNumber.Value().size());
+        VerifyOrDie(configManager.StoreSerialNumber(serial_number) == CHIP_NO_ERROR);
+    }
+
     return CHIP_NO_ERROR;
 }
 

examples/platform/linux/Options.cpp

@@ -106,6 +106,12 @@ enum
 #if CHIP_WITH_NLFAULTINJECTION
     kDeviceOption_FaultInjection,
 #endif
+    kDeviceOption_VendorName            = 0x1028,
+    kDeviceOption_ProductName           = 0x1029,
+    kDeviceOption_HardwareVersionString = 0x102a,
+    kDeviceOption_SoftwareVersionString = 0x102b,
+    kDeviceOption_SerialNumber          = 0x102c,
+
 };
 
 constexpr unsigned kAppUsageLength = 64;
@@ -124,6 +130,11 @@ OptionDef sDeviceOptionDefs[] = {
     { "version", kArgumentRequired, kDeviceOption_Version },
     { "vendor-id", kArgumentRequired, kDeviceOption_VendorID },
     { "product-id", kArgumentRequired, kDeviceOption_ProductID },
+    { "vendor-name", kArgumentRequired, kDeviceOption_VendorName },
+    { "product-name", kArgumentRequired, kDeviceOption_ProductName },
+    { "hardware-version-string", kArgumentRequired, kDeviceOption_HardwareVersionString },
+    { "software-version-string", kArgumentRequired, kDeviceOption_SoftwareVersionString },
+    { "serial-number", kArgumentRequired, kDeviceOption_SerialNumber },
     { "custom-flow", kArgumentRequired, kDeviceOption_CustomFlow },
     { "capabilities", kArgumentRequired, kDeviceOption_Capabilities },
     { "discriminator", kArgumentRequired, kDeviceOption_Discriminator },
@@ -204,6 +215,21 @@ const char * sDeviceOptionHelp =
     "  --product-id <id>\n"
     "       The Product ID is specified by vendor.\n"
     "\n"
+    "  --vendor-name <name>\n"
+    "       The vendor name specified by the vendor.\n"
+    "\n"
+    "  --product-name <name>\n"
+    "       The product name specified by vendor.\n"
+    "\n"
+    "  --hardware-version-string <string>\n"
+    "       The HardwareVersionString used in the basic information cluster.\n"
+    "\n"
+    "  --software-version-string <string>\n"
+    "       The SoftwareVersionString used in the basic information cluster.\n"
+    "\n"
+    "  --serial-number <serial_number>\n"
+    "       The serial number specified by vendor.\n"
+    "\n"
     "  --custom-flow <Standard = 0 | UserActionRequired = 1 | Custom = 2>\n"
     "       A 2-bit unsigned enumeration specifying manufacturer-specific custom flow options.\n"
     "\n"
@@ -589,6 +615,26 @@ bool HandleOption(const char * aProgram, OptionSet * aOptions, int aIdentifier,
         break;
     }
 #endif
+    case kDeviceOption_VendorName:
+        LinuxDeviceOptions::GetInstance().vendorName.SetValue(std::string{ aValue });
+        break;
+
+    case kDeviceOption_ProductName:
+        LinuxDeviceOptions::GetInstance().productName.SetValue(std::string{ aValue });
+        break;
+
+    case kDeviceOption_HardwareVersionString:
+        LinuxDeviceOptions::GetInstance().hardwareVersionString.SetValue(std::string{ aValue });
+        break;
+
+    case kDeviceOption_SoftwareVersionString:
+        LinuxDeviceOptions::GetInstance().softwareVersionString.SetValue(std::string{ aValue });
+        break;
+
+    case kDeviceOption_SerialNumber:
+        LinuxDeviceOptions::GetInstance().serialNumber.SetValue(std::string{ aValue });
+        break;
+
     default:
         PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", aProgram, aName);
         retval = false;

examples/platform/linux/Options.h

@@ -78,6 +78,12 @@ struct LinuxDeviceOptions
     int32_t subscriptionCapacity                   = CHIP_IM_MAX_NUM_SUBSCRIPTIONS;
     int32_t subscriptionResumptionRetryIntervalSec = -1;
 #endif
+    chip::Optional<std::string> vendorName;
+    chip::Optional<std::string> productName;
+    chip::Optional<std::string> hardwareVersionString;
+    chip::Optional<std::string> softwareVersionString;
+    chip::Optional<std::string> serialNumber;
+
     static LinuxDeviceOptions & GetInstance();
 };
 

src/include/platform/ConfigurationManager.h

@@ -114,7 +114,6 @@ class ConfigurationManager
 #endif
     virtual CHIP_ERROR GetRegulatoryLocation(uint8_t & location)                       = 0;
     virtual CHIP_ERROR GetCountryCode(char * buf, size_t bufSize, size_t & codeLen)    = 0;
-    virtual CHIP_ERROR StoreSerialNumber(const char * serialNum, size_t serialNumLen)  = 0;
     virtual CHIP_ERROR StoreManufacturingDate(const char * mfgDate, size_t mfgDateLen) = 0;
     virtual CHIP_ERROR StoreSoftwareVersion(uint32_t softwareVer)                      = 0;
     virtual CHIP_ERROR StoreHardwareVersion(uint16_t hardwareVer)                      = 0;
@@ -133,6 +132,11 @@ class ConfigurationManager
     virtual CHIP_ERROR SetFailSafeArmed(bool val)                                      = 0;
 
     virtual CHIP_ERROR GetBLEDeviceIdentificationInfo(Ble::ChipBLEDeviceIdentificationInfo & deviceIdInfo) = 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(const char * serialNum, size_t serialNumLen) 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;
@@ -103,6 +103,11 @@ class GenericConfigurationManagerImpl : public ConfigurationManager
     CHIP_ERROR GetUniqueId(char * buf, size_t bufSize) override;
     CHIP_ERROR StoreUniqueId(const char * uniqueId, size_t uniqueIdLen) override;
     CHIP_ERROR GenerateUniqueId(char * buf, size_t bufSize) 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,15 +351,50 @@ CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetSecondaryPairingHint
 template <class ConfigClass>
 CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::GetSoftwareVersionString(char * buf, size_t bufSize)
 {
-    ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
-    strcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION_STRING);
-    return 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 (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));
+
+        return CHIP_NO_ERROR;
+    }
+
+    VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
+    return err;
 }
 
 template <class ConfigClass>
-CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSerialNumber(const char * serialNum, size_t serialNumLen)
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSerialNumber(CharSpan serialNumber)
+{
+    return WriteConfigValueStr(ConfigClass::kConfigKey_SerialNum, serialNumber.data(), serialNumber.size());
+}
+template <class ConfigClass>
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreVendorName(CharSpan vendorName)
+{
+
+    return WriteConfigValueStr(ConfigClass::kConfigKey_VendorName, vendorName.data(), vendorName.size());
+}
+template <class ConfigClass>
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreProductName(CharSpan productName)
+{
+    return WriteConfigValueStr(ConfigClass::kConfigKey_ProductName, productName.data(), productName.size());
+}
+template <class ConfigClass>
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreHardwareVersionString(CharSpan hardwareVersionString)
+{
+    return WriteConfigValueStr(ConfigClass::kConfigKey_HardwareVersionString, hardwareVersionString.data(),
+                               hardwareVersionString.size());
+}
+template <class ConfigClass>
+CHIP_ERROR GenericConfigurationManagerImpl<ConfigClass>::StoreSoftwareVersionString(CharSpan softwareVersionString)
 {
-    return WriteConfigValueStr(ConfigClass::kConfigKey_SerialNum, serialNum, serialNumLen);
+    return WriteConfigValueStr(ConfigClass::kConfigKey_SoftwareVersionString, softwareVersionString.data(),
+                               softwareVersionString.size());
 }
 
 template <class ConfigClass>

src/include/platform/internal/GenericDeviceInstanceInfoProvider.ipp

@@ -38,18 +38,41 @@ CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetProductId(uint16_t
 template <class ConfigClass>
 CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetVendorName(char * buf, size_t bufSize)
 {
-    ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
-    strcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_VENDOR_NAME);
-    return CHIP_NO_ERROR;
+    ChipError err        = CHIP_NO_ERROR;
+    size_t vendorNameLen = 0; // without counting null-terminator
+
+    err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_VendorName, buf, bufSize, vendorNameLen);
+
+    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));
+        err = CHIP_NO_ERROR;
+    }
+
+    VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
+
+    return err;
 }
 
 template <class ConfigClass>
 CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetProductName(char * buf, size_t bufSize)
 {
-    ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME), CHIP_ERROR_BUFFER_TOO_SMALL);
-    strcpy(buf, CHIP_DEVICE_CONFIG_DEVICE_PRODUCT_NAME);
+    ChipError err         = CHIP_NO_ERROR;
+    size_t productNameLen = 0; // without counting null-terminator
 
-    return CHIP_NO_ERROR;
+    err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_ProductName, buf, bufSize, productNameLen);
+
+    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));
+        err = CHIP_NO_ERROR;
+    }
+
+    VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
+
+    return err;
 }
 
 template <class ConfigClass>
@@ -96,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;
 }
@@ -176,9 +195,23 @@ CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetHardwareVersion(ui
 template <class ConfigClass>
 CHIP_ERROR GenericDeviceInstanceInfoProvider<ConfigClass>::GetHardwareVersionString(char * buf, size_t bufSize)
 {
-    ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING), CHIP_ERROR_BUFFER_TOO_SMALL);
-    strcpy(buf, CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION_STRING);
-    return CHIP_NO_ERROR;
+    ChipError err                   = CHIP_NO_ERROR;
+    size_t hardwareVersionStringLen = 0; // without counting null-terminator
+
+    err = mGenericConfigManager.ReadConfigValueStr(ConfigClass::kConfigKey_HardwareVersionString, buf, bufSize,
+                                                   hardwareVersionStringLen);
+
+    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));
+        err = CHIP_NO_ERROR;
+    }
+
+    VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INTERNAL);
+
+    return err;
 }
 
 template <class ConfigClass>

src/platform/ASR/ASRConfig.cpp

@@ -80,6 +80,11 @@ const ASRConfig::Key ASRConfig::kConfigKey_WiFiSecurity       = { kConfigNamespa
 const ASRConfig::Key ASRConfig::kConfigKey_WiFiMode           = { kConfigNamespace_ChipConfig, "wifimode" };
 const ASRConfig::Key ASRConfig::kConfigKey_UniqueId           = { kConfigNamespace_ChipConfig, "unique-id" };
 
+const ASRConfig::Key ASRConfig::kConfigKey_VendorName            = { kConfigNamespace_ChipConfig, "vendor-name" };
+const ASRConfig::Key ASRConfig::kConfigKey_ProductName           = { kConfigNamespace_ChipConfig, "product-name" };
+const ASRConfig::Key ASRConfig::kConfigKey_HardwareVersionString = { kConfigNamespace_ChipConfig, "hardware-version-string" };
+const ASRConfig::Key ASRConfig::kConfigKey_SoftwareVersionString = { kConfigNamespace_ChipConfig, "software-version-string" };
+
 // Keys stored in the Chip-counters namespace
 const ASRConfig::Key ASRConfig::kCounterKey_RebootCount           = { kConfigNamespace_ChipCounters, "reboot-count" };
 const ASRConfig::Key ASRConfig::kCounterKey_UpTime                = { kConfigNamespace_ChipCounters, "up-time" };

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.cpp

@@ -79,6 +79,11 @@ const AmebaConfig::Key AmebaConfig::kConfigKey_RegulatoryLocation          = { k
 const AmebaConfig::Key AmebaConfig::kConfigKey_LocationCapability          = { kConfigNamespace_ChipConfig, "location-capability" };
 const AmebaConfig::Key AmebaConfig::kConfigKey_CountryCode                 = { kConfigNamespace_ChipConfig, "country-code" };
 
+const AmebaConfig::Key AmebaConfig::kConfigKey_VendorName            = { kConfigNamespace_ChipConfig, "vendor-name" };
+const AmebaConfig::Key AmebaConfig::kConfigKey_ProductName           = { kConfigNamespace_ChipConfig, "product-name" };
+const AmebaConfig::Key AmebaConfig::kConfigKey_HardwareVersionString = { kConfigNamespace_ChipConfig, "hardware-version-string" };
+const AmebaConfig::Key AmebaConfig::kConfigKey_SoftwareVersionString = { kConfigNamespace_ChipConfig, "software-version-string" };
+
 // Keys stored in the Chip-counters namespace
 const AmebaConfig::Key AmebaConfig::kCounterKey_RebootCount           = { kConfigNamespace_ChipCounters, "reboot-count" };
 const AmebaConfig::Key AmebaConfig::kCounterKey_UpTime                = { kConfigNamespace_ChipCounters, "up-time" };

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.cpp

@@ -79,6 +79,11 @@ const BekenConfig::Key BekenConfig::kConfigKey_RegulatoryLocation          = { k
 const BekenConfig::Key BekenConfig::kConfigKey_CountryCode                 = { kConfigNamespace_ChipConfig, "country-code" };
 const BekenConfig::Key BekenConfig::kConfigKey_Breadcrumb                  = { kConfigNamespace_ChipConfig, "breadcrumb" };
 
+const BekenConfig::Key BekenConfig::kConfigKey_VendorName            = { kConfigNamespace_ChipConfig, "vendor-name" };
+const BekenConfig::Key BekenConfig::kConfigKey_ProductName           = { kConfigNamespace_ChipConfig, "product-name" };
+const BekenConfig::Key BekenConfig::kConfigKey_HardwareVersionString = { kConfigNamespace_ChipConfig, "hardware-version-string" };
+const BekenConfig::Key BekenConfig::kConfigKey_SoftwareVersionString = { kConfigNamespace_ChipConfig, "software-version-string" };
+
 // Keys stored in the Chip-counters namespace
 const BekenConfig::Key BekenConfig::kCounterKey_RebootCount           = { kConfigNamespace_ChipCounters, "reboot-count" };
 const BekenConfig::Key BekenConfig::kCounterKey_UpTime                = { kConfigNamespace_ChipCounters, "up-time" };

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.