refactor Encode* functions to rcv 8 bit args; begin adding spi3w

Author: soypat

rp2-pio/instr.go

@@ -5,23 +5,39 @@ import (
 	"math"
 )
 
+// InstrKind is a enum for the PIO instruction type. It only represents the kind of
+// instruction. It cannot store the arguments.
+type InstrKind uint8
+
+const (
+	InstrJMP InstrKind = iota
+	InstrWAIT
+	InstrIN
+	InstrOUT
+	InstrPUSH
+	InstrPULL
+	InstrMOV
+	InstrIRQ
+	InstrSET
+)
+
 // This file contains the primitives for creating instructions dynamically
 const (
-	INSTR_BITS_JMP  = 0x0000
-	INSTR_BITS_WAIT = 0x2000
-	INSTR_BITS_IN   = 0x4000
-	INSTR_BITS_OUT  = 0x6000
-	INSTR_BITS_PUSH = 0x8000
-	INSTR_BITS_PULL = 0x8080
-	INSTR_BITS_MOV  = 0xa000
-	INSTR_BITS_IRQ  = 0xc000
-	INSTR_BITS_SET  = 0xe000
+	_INSTR_BITS_JMP  = 0x0000
+	_INSTR_BITS_WAIT = 0x2000
+	_INSTR_BITS_IN   = 0x4000
+	_INSTR_BITS_OUT  = 0x6000
+	_INSTR_BITS_PUSH = 0x8000
+	_INSTR_BITS_PULL = 0x8080
+	_INSTR_BITS_MOV  = 0xa000
+	_INSTR_BITS_IRQ  = 0xc000
+	_INSTR_BITS_SET  = 0xe000
 
 	// Bit mask for instruction code
-	INSTR_BITS_Msk = 0xe000
+	_INSTR_BITS_Msk = 0xe000
 )
 
-type SrcDest uint16
+type SrcDest uint8
 
 const (
 	SrcDestPins    SrcDest = 0
@@ -37,125 +53,122 @@ const (
 	SrcExecOut     SrcDest = 7
 )
 
-func MajorInstrBits(instr uint16) uint16 {
-	return instr & INSTR_BITS_Msk
-}
+type JmpCond uint8
 
-func EncodeInstrAndArgs(instr uint16, arg1 uint16, arg2 uint16) uint16 {
-	return instr | (arg1 << 5) | (arg2 & 0x1f)
-}
+const (
+	// No condition, always jumps.
+	JmpAlways JmpCond = iota
+	// Jump if X is zero.
+	JmpXZero
+	// Jump if X is not zero, prior to decrement of X.
+	JmpXNZeroDec
+	// Jump if Y is zero.
+	JmpYZero
+	// Jump if Y is not zero, prior to decrement of Y.
+	JmpYNZeroDec
+	// Jump if X is not equal to Y.
+	JmpXNotEqualY
+	// Jump if EXECCTRL_JMP_PIN (state machine configured) is high.
+	JmpPinInput
+	// Compares the bits shifted out since last pull with the shift count theshold
+	// (configured by SHIFTCTRL_PULL_THRESH) and jumps if there are remaining bits to shift.
+	JmpOSRNotEmpty
+)
 
-func EncodeInstrAndSrcDest(instr uint16, dest SrcDest, value uint16) uint16 {
-	return EncodeInstrAndArgs(instr, uint16(dest)&7, value)
+// EncodeInstr encodes an arbitrary PIO instruction with the given arguments.
+func EncodeInstr(instr InstrKind, delaySideset, arg1_3b, arg2_5b uint8) uint16 {
+	return uint16(instr&0b111)<<13 | uint16(delaySideset&0x1f)<<8 | uint16(arg1_3b&0b111)<<5 | uint16(arg2_5b&0x1f)
 }
 
-func EncodeDelay(cycles uint16) uint16 {
-	return cycles << 8
+func majorInstrBits(instr uint16) uint16 {
+	return instr & _INSTR_BITS_Msk
 }
 
-func EncodeSideSet(bitCount uint16, value uint16) uint16 {
-	return value << (13 - bitCount)
+func encodeInstrAndArgs(instr uint16, arg1 uint8, arg2 uint8) uint16 {
+	return instr | (uint16(arg1) << 5) | uint16(arg2&0x1f)
 }
 
-func EncodeSetSetOpt(bitCount uint16, value uint16) uint16 {
-	return 0x1000 | value<<(12-bitCount)
+func encodeInstrAndSrcDest(instr uint16, dest SrcDest, value uint8) uint16 {
+	return encodeInstrAndArgs(instr, uint8(dest)&7, value)
 }
 
-func EncodeJmp(addr uint16) uint16 {
-	return EncodeInstrAndArgs(INSTR_BITS_JMP, 0, addr)
+func EncodeDelay(cycles uint8) uint16 {
+	return 0b11111 & (uint16(cycles) << 8)
 }
 
-func EncodeIRQ(relative bool, irq uint16) uint16 {
-	instr := irq
+func EncodeSideSet(bitCount, value uint8) uint16 {
+	return uint16(value) << (13 - bitCount)
+}
 
-	if relative {
-		instr |= 0x10
-	}
+func EncodeSetSetOpt(bitCount uint8, value uint8) uint16 {
+	return 0x1000 | uint16(value)<<(12-bitCount)
+}
 
-	return instr
+func EncodeJmp(addr uint8, condition JmpCond) uint16 {
+	return encodeInstrAndArgs(_INSTR_BITS_JMP, uint8(condition&0b111), addr)
 }
 
-func EncodeWaitGPIO(polarity bool, pin uint16) uint16 {
-	flag := uint16(0)
-	if polarity {
-		flag = 0x4
-	}
+func encodeIRQ(relative bool, irq uint8) uint8 {
+	return boolAsU8(relative) << 4
+}
 
-	return EncodeInstrAndArgs(INSTR_BITS_WAIT, 0|flag, pin)
+func EncodeWaitGPIO(polarity bool, pin uint8) uint16 {
+	flag := boolAsU8(polarity) << 2
+	return encodeInstrAndArgs(_INSTR_BITS_WAIT, 0|flag, pin)
 }
 
-func EncodeWaitPin(polarity bool, pin uint16) uint16 {
-	flag := uint16(0)
-	if polarity {
-		flag = 0x4
-	}
+func EncodeWaitPin(polarity bool, pin uint8) uint16 {
+	flag := boolAsU8(polarity) << 2
 
-	return EncodeInstrAndArgs(INSTR_BITS_WAIT, 1|flag, pin)
+	return encodeInstrAndArgs(_INSTR_BITS_WAIT, 1|flag, pin)
 }
 
-func EncodeWaitIRQ(polarity bool, relative bool, irq uint16) uint16 {
-	flag := uint16(0)
-	if polarity {
-		flag = 0x4
-	}
+func EncodeWaitIRQ(polarity bool, relative bool, irq uint8) uint16 {
+	flag := boolAsU8(polarity) << 2
 
-	return EncodeInstrAndArgs(INSTR_BITS_WAIT, 2|flag, EncodeIRQ(relative, irq))
+	return encodeInstrAndArgs(_INSTR_BITS_WAIT, 2|flag, encodeIRQ(relative, irq))
 }
 
-func EncodeIn(src SrcDest, value uint16) uint16 {
-	return EncodeInstrAndSrcDest(INSTR_BITS_IN, src, value)
+func EncodeIn(src SrcDest, value uint8) uint16 {
+	return encodeInstrAndSrcDest(_INSTR_BITS_IN, src, value)
 }
 
-func EncodeOut(dest SrcDest, value uint16) uint16 {
-	return EncodeInstrAndSrcDest(INSTR_BITS_OUT, dest, value)
+func EncodeOut(dest SrcDest, value uint8) uint16 {
+	return encodeInstrAndSrcDest(_INSTR_BITS_OUT, dest, value)
 }
 
 func EncodePush(ifFull bool, block bool) uint16 {
-	arg := uint16(0)
-	if ifFull {
-		arg |= 2
-	}
-	if block {
-		arg |= 1
-	}
-
-	return EncodeInstrAndArgs(INSTR_BITS_PUSH, arg, 0)
+	arg := boolAsU8(ifFull)<<1 | boolAsU8(block)
+	return encodeInstrAndArgs(_INSTR_BITS_PUSH, arg, 0)
 }
 
 func EncodePull(ifEmpty bool, block bool) uint16 {
-	arg := uint16(0)
-	if ifEmpty {
-		arg |= 2
-	}
-	if block {
-		arg |= 1
-	}
-
-	return EncodeInstrAndArgs(INSTR_BITS_PULL, arg, 0)
+	arg := boolAsU8(ifEmpty)<<1 | boolAsU8(block)
+	return encodeInstrAndArgs(_INSTR_BITS_PULL, arg, 0)
 }
 
 func EncodeMov(dest SrcDest, src SrcDest) uint16 {
-	return EncodeInstrAndSrcDest(INSTR_BITS_MOV, dest, uint16(src)&7)
+	return encodeInstrAndSrcDest(_INSTR_BITS_MOV, dest, uint8(src)&7)
 }
 
 func EncodeMovNot(dest SrcDest, src SrcDest) uint16 {
-	return EncodeInstrAndSrcDest(INSTR_BITS_MOV, dest, (1<<3)|(uint16(src)&7))
+	return encodeInstrAndSrcDest(_INSTR_BITS_MOV, dest, (1<<3)|(uint8(src)&7))
 }
 
 func EncodeMovReverse(dest SrcDest, src SrcDest) uint16 {
-	return EncodeInstrAndSrcDest(INSTR_BITS_MOV, dest, (2<<3)|(uint16(src)&7))
+	return encodeInstrAndSrcDest(_INSTR_BITS_MOV, dest, (2<<3)|(uint8(src)&7))
 }
 
-func EncodeIRQSet(relative bool, irq uint16) uint16 {
-	return EncodeInstrAndArgs(INSTR_BITS_IRQ, 0, EncodeIRQ(relative, irq))
+func EncodeIRQSet(relative bool, irq uint8) uint16 {
+	return encodeInstrAndArgs(_INSTR_BITS_IRQ, 0, encodeIRQ(relative, irq))
 }
 
-func EncodeIRQClear(relative bool, irq uint16) uint16 {
-	return EncodeInstrAndArgs(INSTR_BITS_IRQ, 2, EncodeIRQ(relative, irq))
+func EncodeIRQClear(relative bool, irq uint8) uint16 {
+	return encodeInstrAndArgs(_INSTR_BITS_IRQ, 2, encodeIRQ(relative, irq))
 }
 
-func EncodeSet(dest SrcDest, value uint16) uint16 {
-	return EncodeInstrAndSrcDest(INSTR_BITS_SET, dest, value)
+func EncodeSet(dest SrcDest, value uint8) uint16 {
+	return encodeInstrAndSrcDest(_INSTR_BITS_SET, dest, value)
 }
 
 func EncodeNOP() uint16 {
@@ -196,3 +209,10 @@ func splitClkdiv(clkdiv uint64) (whole uint16, frac uint8, err error) {
 	frac = uint8(clkdiv % 256)
 	return whole, frac, nil
 }
+
+func boolAsU8(b bool) uint8 {
+	if b {
+		return 1
+	}
+	return 0
+}

rp2-pio/pio.go

@@ -104,7 +104,7 @@ func (pio *PIO) AddProgramAtOffset(instructions []uint16, origin int8, offset ui
 		instr := instructions[i]
 
 		// Patch jump instructions with relative offset
-		if INSTR_BITS_JMP == instr&INSTR_BITS_Msk {
+		if _INSTR_BITS_JMP == instr&_INSTR_BITS_Msk {
 			pio.writeInstructionMemory(offset+i, instr+uint16(offset))
 		} else {
 			pio.writeInstructionMemory(offset+i, instr)

rp2-pio/piolib/all_generate.go

@@ -15,6 +15,7 @@ var (
 //go:generate pioasm -o go spi.pio        spi_pio.go
 //go:generate pioasm -o go ws2812.pio     ws2812_pio.go
 //go:generate pioasm -o go i2s.pio        i2s_pio.go
+//go:generate pioasm -o go spi3w.pio       spi3w_pio.go
 func gosched() {
 	runtime.Gosched()
 }

rp2-pio/piolib/i2s.go

@@ -41,7 +41,7 @@ func NewI2S(sm pio.StateMachine, data, clockAndNext machine.Pin) (*I2S, error) {
 	sm.SetPindirsMasked(pinMask, pinMask)
 	sm.SetPinsMasked(0, pinMask)
 
-	sm.Exec(pio.EncodeJmp(uint16(offset) + i2soffset_entry_point))
+	sm.Exec(pio.EncodeJmp(offset+i2soffset_entry_point, pio.JmpAlways))
 
 	i2s := &I2S{
 		sm:     sm,

rp2-pio/piolib/pulsar.go

@@ -85,7 +85,7 @@ func (p *Pulsar) Stop() {
 	p.sm.ClearFIFOs()
 	p.sm.Restart()
 	p.sm.ClkDivRestart()
-	p.sm.Exec(pio.EncodeJmp(uint16(p.offsetPlusOne - 1)))
+	p.sm.Exec(pio.EncodeJmp(p.offsetPlusOne-1, pio.JmpAlways))
 	p.sm.SetEnabled(true)
 }
 

rp2-pio/piolib/spi3w.go

@@ -0,0 +1,69 @@
+//go:build rp2040
+
+package piolib
+
+import (
+	"machine"
+
+	pio "github.com/tinygo-org/pio/rp2-pio"
+)
+
+// SPI3 is a 3-wire SPI implementation for specialized use cases, such as
+// the Pico W's on-board CYW43439 WiFi module. It uses a shared data input/output pin.
+type SPI3w struct {
+	sm     pio.StateMachine
+	offset uint8
+}
+
+func NewSPI3(sm pio.StateMachine, dio, clk machine.Pin, baud uint32) (*SPI3w, error) {
+	sm.Claim() // SM should be claimed beforehand, we just guarantee it's claimed.
+
+	Pio := sm.PIO()
+	offset, err := Pio.AddProgram(spi3wInstructions, spi3wOrigin)
+	if err != nil {
+		return nil, err
+	}
+
+	// Configure state machine.
+	cfg := spi3wProgramDefaultConfig(offset)
+	cfg.SetOutPins(dio, 1)
+	cfg.SetSetPins(dio, 1)
+	cfg.SetInPins(dio)
+	cfg.SetSidesetPins(clk)
+	cfg.SetOutShift(false, true, 32)
+	cfg.SetInShift(false, true, 32)
+
+	whole, frac, err := pio.ClkDivFromFrequency(baud, machine.CPUFrequency())
+	if err != nil {
+		return nil, err
+	}
+	cfg.SetClkDivIntFrac(whole, frac)
+
+	// Configure pins
+	pinCfg := machine.PinConfig{Mode: Pio.PinMode()}
+	dio.Configure(pinCfg)
+	clk.Configure(pinCfg)
+	Pio.HW().INPUT_SYNC_BYPASS.SetBits(1 << dio)
+
+	// Initialize state machine.
+	sm.Init(offset, cfg)
+	pinMask := uint32(1<<dio | 1<<clk)
+	sm.SetPindirsMasked(0, pinMask)
+	sm.SetPinsMasked(0, pinMask)
+
+	sm.SetEnabled(true)
+
+	spiw := &SPI3w{
+		sm:     sm,
+		offset: offset,
+	}
+	return spiw, nil
+}
+
+func (spi *SPI3w) CmdRead(cmd uint32, r []uint32) error {
+	spi.sm.SetEnabled(false)
+	// writeBits := 31
+	// readBits := len(r)*32 + 32 - 1
+
+	return nil
+}

rp2-pio/piolib/spi3w.pio

@@ -0,0 +1,37 @@
+; Pico W SPI interface with CY43439 support.
+
+.program spi3w
+.side_set 1
+
+.wrap_target
+
+; write out x-1 bits
+lp: 
+    out pins, 1   side 0
+    jmp x-- lp    side 1
+    
+    ; Switch directions
+    
+    set pindirs, 0 side 0
+    nop            side 0
+    
+; read in y-1 bits
+lp2:
+    in pins, 1     side 1
+    jmp y--  lp2   side 0
+
+    ; wait for event and irq host
+
+    wait 1 pin 0   side 0
+    irq  0         side 0
+
+.wrap
+
+% go {
+//go:build rp2040
+package piolib
+
+import (
+    pio "github.com/tinygo-org/pio/rp2-pio"
+)
+%}