Update codebase for CMSIS5/RTX5

Update all of mbed-os to use RTX5.

Author: bulislaw

TESTS/mbedmicro-rtos-mbed/mutex/main.cpp

@@ -142,7 +142,7 @@ void test_dual_thread_lock_lock_thread(Mutex *mutex)
     uint32_t start = us_ticker_read();
 
     osStatus stat = mutex->lock(TEST_HALF_SEC_MS);
-    TEST_ASSERT_EQUAL(stat, osEventTimeout);
+    TEST_ASSERT_EQUAL(stat, osErrorTimeout);
     TEST_ASSERT_UINT32_WITHIN(TEST_ONE_MS_US, TEST_HALF_SEC_US, us_ticker_read() - start);
 }
 

TESTS/mbedmicro-rtos-mbed/threads/main.cpp

@@ -61,11 +61,13 @@ void self_terminate(Thread *self) {
 // Tests that spawn tasks in different configurations
 template <void (*F)(counter_t *)>
 void test_single_thread() {
+    const char tname[] = "Single Thread";
     counter_t counter(0);
-    Thread thread(osPriorityNormal, THREAD_STACK_SIZE, NULL);
+    Thread thread(osPriorityNormal, THREAD_STACK_SIZE, NULL, tname);
     thread.start(callback(F, &counter));
     thread.join();
     TEST_ASSERT_EQUAL(counter, 1);
+    TEST_ASSERT_EQUAL(strcmp(tname, thread.get_name()), 0);
 }
 
 template <int N, void (*F)(counter_t *)>

events/equeue/equeue_platform.h

@@ -112,7 +112,7 @@ typedef struct equeue_sema {
     bool signal;
 } equeue_sema_t;
 #elif defined(EQUEUE_PLATFORM_MBED) && defined(MBED_CONF_RTOS_PRESENT)
-typedef unsigned equeue_sema_t[8];
+typedef unsigned equeue_sema_t[9];
 #elif defined(EQUEUE_PLATFORM_MBED)
 typedef volatile int equeue_sema_t;
 #endif

features/FEATURE_BLE/ble/services/iBeacon.h

@@ -16,7 +16,7 @@
 #ifndef __BLE_IBEACON_H__
 #define __BLE_IBEACON_H__
 
-#include "core_cmInstr.h"
+#include "cmsis_compiler.h"
 #include "ble/BLE.h"
 
 /**

features/FEATURE_COMMON_PAL/nanostack-hal-mbed-cmsis-rtos/arm_hal_interrupt.c

@@ -4,22 +4,30 @@
 
 #include "arm_hal_interrupt.h"
 #include "arm_hal_interrupt_private.h"
-#include "cmsis_os.h"
-
+#include "cmsis_os2.h"
+#include "mbed_rtos_storage.h"
+#include <mbed_assert.h>
 
 static uint8_t sys_irq_disable_counter;
 
-static osMutexDef(critical);
-static osMutexId critical_mutex_id;
+static mbed_rtos_storage_mutex_t critical_mutex;
+static const osMutexAttr_t critical_mutex_attr = {
+  .name = "critical_mutex",
+  .attr_bits = osMutexRecursive,
+  .cb_mem = &critical_mutex,
+  .cb_size = sizeof critical_mutex,
+};
+static osMutexId_t critical_mutex_id;
 
 void platform_critical_init(void)
 {
-    critical_mutex_id = osMutexCreate(osMutex(critical));
+    critical_mutex_id = osMutexNew(&critical_mutex_attr);
+    MBED_ASSERT(critical_mutex_id);
 }
 
 void platform_enter_critical(void)
 {
-    osMutexWait(critical_mutex_id, osWaitForever);
+    osMutexAcquire(critical_mutex_id, osWaitForever);
     sys_irq_disable_counter++;
 }
 

features/FEATURE_COMMON_PAL/nanostack-hal-mbed-cmsis-rtos/arm_hal_timer.cpp

@@ -4,24 +4,27 @@
 
 // Include before mbed.h to properly get UINT*_C()
 #include "ns_types.h"
-
-#include "cmsis_os.h"
 #include "mbed.h"
-
+#include "cmsis_os2.h"
+#include "rtx_os.h"
 #include "platform/arm_hal_timer.h"
 #include "platform/arm_hal_interrupt.h"
+#include <mbed_assert.h>
 
-static osThreadId timer_thread_id;
+static osThreadId_t timer_thread_id;
+static uint64_t timer_thread_stk[2048];
+static osRtxThread_t timer_thread_tcb;
 
 static Timer timer;
 static Timeout timeout;
 static uint32_t due;
 static void (*arm_hal_callback)(void);
 
-static void timer_thread(const void *)
+static void timer_thread(void *arg)
 {
+    (void)arg;
     for (;;) {
-        osSignalWait(1, osWaitForever);
+        osThreadFlagsWait(1, osFlagsWaitAny, osWaitForever);
         // !!! We don't do our own enter/exit critical - we rely on callback
         // doing it (ns_timer_interrupt_handler does)
         //platform_enter_critical();
@@ -33,8 +36,14 @@ static void timer_thread(const void *)
 // Called once at boot
 void platform_timer_enable(void)
 {
-    static osThreadDef(timer_thread, osPriorityRealtime, /*1,*/ 2*1024);
-    timer_thread_id = osThreadCreate(osThread(timer_thread), NULL);
+    static osThreadAttr_t timer_thread_attr = {0};
+    timer_thread_attr.stack_mem  = &timer_thread_stk[0];
+    timer_thread_attr.cb_mem  = &timer_thread_tcb;
+    timer_thread_attr.stack_size = sizeof(timer_thread_stk);
+    timer_thread_attr.cb_size = sizeof(timer_thread_tcb);
+    timer_thread_attr.priority = osPriorityRealtime;
+    timer_thread_id = osThreadNew(timer_thread, NULL, &timer_thread_attr);
+    MBED_ASSERT(timer_thread_id != NULL);
     timer.start();
 }
 
@@ -53,8 +62,7 @@ void platform_timer_set_cb(void (*new_fp)(void))
 static void timer_callback(void)
 {
     due = 0;
-    osSignalSet(timer_thread_id, 1);
-    //callback();
+    osThreadFlagsSet(timer_thread_id, 1);
 }
 
 // This is called from inside platform_enter_critical - IRQs can't happen

features/FEATURE_COMMON_PAL/nanostack-hal-mbed-cmsis-rtos/ns_event_loop.c

@@ -2,8 +2,10 @@
  * Copyright (c) 2016 ARM Limited, All Rights Reserved
  */
 
+#include <mbed_assert.h>
 #include "cmsis.h"
-#include "cmsis_os.h"
+#include "cmsis_os2.h"
+#include "mbed_rtos_storage.h"
 #include "ns_trace.h"
 
 #include "eventOS_scheduler.h"
@@ -12,21 +14,32 @@
 
 #define TRACE_GROUP "evlp"
 
-static void event_loop_thread(const void *arg);
-
-// 1K should be enough - it's what the SAM4E port uses...
-// What happened to the instances parameter?
-static osThreadDef(event_loop_thread, osPriorityNormal, /*1,*/ MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_THREAD_STACK_SIZE);
-static osMutexDef(event);
-
-static osThreadId event_thread_id;
-static osMutexId event_mutex_id;
-static osThreadId event_mutex_owner_id = NULL;
+static void event_loop_thread(void *arg);
+
+static uint64_t event_thread_stk[MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_THREAD_STACK_SIZE/8];
+static mbed_rtos_storage_thread_t event_thread_tcb;
+static const osThreadAttr_t event_thread_attr = {
+    .priority = osPriorityNormal,
+    .stack_mem = &event_thread_stk[0],
+    .stack_size = sizeof event_thread_stk,
+    .cb_mem = &event_thread_tcb,
+    .cb_size = sizeof event_thread_tcb,
+};
+static osThreadId_t event_thread_id;
+static mbed_rtos_storage_mutex_t event_mutex;
+static const osMutexAttr_t event_mutex_attr = {
+  .name = "event_mutex",
+  .attr_bits = osMutexRecursive,
+  .cb_mem = &event_mutex,
+  .cb_size = sizeof event_mutex,
+};
+static osMutexId_t event_mutex_id;
+static osThreadId_t event_mutex_owner_id = NULL;
 static uint32_t owner_count = 0;
 
 void eventOS_scheduler_mutex_wait(void)
 {
-    osMutexWait(event_mutex_id, osWaitForever);
+    osMutexAcquire(event_mutex_id, osWaitForever);
     if (0 == owner_count) {
         event_mutex_owner_id = osThreadGetId();
     }
@@ -52,37 +65,34 @@ void eventOS_scheduler_signal(void)
     // XXX why does signal set lock if called with irqs disabled?
     //__enable_irq();
     //tr_debug("signal %p", (void*)event_thread_id);
-    osSignalSet(event_thread_id, 1);
+    osThreadFlagsSet(event_thread_id, 1);
     //tr_debug("signalled %p", (void*)event_thread_id);
 }
 
 void eventOS_scheduler_idle(void)
 {
     //tr_debug("idle");
     eventOS_scheduler_mutex_release();
-    osSignalWait(1, osWaitForever);
+    osThreadFlagsWait(1, 0, osWaitForever);
     eventOS_scheduler_mutex_wait();
 }
 
-static void event_loop_thread(const void *arg)
+static void event_loop_thread(void *arg)
 {
-    //tr_debug("event_loop_thread create");
-    osSignalWait(2, osWaitForever);
-
+    (void)arg;
     eventOS_scheduler_mutex_wait();
-    tr_debug("event_loop_thread");
-
-    // Run does not return - it calls eventOS_scheduler_idle when it's, er, idle
-    eventOS_scheduler_run();
+    eventOS_scheduler_run(); //Does not return
 }
 
 void ns_event_loop_thread_create(void)
 {
-    event_mutex_id = osMutexCreate(osMutex(event));
-    event_thread_id = osThreadCreate(osThread(event_loop_thread), NULL);
+    event_mutex_id = osMutexNew(&event_mutex_attr);
+    MBED_ASSERT(event_mutex_id != NULL);
+
+    event_thread_id = osThreadNew(event_loop_thread, NULL, &event_thread_attr);
+    MBED_ASSERT(event_thread_id != NULL);
 }
 
 void ns_event_loop_thread_start(void)
 {
-    osSignalSet(event_thread_id, 2);
 }

features/FEATURE_LWIP/lwip-interface/lwip-eth/arch/TARGET_Freescale/k64f_emac.c

@@ -532,8 +532,8 @@ static err_t k64f_low_level_output(struct netif *netif, struct pbuf *p)
   }
 
   /* Check if a descriptor is available for the transfer. */
-  int32_t count = osSemaphoreWait(k64f_enet->xTXDCountSem.id, 0);
-  if (count < 1)
+  osStatus_t stat = osSemaphoreAcquire(k64f_enet->xTXDCountSem.id, 0);
+  if (stat != osOK)
     return ERR_BUF;
 
   /* Get exclusive access */
@@ -697,11 +697,10 @@ err_t eth_arch_enetif_init(struct netif *netif)
   netif->linkoutput = k64f_low_level_output;
 
   /* CMSIS-RTOS, start tasks */
-#ifdef CMSIS_OS_RTX
-  memset(k64f_enetdata.xTXDCountSem.data, 0, sizeof(k64f_enetdata.xTXDCountSem.data));
-  k64f_enetdata.xTXDCountSem.def.semaphore = k64f_enetdata.xTXDCountSem.data;
-#endif
-  k64f_enetdata.xTXDCountSem.id = osSemaphoreCreate(&k64f_enetdata.xTXDCountSem.def, ENET_TX_RING_LEN);
+  memset(&k64f_enetdata.xTXDCountSem.data, 0, sizeof(k64f_enetdata.xTXDCountSem.data));
+  k64f_enetdata.xTXDCountSem.attr.cb_mem = &k64f_enetdata.xTXDCountSem.data;
+  k64f_enetdata.xTXDCountSem.attr.cb_size = sizeof(k64f_enetdata.xTXDCountSem.data);
+  k64f_enetdata.xTXDCountSem.id = osSemaphoreNew(ENET_TX_RING_LEN, ENET_TX_RING_LEN, &k64f_enetdata.xTXDCountSem.attr);
 
   LWIP_ASSERT("xTXDCountSem creation error", (k64f_enetdata.xTXDCountSem.id != NULL));
 

features/FEATURE_LWIP/lwip-interface/lwip-eth/arch/TARGET_NXP/lpc17_emac.c

@@ -70,6 +70,7 @@
  * the same. */
 #define RX_PRIORITY   (osPriorityNormal)
 #define TX_PRIORITY   (osPriorityNormal)
+#define PHY_PRIORITY  (osPriorityNormal)
 
 /** \brief  Debug output formatter lock define
  *
@@ -603,7 +604,7 @@ static err_t lpc_low_level_output(struct netif *netif, struct pbuf *p)
 	/* THIS WILL BLOCK UNTIL THERE ARE ENOUGH DESCRIPTORS AVAILABLE */
 	while (dn > lpc_tx_ready(netif))
 #if NO_SYS == 0
-	    osSemaphoreWait(lpc_enetif->xTXDCountSem.id, osWaitForever);
+	    osSemaphoreAcquire(lpc_enetif->xTXDCountSem.id, osWaitForever);
 #else
 		osDelay(1);
 #endif
@@ -685,7 +686,7 @@ void LPC17xxEthernetHandler(void)
 
 	if (ints & RXINTGROUP) {
         /* RX group interrupt(s): Give signal to wakeup RX receive task.*/
-        osSignalSet(lpc_enetdata.RxThread->id, RX_SIGNAL);
+        osThreadFlagsSet(lpc_enetdata.RxThread->id, RX_SIGNAL);
     }
 
     if (ints & TXINTGROUP) {
@@ -711,7 +712,7 @@ static void packet_rx(void* pvParameters) {
 
     while (1) {
         /* Wait for receive task to wakeup */
-        osSignalWait(RX_SIGNAL, osWaitForever);
+        osThreadFlagsWait(RX_SIGNAL, 0, osWaitForever);
 
         /* Process packets until all empty */
         while (LPC_EMAC->RxConsumeIndex != LPC_EMAC->RxProduceIndex)
@@ -942,10 +943,13 @@ err_t lpc_etharp_output_ipv6(struct netif *netif, struct pbuf *q,
 
 #if NO_SYS == 0
 /* periodic PHY status update */
-void phy_update(void const *nif) {
-    lpc_phy_sts_sm((struct netif*)nif);
+void phy_update(void *nif) {
+    while (true) {
+        lpc_phy_sts_sm((struct netif*)nif);
+        osDelay(250);
+    }
 }
-osTimerDef(phy_update, phy_update);
+
 #endif
 
 /**
@@ -1017,11 +1021,10 @@ err_t eth_arch_enetif_init(struct netif *netif)
 
     /* CMSIS-RTOS, start tasks */
 #if NO_SYS == 0
-#ifdef CMSIS_OS_RTX
-    memset(lpc_enetdata.xTXDCountSem.data, 0, sizeof(lpc_enetdata.xTXDCountSem.data));
-    lpc_enetdata.xTXDCountSem.def.semaphore = lpc_enetdata.xTXDCountSem.data;
-#endif
-    lpc_enetdata.xTXDCountSem.id = osSemaphoreCreate(&lpc_enetdata.xTXDCountSem.def, LPC_NUM_BUFF_TXDESCS);
+    memset(&lpc_enetdata.xTXDCountSem.data, 0, sizeof(lpc_enetdata.xTXDCountSem.data));
+    lpc_enetdata.xTXDCountSem.attr.cb_mem = &lpc_enetdata.xTXDCountSem.data;
+    lpc_enetdata.xTXDCountSem.attr.cb_size = sizeof(lpc_enetdata.xTXDCountSem.data);
+    lpc_enetdata.xTXDCountSem.id = osSemaphoreNew(LPC_NUM_BUFF_TXDESCS, LPC_NUM_BUFF_TXDESCS, &lpc_enetdata.xTXDCountSem.attr);
 	LWIP_ASSERT("xTXDCountSem creation error", (lpc_enetdata.xTXDCountSem.id != NULL));
 
 	err = sys_mutex_new(&lpc_enetdata.TXLockMutex);
@@ -1037,8 +1040,7 @@ err_t eth_arch_enetif_init(struct netif *netif)
 	sys_thread_new("txclean_thread", packet_tx, netif->state, DEFAULT_THREAD_STACKSIZE, TX_PRIORITY);
 
 	/* periodic PHY status update */
-	osTimerId phy_timer = osTimerCreate(osTimer(phy_update), osTimerPeriodic, (void *)netif);
-	osTimerStart(phy_timer, 250);
+	sys_thread_new("phy_thread", phy_update, netif, DEFAULT_THREAD_STACKSIZE, TX_PRIORITY);
 #endif
 
     return ERR_OK;

features/FEATURE_LWIP/lwip-interface/lwip-eth/arch/TARGET_STM/stm32xx_emac.c

@@ -4,7 +4,7 @@
 #include "lwip/tcpip.h"
 #include "lwip/ethip6.h"
 #include <string.h>
-#include "cmsis_os.h"
+#include "cmsis_os2.h"
 #include "mbed_interface.h"
 
 #define RECV_TASK_PRI           (osPriorityHigh)