OS/ThreadX: fix threadx smp scheduler flow and core control handling

- always process thread time slice in SysTick_Handler
- clear tx_thread_smp_core_control before first thread restore in gcc/iar context.S
- update PortThreadSwitch to synchronize tx_thread_smp_core_control state transitions
- add missing memory barriers in scheduler return path
- fix _tx_thread_smp_protect_count reset in _tx_thread_smp_force_unprotect
- fix _tx_thread_interrupt_control and enable TSP on boot hart

Signed-off-by: Huaqi Fang <578567190@qq.com>

Author: fanghuaqi

OS/ThreadX/ports_smp/nuclei/gcc/context.S

@@ -9,8 +9,15 @@
 
 #define portCONTEXT_SIZE    ( portRegNum * REGBYTES )
 
+#if __riscv_xlen == 64
+#define CALL_FRAME_SIZE     32
+#else
+#define CALL_FRAME_SIZE     16
+#endif
+
     .extern _tx_thread_current_ptr
     .extern _tx_thread_execute_ptr
+    .extern _tx_clear_thread_smp_core_control
 
 
 .section    .text
@@ -77,13 +84,23 @@ _tx_thread_schedule_ready:
     la a1, _tx_thread_current_ptr   /* _tx_thread_current_ptr = _tx_thread_execute_ptr */
 #endif
     STORE a0, 0(a1)
+    addi sp, sp, -CALL_FRAME_SIZE
+    STORE ra, 0 * REGBYTES(sp)
+    STORE a0, 1 * REGBYTES(sp)
+    STORE a1, 2 * REGBYTES(sp)
+    jal _tx_clear_thread_smp_core_control
+    LOAD ra, 0 * REGBYTES(sp)
+    LOAD a0, 1 * REGBYTES(sp)
+    LOAD a1, 2 * REGBYTES(sp)
+    addi sp, sp, CALL_FRAME_SIZE
+
     /* Increment the run count for this thread.  */
     /* _tx_thread_current_ptr[coreid] -> tx_thread_run_count++;  */
     LOAD  t0, 1  * REGBYTES(a0)
     addi  t0, t0, 1
     STORE t0, 1 * REGBYTES(a0)
 
-    LOAD sp, 2  * REGBYTES(a0)      /* Read sp from _tx_thread_execute_ptr[coreid] -> tx_thread_stack_ptr */
+    LOAD sp, 2 * REGBYTES(a0)      /* Read sp from _tx_thread_execute_ptr[coreid] -> tx_thread_stack_ptr */
     /* Pop PC from stack and set MEPC */
     LOAD t0,  0  * REGBYTES(sp)
     csrw CSR_MEPC, t0

OS/ThreadX/ports_smp/nuclei/iar/context.S

@@ -9,8 +9,15 @@
 
 #define portCONTEXT_SIZE    ( portRegNum * REGBYTES )
 
+#if __riscv_xlen == 64
+#define CALL_FRAME_SIZE     32
+#else
+#define CALL_FRAME_SIZE     16
+#endif
+
     EXTERN _tx_thread_current_ptr
     EXTERN _tx_thread_execute_ptr
+    EXTERN _tx_clear_thread_smp_core_control
     EXTERN CSTACK$$Limit
     EXTERN PortThreadSwitch
     PUBLIC _tx_thread_schedule, eclic_msip_handler
@@ -79,6 +86,15 @@ _tx_thread_schedule_ready:
     la a1, _tx_thread_current_ptr   /* _tx_thread_current_ptr = _tx_thread_execute_ptr */
 #endif
     STORE a0, 0(a1)
+    addi sp, sp, -CALL_FRAME_SIZE
+    STORE ra, 0 * REGBYTES(sp)
+    STORE a0, 1 * REGBYTES(sp)
+    STORE a1, 2 * REGBYTES(sp)
+    jal _tx_clear_thread_smp_core_control
+    LOAD ra, 0 * REGBYTES(sp)
+    LOAD a0, 1 * REGBYTES(sp)
+    LOAD a1, 2 * REGBYTES(sp)
+    addi sp, sp, CALL_FRAME_SIZE
 
     /* Increment the run count for this thread.  */
     /* _tx_thread_current_ptr[coreid] -> tx_thread_run_count++;  */

OS/ThreadX/ports_smp/nuclei/port.c

@@ -1,3 +1,4 @@
+#include "core_feature_base.h"
 #define TX_SOURCE_CODE
 #define TX_THREAD_SMP_SOURCE_CODE
 
@@ -49,29 +50,32 @@ void SysTick_Handler(void)
 
     /* See if anything has expired.  */
     if (_tx_timer_expired) {
-        /* Did a timer expire?  */
-        if (_tx_timer_expired) {
-            /* Process timer expiration.  */
-            _tx_timer_expiration_process();
-        }
-        /* Did time slice expire?  */
-        if (_tx_timer_expired_time_slice) {
-            /* Time slice interrupted thread.  */
-            _tx_thread_time_slice();
-        }
+        /* Process timer expiration.  */
+        _tx_timer_expiration_process();
     }
-    /* Increment the system active counter.  */
-    _tx_timer_interrupt_active ++;
+    /* Call time-slice processing to process time-slice for all threads on each core. */
+    _tx_thread_time_slice();
+    /* Decrease the system active counter.  */
+    _tx_timer_interrupt_active --;
     /* Release the protection.  */
     _tx_thread_smp_unprotect(saved_posture);
 }
 
+void _tx_clear_thread_smp_core_control(TX_THREAD *thread_ptr)
+{
+    if (thread_ptr != TX_NULL) {
+        thread_ptr->tx_thread_smp_core_control = 0;
+        __RWMB();
+    }
+}
+
 // Task Switch code called in eclic_msip_handler
 void PortThreadSwitch(void)
 {
 #ifdef TX_ENABLE_EXECUTION_CHANGE_NOTIFY
     _tx_execution_thread_exit();
 #endif
+    TX_THREAD *rdy_thread;
     UINT coreid = _tx_thread_smp_core_get();
     /*
      * Magic idle task emulation for threadx
@@ -84,9 +88,15 @@ void PortThreadSwitch(void)
         _tx_thread_current_ptr[coreid] -> tx_thread_time_slice = _tx_timer_time_slice[coreid];
         _tx_timer_time_slice[coreid] =  0;
     }
-    _tx_thread_current_ptr[coreid] =  TX_NULL;
+    if (_tx_thread_current_ptr[coreid]) {
+        /* Current thread context is saved, ready for scheduling */
+        _tx_thread_current_ptr[coreid] -> tx_thread_smp_core_control = 1;
+        _tx_thread_current_ptr[coreid] =  TX_NULL;
+        __RWMB();
+    }
 
-    if (!_tx_thread_execute_ptr[coreid]) {
+    rdy_thread = _tx_thread_execute_ptr[coreid];
+    if ((!rdy_thread) || (rdy_thread ->tx_thread_smp_core_control != 1)) {
         if (coreid == 0) {
             /* increase the timer interrupt to higher priority to enable interrupt nesting */
             ECLIC_SetLevelIRQ(SysTimer_IRQn, KERNEL_INTERRUPT_PRIORITY + 1);
@@ -100,11 +110,13 @@ void PortThreadSwitch(void)
         rv_csr_t msubm = __RV_CSR_READ(CSR_MSUBM);
         __enable_irq();
         __RWMB();
+        rdy_thread = _tx_thread_execute_ptr[coreid];
         /* If no ready task just go to idle and wait for interrupt */
-        while (!_tx_thread_execute_ptr[coreid]) {
+        while ((!rdy_thread) || (rdy_thread ->tx_thread_smp_core_control != 1)) {
             // if wfi here, it may not wakeup even swi is pending, since new swi could happen during eclic_msip_handler
             __NOP();
             __RWMB();
+            rdy_thread = _tx_thread_execute_ptr[coreid];
         }
         /* disable interrupt to avoid interrupt nesting since new task handle found */
         __disable_irq();
@@ -121,7 +133,9 @@ void PortThreadSwitch(void)
         }
     }
 
-    _tx_thread_current_ptr[coreid] = _tx_thread_execute_ptr[coreid];
+    /* Clear the execution control flag.  */
+    rdy_thread -> tx_thread_smp_core_control = 0;
+    _tx_thread_current_ptr[coreid] = rdy_thread;
     _tx_thread_current_ptr[coreid] -> tx_thread_run_count ++;
     /* Clear Software IRQ, A MUST */
     SysTimer_ClearSWIRQ();
@@ -159,7 +173,7 @@ VOID _tx_initialize_low_level(VOID)
 //    _tx_initialize_unused_memory = s_threadx_heap;
     _tx_initialize_unused_memory = NULL;
     SetupSysTickInterrupt();
-    _tx_thread_interrupt_control(0);
+    _tx_thread_interrupt_control(TX_INT_DISABLE);
 }
 
 UINT _tx_thread_interrupt_control(UINT new_posture)
@@ -168,9 +182,9 @@ UINT _tx_thread_interrupt_control(UINT new_posture)
 
     if (new_posture == TX_INT_DISABLE) {
         // clear interrupt
-        temp = __RV_CSR_READ_CLEAR(CSR_MSTATUS, MSTATUS_MIE);
+        temp = __RV_CSR_READ_CLEAR(CSR_MSTATUS, MSTATUS_MIE) & MSTATUS_MIE;
     } else {
-        temp = __RV_CSR_SWAP(CSR_MSTATUS, new_posture);
+        temp = __RV_CSR_READ_SET(CSR_MSTATUS, MSTATUS_MIE) & MSTATUS_MIE;
     }
     __RWMB();
     return (UINT)temp;
@@ -185,7 +199,7 @@ void _tx_thread_smp_force_unprotect(UINT new_interrupt_posture)
     __RV_CSR_READ_CLEAR(CSR_MSTATUS, MSTATUS_MIE);
     core_id = _tx_thread_smp_core_get();
     if (_tx_thread_smp_protection.tx_thread_smp_protect_core == core_id) {
-        _tx_thread_smp_protection.tx_thread_smp_protect_count == 0;
+        _tx_thread_smp_protection.tx_thread_smp_protect_count = 0;
         if ((_tx_thread_smp_protection.tx_thread_smp_protect_count == 0) && (_tx_thread_preempt_disable == 0)) {
             _tx_thread_smp_protection.tx_thread_smp_protect_core = ((ULONG) 0xFFFFFFFFUL);
             __RWMB();   /* ensure prior stores visible */
@@ -202,6 +216,7 @@ extern volatile UINT _tx_thread_preempt_disable;
 void _tx_thread_system_return(void)
 {
     _tx_thread_preempt_disable = 0;
+    __RWMB();
     _tx_thread_smp_force_unprotect(MSTATUS_MIE);
 
     /* Set a software interrupt(SWI) request to request a context switch. */
@@ -329,7 +344,10 @@ ULONG _tx_thread_smp_time_get(void)
 /*    core.                                                               */
 void _tx_thread_smp_low_level_initialize(UINT number_of_cores)
 {
-
+    // Enable interrupt and task sp swap
+#if defined(ECLIC_HW_CTX_AUTO) && defined(CFG_HAS_ECLICV2)
+    __RV_CSR_SET(CSR_MECLIC_CTL, MECLIC_CTL_TSP_EN);
+#endif
 }
 
 /*    This function is the place where additional cores wait until        */

doc/source/changelog.rst

@@ -135,6 +135,7 @@ This is release version of ``0.9.0`` of Nuclei SDK.
   - Fix ThreadX ``tx_port.h`` interrupt disable/restore macros (``TX_DISABLE``/``TX_RESTORE``) by adding ``volatile`` keyword and ``memory`` clobber to inline assembly to prevent compiler reordering and ensure proper memory barrier semantics
   - Add memory barriers to ThreadX UP and SMP ports after interrupt control operations (such as ``__enable_irq()`` and ``CSR_MSTATUS`` access) to ensure proper synchronization and prevent potential compiler/CPU reordering issues
   - Fix ThreadX SMP port ``PortThreadSwitch`` function by adding memory barriers (``__RWMB()``) around ECLIC IRQ priority changes and stack pointer swaps to ensure proper ordering of memory operations on Nuclei 1000 series out-of-order processors, preventing potential race conditions in multi-core task switching
+  - Fix ThreadX SMP scheduler flow by always processing time-slice updates in ``SysTick_Handler``, clearing/checking ``tx_thread_smp_core_control`` during first-thread restore and ``PortThreadSwitch``, adding missing memory barriers in the return path, and correcting the ``_tx_thread_smp_protect_count`` reset bug
 
 * Build System