[Silabs] Continue Migration to CMSIS OS2 api (#32901)

* Migrate pw rpc support to cmsis os api

* Migration efr32 uart.cpp to cmsis os

examples/common/pigweed/efr32/PigweedLoggerMutex.h

@@ -20,8 +20,7 @@
 
 #include "PigweedLogger.h"
 #include "pigweed/RpcService.h"
-#include "semphr.h"
-#include <FreeRTOS.h>
+#include <cmsis_os2.h>
 
 namespace chip {
 namespace rpc {
@@ -32,18 +31,18 @@ class PigweedLoggerMutex : public ::chip::rpc::Mutex
  PigweedLoggerMutex() {}
  void Lock() override
  {
- SemaphoreHandle_t * sem = PigweedLogger::GetSemaphore();
+ osMutexId_t * sem = PigweedLogger::GetMutex();
  if (sem)
  {
- xSemaphoreTake(*sem, portMAX_DELAY);
+ osMutexAcquire(*sem, osWaitForever);
  }
  }
  void Unlock() override
  {
- SemaphoreHandle_t * sem = PigweedLogger::GetSemaphore();
+ osMutexId_t * sem = PigweedLogger::GetMutex();
  if (sem)
  {
- xSemaphoreGive(*sem);
+ osMutexRelease(*sem);
  }
  }
 };

examples/platform/silabs/PigweedLogger.cpp

@@ -24,16 +24,13 @@
  * needs to use HDLC/UART for another purpose like the RPC server.
  */
 
-#include <FreeRTOS.h>
-
-#include "semphr.h"
-#include <pw_hdlc/encoder.h>
-#include <pw_stream/sys_io_stream.h>
-#include <pw_sys_io_efr32/init.h>
-
+#include "PigweedLogger.h"
 #include "pw_span/span.h"
 #include <cassert>
 #include <cstdint>
+#include <pw_hdlc/encoder.h>
+#include <pw_stream/sys_io_stream.h>
+#include <pw_sys_io_efr32/init.h>
 #include <string_view>
 
 namespace PigweedLogger {
@@ -44,7 +41,7 @@ constexpr size_t kWriteBufferSize = 128; // Buffer for constructing HDLC frames
 
 // Exclusive access to the backend is needed to make sure that log messages coming
 // from different threads are not interwoven.
-SemaphoreHandle_t sLoggerLock;
+osMutexId_t sLoggerLock;
 
 static pw::stream::SysIoWriter sWriter;
 static size_t sWriteBufferPos;
@@ -60,15 +57,15 @@ static void send(void)
 
 void init(void)
 {
- sLoggerLock = xSemaphoreCreateMutex();
+ sLoggerLock = osMutexNew(nullptr);
  assert(sLoggerLock != NULL);
 
  pw_sys_io_Init();
 }
 
 int putString(const char * buffer, size_t size)
 {
- xSemaphoreTake(sLoggerLock, portMAX_DELAY);
+ osMutexAcquire(sLoggerLock, osWaitForever);
  assert(sWriteBufferPos < kWriteBufferSize);
 
  for (size_t i = 0; i < size; ++i)
@@ -90,11 +87,11 @@ int putString(const char * buffer, size_t size)
  send();
  }
 
- xSemaphoreGive(sLoggerLock);
+ osMutexRelease(sLoggerLock);
  return size;
 }
 
-SemaphoreHandle_t * GetSemaphore()
+osMutexId_t * GetMutex()
 {
  return &sLoggerLock;
 }

examples/platform/silabs/PigweedLogger.h

@@ -17,15 +17,13 @@
 
 #pragma once
 
-#include <FreeRTOS.h>
-
-#include "semphr.h"
+#include <cmsis_os2.h>
 #include <cstdint>
 
 namespace PigweedLogger {
 
 void init(void);
 int putString(const char * buffer, size_t size);
-SemaphoreHandle_t * GetSemaphore();
+osMutexId_t * GetMutex();
 
 } // namespace PigweedLogger

examples/platform/silabs/Rpc.cpp

@@ -17,11 +17,11 @@
  */
 
 #include "AppTask.h"
-#include "FreeRTOS.h"
 #include "PigweedLoggerMutex.h"
 #include "pigweed/RpcService.h"
 #include "pw_sys_io_efr32/init.h"
-#include "task.h"
+#include <cmsis_os2.h>
+#include <sl_cmsis_os2_common.h>
 
 #if defined(PW_RPC_ATTRIBUTE_SERVICE) && PW_RPC_ATTRIBUTE_SERVICE
 #include "pigweed/rpc_services/Attributes.h"
@@ -94,7 +94,7 @@ class Efr32Device final : public Device
 public:
  pw::Status Reboot(const chip_rpc_RebootRequest & request, pw_protobuf_Empty & response) override
  {
- TickType_t delayMs = kRebootTimerPeriodMs;
+ uint32_t delayMs = kRebootTimerPeriodMs;
  if (request.delay_ms != 0)
  {
  delayMs = request.delay_ms;
@@ -104,27 +104,36 @@ class Efr32Device final : public Device
  ChipLogProgress(NotSpecified, "Did not receive a reboot delay. Defaulting to %d ms",
  static_cast<int>(kRebootTimerPeriodMs));
  }
- mRebootTimer = xTimerCreateStatic("Reboot", pdMS_TO_TICKS(delayMs), false, nullptr, RebootHandler, &mRebootTimerBuffer);
- xTimerStart(mRebootTimer, 0);
+
+ mRebootTimer = osTimerNew(RebootHandler, osTimerOnce, nullptr, &mRebootTimerAttr);
+ uint32_t delayTicks = ((uint64_t) osKernelGetTickFreq() * delayMs) / 1000;
+ osTimerStart(mRebootTimer, delayTicks);
  return pw::OkStatus();
  }
 
 private:
  static constexpr uint32_t kRebootTimerPeriodMs = 1000;
- TimerHandle_t mRebootTimer;
- StaticTimer_t mRebootTimerBuffer;
+ osTimerId_t mRebootTimer;
+ osTimer_t mRebootTimerBuffer;
+ osTimerAttr_t mRebootTimerAttr = { .name = "Reboot", .cb_mem = &mRebootTimerBuffer, .cb_size = osTimerCbSize };
 
- static void RebootHandler(TimerHandle_t) { NVIC_SystemReset(); }
+ static void RebootHandler(void * timerCbArg) { NVIC_SystemReset(); }
 };
 #endif // defined(PW_RPC_DEVICE_SERVICE) && PW_RPC_DEVICE_SERVICE
 
 namespace {
 
-#define RPC_TASK_STACK_SIZE 4096
-#define RPC_TASK_PRIORITY 1
-static TaskHandle_t sRpcTaskHandle;
-StaticTask_t sRpcTaskBuffer;
-StackType_t sRpcTaskStack[RPC_TASK_STACK_SIZE];
+static osThreadId_t sRpcTaskHandle;
+osThread_t sRpcTaskControlBlock;
+constexpr uint32_t kRpcTaskSize = 4096;
+uint8_t sRpcTaskStack[kRpcTaskSize];
+constexpr osThreadAttr_t kRpcTaskAttr = { .name = "RPC",
+ .attr_bits = osThreadDetached,
+ .cb_mem = &sRpcTaskControlBlock,
+ .cb_size = osThreadCbSize,
+ .stack_mem = sRpcTaskStack,
+ .stack_size = kRpcTaskSize,
+ .priority = osPriorityLow };
 
 #if defined(PW_RPC_ATTRIBUTE_SERVICE) && PW_RPC_ATTRIBUTE_SERVICE
 Attributes attributes_service;
@@ -214,8 +223,7 @@ void Init()
  pw_sys_io_Init();
 
  // Start App task.
- sRpcTaskHandle = xTaskCreateStatic(RunRpcService, "RPC_TASK", ArraySize(sRpcTaskStack), nullptr, RPC_TASK_PRIORITY,
- sRpcTaskStack, &sRpcTaskBuffer);
+ sRpcTaskHandle = osThreadNew(RunRpcService, nullptr, &kRpcTaskAttr);
 }
 
 } // namespace rpc

examples/platform/silabs/efr32/uart.cpp

@@ -16,11 +16,9 @@
  * limitations under the License.
  */
 #include "AppConfig.h"
-#include "FreeRTOS.h"
-#include "event_groups.h"
 #include "matter_shell.h"
-#include "semphr.h"
-#include "task.h"
+#include <cmsis_os2.h>
+#include <sl_cmsis_os2_common.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -108,28 +106,39 @@ static uint16_t lastCount; // Nb of bytes already processed from the active dmaB
 #else
 #define UART_MAX_QUEUE_SIZE 25
 #endif
-#define UART_TASK_SIZE 256
-#define UART_TASK_NAME "UART"
 
 #ifdef CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE
 #define UART_TX_MAX_BUF_LEN (CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE + 2) // \r\n
 #else
 #define UART_TX_MAX_BUF_LEN (258)
 #endif
 
-static TaskHandle_t sUartTaskHandle;
-static StackType_t uartStack[UART_TASK_SIZE * sizeof(StackType_t)];
-static StaticTask_t uartTaskStruct;
+static constexpr uint32_t kUartTxCompleteFlag = 1;
+static osThreadId_t sUartTaskHandle;
+constexpr uint32_t kUartTaskSize = 1024;
+static uint8_t uartStack[kUartTaskSize];
+static osThread_t sUartTaskControlBlock;
+constexpr osThreadAttr_t kUartTaskAttr = { .name = "UART",
+ .attr_bits = osThreadDetached,
+ .cb_mem = &sUartTaskControlBlock,
+ .cb_size = osThreadCbSize,
+ .stack_mem = uartStack,
+ .stack_size = kUartTaskSize,
+ .priority = osPriorityRealtime };
 
 typedef struct
 {
  uint8_t data[UART_TX_MAX_BUF_LEN];
  uint16_t length = 0;
 } UartTxStruct_t;
 
+static osMessageQueueId_t sUartTxQueue;
+static osMessageQueue_t sUartTxQueueStruct;
 uint8_t sUartTxQueueBuffer[UART_MAX_QUEUE_SIZE * sizeof(UartTxStruct_t)];
-static StaticQueue_t sUartTxQueueStruct;
-static QueueHandle_t sUartTxQueue;
+constexpr osMessageQueueAttr_t kUartTxQueueAttr = { .cb_mem = &sUartTxQueueStruct,
+ .cb_size = osMessageQueueCbSize,
+ .mq_mem = sUartTxQueueBuffer,
+ .mq_size = sizeof(sUartTxQueueBuffer) };
 
 // Rx buffer for the receive Fifo
 static uint8_t sRxFifoBuffer[MAX_BUFFER_SIZE];
@@ -264,8 +273,8 @@ void uartConsoleInit(void)
  UARTDRV_Receive(vcom_handle, sRxDmaBuffer, MAX_DMA_BUFFER_SIZE, UART_rx_callback);
  UARTDRV_Receive(vcom_handle, sRxDmaBuffer2, MAX_DMA_BUFFER_SIZE, UART_rx_callback);
 
- sUartTxQueue = xQueueCreateStatic(UART_MAX_QUEUE_SIZE, sizeof(UartTxStruct_t), sUartTxQueueBuffer, &sUartTxQueueStruct);
- sUartTaskHandle = xTaskCreateStatic(uartMainLoop, UART_TASK_NAME, UART_TASK_SIZE, nullptr, 30, uartStack, &uartTaskStruct);
+ sUartTxQueue = osMessageQueueNew(UART_MAX_QUEUE_SIZE, sizeof(UartTxStruct_t), &kUartTxQueueAttr);
+ sUartTaskHandle = osThreadNew(uartMainLoop, nullptr, &kUartTaskAttr);
 
  assert(sUartTaskHandle);
  assert(sUartTxQueue);
@@ -311,9 +320,8 @@ void USART_IRQHandler(void)
  */
 void UART_tx_callback(struct UARTDRV_HandleData * handle, Ecode_t transferStatus, uint8_t * data, UARTDRV_Count_t transferCount)
 {
- BaseType_t xHigherPriorityTaskWoken;
-
- vTaskNotifyGiveFromISR(sUartTaskHandle, &xHigherPriorityTaskWoken) portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
+ // This function may be called from Interrupt Service Routines.
+ osThreadFlagsSet(sUartTaskHandle, kUartTxCompleteFlag);
 }
 
 /*
@@ -363,20 +371,10 @@ int16_t uartConsoleWrite(const char * Buf, uint16_t BufLength)
  memcpy(workBuffer.data, Buf, BufLength);
  workBuffer.length = BufLength;
 
- if (xPortIsInsideInterrupt())
+ if (osMessageQueuePut(sUartTxQueue, &workBuffer, osPriorityNormal, 0) == osOK)
  {
- BaseType_t xHigherPriorityTaskWoken;
- xQueueSendFromISR(sUartTxQueue, &workBuffer, &xHigherPriorityTaskWoken);
- portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
  return BufLength;
  }
- else
- {
- if (pdTRUE == xQueueSend(sUartTxQueue, &workBuffer, portMAX_DELAY))
- {
- return BufLength;
- }
- }
 
  return UART_CONSOLE_ERR;
 }
@@ -400,20 +398,10 @@ int16_t uartLogWrite(const char * log, uint16_t length)
  memcpy(workBuffer.data + length, "\r\n", 2);
  workBuffer.length = length + 2;
 
- if (xPortIsInsideInterrupt())
+ if (osMessageQueuePut(sUartTxQueue, &workBuffer, osPriorityNormal, 0) == osOK)
  {
- BaseType_t xHigherPriorityTaskWoken;
- xQueueSendFromISR(sUartTxQueue, &workBuffer, &xHigherPriorityTaskWoken);
- portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
  return length;
  }
- else
- {
- if (pdTRUE == xQueueSend(sUartTxQueue, &workBuffer, 0))
- {
- return length;
- }
- }
 
  return UART_CONSOLE_ERR;
 }
@@ -453,11 +441,11 @@ void uartMainLoop(void * args)
  while (1)
  {
 
- BaseType_t eventReceived = xQueueReceive(sUartTxQueue, &workBuffer, portMAX_DELAY);
+ osStatus_t eventReceived = osMessageQueueGet(sUartTxQueue, &workBuffer, nullptr, osWaitForever);
  while (eventReceived == pdTRUE)
  {
  uartSendBytes(workBuffer.data, workBuffer.length);
- eventReceived = xQueueReceive(sUartTxQueue, &workBuffer, 0);
+ eventReceived = osMessageQueueGet(sUartTxQueue, &workBuffer, nullptr, 0);
  }
  }
 }
@@ -470,29 +458,31 @@ void uartMainLoop(void * args)
  */
 void uartSendBytes(uint8_t * buffer, uint16_t nbOfBytes)
 {
-
 #if defined(SL_CATALOG_POWER_MANAGER_PRESENT)
  sl_power_manager_add_em_requirement(SL_POWER_MANAGER_EM1);
-#endif
+#endif // SL_CATALOG_POWER_MANAGER_PRESENT
+
 #if SL_UARTCTRL_MUX
  sl_wfx_host_pre_uart_transfer();
 #endif // SL_UARTCTRL_MUX
+
 #if (defined(EFR32MG24) && defined(WF200_WIFI))
  // Blocking transmit for the MG24 + WF200 since UART TX is multiplexed with
  // WF200 SPI IRQ
  UARTDRV_ForceTransmit(vcom_handle, (uint8_t *) buffer, nbOfBytes);
 #else
  // Non Blocking Transmit
  UARTDRV_Transmit(vcom_handle, (uint8_t *) buffer, nbOfBytes, UART_tx_callback);
- ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+ osThreadFlagsWait(kUartTxCompleteFlag, osFlagsWaitAny, osWaitForever);
 #endif /* EFR32MG24 && WF200_WIFI */
+
 #if SL_UARTCTRL_MUX
  sl_wfx_host_post_uart_transfer();
 #endif // SL_UARTCTRL_MUX
 
 #if defined(SL_CATALOG_POWER_MANAGER_PRESENT)
  sl_power_manager_remove_em_requirement(SL_POWER_MANAGER_EM1);
-#endif
+#endif // SL_CATALOG_POWER_MANAGER_PRESENT
 }
 
 #ifdef __cplusplus