add cpu up

include/rtthread.h

@@ -604,45 +604,12 @@ rt_thread_t rt_thread_defunct_dequeue(void);
  * spinlock
  */
 struct rt_spinlock;
-#ifdef RT_USING_SMP
 
 void rt_spin_lock_init(struct rt_spinlock *lock);
 void rt_spin_lock(struct rt_spinlock *lock);
 void rt_spin_unlock(struct rt_spinlock *lock);
 rt_base_t rt_spin_lock_irqsave(struct rt_spinlock *lock);
 void rt_spin_unlock_irqrestore(struct rt_spinlock *lock, rt_base_t level);
-#else
-
-rt_inline void rt_spin_lock_init(struct rt_spinlock *lock)
-{
-    RT_UNUSED(lock);
-}
-rt_inline void rt_spin_lock(struct rt_spinlock *lock)
-{
-    RT_UNUSED(lock);
-    rt_enter_critical();
-}
-rt_inline void rt_spin_unlock(struct rt_spinlock *lock)
-{
-    RT_UNUSED(lock);
-    rt_exit_critical();
-}
-rt_inline rt_base_t rt_spin_lock_irqsave(struct rt_spinlock *lock)
-{
-    rt_base_t level;
-    RT_UNUSED(lock);
-    level = rt_hw_interrupt_disable();
-    rt_enter_critical();
-    return level;
-}
-rt_inline void rt_spin_unlock_irqrestore(struct rt_spinlock *lock, rt_base_t level)
-{
-    RT_UNUSED(lock);
-    rt_exit_critical();
-    rt_hw_interrupt_enable(level);
-}
-
-#endif /* RT_USING_SMP */
 
 /**@}*/
 

include/rttypes.h

@@ -135,15 +135,30 @@ struct rt_spinlock
 #endif /* RT_DEBUGING_SPINLOCK */
 };
 
-#ifdef RT_DEBUGING_SPINLOCK
+#ifndef RT_SPINLOCK_INIT
+#define RT_SPINLOCK_INIT {{0}} /* can be overridden by cpuport.h */
+#endif /* RT_SPINLOCK_INIT */
+
+#else /* !RT_USING_SMP */
+
+struct rt_spinlock
+{
+#ifdef RT_USING_DEBUG
+    rt_uint32_t critical_level;
+#endif /* RT_USING_DEBUG */
+    rt_ubase_t lock;
+};
+#define RT_SPINLOCK_INIT {0}
+#endif /* RT_USING_SMP */
+#if defined(RT_DEBUGING_SPINLOCK) && defined(RT_USING_SMP)
 
     #define __OWNER_MAGIC ((void *)0xdeadbeaf)
 
     #if defined(__GNUC__)
     #define __GET_RETURN_ADDRESS __builtin_return_address(0)
-#else
+    #else /* !__GNUC__ */
     #define __GET_RETURN_ADDRESS RT_NULL
-#endif
+    #endif /* __GNUC__ */
 
     #define _SPIN_LOCK_DEBUG_OWNER(lock)                  \
         do                                                \
@@ -163,14 +178,13 @@ struct rt_spinlock
             (lock)->pc = RT_NULL;          \
         } while (0)
 
-#else
+#else /* !RT_DEBUGING_SPINLOCK */
 
     #define _SPIN_LOCK_DEBUG_OWNER(lock)
     #define _SPIN_UNLOCK_DEBUG_OWNER(lock)
-#endif
+#endif /* RT_DEBUGING_SPINLOCK */
 
 #ifdef RT_USING_DEBUG
-
     #define _SPIN_LOCK_DEBUG_CRITICAL(lock)                   \
         do                                                    \
         {                                                     \
@@ -187,10 +201,10 @@ struct rt_spinlock
             (critical) = (lock)->critical_level;        \
         } while (0)
 
-#else
+#else /* !RT_USING_DEBUG */
-
     #define _SPIN_LOCK_DEBUG_CRITICAL(lock)
     #define _SPIN_UNLOCK_DEBUG_CRITICAL(lock, critical) (critical = 0)
+
 #endif /* RT_USING_DEBUG */
 
 #define RT_SPIN_LOCK_DEBUG(lock)         \
@@ -207,22 +221,6 @@ struct rt_spinlock
         _SPIN_UNLOCK_DEBUG_CRITICAL(lock, critical); \
     } while (0)
 
-#ifndef RT_SPINLOCK_INIT
-#define RT_SPINLOCK_INIT {{0}} /* can be overridden by cpuport.h */
-#endif /* RT_SPINLOCK_INIT */
-
-#else
-
-struct rt_spinlock
-{
-#ifdef RT_USING_DEBUG
-    rt_uint32_t critical_level;
-#endif /* RT_USING_DEBUG */
-    rt_ubase_t lock;
-};
-#define RT_SPINLOCK_INIT {0}
-#endif /* RT_USING_SMP */
-
 typedef struct rt_spinlock rt_spinlock_t;
 
 #define RT_DEFINE_SPINLOCK(x)  struct rt_spinlock x = RT_SPINLOCK_INIT

src/SConscript

@@ -25,9 +25,9 @@ if GetDepend('RT_USING_DEVICE') == False:
     SrcRemove(src, ['device.c'])
 
 if GetDepend('RT_USING_SMP') == False:
-    SrcRemove(src, ['cpu.c', 'scheduler_mp.c'])
+    SrcRemove(src, ['cpu_mp.c', 'scheduler_mp.c'])
 else:
-    SrcRemove(src, ['scheduler_up.c'])
+    SrcRemove(src, ['cpu_up.c', 'scheduler_up.c'])
 
 LOCAL_CFLAGS = ''
 LINKFLAGS = ''

src/cpu_mp.c

@@ -21,7 +21,6 @@
 rt_base_t _cpus_critical_level;
 #endif /* RT_USING_DEBUG */
 
-#ifdef RT_USING_SMP
 static struct rt_cpu _cpus[RT_CPUS_NR];
 rt_hw_spinlock_t _cpus_lock;
 #if defined(RT_DEBUGING_SPINLOCK)
@@ -217,4 +216,3 @@ void rt_cpus_lock_status_restore(struct rt_thread *thread)
     rt_sched_post_ctx_switch(thread);
 }
 RTM_EXPORT(rt_cpus_lock_status_restore);
-#endif /* RT_USING_SMP */

src/cpu_up.c

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2006-2024, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2024-04-19     Shell        Fixup UP irq spinlock
+ */
+#include <rthw.h>
+#include <rtthread.h>
+
+/**
+ * @brief   Initialize a static spinlock object.
+ *
+ * @param   lock is a pointer to the spinlock to initialize.
+ */
+void rt_spin_lock_init(struct rt_spinlock *lock)
+{
+    RT_UNUSED(lock);
+}
+
+/**
+ * @brief   This function will lock the spinlock, will lock the thread scheduler.
+ *
+ * @note    If the spinlock is locked, the current CPU will keep polling the spinlock state
+ *          until the spinlock is unlocked.
+ *
+ * @param   lock is a pointer to the spinlock.
+ */
+void rt_spin_lock(struct rt_spinlock *lock)
+{
+    RT_UNUSED(lock);
+    rt_enter_critical();
+}
+
+/**
+ * @brief   This function will unlock the spinlock, will unlock the thread scheduler.
+ *
+ * @param   lock is a pointer to the spinlock.
+ */
+void rt_spin_unlock(struct rt_spinlock *lock)
+{
+    RT_UNUSED(lock);
+    rt_exit_critical();
+}
+
+/**
+ * @brief   This function will disable the local interrupt and then lock the spinlock, will lock the thread scheduler.
+ *
+ * @note    If the spinlock is locked, the current CPU will keep polling the spinlock state
+ *          until the spinlock is unlocked.
+ *
+ * @param   lock is a pointer to the spinlock.
+ *
+ * @return  Return current cpu interrupt status.
+ */
+rt_base_t rt_spin_lock_irqsave(struct rt_spinlock *lock)
+{
+    rt_base_t level;
+    RT_UNUSED(lock);
+    level = rt_hw_interrupt_disable();
+    rt_enter_critical();
+    return level;
+}
+
+/**
+ * @brief   This function will unlock the spinlock and then restore current cpu interrupt status, will unlock the thread scheduler.
+ *
+ * @param   lock is a pointer to the spinlock.
+ *
+ * @param   level is interrupt status returned by rt_spin_lock_irqsave().
+ */
+void rt_spin_unlock_irqrestore(struct rt_spinlock *lock, rt_base_t level)
+{
+    RT_UNUSED(lock);
+    rt_exit_critical();
+    rt_hw_interrupt_enable(level);
+}