Add spinlock implementation using RV32A atomics

Introduce a simple spinlock implementation based on test-and-set using
RV32A atomic instructions. The spinlock API includes basic locking,
IRQ-safe variants, and versions that save and restore interrupt state.

To support atomic instructions, the Makefile is updated to enable the
'A' extension by changing the -march flag.

This is the first step toward enabling multi-core task scheduling
support on RISC-V SMP systems.

Author: visitorckw

arch/riscv/build.mk

@@ -17,10 +17,10 @@ DEFINES := -DF_CPU=$(F_CLK) \
            -DF_TIMER=$(F_TICK) \
            -include config.h
 
-ASFLAGS = -march=rv32imzicsr -mabi=ilp32
+ASFLAGS = -march=rv32imzaicsr -mabi=ilp32
 CFLAGS += -Wall -Wextra -Wshadow -Wno-unused-parameter -Werror
 CFLAGS += -O2 -std=gnu99
-CFLAGS += -march=rv32imzicsr -mabi=ilp32
+CFLAGS += -march=rv32imazicsr -mabi=ilp32
 CFLAGS += -mstrict-align -ffreestanding -nostdlib -fomit-frame-pointer
 CFLAGS += $(INC_DIRS) $(DEFINES) -fdata-sections -ffunction-sections
 ARFLAGS = r

arch/riscv/spinlock.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <hal.h>
+
+/* Spinlock structure */
+typedef struct {
+    volatile uint32_t lock;
+} spinlock_t;
+
+#define SPINLOCK_INITIALIZER { 0 }
+
+/* Save and restore interrupt state */
+static inline uint32_t intr_save(void)
+{
+    uint32_t mstatus_val = read_csr(mstatus);
+    _di();
+    return mstatus_val;
+}
+
+static inline void intr_restore(uint32_t mstatus_val)
+{
+    write_csr(mstatus, mstatus_val);
+}
+
+/* CPU relax */
+static inline void cpu_relax(void)
+{
+    asm volatile("nop");
+}
+
+/* Basic spinlock API */
+static inline void spin_lock(spinlock_t *lock)
+{
+    while (__sync_lock_test_and_set(&lock->lock, 1)) {
+        while (lock->lock)
+            cpu_relax();
+    }
+}
+
+static inline void spin_unlock(spinlock_t *lock)
+{
+    __sync_lock_release(&lock->lock);
+}
+
+static inline int spin_trylock(spinlock_t *lock)
+{
+    return (__sync_lock_test_and_set(&lock->lock, 1) == 0);
+}
+
+/* IRQ-safe spinlock (no state saving) */
+static inline void spin_lock_irq(spinlock_t *lock)
+{
+    _di();
+    spin_lock(lock);
+}
+
+static inline void spin_unlock_irq(spinlock_t *lock)
+{
+    spin_unlock(lock);
+    _ei();
+}
+
+/* IRQ-safe spinlock (with state saving) */
+static inline void spin_lock_irqsave(spinlock_t *lock, uint32_t *flags)
+{
+    *flags = intr_save();
+    spin_lock(lock);
+}
+
+static inline void spin_unlock_irqrestore(spinlock_t *lock, uint32_t flags)
+{
+    spin_unlock(lock);
+    intr_restore(flags);
+}