[ASR] add asr550x support, fix some platform issue (#27987)

* [ASR] add asr550x support

* update CI with all build options

* add Identify implementation example

.github/workflows/examples-asr.yaml

@@ -50,12 +50,12 @@ jobs:
                      "./scripts/build/build_examples.py \
                         --target asr-asr582x-all-clusters \
                         --target asr-asr582x-all-clusters-minimal \
-                        --target asr-asr582x-lighting \
-                        --target asr-asr582x-light-switch \
-                        --target asr-asr582x-lock \
+                        --target asr-asr582x-lighting-ota \
+                        --target asr-asr582x-light-switch-shell \
+                        --target asr-asr582x-lock-no_logging \
                         --target asr-asr582x-ota-requestor \
-                        --target asr-asr582x-bridge \
-                        --target asr-asr582x-temperature-measurement \
-                        --target asr-asr582x-thermostat \
+                        --target asr-asr582x-bridge-factory \
+                        --target asr-asr582x-temperature-measurement-rotating_id \
+                        --target asr-asr582x-thermostat-rio \
                         build \
                      "

.gitmodules

@@ -308,3 +308,13 @@
 	url = https://github.com/google/perfetto.git
 	branch = master
 	platforms = linux,android
+[submodule "third_party/asr/components"]
+	path = third_party/asr/components
+	url = https://github.com/asriot/asriot_components.git
+	branch = matter
+	platforms = asr
+[submodule "third_party/asr/asr550x/asr_sdk"]
+	path = third_party/asr/asr550x/asr_sdk
+	url = https://github.com/asriot/ASR550X_Freertos.git
+	branch = matter
+	platforms = asr

config/asr/toolchain/BUILD.gn

@@ -16,10 +16,11 @@ import("//build_overrides/asr.gni")
 import("//build_overrides/build.gni")
 import("//build_overrides/chip.gni")
 
-assert(asr_ic_family == "asr582x" || asr_ic_family == "asr595x",
+assert(asr_ic_family == "asr582x" || asr_ic_family == "asr595x" ||
+           asr_ic_family == "asr550x",
        "Unsupported ASR IC: ${asr_ic_family}")
 
-if (asr_ic_family == "asr582x") {
+if (asr_ic_family == "asr582x" || asr_ic_family == "asr550x") {
   import("${build_root}/toolchain/arm_gcc/arm_toolchain.gni")
   _tool_name_root = "${asr_toolchain_root}arm-none-eabi-"
 }

docs/guides/asr_getting_started_guide.md

@@ -24,6 +24,7 @@ The ASR platform is supported on:
 
 -   [ASR582X](http://www.asrmicro.com/en/goods/proinfo/36.html)
 -   [ASR595X](http://www.asrmicro.com/en/goods/proinfo/42.html)
+-   [ASR550X](http://www.asrmicro.com/en/goods/proinfo/14.html)
 
 ## Matter Example Applications
 
@@ -35,9 +36,8 @@ to speed up development. You can find them in the samples with `/asr` subfolder.
 -   [Setup Matter Environment](./BUILDING.md)
 
 -   Setup toolchain
-    -   for ASR582X
+    -   for ASR582X and ASR550X
         ```
-        cd toolchain
         wget https://developer.arm.com/-/media/Files/downloads/gnu-rm/9-2019q4/RC2.1/gcc-arm-none-eabi-9-2019-q4-major-x86_64-linux.tar.bz2
         tar -jxvf gcc-arm-none-eabi-9-2019-q4-major-x86_64-linux.tar.bz2
         export ASR_TOOLCHAIN_PATH={abs-path-to-toolchain}/gcc-arm-none-eabi-9-2019-q4-major/bin/
@@ -60,6 +60,10 @@ to speed up development. You can find them in the samples with `/asr` subfolder.
         ```
         export ASR_BOARD=asr595x
         ```
+    -   for ASR550X:
+        ```
+        export ASR_BOARD=asr550x
+        ```
 -   Building the Application
 
     If the lighting example is to be built:
@@ -91,6 +95,7 @@ There are two commissioning modes supported by ASR platform:
     ```
     ./chip-tool pairing ble-wifi <node_id> <ssid> <password> <pin_code> <discriminator>
     ```
+5. Only ASR582X and ASR595X support BLE
 
 ### IP mode
 

examples/platform/asr/CHIPDeviceManager.cpp

@@ -31,7 +31,12 @@
 #include <support/CodeUtils.h>
 #include <support/ErrorStr.h>
 
+#ifdef EMBER_AF_PLUGIN_IDENTIFY_SERVER
+#include <app/clusters/identify-server/identify-server.h>
+#endif
+
 using namespace ::chip;
+using namespace ::chip::app;
 
 namespace chip {
 
@@ -74,3 +79,42 @@ void MatterPostAttributeChangeCallback(const chip::app::ConcreteAttributePath &
         cb->PostAttributeChangeCallback(path.mEndpointId, path.mClusterId, path.mAttributeId, type, size, value);
     }
 }
+
+#ifdef EMBER_AF_PLUGIN_IDENTIFY_SERVER
+void OnIdentifyStart(Identify *)
+{
+    ChipLogProgress(Zcl, "OnIdentifyStart");
+}
+
+void OnIdentifyStop(Identify *)
+{
+    ChipLogProgress(Zcl, "OnIdentifyStop");
+}
+
+void OnTriggerEffect(Identify * identify)
+{
+    switch (identify->mCurrentEffectIdentifier)
+    {
+    case Clusters::Identify::EffectIdentifierEnum::kBlink:
+        ChipLogProgress(Zcl, "Clusters::Identify::EffectIdentifierEnum::kBlink");
+        break;
+    case Clusters::Identify::EffectIdentifierEnum::kBreathe:
+        ChipLogProgress(Zcl, "Clusters::Identify::EffectIdentifierEnum::kBreathe");
+        break;
+    case Clusters::Identify::EffectIdentifierEnum::kOkay:
+        ChipLogProgress(Zcl, "Clusters::Identify::EffectIdentifierEnum::kOkay");
+        break;
+    case Clusters::Identify::EffectIdentifierEnum::kChannelChange:
+        ChipLogProgress(Zcl, "Clusters::Identify::EffectIdentifierEnum::kChannelChange");
+        break;
+    default:
+        ChipLogProgress(Zcl, "No identifier effect");
+        return;
+    }
+}
+
+static Identify gIdentify1 = {
+    chip::EndpointId{ 1 }, OnIdentifyStart, OnIdentifyStop, Clusters::Identify::IdentifyTypeEnum::kVisibleIndicator,
+    OnTriggerEffect,
+};
+#endif

scripts/build/build/targets.py

@@ -415,6 +415,7 @@ def BuildASRTarget():
     target.AppendFixedTargets([
         TargetPart('asr582x', board=ASRBoard.ASR582X),
         TargetPart('asr595x', board=ASRBoard.ASR595X),
+        TargetPart('asr550x', board=ASRBoard.ASR550X),
     ])
 
     # apps
@@ -436,6 +437,7 @@ def BuildASRTarget():
     target.AppendModifier('no_logging', chip_logging=False)
     target.AppendModifier('factory', enable_factory=True)
     target.AppendModifier('rotating_id', enable_rotating_device_id=True)
+    target.AppendModifier('rio', enable_lwip_ip6_hook=True)
 
     return target
 

scripts/build/builders/asr.py

@@ -80,12 +80,15 @@ def BuildRoot(self, root):
 class ASRBoard(Enum):
     ASR582X = auto()
     ASR595X = auto()
+    ASR550X = auto()
 
     def GetIC(self):
         if self == ASRBoard.ASR582X:
             return 'asr582x'
         elif self == ASRBoard.ASR595X:
             return 'asr595x'
+        elif self == ASRBoard.ASR550X:
+            return 'asr550x'
         else:
             raise Exception('Unknown board #: %r' % self)
 
@@ -101,7 +104,8 @@ def __init__(self,
                  chip_logging: bool = True,
                  enable_factory: bool = False,
                  enable_rotating_device_id: bool = False,
-                 enable_ota_requestor: bool = False):
+                 enable_ota_requestor: bool = False,
+                 enable_lwip_ip6_hook: bool = False):
         super(ASRBuilder, self).__init__(
             root=app.BuildRoot(root),
             runner=runner)
@@ -118,6 +122,9 @@ def __init__(self,
         elif asr_chip == "asr595x":
             ASR_ARCH = "riscv"
             ASR_SDK_ROOT = "//third_party/connectedhomeip/third_party/asr/asr595x"
+        elif asr_chip == "asr550x":
+            ASR_ARCH = "arm"
+            ASR_SDK_ROOT = "//third_party/connectedhomeip/third_party/asr/asr550x"
         self.extra_gn_options.append('target_cpu="%s"' % ASR_ARCH)
 
         toolchain = os.path.join(root, os.path.split(os.path.realpath(__file__))[0], '../../../config/asr/toolchain')
@@ -132,6 +139,9 @@ def __init__(self,
                 or asr_chip == "asr595x"):
             self.extra_gn_options.append('chip_config_network_layer_ble=true')
 
+        if (asr_chip == "asr550x"):
+            self.extra_gn_options.append('chip_config_network_layer_ble=false')
+
         if enable_ota_requestor:
             self.extra_gn_options.append('chip_enable_ota_requestor=true')
 
@@ -149,6 +159,9 @@ def __init__(self,
             self.extra_gn_options.append('chip_enable_additional_data_advertising=true')
             self.extra_gn_options.append('chip_enable_rotating_device_id=true')
 
+        if enable_lwip_ip6_hook:
+            self.extra_gn_options.append('chip_lwip_ip6_hook=true')
+
         self.extra_gn_options.append('asr_toolchain_root="%s"' % os.environ['ASR_TOOLCHAIN_PATH'])
 
     def GnBuildArgs(self):

scripts/build/testdata/all_targets_linux_x64.txt

@@ -1,5 +1,5 @@
 ameba-amebad-{all-clusters,all-clusters-minimal,light,light-switch,pigweed}
-asr-{asr582x,asr595x}-{all-clusters,all-clusters-minimal,lighting,light-switch,lock,bridge,temperature-measurement,thermostat,ota-requestor}[-ota][-shell][-no_logging][-factory][-rotating_id]
+asr-{asr582x,asr595x,asr550x}-{all-clusters,all-clusters-minimal,lighting,light-switch,lock,bridge,temperature-measurement,thermostat,ota-requestor}[-ota][-shell][-no_logging][-factory][-rotating_id][-rio]
 android-{arm,arm64,x86,x64,androidstudio-arm,androidstudio-arm64,androidstudio-x86,androidstudio-x64}-{chip-tool,chip-test,tv-server,tv-casting-app,java-matter-controller}[-no-debug]
 bouffalolab-{bl602-iot-matter-v1,bl602-iot-dvk-3s,bl602-night-light,xt-zb6-devkit,bl706-iot-dvk,bl706-night-light,bl704l-dvk}-light[-shell][-115200][-rpc][-cdc][-rotating_device_id]
 cc32xx-lock

src/platform/ASR/ASRFactoryDataProvider.cpp

@@ -402,7 +402,7 @@ CHIP_ERROR ASRFactoryDataProvider::GetProductId(uint16_t & productId)
 #else
     uint32_t productId32;
     ReturnErrorOnFailure(ASRConfig::ReadFactoryConfigValue(ASR_PRODUCT_ID_PARTITION, productId32));
-    productId = static_cast<uint16_t>(productId32);
+    productId                           = static_cast<uint16_t>(productId32);
 #endif
     return CHIP_NO_ERROR;
 }
@@ -424,40 +424,88 @@ CHIP_ERROR ASRFactoryDataProvider::GetProductLabel(char * buf, size_t bufSize)
 
 CHIP_ERROR ASRFactoryDataProvider::GetSerialNumber(char * buf, size_t bufSize)
 {
-    ChipError err = CHIP_NO_ERROR;
+#if !CONFIG_ENABLE_ASR_FACTORY_DEVICE_INFO_PROVIDER
+    ReturnErrorCodeIf(bufSize < sizeof(CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER), CHIP_ERROR_BUFFER_TOO_SMALL);
+    strcpy(buf, CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER);
+#else
+#define BUFFER_MAX_SIZE 32
+    uint8_t buffer[BUFFER_MAX_SIZE + 1] = { 0 };
+    size_t buffer_len                   = BUFFER_MAX_SIZE + 1;
+    ReturnErrorOnFailure(ASRConfig::ReadFactoryConfigValue(ASR_SERIAL_NUMBER_PARTITION, buffer, buffer_len, buffer_len));
+    ReturnErrorCodeIf(bufSize < buffer_len, CHIP_ERROR_BUFFER_TOO_SMALL);
+    memcpy(buf, buffer, buffer_len);
+    buf[buffer_len] = 0;
+#endif
+    return CHIP_NO_ERROR;
+}
 
-    size_t serialNumLen = 0; // without counting null-terminator
+CHIP_ERROR ASRFactoryDataProvider::GetManufacturingDate(uint16_t & year, uint8_t & month, uint8_t & day)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+    enum
+    {
+        kDateStringLength = 10 // YYYY-MM-DD
+    };
+    char dateStr[kDateStringLength + 1];
+    char * parseEnd;
+#if !CONFIG_ENABLE_ASR_FACTORY_DEVICE_INFO_PROVIDER
+    memcpy(dateStr, CHIP_DEVICE_CONFIG_TEST_MANUFACTURY_DATE, kDateStringLength + 1);
+#else
+    size_t dateLen;
+    err = ASRConfig::ReadFactoryConfigValue(ASR_MANUFACTURY_DATE_PARTITION, (uint8_t *) dateStr, sizeof(dateStr), dateLen);
+    SuccessOrExit(err);
 
-#ifdef CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER
-    if (CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER[0] != 0)
+    VerifyOrExit(dateLen == kDateStringLength, err = CHIP_ERROR_INVALID_ARGUMENT);
+#endif
+    // Cast does not lose information, because we then check that we only parsed
+    // 4 digits, so our number can't be bigger than 9999.
+    year = static_cast<uint16_t>(strtoul(dateStr, &parseEnd, 10));
+    VerifyOrExit(parseEnd == dateStr + 4, err = CHIP_ERROR_INVALID_ARGUMENT);
+
+    // Cast does not lose information, because we then check that we only parsed
+    // 2 digits, so our number can't be bigger than 99.
+    month = static_cast<uint8_t>(strtoul(dateStr + 5, &parseEnd, 10));
+    VerifyOrExit(parseEnd == dateStr + 7, err = CHIP_ERROR_INVALID_ARGUMENT);
+
+    // Cast does not lose information, because we then check that we only parsed
+    // 2 digits, so our number can't be bigger than 99.
+    day = static_cast<uint8_t>(strtoul(dateStr + 8, &parseEnd, 10));
+    VerifyOrExit(parseEnd == dateStr + 10, err = CHIP_ERROR_INVALID_ARGUMENT);
+
+exit:
+    if (err != CHIP_NO_ERROR && 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;
+        ChipLogError(DeviceLayer, "Invalid manufacturing date: %s", dateStr);
     }
-#endif // CHIP_DEVICE_CONFIG_TEST_SERIAL_NUMBER
-
-    ReturnErrorCodeIf(serialNumLen >= bufSize, CHIP_ERROR_BUFFER_TOO_SMALL);
-    ReturnErrorCodeIf(buf[serialNumLen] != 0, CHIP_ERROR_INVALID_STRING_LENGTH);
-
     return err;
 }
 
-CHIP_ERROR ASRFactoryDataProvider::GetManufacturingDate(uint16_t & year, uint8_t & month, uint8_t & day)
-{
-    return CHIP_ERROR_NOT_IMPLEMENTED;
-}
-
 CHIP_ERROR ASRFactoryDataProvider::GetHardwareVersion(uint16_t & hardwareVersion)
 {
-    return CHIP_ERROR_NOT_IMPLEMENTED;
+#if !CONFIG_ENABLE_ASR_FACTORY_DEVICE_INFO_PROVIDER
+    hardwareVersion = static_cast<uint16_t>(CHIP_DEVICE_CONFIG_DEFAULT_DEVICE_HARDWARE_VERSION);
+#else
+    uint32_t hardwareVersion32;
+    ReturnErrorOnFailure(ASRConfig::ReadFactoryConfigValue(ASR_HARDWARE_VERSION_PARTITION, hardwareVersion32));
+    hardwareVersion                     = static_cast<uint16_t>(hardwareVersion32);
+#endif
+    return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR ASRFactoryDataProvider::GetHardwareVersionString(char * buf, size_t bufSize)
 {
+#if !CONFIG_ENABLE_ASR_FACTORY_DEVICE_INFO_PROVIDER
     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);
+#else
+#define BUFFER_MAX_SIZE 32
+    uint8_t buffer[BUFFER_MAX_SIZE + 1] = { 0 };
+    size_t buffer_len                   = BUFFER_MAX_SIZE + 1;
+    ReturnErrorOnFailure(ASRConfig::ReadFactoryConfigValue(ASR_HARDWARE_VERSION_STR_PARTITION, buffer, buffer_len, buffer_len));
+    ReturnErrorCodeIf(bufSize < buffer_len, CHIP_ERROR_BUFFER_TOO_SMALL);
+    memcpy(buf, buffer, buffer_len);
+    buf[buffer_len] = 0;
+#endif
     return CHIP_NO_ERROR;
 }
 

src/platform/ASR/CHIPDevicePlatformConfig.h

@@ -30,6 +30,7 @@
 #define CHIP_DEVICE_CONFIG_CHIP_TASK_STACK_SIZE 1024 * 8
 #define CHIP_DEVICE_CONFIG_CHIP_TASK_PRIORITY 1
 #define CHIP_DEVICE_CONFIG_ENABLE_TEST_SETUP_PARAMS 1
+#define CHIP_DEVICE_CONFIG_TEST_MANUFACTURY_DATE "2023-07-07"
 
 #if defined(CFG_PLF_RV32) || defined(CFG_PLF_DUET)
 // ASR582X/ASR595X support Wi-Fi and BLE

src/platform/ASR/NetworkCommissioningWiFiDriver.cpp

@@ -297,8 +297,7 @@ void ASRWiFiDriver::OnNetworkStatusChange()
     if (staConnected)
     {
         mpStatusChangeCallback->OnNetworkingStatusChange(
-            Status::kSuccess, MakeOptional(ByteSpan(configuredNetwork.networkID, configuredNetwork.networkIDLen)),
-            MakeOptional(GetLastDisconnectReason()));
+            Status::kSuccess, MakeOptional(ByteSpan(configuredNetwork.networkID, configuredNetwork.networkIDLen)), NullOptional);
         return;
     }
     mpStatusChangeCallback->OnNetworkingStatusChange(