chore: add task queueing for flash writes

Author: mikesmitty

src/machine/machine_rp2040_usb.go

@@ -95,10 +95,9 @@ func handleUSBIRQ(intr interrupt.Interrupt) {
 		for i := 0; i < 16; i++ {
 			if s2&(1<<(i*2+1)) > 0 {
 				buf := handleEndpointRx(uint32(i))
-				if usbRxHandler[i] != nil {
-					usbRxHandler[i](buf)
+				if usbRxHandler[i] == nil || usbRxHandler[i](buf) {
+					AckEndpointRxMessage(uint32(i))
 				}
-				handleEndpointRxComplete(uint32(i))
 			}
 		}
 

src/machine/machine_rp2350_usb.go

@@ -98,10 +98,9 @@ func handleUSBIRQ(intr interrupt.Interrupt) {
 		for i := 0; i < 16; i++ {
 			if s2&(1<<(i*2+1)) > 0 {
 				buf := handleEndpointRx(uint32(i))
-				if usbRxHandler[i] != nil {
-					usbRxHandler[i](buf)
+				if usbRxHandler[i] == nil || usbRxHandler[i](buf) {
+					AckEndpointRxMessage(uint32(i))
 				}
-				handleEndpointRxComplete(uint32(i))
 			}
 		}
 

src/machine/machine_rp2_usb.go

@@ -115,7 +115,9 @@ func handleEndpointRx(ep uint32) []byte {
 	return _usbDPSRAM.EPxBuffer[ep].Buffer0[:sz]
 }
 
-func handleEndpointRxComplete(ep uint32) {
+// AckEndpointRxMessage is called to acknowledge the completion of a delayed USB OUT transfer.
+func AckEndpointRxMessage(ep uint32) {
+	ep = ep & 0x7F
 	setEPDataPID(ep, !epXdata0[ep])
 }
 

src/machine/usb.go

@@ -121,7 +121,7 @@ var usb_trans_buffer [255]uint8
 
 var (
 	usbTxHandler    [usb.NumberOfEndpoints]func()
-	usbRxHandler    [usb.NumberOfEndpoints]func([]byte)
+	usbRxHandler    [usb.NumberOfEndpoints]func([]byte) bool
 	usbSetupHandler [usb.NumberOfInterfaces]func(usb.Setup) bool
 	usbStallHandler [usb.NumberOfEndpoints]func(usb.Setup) bool
 
@@ -332,7 +332,12 @@ func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointC
 		} else {
 			endPoints[ep.Index] = uint32(ep.Type | usb.EndpointOut)
 			if ep.RxHandler != nil {
-				usbRxHandler[ep.Index] = ep.RxHandler
+				usbRxHandler[ep.Index] = func(b []byte) bool {
+					ep.RxHandler(b)
+					return true
+				}
+			} else if ep.DelayRxHandler != nil {
+				usbRxHandler[ep.Index] = ep.DelayRxHandler
 			}
 		}
 		if ep.StallHandler != nil {

src/machine/usb/config.go

@@ -1,12 +1,13 @@
 package usb
 
 type EndpointConfig struct {
-	Index        uint8
-	IsIn         bool
-	TxHandler    func()
-	RxHandler    func([]byte)
-	StallHandler func(Setup) bool
-	Type         uint8
+	Index          uint8
+	IsIn           bool
+	TxHandler      func()
+	RxHandler      func([]byte)
+	DelayRxHandler func([]byte) bool
+	StallHandler   func(Setup) bool
+	Type           uint8
 }
 
 type SetupConfig struct {

src/machine/usb/msc/cbw.go

@@ -12,7 +12,12 @@ const (
 )
 
 type CBW struct {
-	Data []byte
+	HasCmd bool
+	Data   []byte
+}
+
+func (c *CBW) Tag() uint32 {
+	return binary.LittleEndian.Uint32(c.Data[4:8])
 }
 
 func (c *CBW) length() int {
@@ -27,7 +32,7 @@ func (c *CBW) validSignature() bool {
 	return binary.LittleEndian.Uint32(c.Data[:4]) == Signature
 }
 
-func (c *CBW) scsiCmd() scsi.Cmd {
+func (c *CBW) SCSICmd() scsi.Cmd {
 	return scsi.Cmd{Data: c.Data[15:]}
 }
 

src/machine/usb/msc/disk.go

@@ -2,72 +2,206 @@ package msc
 
 import (
 	"encoding/binary"
+	"errors"
+	"fmt"
 	"machine"
+	"runtime/interrupt"
+	"time"
 )
 
-var _ machine.BlockDevice = (*DefaultDisk)(nil)
+var (
+	errWriteOutOfBounds = errors.New("WriteAt offset out of bounds")
+)
+
+// RegisterBlockDevice registers a BlockDevice provider with the MSC driver
+func (m *msc) RegisterBlockDevice(dev machine.BlockDevice) {
+	m.dev = dev
+
+	m.blockRatio = 1
+	m.blockSize = uint32(m.dev.WriteBlockSize())
+	if m.blockSize < 512 {
+		// If the block size is less than 512 bytes, we'll scale it up to 512 for compatibility
+		m.blockRatio = 512 / m.blockSize
+		m.blockSize = 512
+	}
+	m.blockCount = uint32(m.dev.Size()) / m.blockSize
+	// FIXME: Figure out what to do if the emulated write block size is larger than the erase block size
+
+	// Set VPD UNMAP fields
+	for i := range vpdPages {
+		if vpdPages[i].PageCode == 0xb0 {
+			// 0xb0 - 5.4.5 Block Limits VPD page (B0h)
+			if len(vpdPages[i].Data) >= 28 {
+				// Set the OPTIMAL UNMAP GRANULARITY (write blocks per erase block)
+				granularity := uint32(dev.EraseBlockSize()) / m.blockSize
+				binary.BigEndian.PutUint32(vpdPages[i].Data[24:28], granularity)
+			}
+			if len(vpdPages[i].Data) >= 32 {
+				// Set the UNMAP GRANULARITY ALIGNMENT (first sector of first full erase block)
+				// The unmap granularity alignment is used to calculate an optimal unmap request starting LBA as follows:
+				// optimal unmap request starting LBA = (n * OPTIMAL UNMAP GRANULARITY) + UNMAP GRANULARITY ALIGNMENT
+				// where n is zero or any positive integer value
+				// https://www.seagate.com/files/staticfiles/support/docs/manual/Interface%20manuals/100293068j.pdf
+
+				// We assume the block device is aligned to the end of the underlying block device
+				blockOffset := uint32(dev.EraseBlockSize()) % m.blockSize
+				binary.BigEndian.PutUint32(vpdPages[i].Data[28:32], blockOffset)
+			}
+			break
+		}
+	}
+}
+
+var _ machine.BlockDevice = (*RecorderDisk)(nil)
 
-// DefaultDisk is a placeholder disk implementation
-type DefaultDisk struct {
+// RecorderDisk is a block device that records actions taken on it
+type RecorderDisk struct {
+	data map[int64][]byte
+	log  []RecorderRecord
+	last time.Time
+	time time.Time
 }
 
-// NewDefaultDisk creates a new DefaultDisk instance
-func NewDefaultDisk() *DefaultDisk {
-	return &DefaultDisk{}
+type RecorderRecord struct {
+	OpCode RecorderOpCode
+	Offset int64
+	Length int
+	Data   []byte
+	Time   int64
+	valid  bool
 }
 
-func (d *DefaultDisk) Size() int64 {
+type RecorderOpCode uint8
+
+const (
+	RecorderOpCodeRead RecorderOpCode = iota
+	RecorderOpCodeWrite
+	RecorderOpCodeEraseBlocks
+)
+
+// NewRecorderDisk creates a new RecorderDisk instance
+func NewRecorderDisk(count int) *RecorderDisk {
+	d := &RecorderDisk{
+		data: make(map[int64][]byte),
+		log:  make([]RecorderRecord, 0, count),
+		last: time.Now(),
+	}
+	for i := 0; i < count; i++ {
+		d.log = append(d.log, RecorderRecord{
+			OpCode: RecorderOpCodeRead,
+			Offset: 0,
+			Length: 0,
+			Data:   make([]byte, 0, 64),
+			Time:   0,
+		})
+	}
+	return d
+}
+
+func (d *RecorderDisk) Size() int64 {
 	return 4096 * int64(d.WriteBlockSize()) // 2MB
 }
 
-func (d *DefaultDisk) WriteBlockSize() int64 {
+func (d *RecorderDisk) WriteBlockSize() int64 {
 	return 512 // 512 bytes
 }
 
-func (d *DefaultDisk) EraseBlockSize() int64 {
+func (d *RecorderDisk) EraseBlockSize() int64 {
 	return 2048 // 4 blocks of 512 bytes
 }
 
-func (d *DefaultDisk) EraseBlocks(startBlock, numBlocks int64) error {
+func (d *RecorderDisk) EraseBlocks(startBlock, numBlocks int64) error {
+	d.Record(RecorderOpCodeEraseBlocks, startBlock, int(numBlocks), []byte{})
+	if interrupt.In() {
+		// Flash erase commands are not allowed in interrupt context
+		panic("EraseBlocks attempted in interrupt context")
+	}
 	return nil
 }
 
-func (d *DefaultDisk) ReadAt(buffer []byte, offset int64) (int, error) {
-	n := uint8(offset)
-	for i := range buffer {
-		n++
-		buffer[i] = n
+func (d *RecorderDisk) ReadAt(buffer []byte, offset int64) (int, error) {
+	d.Record(RecorderOpCodeRead, offset, len(buffer), []byte{})
+	sector := offset / d.WriteBlockSize()
+	if sector < 0 || offset+int64(len(buffer)) > d.Size() {
+		return 0, fmt.Errorf("read out of bounds: %d", offset)
+	}
+
+	sectorCount := int64(len(buffer)) / d.WriteBlockSize()
+	for i := int64(0); i < sectorCount; i++ {
+		if _, ok := d.data[sector+i]; ok {
+			n := int(offset % d.WriteBlockSize())
+			copy(buffer, d.data[sector+i][n:])
+		}
 	}
+
 	return len(buffer), nil
 }
 
-func (d *DefaultDisk) WriteAt(buffer []byte, offset int64) (int, error) {
+func (d *RecorderDisk) WriteAt(buffer []byte, offset int64) (int, error) {
+	if interrupt.In() {
+		// Flash writes aren't possible in interrupt context
+		panic("WriteAt attempted in interrupt context")
+	}
+	if offset < 0 || offset+int64(len(buffer)) > d.Size() {
+		return 0, errWriteOutOfBounds
+	}
+
+	d.Record(RecorderOpCodeWrite, offset, len(buffer), buffer)
+
+	sector := offset / d.WriteBlockSize()
+	sectorCount := int64(len(buffer)) / d.WriteBlockSize()
+	for i := int64(0); i < sectorCount; i++ {
+		_, ok := d.data[sector+i]
+		if !ok {
+			d.data[sector+i] = make([]byte, d.WriteBlockSize())
+		}
+		n := int(offset % d.WriteBlockSize())
+		copy(d.data[sector+i][n:], buffer)
+	}
 	return len(buffer), nil
 }
 
-// RegisterBlockDevice registers a BlockDevice provider with the MSC driver
-func (m *msc) RegisterBlockDevice(dev machine.BlockDevice) {
-	m.dev = dev
-
-	// Set VPD UNMAP fields
-	for i := range vpdPages {
-		if vpdPages[i].PageCode == 0xb0 {
-			// 0xb0 - 5.4.5 Block Limits VPD page (B0h)
-			if len(vpdPages[i].Data) >= 28 {
-				// Set the OPTIMAL UNMAP GRANULARITY (write blocks per erase block)
-				granularity := uint32(dev.EraseBlockSize()) / uint32(dev.WriteBlockSize())
-				binary.BigEndian.PutUint32(vpdPages[i].Data[24:28], granularity)
-			}
-			/* TODO: Add method for working out the optimal unmap granularity alignment
-			if len(vpdPages[i].Data) >= 32 {
-				// Set the UNMAP GRANULARITY ALIGNMENT (first sector of first full erase block)
-				// The unmap granularity alignment is used to calculate an optimal unmap request starting LBA as follows:
-				// optimal unmap request starting LBA = (n * OPTIMAL UNMAP GRANULARITY) + UNMAP GRANULARITY ALIGNMENT
-				// where n is zero or any positive integer value
-				// https://www.seagate.com/files/staticfiles/support/docs/manual/Interface%20manuals/100293068j.pdf
-			}
-			*/
-			break
+func (d *RecorderDisk) Record(opCode RecorderOpCode, offset int64, length int, data []byte) {
+	n := len(d.log)
+	if n == 0 {
+		return
+	} else if n == cap(d.log) {
+		for i := 0; i < n-1; i++ {
+			d.log[i] = d.log[i+1]
 		}
 	}
+
+	// Append the new record
+	d.log[n-1].OpCode = opCode
+	d.log[n-1].Offset = offset
+	d.log[n-1].Length = length
+	d.log[n-1].Data = d.log[n-1].Data[:len(data)]
+	copy(d.log[n-1].Data, data)
+	d.log[n-1].Time = time.Since(d.time).Microseconds()
+	d.time = d.time.Add(time.Since(d.time))
+	d.log[n-1].valid = true
+}
+
+func (d *RecorderDisk) ClearLog() {
+	for i := range d.log {
+		d.log[i].valid = false
+	}
+	d.time = time.Now()
+}
+
+func (d *RecorderDisk) GetLog() []RecorderRecord {
+	return d.log
+}
+
+func (r RecorderRecord) String() (string, bool) {
+	opCode := "Unknown"
+	switch r.OpCode {
+	case RecorderOpCodeRead:
+		opCode = "Read"
+	case RecorderOpCodeWrite:
+		opCode = "Write"
+	case RecorderOpCodeEraseBlocks:
+		opCode = "EraseBlocks"
+	}
+	return fmt.Sprintf("%s: %05d+%02d t:%d| % 0x", opCode, r.Offset, r.Length, r.Time, r.Data), r.valid
 }