Merge branch 'master' into feature/refresh-content-app-acl

examples/darwin-framework-tool/commands/common/CHIPCommandBridge.h

@@ -39,7 +39,7 @@ class CHIPCommandBridge : public Command {
     {
         AddArgument("commissioner-name", &mCommissionerName);
         AddArgument("commissioner-nodeId", 0, UINT64_MAX, &mCommissionerNodeId,
-            "Sets the commisser node ID of the given "
+            "Sets the commissioner node ID of the given "
             "commissioner-name. Interactive mode will only set a single commissioner on the inital command. "
             "The commissioner node ID will be persisted until a different one is specified.");
         AddArgument("paa-trust-store-path", &mPaaTrustStorePath,

examples/darwin-framework-tool/commands/pairing/DeviceControllerDelegateBridge.mm

@@ -36,7 +36,7 @@ - (void)controller:(MTRDeviceController *)controller statusUpdate:(MTRCommission
         ChipLogError(chipTool, "MTRCommissioningStatusDiscoveringMoreDevices: This should not happen.");
         break;
     case MTRCommissioningStatusUnknown:
-        ChipLogError(chipTool, "Uknown Pairing Status");
+        ChipLogError(chipTool, "Unknown Pairing Status");
         break;
     }
 }

src/darwin/Framework/CHIP/MTRDevice.mm

@@ -844,11 +844,13 @@ - (void)_addDelegate:(id<MTRDeviceDelegate>)delegate queue:(dispatch_queue_t)que
 #endif
 
     if (shouldSetUpSubscription) {
+        MTR_LOG("%@ - starting subscription setup", self);
         // Record the time of first addDelegate call that triggers initial subscribe, and do not reset this value on subsequent addDelegate calls
         if (!_initialSubscribeStart) {
             _initialSubscribeStart = [NSDate now];
         }
         if ([self _deviceUsesThread]) {
+            MTR_LOG(" => %@ - device is a thread device, scheduling in pool", self);
             [self _scheduleSubscriptionPoolWork:^{
                 std::lock_guard lock(self->_lock);
                 [self _setupSubscriptionWithReason:@"delegate is set and scheduled subscription is happening"];
@@ -1301,7 +1303,7 @@ - (void)_scheduleSubscriptionPoolWork:(dispatch_block_t)workBlock inNanoseconds:
 
     // Sanity check we are not scheduling for this device multiple times in the pool
     if (_subscriptionPoolWorkCompletionBlock) {
-        MTR_LOG_ERROR("%@ already scheduled in subscription pool for this device - ignoring: %@", self, description);
+        MTR_LOG("%@ already scheduled in subscription pool for this device - ignoring: %@", self, description);
         return;
     }
 
@@ -1310,6 +1312,7 @@ - (void)_scheduleSubscriptionPoolWork:(dispatch_block_t)workBlock inNanoseconds:
         // In the case where a resubscription triggering event happened and already established, running the work block should result in a no-op
         MTRAsyncWorkItem * workItem = [[MTRAsyncWorkItem alloc] initWithQueue:self.queue];
         [workItem setReadyHandler:^(id _Nonnull context, NSInteger retryCount, MTRAsyncWorkCompletionBlock _Nonnull completion) {
+            MTR_LOG("%@ - work item is ready to attempt pooled subscription", self);
             os_unfair_lock_lock(&self->_lock);
 #ifdef DEBUG
             [self _callDelegatesWithBlock:^(id testDelegate) {
@@ -1335,6 +1338,7 @@ - (void)_scheduleSubscriptionPoolWork:(dispatch_block_t)workBlock inNanoseconds:
             workBlock();
         }];
         [self->_deviceController.concurrentSubscriptionPool enqueueWorkItem:workItem description:description];
+        MTR_LOG("%@ - enqueued in the subscription pool", self);
     });
 }
 

src/darwin/Framework/CHIP/MTRError_Internal.h

@@ -26,6 +26,10 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+#ifndef YES_NO
+#define YES_NO(x) ((x) ? @"YES" : @"NO")
+#endif
+
 MTR_DIRECT_MEMBERS
 @interface MTRError : NSObject
 + (NSError *)errorWithCode:(MTRErrorCode)code;

src/platform/nxp/common/CHIPDeviceNXPPlatformDefaultConfig.h

@@ -106,3 +106,15 @@
 #define CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONABLE_DISCOVERY 1
 #define CHIP_DEVICE_CONFIG_ENABLE_EXTENDED_DISCOVERY 1
 #endif
+
+#ifndef CHIP_DEVICE_CONFIG_USE_ZEPHYR_BLE
+#define CHIP_DEVICE_CONFIG_USE_ZEPHYR_BLE 1
+#endif // CHIP_DEVICE_CONFIG_USE_ZEPHYR_BLE
+
+#ifndef CHIP_DEVICE_CONFIG_PROCESS_BLE_IN_THREAD
+#define CHIP_DEVICE_CONFIG_PROCESS_BLE_IN_THREAD 0
+#endif // CHIP_DEVICE_CONFIG_PROCESS_BLE_IN_THREAD
+
+#ifndef CHIP_DEVICE_CONFIG_INIT_OT_PLAT_ALARM
+#define CHIP_DEVICE_CONFIG_INIT_OT_PLAT_ALARM 1
+#endif // CHIP_DEVICE_CONFIG_INIT_OT_PLAT_ALARM

src/platform/nxp/common/CHIPDevicePlatformEvent.h

@@ -24,7 +24,7 @@
  */
 
 #pragma once
-#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
+#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE && CHIP_DEVICE_CONFIG_USE_ZEPHYR_BLE
 #include <sys/atomic.h>
 #include <toolchain.h>
 #include <zephyr/bluetooth/bluetooth.h>
@@ -74,7 +74,7 @@ enum InternalPlatformSpecificEventTypes
 
 } // namespace DeviceEventType
 
-#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
+#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE && CHIP_DEVICE_CONFIG_USE_ZEPHYR_BLE
 struct BleConnEventType
 {
     bt_conn * BtConn;
@@ -108,7 +108,7 @@ struct ChipDevicePlatformEvent final
 {
     union
     {
-#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
+#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE && CHIP_DEVICE_CONFIG_USE_ZEPHYR_BLE
         BleConnEventType BleConnEvent;
         BleCCCWriteEventType BleCCCWriteEvent;
         BleC1WriteEventType BleC1WriteEvent;

src/platform/nxp/common/CHIPNXPPlatformDefaultConfig.h

@@ -217,6 +217,34 @@
 #define WDM_PUBLISHER_MAX_NOTIFIES_IN_FLIGHT 2
 #endif // WDM_PUBLISHER_MAX_NOTIFIES_IN_FLIGHT
 
+// ==================== ICD Configuration Overrides ====================
+
+#ifndef NXP_ICD_ENABLED
+#define NXP_ICD_ENABLED 0
+#endif // NXP_ICD_ENABLED
+
+#if NXP_ICD_ENABLED
+#ifndef CHIP_CONFIG_ICD_IDLE_MODE_DURATION_SEC
+#define CHIP_CONFIG_ICD_IDLE_MODE_DURATION_SEC NXP_IDLE_MODE_DURATION_SEC
+#endif // CHIP_CONFIG_ICD_IDLE_MODE_DURATION_SEC
+
+#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_DURATION_MS
+#define CHIP_CONFIG_ICD_ACTIVE_MODE_DURATION_MS NXP_ACTIVE_MODE_DURATION_MS
+#endif // CHIP_CONFIG_ICD_ACTIVE_MODE_DURATION_MS
+
+#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS
+#define CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS NXP_ACTIVE_MODE_THRESHOLD
+#endif // CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS
+
+#ifndef CHIP_CONFIG_ICD_CLIENTS_SUPPORTED_PER_FABRIC
+#define CHIP_CONFIG_ICD_CLIENTS_SUPPORTED_PER_FABRIC NXP_ICD_SUPPORTED_CLIENTS_PER_FABRIC
+#endif // CHIP_CONFIG_ICD_CLIENTS_SUPPORTED_PER_FABRIC
+
+#ifndef CHIP_CONFIG_SYNCHRONOUS_REPORTS_ENABLED
+#define CHIP_CONFIG_SYNCHRONOUS_REPORTS_ENABLED 1
+#endif
+#endif // NXP_ICD_ENABLED
+
 // ==================== Other Configuration Overrides ====================
 
 #ifndef CHIP_CONFIG_RMP_DEFAULT_MAX_RETRANS

src/platform/nxp/common/ConfigurationManagerImpl.cpp

@@ -33,6 +33,10 @@
 
 #include "fsl_device_registers.h"
 
+#if CONFIG_BOOT_REASON_SDK_SUPPORT
+#include "fsl_power.h"
+#endif
+
 #if CONFIG_CHIP_PLAT_LOAD_REAL_FACTORY_DATA
 #include "FactoryDataProvider.h"
 #endif
@@ -54,12 +58,61 @@ ConfigurationManagerImpl & ConfigurationManagerImpl::GetDefaultInstance()
     return sInstance;
 }
 
+#if CONFIG_BOOT_REASON_SDK_SUPPORT
+CHIP_ERROR ConfigurationManagerImpl::DetermineBootReason(uint8_t rebootCause)
+{
+    /*
+    With current implementation kBrownOutReset couldn't be catched
+    */
+    BootReasonType bootReason = BootReasonType::kUnspecified;
+
+    if (rebootCause == 0)
+    {
+        bootReason = BootReasonType::kPowerOnReboot;
+    }
+
+    else if (rebootCause == kPOWER_ResetCauseWdt)
+    {
+        /* Reboot can be due to hardware or software watchdog */
+        bootReason = BootReasonType::kHardwareWatchdogReset;
+    }
+    else if (rebootCause == kPOWER_ResetCauseSysResetReq)
+    {
+        /*
+        kConfigKey_SoftwareUpdateCompleted not supported for now
+        if (NXPConfig::ConfigValueExists(NXPConfig::kConfigKey_SoftwareUpdateCompleted))
+        {
+            bootReason = BootReasonType::kSoftwareUpdateCompleted;
+        }
+        else
+        {
+            bootReason = BootReasonType::kSoftwareReset;
+        }
+        */
+        bootReason = BootReasonType::kSoftwareReset;
+    }
+
+    return StoreBootReason(to_underlying(bootReason));
+}
+#endif
+
+CHIP_ERROR ConfigurationManagerImpl::StoreSoftwareUpdateCompleted()
+{
+    /* Empty implementation*/
+    return CHIP_NO_ERROR;
+}
+
 CHIP_ERROR ConfigurationManagerImpl::Init()
 {
     CHIP_ERROR err;
     uint32_t rebootCount = 0;
     bool failSafeArmed;
 
+#if CONFIG_BOOT_REASON_SDK_SUPPORT
+    uint8_t rebootCause = POWER_GetResetCause();
+    POWER_ClearResetCause(rebootCause);
+#endif
+
     // Initialize the generic implementation base class.
     err = Internal::GenericConfigurationManagerImpl<NXPConfig>::Init();
     SuccessOrExit(err);
@@ -84,12 +137,15 @@ CHIP_ERROR ConfigurationManagerImpl::Init()
         err = StoreTotalOperationalHours(0);
         SuccessOrExit(err);
     }
-
+#if CONFIG_BOOT_REASON_SDK_SUPPORT
+    SuccessOrExit(err = DetermineBootReason(rebootCause));
+#else
     if (!NXPConfig::ConfigValueExists(NXPConfig::kCounterKey_BootReason))
     {
         err = StoreBootReason(to_underlying(BootReasonType::kUnspecified));
         SuccessOrExit(err);
     }
+#endif
 
     // TODO: Initialize the global GroupKeyStore object here
 

src/platform/nxp/common/ConfigurationManagerImpl.h

@@ -39,6 +39,7 @@ class ConfigurationManagerImpl final : public Internal::GenericConfigurationMana
 public:
     // This returns an instance of this class.
     static ConfigurationManagerImpl & GetDefaultInstance();
+    CHIP_ERROR StoreSoftwareUpdateCompleted();
 
 private:
     // ===== Members that implement the ConfigurationManager public interface.
@@ -78,6 +79,9 @@ class ConfigurationManagerImpl final : public Internal::GenericConfigurationMana
     // ===== Private members reserved for use by this class only.
 
     static void DoFactoryReset(intptr_t arg);
+#if CONFIG_BOOT_REASON_SDK_SUPPORT
+    CHIP_ERROR DetermineBootReason(uint8_t rebootCause);
+#endif
 };
 
 /**

src/platform/nxp/common/ConnectivityManagerImpl.cpp

@@ -32,10 +32,12 @@
 #include <platform/internal/GenericConnectivityManagerImpl_TCP.ipp>
 #endif
 
+#if CHIP_SYSTEM_CONFIG_USE_LWIP
 #include <lwip/dns.h>
 #include <lwip/ip_addr.h>
 #include <lwip/nd6.h>
 #include <lwip/netif.h>
+#endif
 
 #if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
 #include <platform/internal/GenericConnectivityManagerImpl_BLE.ipp>

src/platform/nxp/common/DiagnosticDataProviderImpl.cpp

@@ -29,7 +29,10 @@
 #include <platform/DiagnosticDataProvider.h>
 
 #include <inet/InetInterface.h>
+
+#if CHIP_SYSTEM_CONFIG_USE_LWIP
 #include <lwip/tcpip.h>
+#endif
 
 #if CHIP_DEVICE_CONFIG_ENABLE_WPA
 extern "C" {

src/platform/nxp/common/ThreadStackManagerImpl.cpp

@@ -20,8 +20,7 @@
 /**
  *    @file
  *          Provides an implementation of the ThreadStackManager object for
- *          NXP platforms using the NXP SDK and the OpenThread
- *          stack.
+ *          NXP platforms using the NXP SDK and the OpenThread stack.
  *
  */
 
@@ -32,7 +31,11 @@
 #include <platform/ThreadStackManager.h>
 
 #include <platform/FreeRTOS/GenericThreadStackManagerImpl_FreeRTOS.hpp>
+#if CHIP_SYSTEM_CONFIG_USE_LWIP
 #include <platform/OpenThread/GenericThreadStackManagerImpl_OpenThread_LwIP.cpp>
+#else
+#include <platform/OpenThread/GenericThreadStackManagerImpl_OpenThread.hpp>
+#endif
 
 #include <lib/support/CHIPPlatformMemory.h>
 
@@ -59,21 +62,44 @@ CHIP_ERROR ThreadStackManagerImpl::_InitThreadStack(void)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
+#if CHIP_DEVICE_CONFIG_INIT_OT_PLAT_ALARM
     /* Initialize the OpenThread Alarm module to make sure that if calling otInstance,
      * it can schedule events
      */
     otPlatAlarmInit();
+#endif
 
     // Initialize the generic implementation base classes.
     err = GenericThreadStackManagerImpl_FreeRTOS<ThreadStackManagerImpl>::DoInit();
     SuccessOrExit(err);
+#if CHIP_SYSTEM_CONFIG_USE_LWIP
     err = GenericThreadStackManagerImpl_OpenThread_LwIP<ThreadStackManagerImpl>::DoInit(NULL);
+#else
+    err = GenericThreadStackManagerImpl_OpenThread<ThreadStackManagerImpl>::DoInit(NULL);
+#endif
     SuccessOrExit(err);
 
 exit:
     return err;
 }
 
+#if CHIP_DEVICE_CONFIG_PROCESS_BLE_IN_THREAD
+void ThreadStackManagerImpl::ProcessThreadActivity()
+{
+    /* reuse thread task for ble processing.
+     * by doing this, we avoid allocating a new stack for short-lived
+     * BLE processing (e.g.: only during Matter commissioning)
+     */
+#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
+    auto * bleManager = &chip::DeviceLayer::Internal::BLEMgrImpl();
+    bleManager->DoBleProcessing();
+#endif
+
+    otTaskletsProcess(OTInstance());
+    otSysProcessDrivers(OTInstance());
+}
+#endif
+
 bool ThreadStackManagerImpl::IsInitialized()
 {
     return sInstance.mThreadStackLock != NULL;
@@ -112,3 +138,8 @@ extern "C" void otPlatFree(void * aPtr)
 {
     return CHIPPlatformMemoryFree(aPtr);
 }
+
+extern "C" void * otPlatRealloc(void * p, size_t aSize)
+{
+    return CHIPPlatformMemoryRealloc(p, aSize);
+}