fix: handle write block sizes < usb packet size

refactor: clean up duplicated device init logic

Author: mikesmitty

src/machine/usb/msc/msc.go

@@ -1,6 +1,7 @@
 package msc
 
 import (
+	"encoding/binary"
 	"machine"
 	"machine/usb"
 	"machine/usb/descriptor"
@@ -72,9 +73,7 @@ func newMSC(dev machine.BlockDevice) *msc {
 	maxPacketSize := descriptor.EndpointMSCIN.GetMaxPacketSize()
 	m := &msc{
 		// Some platforms require reads/writes to be aligned to the full underlying hardware block
-		blockCache:    make([]byte, dev.WriteBlockSize()),
 		blockSizeUSB:  512,
-		buf:           make([]byte, dev.WriteBlockSize()),
 		cswBuf:        make([]byte, csw.MsgLen),
 		cbw:           &CBW{Data: make([]byte, 31)},
 		maxPacketSize: uint32(maxPacketSize),
@@ -297,3 +296,49 @@ func (m *msc) run(b []byte, isEpOut bool) bool {
 
 	return ack
 }
+
+// RegisterBlockDevice registers a BlockDevice provider with the MSC driver
+func (m *msc) RegisterBlockDevice(dev machine.BlockDevice) {
+	m.dev = dev
+
+	maxPacketSize := descriptor.EndpointMSCIN.GetMaxPacketSize()
+	bufSize := max(dev.WriteBlockSize(), int64(maxPacketSize))
+
+	if cap(m.blockCache) != int(bufSize) {
+		m.blockCache = make([]byte, bufSize)
+		m.buf = make([]byte, bufSize)
+	}
+
+	m.blockSizeRaw = uint32(m.dev.WriteBlockSize())
+	m.blockCount = uint32(m.dev.Size()) / m.blockSizeUSB
+	// Read/write/erase operations must be aligned to the underlying hardware blocks. In order to align
+	// them we assume the provided block device is aligned to the end of the underlying hardware block
+	// device and offset all reads/writes by the remaining bytes that don't make up a full block.
+	m.blockOffset = uint32(m.dev.Size()) % m.blockSizeUSB
+
+	// 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.blockSizeUSB
+				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.blockSizeUSB
+				// Set the UGAVALID bit to indicate that the UNMAP GRANULARITY ALIGNMENT is valid
+				blockOffset |= 0x80000000
+				binary.BigEndian.PutUint32(vpdPages[i].Data[28:32], blockOffset)
+			}
+			break
+		}
+	}
+}

src/machine/usb/msc/disk.go renamed to src/machine/usb/msc/recorder.go

@@ -1,7 +1,6 @@
 package msc
 
 import (
-	"encoding/binary"
 	"errors"
 	"fmt"
 	"machine"
@@ -12,50 +11,6 @@ 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
-
-	if cap(m.blockCache) != int(dev.WriteBlockSize()) {
-		m.blockCache = make([]byte, dev.WriteBlockSize())
-		m.buf = make([]byte, dev.WriteBlockSize())
-	}
-
-	m.blockSizeRaw = uint32(m.dev.WriteBlockSize())
-	m.blockCount = uint32(m.dev.Size()) / m.blockSizeUSB
-	// Read/write/erase operations must be aligned to the underlying hardware blocks. In order to align
-	// them we assume the provided block device is aligned to the end of the underlying hardware block
-	// device and offset all reads/writes by the remaining bytes that don't make up a full block.
-	m.blockOffset = uint32(m.dev.Size()) % m.blockSizeUSB
-	// 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.blockSizeUSB
-				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.blockSizeUSB
-				// Set the UGAVALID bit to indicate that the UNMAP GRANULARITY ALIGNMENT is valid
-				blockOffset |= 0x80000000
-				binary.BigEndian.PutUint32(vpdPages[i].Data[28:32], blockOffset)
-			}
-			break
-		}
-	}
-}
-
 var _ machine.BlockDevice = (*RecorderDisk)(nil)
 
 // RecorderDisk is a block device that records actions taken on it

src/machine/usb/msc/scsi_readwrite.go

@@ -87,7 +87,7 @@ func (m *msc) writeBlock(b []byte, lba, offset uint32) (n int, err error) {
 	// Convert the emulated block address to the underlying hardware block's start and offset
 	blockStart, blockOffset := m.usbToRawOffset(lba, offset)
 
-	if blockOffset != 0 || len(b) != int(m.blockSizeRaw) {
+	if blockOffset != 0 || len(b)%int(m.blockSizeRaw) != 0 {
 		return 0, invalidWriteError
 	}