fix(rp2350): add software spinlocks

Author: mikesmitty

src/runtime/runtime_rp2.go

@@ -298,36 +298,6 @@ var (
 	futexLock     = spinLock{id: 23}
 )
 
-func resetSpinLocks() {
-	for i := uint8(0); i < numSpinlocks; i++ {
-		l := &spinLock{id: i}
-		l.spinlock().Set(0)
-	}
-}
-
-// A hardware spinlock, one of the 32 spinlocks defined in the SIO peripheral.
-type spinLock struct {
-	id uint8
-}
-
-// Return the spinlock register: rp.SIO.SPINLOCKx
-func (l *spinLock) spinlock() *volatile.Register32 {
-	return (*volatile.Register32)(unsafe.Add(unsafe.Pointer(&rp.SIO.SPINLOCK0), l.id*4))
-}
-
-func (l *spinLock) Lock() {
-	// Wait for the lock to be available.
-	spinlock := l.spinlock()
-	for spinlock.Get() == 0 {
-		arm.Asm("wfe")
-	}
-}
-
-func (l *spinLock) Unlock() {
-	l.spinlock().Set(0)
-	arm.Asm("sev")
-}
-
 // Wait until a signal is received, indicating that it can resume from the
 // spinloop.
 func spinLoopWait() {

src/runtime/runtime_rp2040.go

@@ -3,10 +3,43 @@
 package runtime
 
 import (
+	"device/arm"
 	"device/rp"
+	"runtime/volatile"
+	"unsafe"
 )
 
 const (
 	sioIrqFifoProc0 = rp.IRQ_SIO_IRQ_PROC0
 	sioIrqFifoProc1 = rp.IRQ_SIO_IRQ_PROC1
 )
+
+func resetSpinLocks() {
+	for i := uint8(0); i < numSpinlocks; i++ {
+		l := &spinLock{id: i}
+		l.spinlock().Set(0)
+	}
+}
+
+// A hardware spinlock, one of the 32 spinlocks defined in the SIO peripheral.
+type spinLock struct {
+	id uint8
+}
+
+// Return the spinlock register: rp.SIO.SPINLOCKx
+func (l *spinLock) spinlock() *volatile.Register32 {
+	return (*volatile.Register32)(unsafe.Add(unsafe.Pointer(&rp.SIO.SPINLOCK0), l.id*4))
+}
+
+func (l *spinLock) Lock() {
+	// Wait for the lock to be available.
+	spinlock := l.spinlock()
+	for spinlock.Get() == 0 {
+		arm.Asm("wfe")
+	}
+}
+
+func (l *spinLock) Unlock() {
+	l.spinlock().Set(0)
+	arm.Asm("sev")
+}

src/runtime/runtime_rp2350.go

@@ -3,6 +3,7 @@
 package runtime
 
 import (
+	"device/arm"
 	"device/rp"
 )
 
@@ -14,3 +15,60 @@ const (
 	sioIrqFifoProc0 = rp.IRQ_SIO_IRQ_FIFO
 	sioIrqFifoProc1 = rp.IRQ_SIO_IRQ_FIFO
 )
+
+// Due to hardware errata RP2350-E2 spinlocks are emulated in software as in pico-sdk.
+type spinLock struct {
+	// lock field must be first field so its address is the same as the struct address.
+	lock uint8
+	id   uint8
+	uint16 // Padding to prevent false sharing
+}
+
+func (l *spinLock) Lock() {
+	// Original reference:
+	// https://github.com/raspberrypi/pico-sdk/blob/2.2.0/src/rp2_common/hardware_sync_spin_lock/include/hardware/sync/spin_lock.h#L112
+
+	// r0 is automatically filled with the pointer value "l" here.
+	// We create a variable to allow access the lock byte and avoid a memory
+	// fault when accessing l.lock in assembly.
+	lock := &l.lock
+	_ = lock
+
+	// Set a loop start point
+	arm.Asm("1:")
+	// Exclusively load the state variable (l.lock) and put its value in r2.
+	arm.Asm("ldaexb r2, [r0]")
+	// Store the "locked" state value (1) into r1 to keep things moving.
+	arm.Asm("movs r1, #1")
+	// Check if the lock was already taken (r2 != 0).
+	arm.Asm("cmp r2, #0")
+	// Jump back to "1:" if the lock is already held
+	arm.Asm("bne 1b")
+
+	// Attempt to store '1' into the lock address.
+	// The return code (0 for success, 1 for failure) is placed in r2.
+	arm.Asm("strexb r2, r1, [r0]")
+	// Check if the result was successful (r2 == 0).
+	arm.Asm("cmp r2, #0")
+	// Jump back to "1:" if the lock was not acquired.
+	arm.Asm("bne 1b")
+
+	// Memory barrier to ensure everyone knows we're holding the lock now.
+	arm.Asm("dmb")
+}
+
+func (l *spinLock) Unlock() {
+	// Original reference:
+	// https://github.com/raspberrypi/pico-sdk/blob/2.2.0/src/rp2_common/hardware_sync_spin_lock/include/hardware/sync/spin_lock.h#L197
+
+	// r0 is automatically filled with the pointer value l here.
+	// We create a variable to allow access the lock byte and avoid a memory
+	// fault when accessing l.lock in assembly.
+	lock := &l.lock
+	_ = lock
+	// Fill r1 with 0 and store it to the lock address in r0. stlb requires a
+	// register as a source so we can't use a literal 0 directly.
+	arm.Asm("movs r1, #0")
+	// Release the pseudo-spinlock by writing 0 to and releasing l.lock.
+	arm.Asm("stlb r1, [r0]")
+}