improve threadx support, add multi ROTS support for board_test and msc_dual_lun

8 files changed, 370 insertions, 41 deletions

diff --git a/AGENTS.md b/AGENTS.md
index b4f87e98c..34fc57cb8 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -114,13 +114,65 @@ Use `-DBOARD=...` with any supported board under `hw/bsp/espressif/boards/`. NEV
     - `cd examples/device/cdc_msc_freertos`
     - `idf.py -DBOARD=espressif_s3_devkitc monitor`
 
-## J-Link GDB Server + RTT Logging
+## GDB Debugging
+
+Look up the board's `JLINK_DEVICE` and `OPENOCD_OPTION` from `hw/bsp/*/boards/*/board.cmake` (or `board.mk`).
+
+### JLinkGDBServer
+
+**Terminal 1 – start the GDB server:**
+```bash
+JLinkGDBServer -device stm32h743xi -if SWD -speed 4000 \
+  -port 2331 -swoport 2332 -telnetport 2333 -nogui
+```
+
+**Terminal 2 – connect GDB:**
+```bash
+arm-none-eabi-gdb /tmp/build/firmware.elf
+(gdb) target remote :2331
+(gdb) monitor reset halt
+(gdb) load
+(gdb) continue
+```
+
+To break on entry instead of running immediately:
+```bash
+(gdb) monitor reset halt
+(gdb) load
+(gdb) break main
+(gdb) continue
+```
+
+### OpenOCD
+
+**Terminal 1 – start the GDB server:**
+```bash
+openocd -f interface/stlink.cfg -f target/stm32h7x.cfg
+# or with J-Link probe:
+openocd -f interface/jlink.cfg -f target/stm32h7x.cfg
+```
+
+For boards that define `OPENOCD_OPTION` in `board.cmake`, use those options directly:
+```bash
+openocd $(cat hw/bsp/FAMILY/boards/BOARD/board.cmake | grep OPENOCD_OPTION | ...)
+```
+
+**Terminal 2 – connect GDB (OpenOCD default port is 3333):**
+```bash
+arm-none-eabi-gdb /tmp/build/firmware.elf
+(gdb) target remote :3333
+(gdb) monitor reset halt
+(gdb) load
+(gdb) continue
+```
+
+### RTT Logging with JLinkGDBServer
 
 - Build with RTT logging enabled (example):
   `cd examples/device/cdc_msc && make BOARD=stm32h743eval LOG=2 LOGGER=rtt all`
 - Flash with J-Link:
   `cd examples/device/cdc_msc && make BOARD=stm32h743eval LOG=2 LOGGER=rtt flash-jlink`
-- Launch GDB server (keep this running in terminal 1):
+- Launch GDB server with RTT port (keep this running in terminal 1):
   `JLinkGDBServer -device stm32h743xi -if SWD -speed 4000 -port 2331 -swoport 2332 -telnetport 2333 -RTTTelnetPort 19021 -nogui`
 - Read RTT output (terminal 2):
   `JLinkRTTClient`
@@ -128,7 +180,6 @@ Use `-DBOARD=...` with any supported board under `hw/bsp/espressif/boards/`. NEV
   `JLinkRTTClient | tee rtt.log`
 - For non-interactive capture:
   `timeout 20s JLinkRTTClient > rtt.log`
-- Use the board-specific `JLINK_DEVICE` from `hw/bsp/*/boards/*/board.mk` if you are not using `stm32h743eval`.
 
 ## Unit Testing
 
diff --git a/examples/device/board_test/src/main.c b/examples/device/board_test/src/main.c
index 757876ac8..ddc9bba6b 100644
--- a/examples/device/board_test/src/main.c
+++ b/examples/device/board_test/src/main.c
@@ -39,10 +39,7 @@ enum {
 
 #define HELLO_STR   "Hello from TinyUSB\r\n"
 
-int main(void) {
-  board_init();
-  board_led_write(true);
-
+static void board_test_loop(void) {
   uint32_t start_ms = 0;
   bool led_state = false;
 
@@ -76,8 +73,83 @@ int main(void) {
   }
 }
 
+#if CFG_TUSB_OS == OPT_OS_FREERTOS
+static void freertos_init(void);
+#endif
+
+int main(void) {
+  board_init();
+  board_led_write(true);
+
+#if CFG_TUSB_OS == OPT_OS_FREERTOS
+  freertos_init();
+#elif CFG_TUSB_OS == OPT_OS_THREADX
+  tx_kernel_enter();
+#else
+  board_test_loop();
+#endif
+
+  return 0;
+}
+
 #ifdef ESP_PLATFORM
 void app_main(void) {
   main();
 }
 #endif
+
+//--------------------------------------------------------------------+
+// FreeRTOS
+//--------------------------------------------------------------------+
+#if CFG_TUSB_OS == OPT_OS_FREERTOS
+
+#ifdef ESP_PLATFORM
+#define MAIN_STACK_SIZE   4096
+#else
+#define MAIN_STACK_SIZE   configMINIMAL_STACK_SIZE
+#endif
+
+#if configSUPPORT_STATIC_ALLOCATION
+static StackType_t  _main_stack[MAIN_STACK_SIZE];
+static StaticTask_t _main_taskdef;
+#endif
+
+static void board_test_task(void* param) {
+  (void) param;
+  board_test_loop();
+}
+
+static void freertos_init(void) {
+  #if configSUPPORT_STATIC_ALLOCATION
+  xTaskCreateStatic(board_test_task, "main", MAIN_STACK_SIZE, NULL, 1, _main_stack, &_main_taskdef);
+  #else
+  xTaskCreate(board_test_task, "main", MAIN_STACK_SIZE, NULL, 1, NULL);
+  #endif
+  #ifndef ESP_PLATFORM
+  vTaskStartScheduler();
+  #endif
+}
+
+//--------------------------------------------------------------------+
+// ThreadX
+//--------------------------------------------------------------------+
+#elif CFG_TUSB_OS == OPT_OS_THREADX
+
+#define MAIN_TASK_STACK_SIZE  1024
+static TX_THREAD _main_thread;
+static ULONG _main_thread_stack[MAIN_TASK_STACK_SIZE / sizeof(ULONG)];
+static void main_thread_entry(ULONG arg);
+
+static void main_thread_entry(ULONG arg) {
+  (void) arg;
+  board_test_loop();
+}
+
+void tx_application_define(void *first_unused_memory) {
+  (void) first_unused_memory;
+  static CHAR main_thread_name[] = "main";
+  tx_thread_create(&_main_thread, main_thread_name, main_thread_entry, 0,
+                   _main_thread_stack, MAIN_TASK_STACK_SIZE,
+                   1, 1, TX_NO_TIME_SLICE, TX_AUTO_START);
+}
+#endif
diff --git a/examples/device/msc_dual_lun/src/main.c b/examples/device/msc_dual_lun/src/main.c
index b459871f7..9ca3a1f34 100644
--- a/examples/device/msc_dual_lun/src/main.c
+++ b/examples/device/msc_dual_lun/src/main.c
@@ -31,7 +31,7 @@
 #include "tusb.h"
 
 //--------------------------------------------------------------------+
-// MACRO CONSTANT TYPEDEF PROTYPES
+// MACRO CONSTANT TYPEDEF PROTOTYPES
 //--------------------------------------------------------------------+
 
 /* Blink pattern
@@ -41,71 +41,179 @@
  */
 enum {
   BLINK_NOT_MOUNTED = 250,
-  BLINK_MOUNTED = 1000,
-  BLINK_SUSPENDED = 2500,
+  BLINK_MOUNTED     = 1000,
+  BLINK_SUSPENDED   = 2500,
 };
 
 static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
 
-void led_blinking_task(void);
+// Task parameter type: ULONG for ThreadX, void* for FreeRTOS and noos
+#if CFG_TUSB_OS == OPT_OS_THREADX
+  #define RTOS_PARAM ULONG
+#elif CFG_TUSB_OS == OPT_OS_FREERTOS
+  #define RTOS_PARAM void*
+  static void freertos_init(void);
+#else
+  #define RTOS_PARAM void*
+#endif
 
-/*------------- MAIN -------------*/
-int main(void) {
-  board_init();
+void led_blinking_task(RTOS_PARAM param);
 
-  // init device stack on configured roothub port
+//--------------------------------------------------------------------+
+// USB Device Task
+//--------------------------------------------------------------------+
+static void usb_device_init(void) {
   tusb_rhport_init_t dev_init = {
-    .role = TUSB_ROLE_DEVICE,
+    .role  = TUSB_ROLE_DEVICE,
     .speed = TUSB_SPEED_AUTO
   };
   tusb_init(BOARD_TUD_RHPORT, &dev_init);
-
   board_init_after_tusb();
+}
+
+#if CFG_TUSB_OS != OPT_OS_NONE && CFG_TUSB_OS != OPT_OS_PICO
+static void usb_device_task(RTOS_PARAM param) {
+  (void) param;
+  usb_device_init();
 
   while (1) {
-    tud_task(); // tinyusb device task
-    led_blinking_task();
+    tud_task();
   }
 }
+#endif
 
 //--------------------------------------------------------------------+
-// Device callbacks
+// Main
 //--------------------------------------------------------------------+
+int main(void) {
+  board_init();
+
+#if CFG_TUSB_OS == OPT_OS_FREERTOS
+  freertos_init();
 
-// Invoked when device is mounted
+#elif CFG_TUSB_OS == OPT_OS_THREADX
+  tx_kernel_enter();
+
+#else
+  // noos + pico-sdk: init USB then run polling loop
+  usb_device_init();
+
+  while (1) {
+    tud_task();
+    led_blinking_task(NULL);
+  }
+#endif
+
+  return 0;
+}
+
+#ifdef ESP_PLATFORM
+void app_main(void) {
+  main();
+}
+#endif
+
+//--------------------------------------------------------------------+
+// Device callbacks
+//--------------------------------------------------------------------+
 void tud_mount_cb(void) {
   blink_interval_ms = BLINK_MOUNTED;
 }
 
-// Invoked when device is unmounted
 void tud_umount_cb(void) {
   blink_interval_ms = BLINK_NOT_MOUNTED;
 }
 
-// Invoked when usb bus is suspended
-// remote_wakeup_en : if host allow us  to perform remote wakeup
-// Within 7ms, device must draw an average of current less than 2.5 mA from bus
 void tud_suspend_cb(bool remote_wakeup_en) {
   (void) remote_wakeup_en;
   blink_interval_ms = BLINK_SUSPENDED;
 }
 
-// Invoked when usb bus is resumed
 void tud_resume_cb(void) {
   blink_interval_ms = tud_mounted() ? BLINK_MOUNTED : BLINK_NOT_MOUNTED;
 }
 
 //--------------------------------------------------------------------+
-// BLINKING TASK
+// Blinking Task
 //--------------------------------------------------------------------+
-void led_blinking_task(void) {
+void led_blinking_task(RTOS_PARAM param) {
+  (void) param;
   static uint32_t start_ms = 0;
   static bool led_state = false;
 
-  // Blink every interval ms
-  if (tusb_time_millis_api() - start_ms < blink_interval_ms) return; // not enough time
-  start_ms += blink_interval_ms;
+  while (1) {
+#if CFG_TUSB_OS == OPT_OS_FREERTOS
+    vTaskDelay(blink_interval_ms / portTICK_PERIOD_MS);
+#elif CFG_TUSB_OS == OPT_OS_THREADX
+    tx_thread_sleep(_osal_ms2tick(blink_interval_ms));
+#else
+    if (tusb_time_millis_api() - start_ms < blink_interval_ms) {
+      return; // not enough time
+    }
+#endif
+
+    start_ms += blink_interval_ms;
+    board_led_write(led_state);
+    led_state = 1 - led_state; // toggle
+  }
+}
+
+//--------------------------------------------------------------------+
+// FreeRTOS
+//--------------------------------------------------------------------+
+#if CFG_TUSB_OS == OPT_OS_FREERTOS
+
+#ifdef ESP_PLATFORM
+#define USBD_STACK_SIZE   4096
+#else
+#define USBD_STACK_SIZE   (3*configMINIMAL_STACK_SIZE/2 * (CFG_TUSB_DEBUG ? 2 : 1))
+#endif
+#define BLINKY_STACK_SIZE   configMINIMAL_STACK_SIZE
 
-  board_led_write(led_state);
-  led_state = 1 - led_state; // toggle
+#if configSUPPORT_STATIC_ALLOCATION
+static StackType_t  _usb_device_stack[USBD_STACK_SIZE];
+static StaticTask_t _usb_device_taskdef;
+static StackType_t  _blinky_stack[BLINKY_STACK_SIZE];
+static StaticTask_t _blinky_taskdef;
+#endif
+
+
+static void freertos_init(void) {
+  #if configSUPPORT_STATIC_ALLOCATION
+  xTaskCreateStatic(usb_device_task,     "usbd",   USBD_STACK_SIZE,   NULL, configMAX_PRIORITIES - 1, _usb_device_stack, &_usb_device_taskdef);
+  xTaskCreateStatic(led_blinking_task,   "blinky", BLINKY_STACK_SIZE, NULL, 1,                        _blinky_stack,     &_blinky_taskdef);
+  #else
+  xTaskCreate(usb_device_task,           "usbd",   USBD_STACK_SIZE,   NULL, configMAX_PRIORITIES - 1, NULL);
+  xTaskCreate(led_blinking_task,         "blinky", BLINKY_STACK_SIZE, NULL, 1,                        NULL);
+  #endif
+  #ifndef ESP_PLATFORM
+  vTaskStartScheduler();
+  #endif
+}
+
+//--------------------------------------------------------------------+
+// ThreadX
+//--------------------------------------------------------------------+
+#elif CFG_TUSB_OS == OPT_OS_THREADX
+
+#define USBD_STACK_SIZE   4096
+#define BLINKY_STACK_SIZE 1024
+
+static TX_THREAD _usb_device_thread;
+static ULONG     _usb_device_stack[USBD_STACK_SIZE / sizeof(ULONG)];
+static TX_THREAD _blinky_thread;
+static ULONG     _blinky_stack[BLINKY_STACK_SIZE / sizeof(ULONG)];
+
+void tx_application_define(void *first_unused_memory) {
+  (void) first_unused_memory;
+  static CHAR usbd_name[]   = "usbd";
+  static CHAR blinky_name[] = "blinky";
+  tx_thread_create(&_usb_device_thread, usbd_name, usb_device_task, 0,
+                   _usb_device_stack, USBD_STACK_SIZE,
+                   0, 0, TX_NO_TIME_SLICE, TX_AUTO_START);
+  tx_thread_create(&_blinky_thread, blinky_name, led_blinking_task, 0,
+                   _blinky_stack, BLINKY_STACK_SIZE,
+                   1, 1, TX_NO_TIME_SLICE, TX_AUTO_START);
 }
+
+#endif
diff --git a/hw/bsp/board.c b/hw/bsp/board.c
index 91e7de9fe..0553a7eb7 100644
--- a/hw/bsp/board.c
+++ b/hw/bsp/board.c
@@ -251,3 +251,58 @@ void vApplicationSetupTimerInterrupt(void) {
 #endif
 
 #endif
+
+//--------------------------------------------------------------------
+// ThreadX hooks for ARM Cortex-M
+//--------------------------------------------------------------------
+#if CFG_TUSB_OS == OPT_OS_THREADX && defined(__ARM_ARCH)
+
+#include "tx_api.h"
+#include "tx_initialize.h"
+
+// Newlib linker symbol: end of statically allocated RAM (start of heap)
+extern ULONG _end;
+
+// CMSIS standard variable for system clock frequency
+extern uint32_t SystemCoreClock;
+
+// Cortex-M SysTick registers (fixed addresses on all Cortex-M)
+#define _TX_SYST_CSR    (*((volatile uint32_t *)0xE000E010U))
+#define _TX_SYST_RVR    (*((volatile uint32_t *)0xE000E014U))
+#define _TX_SYST_CVR    (*((volatile uint32_t *)0xE000E018U))
+// SCB->SHP[10] = PendSV priority, [11] = SysTick priority (byte access at SCB base + 0xD22)
+#define _TX_SCB_SHPR3   (*((volatile uint32_t *)0xE000ED20U))
+
+VOID _tx_initialize_low_level(VOID) {
+  // Set the first available memory address for tx_application_define
+  _tx_initialize_unused_memory = (VOID *)(&_end);
+
+  // Configure SysTick for ThreadX tick rate: enable with processor clock + interrupt
+  _TX_SYST_RVR = (SystemCoreClock / TX_TIMER_TICKS_PER_SECOND) - 1u;
+  _TX_SYST_CVR = 0u;
+  _TX_SYST_CSR = 0x07u; // CLKSOURCE=1, TICKINT=1, ENABLE=1
+
+  // SHPR3 bits[31:24] = SysTick priority, bits[23:16] = PendSV priority
+  // PendSV must be lowest priority (0xFF). SysTick must be higher than PendSV (0x40)
+  // so SysTick can preempt the PendSV scheduler idle loop (__tx_ts_wait) to tick the timer.
+  _TX_SCB_SHPR3 = (_TX_SCB_SHPR3 & 0x0000FFFFU) | 0x40FF0000U;
+}
+
+// Weak callback for board-specific SysTick work (e.g. HAL_IncTick on STM32)
+void osal_threadx_tick_cb(void);
+TU_ATTR_WEAK void osal_threadx_tick_cb(void) { }
+
+// SysTick drives the ThreadX timer tick
+extern void _tx_timer_interrupt(void);
+void SysTick_Handler(void);
+void SysTick_Handler(void) {
+  osal_threadx_tick_cb();
+  _tx_timer_interrupt();
+}
+
+// tusb_time_millis_api() based on ThreadX tick counter
+uint32_t tusb_time_millis_api(void) {
+  return (uint32_t)((uint64_t) tx_time_get() * 1000u / TX_TIMER_TICKS_PER_SECOND);
+}
+
+#endif
diff --git a/hw/bsp/family_support.cmake b/hw/bsp/family_support.cmake
index 699afda92..4299ad44e 100644
--- a/hw/bsp/family_support.cmake
+++ b/hw/bsp/family_support.cmake
@@ -380,6 +380,26 @@ function(family_add_rtos TARGET RTOS)
 
     target_link_libraries(${TARGET} PUBLIC freertos_kernel)
     target_compile_definitions(${TARGET} PUBLIC CFG_TUSB_OS=OPT_OS_FREERTOS)
+  elseif (RTOS STREQUAL "threadx")
+    if (NOT TARGET threadx)
+      # Derive THREADX_ARCH from CMAKE_SYSTEM_CPU if not explicitly set
+      if (NOT DEFINED THREADX_ARCH)
+        string(REPLACE "-" "_" THREADX_ARCH ${CMAKE_SYSTEM_CPU})
+      endif ()
+      # Derive THREADX_TOOLCHAIN from TOOLCHAIN if not explicitly set
+      if (NOT DEFINED THREADX_TOOLCHAIN)
+        if (TOOLCHAIN STREQUAL "iar")
+          set(THREADX_TOOLCHAIN "iar")
+        elseif (TOOLCHAIN STREQUAL "clang")
+          set(THREADX_TOOLCHAIN "ac6")
+        else ()
+          set(THREADX_TOOLCHAIN "gnu")
+        endif ()
+      endif ()
+      add_subdirectory(${TOP}/lib/threadx ${CMAKE_BINARY_DIR}/lib/threadx)
+    endif ()
+    target_link_libraries(${TARGET} PUBLIC threadx)
+    target_compile_definitions(${TARGET} PUBLIC CFG_TUSB_OS=OPT_OS_THREADX)
   elseif (RTOS STREQUAL "zephyr")
     target_compile_definitions(${TARGET} PUBLIC CFG_TUSB_OS=OPT_OS_ZEPHYR)
     target_include_directories(${TARGET} PUBLIC ${ZEPHYR_BASE}/include)
diff --git a/hw/bsp/stm32h7/family.c b/hw/bsp/stm32h7/family.c
index 2759dac63..c94c2e755 100644
--- a/hw/bsp/stm32h7/family.c
+++ b/hw/bsp/stm32h7/family.c
@@ -139,6 +139,10 @@ void board_init(void) {
   #endif
 
   NVIC_SetPriority(OTG_HS_IRQn, configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY );
+
+#elif CFG_TUSB_OS == OPT_OS_THREADX
+  // Disable SysTick before kernel entry; _tx_initialize_low_level() will re-configure it
+  SysTick->CTRL &= ~1UL;
 #endif
 
   GPIO_InitTypeDef GPIO_InitStruct;
@@ -299,6 +303,11 @@ uint32_t tusb_time_millis_api(void) {
   return system_ticks;
 }
 
+#elif CFG_TUSB_OS == OPT_OS_THREADX
+// Keep HAL_GetTick() working for HAL functions called from board_init()
+void osal_threadx_tick_cb(void) {
+  HAL_IncTick();
+}
 #endif
 
 void HardFault_Handler(void) {
diff --git a/src/osal/osal_threadx.h b/src/osal/osal_threadx.h
index 4f05ef535..6bcf9c5ab 100644
--- a/src/osal/osal_threadx.h
+++ b/src/osal/osal_threadx.h
@@ -39,18 +39,28 @@ extern "C" {
 //--------------------------------------------------------------------+
 
 TU_ATTR_ALWAYS_INLINE static inline uint32_t _osal_ms2tick(uint32_t msec) {
-  if ( msec == TX_WAIT_FOREVER ) return TX_WAIT_FOREVER;
-  if ( msec == 0 ) return 0;
+  if ( msec == TX_WAIT_FOREVER ) {
+    return TX_WAIT_FOREVER;
+  }
+  if ( msec == 0 ) {
+    return 0;
+  }
 
   uint32_t ticks = msec * TX_TIMER_TICKS_PER_SECOND  / 1000;
 
   // TX_TIMER_TICKS_PER_SECOND is less than 1000 and 1 tick > 1 ms
   // we still need to delay at least 1 tick
-  if ( ticks == 0 ) ticks = 1;
+  if ( ticks == 0 ) {
+    ticks = 1;
+  }
 
   return ticks;
 }
 
+TU_ATTR_ALWAYS_INLINE static inline uint32_t osal_time_millis(void) {
+  return (uint32_t)((uint64_t) tx_time_get() * 1000u / TX_TIMER_TICKS_PER_SECOND);
+}
+
 TU_ATTR_ALWAYS_INLINE static inline void osal_task_delay(uint32_t msec) {
   tx_thread_sleep(_osal_ms2tick(msec));
 }
@@ -94,7 +104,7 @@ TU_ATTR_ALWAYS_INLINE static inline void osal_spin_unlock(osal_spinlock_t *ctx,
 typedef TX_SEMAPHORE osal_semaphore_def_t, * osal_semaphore_t;
 
 TU_ATTR_ALWAYS_INLINE static inline osal_semaphore_t osal_semaphore_create(osal_semaphore_def_t *semdef) {
-  tx_semaphore_create(semdef->semaphore, semdef->name, 0);
+  tx_semaphore_create(semdef, TX_NULL, 0);
   return semdef;
 }
 
@@ -113,6 +123,7 @@ TU_ATTR_ALWAYS_INLINE static inline bool osal_semaphore_wait(osal_semaphore_t se
 }
 
 TU_ATTR_ALWAYS_INLINE static inline void osal_semaphore_reset(osal_semaphore_t sem_hdl) {
+  (void) sem_hdl;
 }
 
 //--------------------------------------------------------------------+
@@ -152,10 +163,10 @@ typedef TX_QUEUE osal_queue_def_t, * osal_queue_t;
 #define OSAL_QUEUE_DEF(_int_set, _name, _depth, _type)    \
 static _type _name##_buf[_depth];                         \
 osal_queue_def_t _name = {                                \
-		.tx_queue_name         = #_name,                  \
+		.tx_queue_name         = (CHAR*)(uintptr_t)#_name,                  \
 		.tx_queue_message_size = (sizeof(_type) + 3) / 4, \
 		.tx_queue_capacity     = _depth,                  \
-		.tx_queue_start        =  _name##_buf }
+		.tx_queue_start        = (ULONG *) _name##_buf }
 
 
 TU_ATTR_ALWAYS_INLINE static inline osal_queue_t osal_queue_create(osal_queue_def_t* qdef) {
@@ -173,8 +184,8 @@ TU_ATTR_ALWAYS_INLINE static inline bool osal_queue_receive(osal_queue_t qhdl, v
   return 0 == tx_queue_receive(qhdl, data, _osal_ms2tick(msec));
 }
 
-TU_ATTR_ALWAYS_INLINE static inline bool osal_queue_send(osal_queue_t qhdl, void *data, bool in_isr) {
-  return 0 == tx_queue_send(qhdl, data, in_isr ? TX_NO_WAIT : TX_WAIT_FOREVER);
+TU_ATTR_ALWAYS_INLINE static inline bool osal_queue_send(osal_queue_t qhdl, void const *data, bool in_isr) {
+  return 0 == tx_queue_send(qhdl, (VOID *)(uintptr_t) data, in_isr ? TX_NO_WAIT : TX_WAIT_FOREVER);
 }
 
 TU_ATTR_ALWAYS_INLINE static inline bool osal_queue_empty(osal_queue_t qhdl) {
diff --git a/tools/get_deps.py b/tools/get_deps.py
index 1d596469b..696914251 100755
--- a/tools/get_deps.py
+++ b/tools/get_deps.py
@@ -14,6 +14,9 @@ deps_mandatory = {
     'lib/lwip': ['https://github.com/lwip-tcpip/lwip.git',
                  '159e31b689577dbf69cf0683bbaffbd71fa5ee10',
                  'all'],
+    'lib/threadx': ['https://github.com/eclipse-threadx/threadx.git',
+                    '4b6e8100d932a3a67b34c6eb17f84f3bffb9e2ae',
+                    'all'],
     'tools/linkermap': ['https://github.com/hathach/linkermap.git',
                         '8e1f440fa15c567aceb5aa0d14f6d18c329cc67f',
                         'all'],