[Infineon] Implement event-based Thread stack task for CYW30739. (#25796

)

* [Infineon] Implement event-based Thread stack task for CYW30739.

* Add EventFlags for platform-specific wrappers of event flags.
* Implement otTaskletsSignalPending and otSysEventSignalPending callback
  functions for the OpenThread stack to notify the Thread stack task if
  there are pending events to be processed.
* Update CYW30739 SDK and ot-ifx submodules for the event-based implementations.
* Use the default value of CHIP_DEVICE_CONFIG_EVENT_LOGGING_CRIT_BUFFER_SIZE.
* Disable OTA of lighting and lock apps because CYW30739 is running out of flash.

* Enable OTA and disable FTD for the flash space.

* Fix the documents.

examples/lighting-app/infineon/cyw30739/args.gni

@@ -18,7 +18,7 @@ import("${chip_root}/src/platform/Infineon/CYW30739/args.gni")
 
 cyw30739_sdk_target = get_label_info(":sdk", "label_no_toolchain")
 
-chip_openthread_ftd = true
+chip_openthread_ftd = false
 
 chip_enable_ota_requestor = true
 

examples/lock-app/infineon/cyw30739/args.gni

@@ -18,7 +18,7 @@ import("${chip_root}/src/platform/Infineon/CYW30739/args.gni")
 
 cyw30739_sdk_target = get_label_info(":sdk", "label_no_toolchain")
 
-chip_openthread_ftd = true
+chip_openthread_ftd = false
 
 chip_enable_ota_requestor = true
 

src/platform/Infineon/CYW30739/BUILD.gn

@@ -39,6 +39,8 @@ static_library("CYW30739") {
  "ConnectivityManagerImpl.h",
  "DiagnosticDataProviderImpl.cpp",
  "DiagnosticDataProviderImpl.h",
+ "EventFlags.cpp",
+ "EventFlags.h",
  "FactoryDataProvider.cpp",
  "FactoryDataProvider.h",
  "InetPlatformConfig.h",

src/platform/Infineon/CYW30739/CHIPDevicePlatformConfig.h

@@ -63,6 +63,5 @@
 // -------------------- Network Telemetry Configuration --------------------
 
 // -------------------- Event Logging Configuration --------------------
-#define CHIP_DEVICE_CONFIG_EVENT_LOGGING_CRIT_BUFFER_SIZE 256
 
 // -------------------- Software Update Manager Configuration --------------------

src/platform/Infineon/CYW30739/EventFlags.cpp

@@ -0,0 +1,72 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ * Copyright (c) 2019 Nest Labs, Inc.
+ *
+ * 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
+ * Provides a class that serves as a wrapper for the event system of CYW30739
+ * platform's underlying RTOS. An event instance is comprised of 32 flags.
+ * Each flag can be utilized for thread synchronization purposes.
+ */
+#include "EventFlags.h"
+
+#include <lib/support/CodeUtils.h>
+
+namespace chip {
+namespace DeviceLayer {
+
+CHIP_ERROR EventFlags::Init(void)
+{
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ wiced_result_t result;
+
+ mFlags = wiced_rtos_create_event_flags();
+ VerifyOrExit(mFlags != nullptr, err = CHIP_ERROR_NO_MEMORY);
+
+ result = wiced_rtos_init_event_flags(mFlags);
+ VerifyOrExit(result == WICED_SUCCESS, err = CHIP_ERROR_NO_MEMORY);
+
+exit:
+ return err;
+}
+
+CHIP_ERROR EventFlags::Set(uint32_t flags)
+{
+ assert(!wiced_rtos_check_for_stack_overflow());
+
+ if (wiced_rtos_set_event_flags(mFlags, flags) != WICED_SUCCESS)
+ {
+ ChipLogError(DeviceLayer, "wiced_rtos_set_event_flags %08lx", flags);
+ return CHIP_ERROR_INTERNAL;
+ }
+ return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR EventFlags::WaitAnyForever(uint32_t & flags)
+{
+ const wiced_result_t result =
+ wiced_rtos_wait_for_event_flags(mFlags, 0xffffffff, &flags, WICED_TRUE, WAIT_FOR_ANY_EVENT, WICED_WAIT_FOREVER);
+ if (result != WICED_SUCCESS)
+ {
+ ChipLogError(DeviceLayer, "wiced_rtos_wait_for_event_flags 0x%08x", result);
+ return CHIP_ERROR_INTERNAL;
+ }
+ return CHIP_NO_ERROR;
+}
+
+} // namespace DeviceLayer
+} // namespace chip

src/platform/Infineon/CYW30739/EventFlags.h

@@ -0,0 +1,49 @@
+/*
+ *
+ * Copyright (c) 2022 Project CHIP Authors
+ * Copyright (c) 2019 Nest Labs, Inc.
+ *
+ * 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
+ * Provides a class that serves as a wrapper for the event system of CYW30739
+ * platform's underlying RTOS. An event instance is comprised of 32 flags.
+ * Each flag can be utilized for thread synchronization purposes.
+ */
+
+#pragma once
+
+#include <lib/core/CHIPError.h>
+#include <wiced_rtos.h>
+
+namespace chip {
+namespace DeviceLayer {
+
+/**
+ * A class represents an event group with 32 flags.
+ */
+class EventFlags
+{
+public:
+ CHIP_ERROR Init(void);
+ CHIP_ERROR Set(uint32_t flags);
+ CHIP_ERROR WaitAnyForever(uint32_t & flags);
+
+private:
+ wiced_event_flags_t * mFlags;
+};
+
+} // namespace DeviceLayer
+} // namespace chip

src/platform/Infineon/CYW30739/PlatformManagerImpl.cpp

@@ -50,11 +50,8 @@ CHIP_ERROR PlatformManagerImpl::_InitChipStack(void)
  VerifyOrExit(mThread != nullptr, err = CHIP_ERROR_NO_MEMORY);
 
  /* Initialize the event flags. */
- mEventFlags = wiced_rtos_create_event_flags();
- VerifyOrExit(mEventFlags != nullptr, err = CHIP_ERROR_NO_MEMORY);
+ ReturnErrorOnFailure(mEventFlags.Init());
 
- result = wiced_rtos_init_event_flags(mEventFlags);
- VerifyOrExit(result == WICED_SUCCESS, err = CHIP_ERROR_NO_MEMORY);
  /* Initialize the event queue. */
  mEventQueue = wiced_rtos_create_queue();
  VerifyOrExit(mEventQueue != nullptr, err = CHIP_ERROR_NO_MEMORY);
@@ -87,12 +84,9 @@ void PlatformManagerImpl::_RunEventLoop(void)
 
  while (true)
  {
- uint32_t flags_set = 0;
- const wiced_result_t result = wiced_rtos_wait_for_event_flags(mEventFlags, 0xffffffff, &flags_set, WICED_TRUE,
- WAIT_FOR_ANY_EVENT, WICED_WAIT_FOREVER);
- if (result != WICED_SUCCESS)
+ uint32_t flags_set = 0;
+ if (mEventFlags.WaitAnyForever(flags_set) != CHIP_NO_ERROR)
  {
- ChipLogError(DeviceLayer, "wiced_rtos_wait_for_event_flags 0x%08x", result);
  continue;
  }
 
@@ -147,7 +141,7 @@ CHIP_ERROR PlatformManagerImpl::_PostEvent(const ChipDeviceEvent * event)
  return CHIP_ERROR_INTERNAL;
  }
 
- SetEventFlags(kPostEventFlag);
+ mEventFlags.Set(kPostEventFlag);
 
  return CHIP_NO_ERROR;
 }
@@ -172,16 +166,6 @@ CHIP_ERROR PlatformManagerImpl::_StartChipTimer(System::Clock::Timeout durationM
 
 void PlatformManagerImpl::_Shutdown() {}
 
-void PlatformManagerImpl::SetEventFlags(uint32_t flags)
-{
- assert(!wiced_rtos_check_for_stack_overflow());
-
- if (wiced_rtos_set_event_flags(mEventFlags, flags) != WICED_SUCCESS)
- {
- ChipLogError(DeviceLayer, "%s wiced_rtos_set_event_flags %08lx", __func__, flags);
- }
-}
-
 void PlatformManagerImpl::HandleTimerEvent(void)
 {
  const CHIP_ERROR err = static_cast<System::LayerImplFreeRTOS &>(DeviceLayer::SystemLayer()).HandlePlatformTimer();
@@ -217,7 +201,7 @@ void PlatformManagerImpl::HandlePostEvent(void)
  /* Set another application thread event if the event queue is not empty. */
  if (!wiced_rtos_is_queue_empty(mEventQueue))
  {
- SetEventFlags(kPostEventFlag);
+ mEventFlags.Set(kPostEventFlag);
  }
 }
 
@@ -229,7 +213,7 @@ void PlatformManagerImpl::EventLoopTaskMain(uint32_t arg)
 
 void PlatformManagerImpl::TimerCallback(WICED_TIMER_PARAM_TYPE params)
 {
- PlatformMgrImpl().SetEventFlags(kTimerEventFlag);
+ PlatformMgrImpl().mEventFlags.Set(kTimerEventFlag);
 }
 
 int PlatformManagerImpl::GetEntropy(void * data, unsigned char * output, size_t len, size_t * olen)

src/platform/Infineon/CYW30739/PlatformManagerImpl.h

@@ -26,7 +26,8 @@
 
 #include <hal/wiced_timer.h>
 #include <platform/internal/GenericPlatformManagerImpl.h>
-#include <wiced_rtos.h>
+
+#include "EventFlags.h"
 
 namespace chip {
 namespace DeviceLayer {
@@ -57,7 +58,6 @@ class PlatformManagerImpl final : public PlatformManager, public Internal::Gener
  CHIP_ERROR _StartChipTimer(System::Clock::Timeout durationMS);
  void _Shutdown(void);
 
- void SetEventFlags(uint32_t flags);
  void HandleTimerEvent(void);
  void HandlePostEvent(void);
 
@@ -67,7 +67,7 @@ class PlatformManagerImpl final : public PlatformManager, public Internal::Gener
  friend PlatformManagerImpl & PlatformMgrImpl(void);
 
  wiced_thread_t * mThread;
- wiced_event_flags_t * mEventFlags;
+ EventFlags mEventFlags;
  wiced_queue_t * mEventQueue;
  wiced_timer_t mTimer;
  wiced_mutex_t * mMutex;

src/platform/Infineon/CYW30739/ThreadStackManagerImpl.cpp

@@ -45,6 +45,8 @@ CHIP_ERROR ThreadStackManagerImpl::_InitThreadStack()
  mThread = wiced_rtos_create_thread();
  VerifyOrExit(mThread != nullptr, err = CHIP_ERROR_NO_MEMORY);
 
+ ReturnErrorOnFailure(mEventFlags.Init());
+
  mMutex = wiced_rtos_create_mutex();
  VerifyOrExit(mMutex != nullptr, err = CHIP_ERROR_NO_MEMORY);
 
@@ -58,6 +60,16 @@ CHIP_ERROR ThreadStackManagerImpl::_InitThreadStack()
  return err;
 }
 
+void ThreadStackManagerImpl::SignalThreadActivityPending()
+{
+ mEventFlags.Set(kActivityPendingEventFlag);
+}
+
+void ThreadStackManagerImpl::SignalThreadActivityPendingFromISR()
+{
+ mEventFlags.Set(kActivityPendingFromISREventFlag);
+}
+
 CHIP_ERROR ThreadStackManagerImpl::_StartThreadTask()
 {
  CHIP_ERROR err = CHIP_NO_ERROR;
@@ -87,6 +99,12 @@ void ThreadStackManagerImpl::ThreadTaskMain(void)
 {
  while (true)
  {
+ uint32_t flags = 0;
+ if (mEventFlags.WaitAnyForever(flags) != CHIP_NO_ERROR)
+ {
+ continue;
+ }
+
  LockThreadStack();
  ProcessThreadActivity();
  UnlockThreadStack();
@@ -102,6 +120,18 @@ void ThreadStackManagerImpl::ThreadTaskMain(uint32_t arg)
 } // namespace DeviceLayer
 } // namespace chip
 
+using namespace ::chip::DeviceLayer;
+
+extern "C" void otTaskletsSignalPending(otInstance * p_instance)
+{
+ ThreadStackMgrImpl().SignalThreadActivityPending();
+}
+
+extern "C" void otSysEventSignalPending(void)
+{
+ ThreadStackMgrImpl().SignalThreadActivityPendingFromISR();
+}
+
 extern "C" void * otPlatCAlloc(size_t aNum, size_t aSize)
 {
  return CHIPPlatformMemoryCalloc(aNum, aSize);

src/platform/Infineon/CYW30739/ThreadStackManagerImpl.h

@@ -26,7 +26,8 @@
 
 #include <platform/CHIPDeviceEvent.h>
 #include <platform/OpenThread/GenericThreadStackManagerImpl_OpenThread.h>
-#include <wiced_rtos.h>
+
+#include "EventFlags.h"
 
 namespace chip {
 namespace DeviceLayer {
@@ -45,6 +46,8 @@ class ThreadStackManagerImpl final : public ThreadStackManager,
  // ===== Methods that implement the ThreadStackManager abstract interface.
  CHIP_ERROR _InitThreadStack();
 
+ void SignalThreadActivityPending();
+ void SignalThreadActivityPendingFromISR();
  inline bool IsCurrentTask(void) { return wiced_rtos_is_current_thread(mThread) == WICED_SUCCESS; }
 
 protected:
@@ -55,18 +58,14 @@ class ThreadStackManagerImpl final : public ThreadStackManager,
  bool _TryLockThreadStack();
  void _UnlockThreadStack();
 
- // ===== Methods that override the GenericThreadStackManagerImpl_OpenThread abstract interface.
-
- void _OnCHIPoBLEAdvertisingStart();
- void _OnCHIPoBLEAdvertisingStop();
-
 private:
  // ===== Members for internal use by the following friends.
 
  friend ThreadStackManager & ::chip::DeviceLayer::ThreadStackMgr(void);
  friend ThreadStackManagerImpl & ::chip::DeviceLayer::ThreadStackMgrImpl(void);
 
  wiced_thread_t * mThread;
+ EventFlags mEventFlags;
  wiced_mutex_t * mMutex;
  static ThreadStackManagerImpl sInstance;
 
@@ -75,6 +74,8 @@ class ThreadStackManagerImpl final : public ThreadStackManager,
  void ThreadTaskMain(void);
 
  static void ThreadTaskMain(uint32_t arg);
+ static constexpr uint32_t kActivityPendingEventFlag = 1 << 0;
+ static constexpr uint32_t kActivityPendingFromISREventFlag = 1 << 1;
 };
 
 /**