sd: overhaul type names; SdCardPeripheral, sdCard, state.

Author: pda

sd/sd_card.go

@@ -0,0 +1,149 @@
+//go:generate stringer -type state
+
+package sd
+
+import "fmt"
+
+type state uint8
+
+// states
+const (
+	sCommand  state = iota // expect command
+	sArgument              // expect argument
+	sChecksum              // expect checksum
+	sData                  // sending data until misoQueue empty.
+)
+
+const (
+	r1_ready = 0x00
+	r1_idle  = 0x01
+)
+
+const (
+	// blockSize isn't strictly constant, but...
+	blockSize = 512
+)
+
+// sdCard is the state of SD protocol (layer above SPI protocol).
+type sdCard struct {
+	state     state
+	acmd      bool // next command is an application-specific command
+	cmd       uint8
+	arg       uint32
+	argByte   uint8
+	misoQueue []byte // data waiting to be sent from card.
+	prevCmd   uint8
+	prevAcmd  uint8
+	data      []byte
+}
+
+func newSdCard() (sd *sdCard) {
+	return &sdCard{
+		misoQueue: make([]byte, 0, 1024),
+	}
+}
+
+func (sd *sdCard) enter(state state) {
+	fmt.Printf("SD state %s -> %s\n", sd.state, state)
+	sd.state = state
+}
+
+func (sd *sdCard) consumeByte(b byte) {
+	switch sd.state {
+	case sCommand:
+		if b>>6 == 1 {
+			sd.cmd = b & (0xFF >> 2)
+			sd.enter(sArgument)
+			sd.arg = 0x00000000
+			sd.argByte = 0
+		}
+	case sArgument:
+		sd.arg |= uint32(b) << ((3 - sd.argByte) * 8)
+		if sd.argByte == 3 {
+			sd.enter(sChecksum)
+		} else {
+			sd.argByte++
+		}
+	case sChecksum:
+		if sd.acmd {
+			sd.handleAcmd()
+		} else {
+			sd.handleCmd()
+		}
+	case sData:
+		// ignore; data it being sent.
+
+	default:
+		panic(fmt.Errorf("Unhandled state: %d", sd.state))
+	}
+}
+
+func (sd *sdCard) handleCmd() {
+	fmt.Printf("SD CMD%d arg: 0x%08X\n", sd.cmd, sd.arg)
+	switch sd.cmd {
+	case 0: // GO_IDLE_STATE
+		fmt.Println("SD CMD0 response: r1_idle")
+		sd.queueMisoBytes(0xFF, 0xFF, r1_idle) // busy then idle
+		sd.enter(sCommand)
+	case 17: // READ_SINGLE_BLOCK
+		fmt.Println("SD CMD17 response: r1_ready, data start block, data")
+		sd.queueMisoBytes(0xFF, 0xFF, r1_ready)   // busy then ready
+		sd.queueMisoBytes(0xFF, 0xFF, 0xFF, 0xFF) // time before data block
+		sd.queueMisoBytes(0xFE)                   // data start block
+		sd.queueMisoBytes(sd.readBlock(sd.arg)...)
+		sd.enter(sData)
+	case 55: // APP_CMD
+		fmt.Println("SD CMD55 response: r1_idle")
+		sd.queueMisoBytes(r1_idle) // busy then idle
+		sd.acmd = true
+		sd.enter(sCommand)
+	default:
+		panic(fmt.Sprintf("Unhandled CMD%d", sd.cmd))
+	}
+	sd.prevCmd = sd.cmd
+}
+
+func (sd *sdCard) handleAcmd() {
+	fmt.Printf("SD ACMD%d arg: 0x%08X\n", sd.cmd, sd.arg)
+	switch sd.cmd {
+	case 41: // SD_SEND_OP_COND
+		if sd.prevAcmd == 41 {
+			// on second attempt, busy, busy, then ready.
+			fmt.Println("SD ACMD41 response: r1_ready")
+			sd.queueMisoBytes(0xFF, 0xFF, r1_ready)
+		} else {
+			// on first attempt, busy, busy, then idle (not yet ready).
+			fmt.Println("SD ACMD41 response: r1_idle")
+			sd.queueMisoBytes(0xFF, 0xFF, r1_idle)
+		}
+		sd.enter(sCommand)
+	default:
+		panic(fmt.Sprintf("Unhandled ACMD%d", sd.cmd))
+	}
+	sd.prevAcmd = sd.cmd
+	sd.acmd = false
+}
+
+func (sd *sdCard) queueMisoBytes(bytes ...byte) {
+	sd.misoQueue = append(sd.misoQueue, bytes...)
+}
+
+func (sd *sdCard) shiftMiso() (b byte) {
+	if len(sd.misoQueue) > 0 {
+		b = sd.misoQueue[0]
+		sd.misoQueue = sd.misoQueue[1:len(sd.misoQueue)]
+		if len(sd.misoQueue) == 0 && sd.state == sData {
+			// transition from sData to sCommand when all data sent.
+			sd.enter(sCommand)
+		}
+	} else {
+		b = 0x00 // default to low for empty buffer.
+	}
+	return
+}
+
+func (sd *sdCard) readBlock(start uint32) []byte {
+	// TODO: bounds checking
+	// TODO: zero-fill remainder of last page in sd.data?
+	return sd.data[start : start+blockSize]
+}

sd/sd_card_peripheral.go

@@ -7,19 +7,19 @@ import (
 )
 
 type SdCardPeripheral struct {
-	state *sdState
-	spi   *spi.Slave
+	card *sdCard
+	spi  *spi.Slave
 }
 
 // SdFromFile creates a new SdCardPeripheral based on the contents of a file.
 func NewSdCardPeripheral(pm spi.PinMap) (sd *SdCardPeripheral, err error) {
 	sd = &SdCardPeripheral{
-		state: newSdState(),
-		spi:   spi.NewSlave(pm),
+		card: newSdCard(),
+		spi:  spi.NewSlave(pm),
 	}
 
 	// two busy bytes, then ready.
-	sd.state.queueMisoBytes(0x00, 0x00, 0xFF)
+	sd.card.queueMisoBytes(0x00, 0x00, 0xFF)
 
 	return
 }
@@ -30,7 +30,7 @@ func (sd *SdCardPeripheral) LoadFile(path string) (err error) {
 	if err != nil {
 		return
 	}
-	sd.state.data = data
+	sd.card.data = data
 	return
 }
 
@@ -56,9 +56,9 @@ func (sd *SdCardPeripheral) Write(data byte) {
 			//	mosi, mosi, sd.spi.Miso, sd.spi.Miso)
 
 			// consume the byte read, queue miso bytes internally
-			sd.state.consumeByte(mosi)
+			sd.card.consumeByte(mosi)
 			// dequeues one miso byte, or a default byte if queue empty.
-			sd.spi.QueueMisoBits(sd.state.shiftMiso())
+			sd.spi.QueueMisoBits(sd.card.shiftMiso())
 		}
 	}
 }

sd/sd_state.go

@@ -0,0 +1,21 @@
+// generated by stringer -type state; DO NOT EDIT
+
+package sd
+
+import "fmt"
+
+const _state_name = "sCommandsArgumentsChecksumsData"
+
+var _state_index = [...]uint8{8, 17, 26, 31}
+
+func (i state) String() string {
+	if i >= state(len(_state_index)) {
+		return fmt.Sprintf("state(%d)", i)
+	}
+	hi := _state_index[i]
+	lo := uint8(0)
+	if i > 0 {
+		lo = _state_index[i-1]
+	}
+	return _state_name[lo:hi]
+}