tidy up deadlines

Author: soypat

rp2-pio/config.go

@@ -110,6 +110,8 @@ func (cfg *StateMachineConfig) SetSidesetParams(bitCount uint8, optional bool, p
 
 // SetSidesetPins sets the lowest-numbered pin that will be affected by a side-set
 // operation.
+//
+// Remember to also set the pindir of the pin(s).
 func (cfg *StateMachineConfig) SetSidesetPins(firstPin machine.Pin) {
 	checkPinBaseAndCount(firstPin, 1)
 	cfg.PinCtrl = (cfg.PinCtrl & ^uint32(rp.PIO0_SM0_PINCTRL_SIDESET_BASE_Msk)) |
@@ -123,6 +125,8 @@ func (cfg *StateMachineConfig) SetSidesetPins(firstPin machine.Pin) {
 //     OUT PINDIRS or MOV PINS instruction. The data written to this pin will always be
 //     the least-significant bit of the OUT or MOV data.
 //   - Count defines the number of pins that will be affected by an OUT PINS, 0..32 inclusive.
+//
+// Remember to also set the pindir of the pin(s).
 func (cfg *StateMachineConfig) SetOutPins(base machine.Pin, count uint8) {
 	checkPinBaseAndCount(base, count)
 	cfg.PinCtrl = (cfg.PinCtrl & ^uint32(rp.PIO0_SM0_PINCTRL_OUT_BASE_Msk|rp.PIO0_SM0_PINCTRL_OUT_COUNT_Msk)) |
@@ -137,6 +141,8 @@ func (cfg *StateMachineConfig) SetOutPins(base machine.Pin, count uint8) {
 // The mapping of SET and OUT onto pins is configured independently. They may be mapped to distinct locations, for example
 // if one pin is to be used as a clock signal, and another for data. They may also be overlapping ranges of pins: a UART
 // transmitter might use SET to assert start and stop bits, and OUT instructions to shift out FIFO data to the same pins.
+//
+// Remember to also set the pindir of the pin(s).
 func (cfg *StateMachineConfig) SetSetPins(base machine.Pin, count uint8) {
 	checkPinBaseAndCount(base, count)
 	cfg.PinCtrl = (cfg.PinCtrl & ^uint32(rp.PIO0_SM0_PINCTRL_SET_BASE_Msk|rp.PIO0_SM0_PINCTRL_SET_COUNT_Msk)) |
@@ -145,6 +151,8 @@ func (cfg *StateMachineConfig) SetSetPins(base machine.Pin, count uint8) {
 }
 
 // SetInPins in a state machine configuration. Can overlap with OUT, SET and SIDESET pins.
+//
+// Remember to also set the pindir of the pin(s).
 func (cfg *StateMachineConfig) SetInPins(base machine.Pin) {
 	checkPinBaseAndCount(base, 1)
 	cfg.PinCtrl = (cfg.PinCtrl & ^uint32(rp.PIO0_SM0_PINCTRL_IN_BASE_Msk)) | (uint32(base) << rp.PIO0_SM0_PINCTRL_IN_BASE_Pos)

rp2-pio/piolib/all_generate.go

@@ -2,10 +2,12 @@ package piolib
 
 import (
 	"errors"
+	"math"
 	"runtime"
+	"time"
 )
 
-const timeoutRetries = 1023
+const timeoutRetries = math.MaxUint16 * 8
 
 var (
 	errTimeout = errors.New("piolib:timeout")
@@ -23,3 +25,40 @@ var (
 func gosched() {
 	runtime.Gosched()
 }
+
+type deadliner struct {
+	// timeout is a bitshift value for the timeout.
+	timeout uint8
+}
+
+type deadline struct {
+	t time.Time
+}
+
+func (dl deadline) expired() bool {
+	if dl.t.IsZero() {
+		return false
+	}
+	return time.Since(dl.t) > 0
+}
+
+func (ch deadliner) newDeadline() deadline {
+	var t time.Time
+	if ch.timeout != 0 {
+		t = time.Now().Add(time.Duration(1 << ch.timeout))
+	}
+	return deadline{t: t}
+}
+
+func (ch *deadliner) setTimeout(timeout time.Duration) {
+	if timeout <= 0 {
+		return // No timeout.
+	}
+	for i := uint8(0); i < 64; i++ {
+		calc := time.Duration(1 << i)
+		if calc > timeout {
+			ch.timeout = i
+			return
+		}
+	}
+}

rp2-pio/piolib/dma.go

@@ -43,6 +43,7 @@ func (arb *dmaArbiter) Channel(channel uint8) dmaChannel {
 type dmaChannel struct {
 	hw  *dmaChannelHW
 	arb *dmaArbiter
+	dl  deadliner
 	idx uint8
 }
 
@@ -163,7 +164,7 @@ const (
 )
 
 // Push32 writes each element of src slice into the memory location at dst.
-func (ch dmaChannel) Push32(dst *uint32, src []uint32, dreq uint32) {
+func (ch dmaChannel) Push32(dst *uint32, src []uint32, dreq uint32) error {
 	hw := ch.HW()
 	srcPtr := uint32(uintptr(unsafe.Pointer(&src[0])))
 	dstPtr := uint32(uintptr(unsafe.Pointer(dst)))
@@ -182,18 +183,18 @@ func (ch dmaChannel) Push32(dst *uint32, src []uint32, dreq uint32) {
 
 	hw.CTRL_TRIG.Set(cc.CTRL)
 
-	retries := timeoutRetries
-	for ch.busy() && retries > 0 {
+	deadline := ch.dl.newDeadline()
+	for ch.busy() {
+		if deadline.expired() {
+			return errTimeout
+		}
 		gosched()
-		retries--
-	}
-	if retries == 0 {
-		println("DMA push32 timeout")
 	}
+	return nil
 }
 
 // Pull32 reads the memory location at src into dst slice, incrementing dst pointer but not src.
-func (ch dmaChannel) Pull32(dst []uint32, src *uint32, dreq uint32) {
+func (ch dmaChannel) Pull32(dst []uint32, src *uint32, dreq uint32) error {
 	hw := ch.HW()
 	srcPtr := uint32(uintptr(unsafe.Pointer(src)))
 	dstPtr := uint32(uintptr(unsafe.Pointer(&dst[0])))
@@ -212,14 +213,14 @@ func (ch dmaChannel) Pull32(dst []uint32, src *uint32, dreq uint32) {
 
 	hw.CTRL_TRIG.Set(cc.CTRL)
 
-	retries := timeoutRetries
-	for ch.busy() && retries > 0 {
+	deadline := ch.dl.newDeadline()
+	for ch.busy() {
+		if deadline.expired() {
+			return errTimeout
+		}
 		gosched()
-		retries--
-	}
-	if retries == 0 {
-		println("DMA push32 timeout")
 	}
+	return nil
 }
 
 // abort aborts the current transfer sequence on the channel and blocks until

rp2-pio/piolib/spi3w.go

@@ -4,6 +4,7 @@ package piolib
 
 import (
 	"machine"
+	"time"
 
 	pio "github.com/tinygo-org/pio/rp2-pio"
 )
@@ -17,6 +18,7 @@ type SPI3w struct {
 
 	enableStatus bool
 	lastStatus   uint32
+	pinMask      uint32
 }
 
 func NewSPI3w(sm pio.StateMachine, dio, clk machine.Pin, baud uint32) (*SPI3w, error) {
@@ -53,14 +55,15 @@ func NewSPI3w(sm pio.StateMachine, dio, clk machine.Pin, baud uint32) (*SPI3w, e
 	// Initialize state machine.
 	sm.Init(offset, cfg)
 	pinMask := uint32(1<<dio | 1<<clk)
-	sm.SetPindirsMasked(0, pinMask)
+	sm.SetPindirsMasked(pinMask, pinMask)
 	sm.SetPinsMasked(0, pinMask)
 
 	sm.SetEnabled(true)
 
 	spiw := &SPI3w{
-		sm:     sm,
-		offset: offset,
+		sm:      sm,
+		offset:  offset,
+		pinMask: pinMask,
 	}
 	return spiw, nil
 }
@@ -103,40 +106,46 @@ func (spi *SPI3w) read(r []uint32) error {
 		return spi.readDMA(r)
 	}
 	i := 0
-	retries := timeoutRetries
-	for i < len(r) && retries > 0 {
+	deadline := spi.newDeadline()
+	for i < len(r) {
 		if spi.sm.IsRxFIFOEmpty() {
+			if deadline.expired() {
+				return errTimeout
+			}
 			gosched()
-			retries--
 			continue
 		}
 		r[i] = spi.sm.RxGet()
 		spi.sm.TxPut(r[i])
 		i++
 	}
-	if retries <= 0 {
-		return errTimeout
-	}
+
 	return nil
 }
 
 func (spi *SPI3w) write(w []uint32) error {
 	if spi.IsDMAEnabled() {
 		return spi.writeDMA(w)
 	}
+
 	i := 0
-	retries := timeoutRetries
-	for i < len(w) && retries > 0 {
+	deadline := spi.newDeadline()
+	for i < len(w) {
 		if spi.sm.IsTxFIFOFull() {
+			if deadline.expired() {
+				return errTimeout
+			}
 			gosched()
-			retries--
 			continue
 		}
 		spi.sm.TxPut(w[i])
 		i++
 	}
-	if retries <= 0 {
-		return errTimeout
+	for !spi.sm.IsTxFIFOEmpty() {
+		if deadline.expired() {
+			return errTimeout
+		}
+		gosched()
 	}
 	return nil
 }
@@ -151,6 +160,15 @@ func (spi *SPI3w) EnableStatus(enabled bool) {
 	spi.enableStatus = enabled
 }
 
+// SetTimeout sets the read/write timeout. Use 0 as argument to disable timeouts.
+func (spi *SPI3w) SetTimeout(timeout time.Duration) {
+	spi.dma.dl.setTimeout(timeout)
+}
+
+func (spi *SPI3w) newDeadline() deadline {
+	return spi.dma.dl.newDeadline()
+}
+
 func (spi *SPI3w) getStatus() error {
 	var buf [1]uint32
 	err := spi.read(buf[:1])
@@ -161,12 +179,14 @@ func (spi *SPI3w) getStatus() error {
 	return nil
 }
 
+func (spi *SPI3w) forcePinsLow() { spi.sm.SetPinsMasked(0, spi.pinMask) }
+
 func (spi *SPI3w) prepTx(readbits, writebits uint32) {
 	spi.sm.SetEnabled(false)
 
-	spi.sm.ClearFIFOs()
-	spi.sm.SetX(readbits)
-	spi.sm.SetY(writebits)
+	// spi.sm.ClearFIFOs()
+	spi.sm.SetX(writebits)
+	spi.sm.SetY(readbits)
 	spi.sm.Exec(pio.EncodeSet(pio.SrcDestPinDirs, 1)) // Set Pindir out.
 	spi.sm.Jmp(spi.offset+spi3wWrapTarget, pio.JmpAlways)
 
@@ -188,6 +208,7 @@ func (spi *SPI3w) EnableDMA(enabled bool) error {
 	if !ok {
 		return errDMAUnavail
 	}
+	channel.dl = spi.dma.dl // Copy deadline.
 	spi.dma = channel
 	return nil
 }