chore: switch to cgo inline asm

Author: mikesmitty

src/runtime/runtime_rp2350.go

@@ -2,9 +2,40 @@
 
 package runtime
 
+// #include <stdint.h>
+//
+// static void spinlock_lock(void *lock) {
+//     uint32_t _tmp0, _tmp1;
+//     __asm volatile (                                           \
+//     "1:\n"                                                     \
+//     "ldaexb %1, [%2]\n"                                        \
+//     "movs %0, #1\n" /* fill dependency slot */                 \
+//     "cmp %1, #0\n"                                             \
+//     /* Immediately retry if lock is seen to be taken */        \
+//     "bne 1b\n"                                                 \
+//     /* Attempt to claim */                                     \
+//     "strexb %1, %0, [%2]\n"                                    \
+//     "cmp %1, #0\n"                                             \
+//     /* Claim failed due to intervening write, so retry */      \
+//     "bne 1b\n"                                                 \
+//     : "=&r" (_tmp0), "=&r" (_tmp1) : "r" (lock)                \
+//     );                                                         \
+//     __asm volatile ("dmb" : : : "memory");
+// }
+//
+// static void spinlock_unlock(void *lock) {
+//     /* Release-ordered store is available: use instead of separate fence */ \
+//     uint32_t zero = 0;                                                      \
+//     __asm volatile (                                                        \
+//         "stlb %0, [%1]\n"                                                   \
+//         : : "r" (zero), "r" (lock)                                          \
+//     );                                                                      \
+// }
+import "C"
+
 import (
 	"device/rp"
-	"sync/atomic"
+	"unsafe"
 )
 
 const (
@@ -16,24 +47,26 @@ const (
 	sioIrqFifoProc1 = rp.IRQ_SIO_IRQ_FIFO
 )
 
+// Software spinlocks don't persist across soft resets so this is a no-op.
+func resetSpinLocks() {}
+
 type spinLock struct {
-	atomic.Uint32
-	id uint8
+	state uint8
+	id    uint8
+	_     [2]uint8
 }
 
 func (l *spinLock) Lock() {
 	// Try to replace 0 with 1. Once we succeed, the lock has been acquired.
-	for !l.Uint32.CompareAndSwap(0, 1) {
-		spinLoopWait()
-	}
+	C.spinlock_lock(unsafe.Pointer(&l.state))
 }
 
 func (l *spinLock) Unlock() {
 	// Safety check: the spinlock should have been locked.
-	if schedulerAsserts && l.Uint32.Load() != 1 {
+	if schedulerAsserts && l.state != 1 {
 		runtimePanic("unlock of unlocked spinlock")
 	}
 
 	// Unlock the lock. Simply write 0, because we already know it is locked.
-	l.Uint32.Store(0)
+	C.spinlock_unlock(unsafe.Pointer(&l.state))
 }