usb: add USB mass storage class support

Author: mikesmitty

src/machine/machine_rp2350_usb.go

@@ -80,7 +80,7 @@ func handleUSBIRQ(intr interrupt.Interrupt) {
 
 		if !ok {
 			// Stall endpoint?
-			sendStallViaEPIn(0)
+			SetStallEPIn(0)
 		}
 
 	}
@@ -248,7 +248,12 @@ func handleEndpointRx(ep uint32) []byte {
 }
 
 func handleEndpointRxComplete(ep uint32) {
-	epXdata0[ep] = !epXdata0[ep]
+	SetEPDataPID(ep, !epXdata0[ep])
+}
+
+// Set the USB endpoint Packet ID to DATA0 or DATA1
+func SetEPDataPID(ep uint32, dataOne bool) {
+	epXdata0[ep&0x7F] = dataOne
 	if epXdata0[ep] || ep == 0 {
 		_usbDPSRAM.EPxBufferControl[ep].Out.SetBits(usbBuf0CtrlData1Pid)
 	}
@@ -277,7 +282,8 @@ func sendViaEPIn(ep uint32, data []byte, count int) {
 	_usbDPSRAM.EPxBufferControl[ep&0x7F].In.Set(val)
 }
 
-func sendStallViaEPIn(ep uint32) {
+// Set the endpoint stall bit on a USB IN endpoint
+func SetStallEPIn(ep uint32) {
 	// Prepare buffer control register value
 	if ep == 0 {
 		rp.USB.EP_STALL_ARM.Set(rp.USB_EP_STALL_ARM_EP0_IN)
@@ -288,6 +294,27 @@ func sendStallViaEPIn(ep uint32) {
 	_usbDPSRAM.EPxBufferControl[ep&0x7F].In.Set(val)
 }
 
+// Set the endpoint stall bit on a USB OUT endpoint
+func SetStallEPOut(ep uint32) {
+	if ep == 0 {
+		panic("SetStallEPOut: EP0 OUT not valid")
+	}
+	val := uint32(usbBuf0CtrlStall)
+	_usbDPSRAM.EPxBufferControl[ep&0x7F].Out.Set(val)
+}
+
+// Clear the endpoint stall bit on a USB IN endpoint
+func ClearStallEPIn(ep uint32) {
+	val := uint32(usbBuf0CtrlStall)
+	_usbDPSRAM.EPxBufferControl[ep&0x7F].In.ClearBits(val)
+}
+
+// Clear the endpoint stall bit on a USB OUT endpoint
+func ClearStallEPOut(ep uint32) {
+	val := uint32(usbBuf0CtrlStall)
+	_usbDPSRAM.EPxBufferControl[ep&0x7F].Out.ClearBits(val)
+}
+
 type usbDPSRAM struct {
 	// Note that EPxControl[0] is not EP0Control but 8-byte setup data.
 	EPxControl [16]usbEndpointControlRegister

src/machine/usb.go

@@ -133,6 +133,8 @@ var (
 		usb.HID_ENDPOINT_OUT:  (usb.ENDPOINT_TYPE_DISABLE), // Interrupt Out
 		usb.MIDI_ENDPOINT_IN:  (usb.ENDPOINT_TYPE_DISABLE), // Bulk In
 		usb.MIDI_ENDPOINT_OUT: (usb.ENDPOINT_TYPE_DISABLE), // Bulk Out
+		usb.MSC_ENDPOINT_IN:   (usb.ENDPOINT_TYPE_DISABLE), // Bulk In
+		usb.MSC_ENDPOINT_OUT:  (usb.ENDPOINT_TYPE_DISABLE), // Bulk Out
 	}
 )
 

src/machine/usb/descriptor/endpoint.go

@@ -4,6 +4,17 @@ import (
 	"internal/binary"
 )
 
+/* Endpoint Descriptor
+USB 2.0 Specification: 9.6.6 Endpoint
+*/
+
+const (
+	TransferTypeControl uint8 = iota
+	TransferTypeIsochronous
+	TransferTypeBulk
+	TransferTypeInterrupt
+)
+
 var endpointEP1IN = [endpointTypeLen]byte{
 	endpointTypeLen,
 	TypeEndpoint,
@@ -74,6 +85,36 @@ var EndpointEP5OUT = EndpointType{
 	data: endpointEP5OUT[:],
 }
 
+// Mass Storage Class bulk in endpoint
+var endpointEP8IN = [endpointTypeLen]byte{
+	endpointTypeLen,
+	TypeEndpoint,
+	0x88,             // EndpointAddress
+	TransferTypeBulk, // Attributes
+	0x40,             // MaxPacketSizeL (64 bytes)
+	0x00,             // MaxPacketSizeH
+	0x00,             // Interval
+}
+
+var EndpointEP8IN = EndpointType{
+	data: endpointEP8IN[:],
+}
+
+// Mass Storage Class bulk out endpoint
+var endpointEP9OUT = [endpointTypeLen]byte{
+	endpointTypeLen,
+	TypeEndpoint,
+	0x09,             // EndpointAddress
+	TransferTypeBulk, // Attributes
+	0x40,             // MaxPacketSizeL (64 bytes)
+	0x00,             // MaxPacketSizeH
+	0x00,             // Interval
+}
+
+var EndpointEP9OUT = EndpointType{
+	data: endpointEP9OUT[:],
+}
+
 const (
 	endpointTypeLen = 7
 )

src/machine/usb/descriptor/msc.go

@@ -0,0 +1,75 @@
+package descriptor
+
+const (
+	interfaceClassMSC = 0x08
+	mscSubclassSCSI   = 0x06
+	mscProtocolBOT    = 0x50
+)
+
+var interfaceAssociationMSC = [interfaceAssociationTypeLen]byte{
+	interfaceAssociationTypeLen,
+	TypeInterfaceAssociation,
+	0x02,              // FirstInterface
+	0x01,              // InterfaceCount
+	interfaceClassMSC, // FunctionClass
+	mscSubclassSCSI,   // FunctionSubClass
+	mscProtocolBOT,    // FunctionProtocol
+	0x00,              // Function
+}
+
+var InterfaceAssociationMSC = InterfaceAssociationType{
+	data: interfaceAssociationMSC[:],
+}
+
+var interfaceMSC = [interfaceTypeLen]byte{
+	interfaceTypeLen,  // Length
+	TypeInterface,     // DescriptorType
+	0x02,              // InterfaceNumber
+	0x00,              // AlternateSetting
+	0x02,              // NumEndpoints
+	interfaceClassMSC, // InterfaceClass (Mass Storage)
+	mscSubclassSCSI,   // InterfaceSubClass (SCSI Transparent)
+	mscProtocolBOT,    // InterfaceProtocol (Bulk-Only Transport)
+	0x00,              // Interface
+}
+
+var InterfaceMSC = InterfaceType{
+	data: interfaceMSC[:],
+}
+
+var configurationMSC = [configurationTypeLen]byte{
+	configurationTypeLen,
+	TypeConfiguration,
+	0x6a, 0x00, // wTotalLength
+	0x03, // number of interfaces (bNumInterfaces)
+	0x01, // configuration value (bConfigurationValue)
+	0x00, // index to string description (iConfiguration)
+	0xa0, // attributes (bmAttributes)
+	0x32, // maxpower (100 mA) (bMaxPower)
+}
+
+var ConfigurationMSC = ConfigurationType{
+	data: configurationMSC[:],
+}
+
+// Mass Storage Class
+var MSC = Descriptor{
+	Device: DeviceCDC.Bytes(),
+	Configuration: Append([][]byte{
+		ConfigurationMSC.Bytes(),
+		InterfaceAssociationCDC.Bytes(),
+		InterfaceCDCControl.Bytes(),
+		ClassSpecificCDCHeader.Bytes(),
+		ClassSpecificCDCACM.Bytes(),
+		ClassSpecificCDCUnion.Bytes(),
+		ClassSpecificCDCCallManagement.Bytes(),
+		EndpointEP1IN.Bytes(),
+		InterfaceCDCData.Bytes(),
+		EndpointEP2OUT.Bytes(),
+		EndpointEP3IN.Bytes(),
+		InterfaceAssociationMSC.Bytes(),
+		InterfaceMSC.Bytes(),
+		EndpointEP8IN.Bytes(),
+		EndpointEP9OUT.Bytes(),
+	}),
+}

src/machine/usb/msc/cbw.go

@@ -0,0 +1,64 @@
+package msc
+
+import (
+	"machine/usb/msc/csw"
+	"machine/usb/msc/scsi"
+)
+
+const (
+	cbwMsgLen = 31 // Command Block Wrapper (CBW) message length
+)
+
+type CBW struct {
+	Data []byte
+}
+
+func (c *CBW) length() int {
+	return len(c.Data)
+}
+
+func (c *CBW) validLength() bool {
+	return len(c.Data) == cbwMsgLen
+}
+
+func (c *CBW) validSignature() bool {
+	return c.Data[0] == 0x55 && c.Data[1] == 0x53 && c.Data[2] == 0x42 && c.Data[3] == 0x43
+}
+
+func (c *CBW) scsiCmd() scsi.Cmd {
+	return scsi.Cmd{Data: c.Data[15:]}
+}
+
+func (c *CBW) transferLength() uint32 {
+	return uint32(c.Data[8]) | uint32(c.Data[9])<<8 | uint32(c.Data[10])<<16 | uint32(c.Data[11])<<24
+}
+
+// isIn returns true if the command direction is from the device to the host.
+func (c *CBW) isIn() bool {
+	return c.Data[12]>>7 != 0
+}
+
+// isOut returns true if the command direction is from the host to the device.
+func (c *CBW) isOut() bool {
+	return !c.isIn()
+}
+
+func (c *CBW) CSW(status csw.Status, residue uint32, b []byte) {
+	// Signature: 53425355h (little endian)
+	b[3] = 0x53
+	b[2] = 0x42
+	b[1] = 0x53
+	b[0] = 0x55
+	// Tag:
+	b[4] = c.Data[4]
+	b[5] = c.Data[5]
+	b[6] = c.Data[6]
+	b[7] = c.Data[7]
+	// Data Residue: (untransferred bytes)
+	b[8] = byte(residue)
+	b[9] = byte(residue >> 8)
+	b[10] = byte(residue >> 16)
+	b[11] = byte(residue >> 24)
+	// Status:
+	b[12] = byte(status)
+}

src/machine/usb/msc/csw/csw.go

@@ -0,0 +1,13 @@
+package csw
+
+type Status uint8
+
+const (
+	StatusPassed Status = iota
+	StatusFailed
+	StatusPhaseError
+)
+
+const (
+	MsgLen = 13
+)

src/machine/usb/msc/disk.go

@@ -0,0 +1,53 @@
+package msc
+
+type Disk interface {
+	Ready() bool
+	ReadOnly() bool
+	BlockCount() uint32
+	BlockSize() uint32
+	Read(offset uint32, buffer []byte) (uint32, error)
+	Write(offset uint32, buffer []byte) (uint32, error)
+}
+
+// DefaultDisk is a placeholder disk implementation
+type DefaultDisk struct {
+}
+
+// NewDefaultDisk creates a new DefaultDisk instance
+func NewDefaultDisk() *DefaultDisk {
+	return &DefaultDisk{}
+}
+
+func (d *DefaultDisk) Ready() bool {
+	return true
+}
+
+func (d *DefaultDisk) ReadOnly() bool {
+	return false
+}
+
+func (d *DefaultDisk) BlockCount() uint32 {
+	return 4096 // 2MB
+}
+
+func (d *DefaultDisk) BlockSize() uint32 {
+	return 512 // 512 bytes
+}
+
+func (d *DefaultDisk) Read(offset uint32, buffer []byte) (uint32, error) {
+	n := uint8(offset)
+	for i := range buffer {
+		n++
+		buffer[i] = n
+	}
+	return uint32(len(buffer)), nil
+}
+
+func (d *DefaultDisk) Write(offset uint32, buffer []byte) (uint32, error) {
+	return uint32(len(buffer)), nil
+}
+
+// RegisterDisk registers a disk provider with the MSC driver
+func (m *msc) RegisterDisk(disk Disk) {
+	m.disk = disk
+}