djsundog/circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
b384bcc5de
circuitpython/stmhal/usbdev/class/src/usbd_cdc_msc_hid.c

921 lines
33 KiB
C
Raw Normal View History

stmhal: Implement selector for USB device mode; improve boot up. Can now choose at boot up whether the USB device is CDC+MSC or CDC+HID. Choice is made by an option in boot.py, with default being CDC+MSC. HID+MSC is not currently supported, but should be easy to implement. Boot up now has ability to change the reset mode: hold down USR switch while booting and LEDs will count from 1 to 7 to indicate the boot mode. Release USR when correct mode is selected. Current modes are 1 (normal boot), 2 (safe mode), 3 (reset FS mode).
2014-03-29 20:00:15 -04:00
#include "usbd_ioreq.h"
#include "usbd_cdc_msc_hid.h"
#define USB_CDC_MSC_CONFIG_DESC_SIZ (98)
#define USB_CDC_HID_CONFIG_DESC_SIZ (100)
#define CDC_IFACE_NUM (1)
#define MSC_IFACE_NUM (0)
#define HID_IFACE_NUM_WITH_CDC (0)
#define HID_IFACE_NUM_WITH_MSC (1)
#define HID_IN_EP_WITH_CDC (0x81)
#define HID_IN_EP_WITH_MSC (0x83)
#define USB_DESC_TYPE_ASSOCIATION (0x0b)
#define CDC_CMD_PACKET_SIZE 8 // Control Endpoint Packet size
#define CDC_DATA_IN_PACKET_SIZE CDC_DATA_FS_MAX_PACKET_SIZE
#define CDC_DATA_OUT_PACKET_SIZE CDC_DATA_FS_MAX_PACKET_SIZE
#define MSC_MAX_PACKET 0x40
#define USB_MSC_CONFIG_DESC_SIZ 32
#define BOT_GET_MAX_LUN 0xFE
#define BOT_RESET 0xFF
#define HID_MAX_PACKET 0x04
#define USB_HID_DESC_SIZ 9
#define HID_MOUSE_REPORT_DESC_SIZE 74
#define HID_KEYBOARD_REPORT_DESC_SIZE 63
#define HID_DESCRIPTOR_TYPE 0x21
#define HID_REPORT_DESC 0x22
#define HID_REQ_SET_PROTOCOL 0x0B
#define HID_REQ_GET_PROTOCOL 0x03
#define HID_REQ_SET_IDLE 0x0A
#define HID_REQ_GET_IDLE 0x02
typedef enum {
HID_IDLE = 0,
HID_BUSY,
} HID_StateTypeDef;
typedef struct {
uint32_t Protocol;
uint32_t IdleState;
uint32_t AltSetting;
HID_StateTypeDef state;
} USBD_HID_HandleTypeDef;
static uint8_t usbd_mode;
static uint8_t hid_in_ep;
static uint8_t hid_iface_num;
static USBD_CDC_ItfTypeDef *CDC_fops;
static USBD_StorageTypeDef *MSC_fops;
static USBD_CDC_HandleTypeDef CDC_ClassData;
static USBD_MSC_BOT_HandleTypeDef MSC_BOT_ClassData;
static USBD_HID_HandleTypeDef HID_ClassData;
// I don't think we can make these descriptors constant because they are
// modified (perhaps unnecessarily) by the USB driver.
// USB Standard Device Descriptor
__ALIGN_BEGIN static uint8_t USBD_CDC_MSC_HID_DeviceQualifierDesc[USB_LEN_DEV_QUALIFIER_DESC] __ALIGN_END = {
USB_LEN_DEV_QUALIFIER_DESC,
USB_DESC_TYPE_DEVICE_QUALIFIER,
0x00,
0x02,
0x00,
0x00,
0x00,
0x40, // same for CDC and MSC (latter being MSC_MAX_PACKET), HID is 0x04
0x01,
0x00,
};
// USB CDC MSC device Configuration Descriptor
__ALIGN_BEGIN static uint8_t USBD_CDC_MSC_CfgDesc[USB_CDC_MSC_CONFIG_DESC_SIZ] __ALIGN_END = {
//--------------------------------------------------------------------------
// Configuration Descriptor
0x09, // bLength: Configuration Descriptor size
USB_DESC_TYPE_CONFIGURATION, // bDescriptorType: Configuration
LOBYTE(USB_CDC_MSC_CONFIG_DESC_SIZ), // wTotalLength: no of returned bytes
HIBYTE(USB_CDC_MSC_CONFIG_DESC_SIZ),
0x03, // bNumInterfaces: 3 interfaces
0x01, // bConfigurationValue: Configuration value
0x00, // iConfiguration: Index of string descriptor describing the configuration
0x80, // bmAttributes: bus powered; 0xc0 for self powered
0xfa, // bMaxPower: in units of 2mA
//==========================================================================
// Interface Association for CDC VCP
0x08, // bLength: 8 bytes
USB_DESC_TYPE_ASSOCIATION, // bDescriptorType: IAD
CDC_IFACE_NUM, // bFirstInterface: first interface for this association
0x02, // bInterfaceCount: nummber of interfaces for this association
USB CDC ACM: populate bFunction{Class,SubClass,Protocol} in the interface association descriptor
2014-10-24 08:54:32 -04:00
0x02, // bFunctionClass: Communication Interface Class
0x02, // bFunctionSubClass: Abstract Control Model
0x01, // bFunctionProtocol: Common AT commands
stmhal: Implement selector for USB device mode; improve boot up. Can now choose at boot up whether the USB device is CDC+MSC or CDC+HID. Choice is made by an option in boot.py, with default being CDC+MSC. HID+MSC is not currently supported, but should be easy to implement. Boot up now has ability to change the reset mode: hold down USR switch while booting and LEDs will count from 1 to 7 to indicate the boot mode. Release USR when correct mode is selected. Current modes are 1 (normal boot), 2 (safe mode), 3 (reset FS mode).
2014-03-29 20:00:15 -04:00
0x00, // iFunction: index of string for this function
//--------------------------------------------------------------------------
// Interface Descriptor
0x09, // bLength: Interface Descriptor size
USB_DESC_TYPE_INTERFACE, // bDescriptorType: Interface
CDC_IFACE_NUM, // bInterfaceNumber: Number of Interface
0x00, // bAlternateSetting: Alternate setting
0x01, // bNumEndpoints: One endpoints used
0x02, // bInterfaceClass: Communication Interface Class
0x02, // bInterfaceSubClass: Abstract Control Model
0x01, // bInterfaceProtocol: Common AT commands
0x00, // iInterface:
// Header Functional Descriptor
0x05, // bLength: Endpoint Descriptor size
0x24, // bDescriptorType: CS_INTERFACE
0x00, // bDescriptorSubtype: Header Func Desc
0x10, // bcdCDC: spec release number
0x01, // ?
// Call Management Functional Descriptor
0x05, // bFunctionLength
0x24, // bDescriptorType: CS_INTERFACE
0x01, // bDescriptorSubtype: Call Management Func Desc
0x00, // bmCapabilities: D0+D1
CDC_IFACE_NUM + 1, // bDataInterface: 1
// ACM Functional Descriptor
0x04, // bFunctionLength
0x24, // bDescriptorType: CS_INTERFACE
0x02, // bDescriptorSubtype: Abstract Control Management desc
0x02, // bmCapabilities
// Union Functional Descriptor
0x05, // bFunctionLength
0x24, // bDescriptorType: CS_INTERFACE
0x06, // bDescriptorSubtype: Union func desc
CDC_IFACE_NUM + 0, // bMasterInterface: Communication class interface
CDC_IFACE_NUM + 1, // bSlaveInterface0: Data Class Interface
// Endpoint 2 Descriptor
0x07, // bLength: Endpoint Descriptor size
USB_DESC_TYPE_ENDPOINT, // bDescriptorType: Endpoint
CDC_CMD_EP, // bEndpointAddress
0x03, // bmAttributes: Interrupt
LOBYTE(CDC_CMD_PACKET_SIZE), // wMaxPacketSize:
HIBYTE(CDC_CMD_PACKET_SIZE),
0x20, // bInterval: polling interval in frames of 1ms
//--------------------------------------------------------------------------
// Data class interface descriptor
0x09, // bLength: Endpoint Descriptor size
USB_DESC_TYPE_INTERFACE, // bDescriptorType: interface
CDC_IFACE_NUM + 1, // bInterfaceNumber: Number of Interface
0x00, // bAlternateSetting: Alternate setting
0x02, // bNumEndpoints: Two endpoints used
0x0A, // bInterfaceClass: CDC
0x00, // bInterfaceSubClass: ?
0x00, // bInterfaceProtocol: ?
0x00, // iInterface:
// Endpoint OUT Descriptor
0x07, // bLength: Endpoint Descriptor size
USB_DESC_TYPE_ENDPOINT, // bDescriptorType: Endpoint
CDC_OUT_EP, // bEndpointAddress
0x02, // bmAttributes: Bulk
LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),// wMaxPacketSize:
HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
0x00, // bInterval: ignore for Bulk transfer
// Endpoint IN Descriptor
0x07, // bLength: Endpoint Descriptor size
USB_DESC_TYPE_ENDPOINT, // bDescriptorType: Endpoint
CDC_IN_EP, // bEndpointAddress
0x02, // bmAttributes: Bulk
LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),// wMaxPacketSize:
HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
0x00, // bInterval: ignore for Bulk transfer
//==========================================================================
// MSC only has 1 interface so doesn't need an IAD
//--------------------------------------------------------------------------
// Interface Descriptor
0x09, // bLength: Interface Descriptor size
USB_DESC_TYPE_INTERFACE, // bDescriptorType: interface descriptor
MSC_IFACE_NUM, // bInterfaceNumber: Number of Interface
0x00, // bAlternateSetting: Alternate setting
0x02, // bNumEndpoints
0x08, // bInterfaceClass: MSC Class
0x06, // bInterfaceSubClass : SCSI transparent
0x50, // nInterfaceProtocol
0x00, // iInterface:
// Endpoint IN descriptor
0x07, // bLength: Endpoint descriptor length
USB_DESC_TYPE_ENDPOINT, // bDescriptorType: Endpoint descriptor type
MSC_IN_EP, // bEndpointAddress: IN, address 3
0x02, // bmAttributes: Bulk endpoint type
LOBYTE(MSC_MAX_PACKET), // wMaxPacketSize
HIBYTE(MSC_MAX_PACKET),
0x00, // bInterval: ignore for Bulk transfer
// Endpoint OUT descriptor
0x07, // bLength: Endpoint descriptor length
USB_DESC_TYPE_ENDPOINT, // bDescriptorType: Endpoint descriptor type
MSC_OUT_EP, // bEndpointAddress: OUT, address 3
0x02, // bmAttributes: Bulk endpoint type
LOBYTE(MSC_MAX_PACKET), // wMaxPacketSize
HIBYTE(MSC_MAX_PACKET),
0x00, // bInterval: ignore for Bulk transfer
};
// USB CDC HID device Configuration Descriptor
__ALIGN_BEGIN static uint8_t USBD_CDC_HID_CfgDesc[USB_CDC_HID_CONFIG_DESC_SIZ] __ALIGN_END = {
//--------------------------------------------------------------------------
// Configuration Descriptor
0x09, // bLength: Configuration Descriptor size
USB_DESC_TYPE_CONFIGURATION, // bDescriptorType: Configuration
LOBYTE(USB_CDC_HID_CONFIG_DESC_SIZ), // wTotalLength: no of returned bytes
HIBYTE(USB_CDC_HID_CONFIG_DESC_SIZ),
0x03, // bNumInterfaces: 3 interfaces
0x01, // bConfigurationValue: Configuration value
0x00, // iConfiguration: Index of string descriptor describing the configuration
0x80, // bmAttributes: bus powered; 0xc0 for self powered
0xfa, // bMaxPower: in units of 2mA
//==========================================================================
// Interface Association for CDC VCP
0x08, // bLength: 8 bytes
USB_DESC_TYPE_ASSOCIATION, // bDescriptorType: IAD
CDC_IFACE_NUM, // bFirstInterface: first interface for this association
0x02, // bInterfaceCount: nummber of interfaces for this association
stmhal: Fill in USB class/subclass/proto for CDC+HID device. Also change HID device from keyboard to mouse (should have been mouse all along).
2014-10-24 20:12:41 -04:00
0x02, // bFunctionClass: Communication Interface Class
0x02, // bFunctionSubClass: Abstract Control Model
0x01, // bFunctionProtocol: Common AT commands
stmhal: Implement selector for USB device mode; improve boot up. Can now choose at boot up whether the USB device is CDC+MSC or CDC+HID. Choice is made by an option in boot.py, with default being CDC+MSC. HID+MSC is not currently supported, but should be easy to implement. Boot up now has ability to change the reset mode: hold down USR switch while booting and LEDs will count from 1 to 7 to indicate the boot mode. Release USR when correct mode is selected. Current modes are 1 (normal boot), 2 (safe mode), 3 (reset FS mode).
2014-03-29 20:00:15 -04:00
0x00, // iFunction: index of string for this function
//--------------------------------------------------------------------------
// Interface Descriptor
0x09, // bLength: Interface Descriptor size
USB_DESC_TYPE_INTERFACE, // bDescriptorType: Interface
CDC_IFACE_NUM, // bInterfaceNumber: Number of Interface
0x00, // bAlternateSetting: Alternate setting
0x01, // bNumEndpoints: One endpoints used
0x02, // bInterfaceClass: Communication Interface Class
0x02, // bInterfaceSubClass: Abstract Control Model
0x01, // bInterfaceProtocol: Common AT commands
0x00, // iInterface:
// Header Functional Descriptor
0x05, // bLength: Endpoint Descriptor size
0x24, // bDescriptorType: CS_INTERFACE
0x00, // bDescriptorSubtype: Header Func Desc
0x10, // bcdCDC: spec release number
0x01, // ?
// Call Management Functional Descriptor
0x05, // bFunctionLength
0x24, // bDescriptorType: CS_INTERFACE
0x01, // bDescriptorSubtype: Call Management Func Desc
0x00, // bmCapabilities: D0+D1
CDC_IFACE_NUM + 1, // bDataInterface: 1
// ACM Functional Descriptor
0x04, // bFunctionLength
0x24, // bDescriptorType: CS_INTERFACE
0x02, // bDescriptorSubtype: Abstract Control Management desc
0x02, // bmCapabilities
// Union Functional Descriptor
0x05, // bFunctionLength
0x24, // bDescriptorType: CS_INTERFACE
0x06, // bDescriptorSubtype: Union func desc
CDC_IFACE_NUM + 0, // bMasterInterface: Communication class interface
CDC_IFACE_NUM + 1, // bSlaveInterface0: Data Class Interface
// Endpoint 2 Descriptor
0x07, // bLength: Endpoint Descriptor size
USB_DESC_TYPE_ENDPOINT, // bDescriptorType: Endpoint
CDC_CMD_EP, // bEndpointAddress
0x03, // bmAttributes: Interrupt
LOBYTE(CDC_CMD_PACKET_SIZE), // wMaxPacketSize:
HIBYTE(CDC_CMD_PACKET_SIZE),
0x20, // bInterval: polling interval in frames of 1ms
//--------------------------------------------------------------------------
// Data class interface descriptor
0x09, // bLength: Endpoint Descriptor size
USB_DESC_TYPE_INTERFACE, // bDescriptorType: interface
CDC_IFACE_NUM + 1, // bInterfaceNumber: Number of Interface
0x00, // bAlternateSetting: Alternate setting
0x02, // bNumEndpoints: Two endpoints used
0x0A, // bInterfaceClass: CDC
0x00, // bInterfaceSubClass: ?
0x00, // bInterfaceProtocol: ?
0x00, // iInterface:
// Endpoint OUT Descriptor
0x07, // bLength: Endpoint Descriptor size
USB_DESC_TYPE_ENDPOINT, // bDescriptorType: Endpoint
CDC_OUT_EP, // bEndpointAddress
0x02, // bmAttributes: Bulk
LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),// wMaxPacketSize:
HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
0x00, // bInterval: ignore for Bulk transfer
// Endpoint IN Descriptor
0x07, // bLength: Endpoint Descriptor size
USB_DESC_TYPE_ENDPOINT, // bDescriptorType: Endpoint
CDC_IN_EP, // bEndpointAddress
0x02, // bmAttributes: Bulk
LOBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),// wMaxPacketSize:
HIBYTE(CDC_DATA_FS_MAX_PACKET_SIZE),
0x00, // bInterval: ignore for Bulk transfer
//==========================================================================
// HID only has 1 interface so doesn't need an IAD
//--------------------------------------------------------------------------
// Interface Descriptor
0x09, // bLength: Interface Descriptor size
USB_DESC_TYPE_INTERFACE, // bDescriptorType: interface descriptor
HID_IFACE_NUM_WITH_CDC, // bInterfaceNumber: Number of Interface
0x00, // bAlternateSetting: Alternate setting
0x01, // bNumEndpoints
0x03, // bInterfaceClass: HID Class
0x01, // bInterfaceSubClass: 1=BOOT, 0=no boot
stmhal: Fill in USB class/subclass/proto for CDC+HID device. Also change HID device from keyboard to mouse (should have been mouse all along).
2014-10-24 20:12:41 -04:00
0x02, // nInterfaceProtocol: 0=none, 1=keyboard, 2=mouse
stmhal: Implement selector for USB device mode; improve boot up. Can now choose at boot up whether the USB device is CDC+MSC or CDC+HID. Choice is made by an option in boot.py, with default being CDC+MSC. HID+MSC is not currently supported, but should be easy to implement. Boot up now has ability to change the reset mode: hold down USR switch while booting and LEDs will count from 1 to 7 to indicate the boot mode. Release USR when correct mode is selected. Current modes are 1 (normal boot), 2 (safe mode), 3 (reset FS mode).
2014-03-29 20:00:15 -04:00
0x00, // iInterface:
// HID descriptor
0x09, // bLength: HID Descriptor size
HID_DESCRIPTOR_TYPE, // bDescriptorType: HID
0x11, // bcdHID: HID Class Spec release number
0x01,
0x00, // bCountryCode: Hardware target country
0x01, // bNumDescriptors: Number of HID class descriptors to follow
0x22, // bDescriptorType
HID_MOUSE_REPORT_DESC_SIZE, // wItemLength: Total length of Report descriptor
0x00,
// Endpoint IN descriptor
0x07, // bLength: Endpoint descriptor length
USB_DESC_TYPE_ENDPOINT, // bDescriptorType: Endpoint descriptor type
HID_IN_EP_WITH_CDC, // bEndpointAddress: IN
0x03, // bmAttributes: Interrupt endpoint type
LOBYTE(HID_MAX_PACKET), // wMaxPacketSize
HIBYTE(HID_MAX_PACKET),
0x08, // bInterval: Polling interval
};
/* USB HID device Configuration Descriptor */
__ALIGN_BEGIN static uint8_t USBD_HID_Desc[USB_HID_DESC_SIZ] __ALIGN_END = {
0x09, /*bLength: HID Descriptor size*/
HID_DESCRIPTOR_TYPE, /*bDescriptorType: HID*/
0x11, /*bcdHID: HID Class Spec release number*/
0x01,
0x00, /*bCountryCode: Hardware target country*/
0x01, /*bNumDescriptors: Number of HID class descriptors to follow*/
0x22, /*bDescriptorType*/
HID_MOUSE_REPORT_DESC_SIZE,/*wItemLength: Total length of Report descriptor*/
0x00,
};
__ALIGN_BEGIN static uint8_t HID_MOUSE_ReportDesc[HID_MOUSE_REPORT_DESC_SIZE] __ALIGN_END = {
0x05, 0x01,
0x09, 0x02,
0xA1, 0x01,
0x09, 0x01,
0xA1, 0x00,
0x05, 0x09,
0x19, 0x01,
0x29, 0x03,
0x15, 0x00,
0x25, 0x01,
0x95, 0x03,
0x75, 0x01,
0x81, 0x02,
0x95, 0x01,
0x75, 0x05,
0x81, 0x01,
0x05, 0x01,
0x09, 0x30,
0x09, 0x31,
0x09, 0x38,
0x15, 0x81,
0x25, 0x7F,
0x75, 0x08,
0x95, 0x03,
0x81, 0x06,
0xC0, 0x09,
0x3c, 0x05,
0xff, 0x09,
0x01, 0x15,
0x00, 0x25,
0x01, 0x75,
0x01, 0x95,
0x02, 0xb1,
0x22, 0x75,
0x06, 0x95,
0x01, 0xb1,
0x01, 0xc0
};
#if 0
__ALIGN_BEGIN static const uint8_t HID_KEYBOARD_ReportDesc[HID_KEYBOARD_REPORT_DESC_SIZE] __ALIGN_END = {
// From p69 of http://www.usb.org/developers/devclass_docs/HID1_11.pdf
0x05, 0x01, // Usage Page (Generic Desktop),
0x09, 0x06, // Usage (Keyboard),
0xA1, 0x01, // Collection (Application),
0x05, 0x07, // Usage Page (Key Codes);
0x19, 0xE0, // Usage Minimum (224),
0x29, 0xE7, // Usage Maximum (231),
0x15, 0x00, // Logical Minimum (0),
0x25, 0x01, // Logical Maximum (1),
0x75, 0x01, // Report Size (1),
0x95, 0x08, // Report Count (8),
0x81, 0x02, // Input (Data, Variable, Absolute), ;Modifier byte
0x95, 0x01, // Report Count (1),
0x75, 0x08, // Report Size (8),
0x81, 0x01, // Input (Constant), ;Reserved byte
0x95, 0x05, // Report Count (5),
0x75, 0x01, // Report Size (1),
0x05, 0x08, // Usage Page (Page# for LEDs),
0x19, 0x01, // Usage Minimum (1),
0x29, 0x05, // Usage Maximum (5),
0x91, 0x02, // Output (Data, Variable, Absolute), ;LED report
0x95, 0x01, // Report Count (1),
0x75, 0x03, // Report Size (3),
0x91, 0x01, // Output (Constant), ;LED report padding
0x95, 0x06, // Report Count (6),
0x75, 0x08, // Report Size (8),
0x15, 0x00, // Logical Minimum (0),
0x25, 0x65, // Logical Maximum(101),
0x05, 0x07, // Usage Page (Key Codes),
0x19, 0x00, // Usage Minimum (0),
0x29, 0x65, // Usage Maximum (101),
0x81, 0x00, // Input (Data, Array), ;Key arrays (6 bytes)
0xC0 // End Collection
};
#endif
void USBD_SelectMode(uint32_t mode) {
// save mode
usbd_mode = mode;
// set up HID parameters if HID is selected
if (mode & USBD_MODE_HID) {
if (mode & USBD_MODE_CDC) {
hid_in_ep = HID_IN_EP_WITH_CDC;
hid_iface_num = HID_IFACE_NUM_WITH_CDC;
} else if (mode & USBD_MODE_MSC) {
hid_in_ep = HID_IN_EP_WITH_MSC;
hid_iface_num = HID_IFACE_NUM_WITH_MSC;
}
}
}
static uint8_t USBD_CDC_MSC_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx) {
if (pdev->dev_speed == USBD_SPEED_HIGH) {
// can't handle high speed
return 1;
}
if (usbd_mode & USBD_MODE_CDC) {
// CDC VCP component
// Open EP IN
USBD_LL_OpenEP(pdev,
CDC_IN_EP,
USBD_EP_TYPE_BULK,
CDC_DATA_IN_PACKET_SIZE);
// Open EP OUT
USBD_LL_OpenEP(pdev,
CDC_OUT_EP,
USBD_EP_TYPE_BULK,
CDC_DATA_OUT_PACKET_SIZE);
// Open Command IN EP
USBD_LL_OpenEP(pdev,
CDC_CMD_EP,
USBD_EP_TYPE_INTR,
CDC_CMD_PACKET_SIZE);
// Init physical Interface components
CDC_fops->Init();
// Init Xfer states
CDC_ClassData.TxState =0;
CDC_ClassData.RxState =0;
// Prepare Out endpoint to receive next packet
USBD_LL_PrepareReceive(pdev, CDC_OUT_EP, CDC_ClassData.RxBuffer, CDC_DATA_OUT_PACKET_SIZE);
}
if (usbd_mode & USBD_MODE_MSC) {
// MSC component
// Open EP OUT
USBD_LL_OpenEP(pdev,
MSC_OUT_EP,
USBD_EP_TYPE_BULK,
MSC_MAX_PACKET);
// Open EP IN
USBD_LL_OpenEP(pdev,
MSC_IN_EP,
USBD_EP_TYPE_BULK,
MSC_MAX_PACKET);
// MSC uses the pClassData pointer because SCSI and BOT reference it
pdev->pClassData = &MSC_BOT_ClassData;
// Init the BOT layer
MSC_BOT_Init(pdev);
}
if (usbd_mode & USBD_MODE_HID) {
// HID component
// Open EP IN
USBD_LL_OpenEP(pdev,
hid_in_ep,
USBD_EP_TYPE_INTR,
HID_MAX_PACKET);
HID_ClassData.state = HID_IDLE;
}
return 0;
}
static uint8_t USBD_CDC_MSC_HID_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx) {
if (usbd_mode & USBD_MODE_CDC) {
// CDC VCP component
// close endpoints
USBD_LL_CloseEP(pdev, CDC_IN_EP);
USBD_LL_CloseEP(pdev, CDC_OUT_EP);
USBD_LL_CloseEP(pdev, CDC_CMD_EP);
// DeInit physical Interface components
CDC_fops->DeInit();
}
if (usbd_mode & USBD_MODE_MSC) {
// MSC component
// close endpoints
USBD_LL_CloseEP(pdev, MSC_OUT_EP);
USBD_LL_CloseEP(pdev, MSC_IN_EP);
// DeInit the BOT layer
MSC_BOT_DeInit(pdev);
// clear the pointer
pdev->pClassData = NULL;
}
if (usbd_mode & USBD_MODE_HID) {
// HID component
// close endpoints
USBD_LL_CloseEP(pdev, hid_in_ep);
}
return 0;
}
static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req) {
/*
printf("SU: %x %x %x %x\n", req->bmRequest, req->bRequest, req->wValue, req->wIndex);
stmhal: Fix USB MSC so that it unmounts correctly on Mac OS X. Mac OS X sends a SCSI command to remove the medium when it unmounts a drive. If this command is not honoured, then OS X will automatically remount the drive, making it impossible to eject. This patch disables the USB MSC when the right SCSI command is sent.
2014-04-15 14:56:32 -04:00
stmhal: Implement selector for USB device mode; improve boot up. Can now choose at boot up whether the USB device is CDC+MSC or CDC+HID. Choice is made by an option in boot.py, with default being CDC+MSC. HID+MSC is not currently supported, but should be easy to implement. Boot up now has ability to change the reset mode: hold down USR switch while booting and LEDs will count from 1 to 7 to indicate the boot mode. Release USR when correct mode is selected. Current modes are 1 (normal boot), 2 (safe mode), 3 (reset FS mode).
2014-03-29 20:00:15 -04:00
This is what we get when MSC is IFACE=0 and CDC is IFACE=1,2:
SU: 21 22 0 1 -- USB_REQ_TYPE_CLASS | USB_REQ_RECIPIENT_INTERFACE; CDC_SET_CONTROL_LINE_STATE
SU: 21 20 0 1 -- USB_REQ_TYPE_CLASS | USB_REQ_RECIPIENT_INTERFACE; CDC_SET_LINE_CODING
SU: a1 fe 0 0 -- 0x80 | USB_REQ_TYPE_CLASS | USB_REQ_RECIPIENT_INTERFACE; BOT_GET_MAX_LUN; 0; 0
SU: 21 22 3 1 -- USB_REQ_TYPE_CLASS | USB_REQ_RECIPIENT_INTERFACE; CDC_SET_CONTROL_LINE_STATE
stmhal: Fix USB MSC so that it unmounts correctly on Mac OS X. Mac OS X sends a SCSI command to remove the medium when it unmounts a drive. If this command is not honoured, then OS X will automatically remount the drive, making it impossible to eject. This patch disables the USB MSC when the right SCSI command is sent.
2014-04-15 14:56:32 -04:00
On a Mac OS X, with MSC then CDC:
SU: a1 fe 0 0
SU: 21 22 2 1
SU: 21 22 3 1
SU: 21 20 0 1
stmhal: Implement selector for USB device mode; improve boot up. Can now choose at boot up whether the USB device is CDC+MSC or CDC+HID. Choice is made by an option in boot.py, with default being CDC+MSC. HID+MSC is not currently supported, but should be easy to implement. Boot up now has ability to change the reset mode: hold down USR switch while booting and LEDs will count from 1 to 7 to indicate the boot mode. Release USR when correct mode is selected. Current modes are 1 (normal boot), 2 (safe mode), 3 (reset FS mode).
2014-03-29 20:00:15 -04:00
*/
switch (req->bmRequest & USB_REQ_TYPE_MASK) {
// Class request
case USB_REQ_TYPE_CLASS:
// req->wIndex is the recipient interface number
if ((usbd_mode & USBD_MODE_CDC) && req->wIndex == CDC_IFACE_NUM) {
// CDC component
if (req->wLength) {
if (req->bmRequest & 0x80) {
// device-to-host request
CDC_fops->Control(req->bRequest, (uint8_t*)CDC_ClassData.data, req->wLength);
USBD_CtlSendData(pdev, (uint8_t*)CDC_ClassData.data, req->wLength);
} else {
// host-to-device request
CDC_ClassData.CmdOpCode = req->bRequest;
CDC_ClassData.CmdLength = req->wLength;
USBD_CtlPrepareRx(pdev, (uint8_t*)CDC_ClassData.data, req->wLength);
}
} else {
// Not a Data request
// Transfer the command to the interface layer
return CDC_fops->Control(req->bRequest, NULL, req->wValue);
}
} else if ((usbd_mode & USBD_MODE_MSC) && req->wIndex == MSC_IFACE_NUM) {
// MSC component
switch (req->bRequest) {
case BOT_GET_MAX_LUN:
if ((req->wValue == 0) && (req->wLength == 1) && ((req->bmRequest & 0x80) == 0x80)) {
MSC_BOT_ClassData.max_lun = MSC_fops->GetMaxLun();
USBD_CtlSendData(pdev, (uint8_t *)&MSC_BOT_ClassData.max_lun, 1);
} else {
USBD_CtlError(pdev, req);
return USBD_FAIL;
}
break;
case BOT_RESET:
if((req->wValue == 0) && (req->wLength == 0) && ((req->bmRequest & 0x80) != 0x80)) {
MSC_BOT_Reset(pdev);
} else {
USBD_CtlError(pdev , req);
return USBD_FAIL;
}
break;
default:
USBD_CtlError(pdev, req);
return USBD_FAIL;
}
} else if ((usbd_mode & USBD_MODE_HID) && req->wIndex == hid_iface_num) {
switch (req->bRequest) {
case HID_REQ_SET_PROTOCOL:
HID_ClassData.Protocol = (uint8_t)(req->wValue);
break;
case HID_REQ_GET_PROTOCOL:
USBD_CtlSendData (pdev, (uint8_t *)&HID_ClassData.Protocol, 1);
break;
case HID_REQ_SET_IDLE:
HID_ClassData.IdleState = (uint8_t)(req->wValue >> 8);
break;
case HID_REQ_GET_IDLE:
USBD_CtlSendData (pdev, (uint8_t *)&HID_ClassData.IdleState, 1);
break;
default:
USBD_CtlError(pdev, req);
return USBD_FAIL;
}
}
break;
// Interface & Endpoint request
case USB_REQ_TYPE_STANDARD:
if ((usbd_mode & USBD_MODE_MSC) && req->wIndex == MSC_IFACE_NUM) {
switch (req->bRequest) {
case USB_REQ_GET_INTERFACE :
USBD_CtlSendData(pdev, (uint8_t *)&MSC_BOT_ClassData.interface, 1);
break;
case USB_REQ_SET_INTERFACE :
MSC_BOT_ClassData.interface = (uint8_t)(req->wValue);
break;
case USB_REQ_CLEAR_FEATURE:
/* Flush the FIFO and Clear the stall status */
USBD_LL_FlushEP(pdev, (uint8_t)req->wIndex);
/* Re-activate the EP */
USBD_LL_CloseEP (pdev , (uint8_t)req->wIndex);
if((((uint8_t)req->wIndex) & 0x80) == 0x80) {
/* Open EP IN */
USBD_LL_OpenEP(pdev, MSC_IN_EP, USBD_EP_TYPE_BULK, MSC_MAX_PACKET);
} else {
/* Open EP OUT */
USBD_LL_OpenEP(pdev, MSC_OUT_EP, USBD_EP_TYPE_BULK, MSC_MAX_PACKET);
}
/* Handle BOT error */
MSC_BOT_CplClrFeature(pdev, (uint8_t)req->wIndex);
break;
}
} else if ((usbd_mode & USBD_MODE_HID) && req->wIndex == hid_iface_num) {
switch (req->bRequest) {
case USB_REQ_GET_DESCRIPTOR: {
uint16_t len = 0;
const uint8_t *pbuf = NULL;
if (req->wValue >> 8 == HID_REPORT_DESC) {
len = MIN(HID_MOUSE_REPORT_DESC_SIZE , req->wLength);
pbuf = HID_MOUSE_ReportDesc;
} else if (req->wValue >> 8 == HID_DESCRIPTOR_TYPE) {
len = MIN(USB_HID_DESC_SIZ , req->wLength);
pbuf = USBD_HID_Desc;
}
USBD_CtlSendData(pdev, (uint8_t*)pbuf, len);
break;
}
case USB_REQ_GET_INTERFACE:
USBD_CtlSendData (pdev, (uint8_t *)&HID_ClassData.AltSetting, 1);
break;
case USB_REQ_SET_INTERFACE:
HID_ClassData.AltSetting = (uint8_t)(req->wValue);
break;
}
}
break;
}
return USBD_OK;
}
stmhal: Fix USB MSC so that it unmounts correctly on Mac OS X. Mac OS X sends a SCSI command to remove the medium when it unmounts a drive. If this command is not honoured, then OS X will automatically remount the drive, making it impossible to eject. This patch disables the USB MSC when the right SCSI command is sent.
2014-04-15 14:56:32 -04:00
/* unused
static uint8_t EP0_TxSent(USBD_HandleTypeDef *pdev) {
}
*/
stmhal: Implement selector for USB device mode; improve boot up. Can now choose at boot up whether the USB device is CDC+MSC or CDC+HID. Choice is made by an option in boot.py, with default being CDC+MSC. HID+MSC is not currently supported, but should be easy to implement. Boot up now has ability to change the reset mode: hold down USR switch while booting and LEDs will count from 1 to 7 to indicate the boot mode. Release USR when correct mode is selected. Current modes are 1 (normal boot), 2 (safe mode), 3 (reset FS mode).
2014-03-29 20:00:15 -04:00
static uint8_t USBD_CDC_MSC_HID_EP0_RxReady(USBD_HandleTypeDef *pdev) {
if((CDC_fops != NULL) && (CDC_ClassData.CmdOpCode != 0xFF)) {
CDC_fops->Control(CDC_ClassData.CmdOpCode, (uint8_t *)CDC_ClassData.data, CDC_ClassData.CmdLength);
CDC_ClassData.CmdOpCode = 0xFF;
}
return USBD_OK;
}
static uint8_t USBD_CDC_MSC_HID_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum) {
if ((usbd_mode & USBD_MODE_CDC) && (epnum == (CDC_IN_EP & 0x7f) || epnum == (CDC_CMD_EP & 0x7f))) {
CDC_ClassData.TxState = 0;
return USBD_OK;
} else if ((usbd_mode & USBD_MODE_MSC) && epnum == (MSC_IN_EP & 0x7f)) {
MSC_BOT_DataIn(pdev, epnum);
return USBD_OK;
} else if ((usbd_mode & USBD_MODE_HID) && epnum == (hid_in_ep & 0x7f)) {
/* Ensure that the FIFO is empty before a new transfer, this condition could
be caused by a new transfer before the end of the previous transfer */
HID_ClassData.state = HID_IDLE;
return USBD_OK;
}
return USBD_OK;
}
static uint8_t USBD_CDC_MSC_HID_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum) {
if ((usbd_mode & USBD_MODE_CDC) && epnum == (CDC_OUT_EP & 0x7f)) {
/* Get the received data length */
CDC_ClassData.RxLength = USBD_LL_GetRxDataSize (pdev, epnum);
/* USB data will be immediately processed, this allow next USB traffic being
NAKed till the end of the application Xfer */
CDC_fops->Receive(CDC_ClassData.RxBuffer, &CDC_ClassData.RxLength);
return USBD_OK;
} else if ((usbd_mode & USBD_MODE_MSC) && epnum == (MSC_OUT_EP & 0x7f)) {
MSC_BOT_DataOut(pdev, epnum);
return USBD_OK;
}
return USBD_OK;
}
static uint8_t *USBD_CDC_MSC_HID_GetCfgDesc(uint16_t *length) {
switch (usbd_mode) {
case USBD_MODE_CDC_MSC:
*length = sizeof(USBD_CDC_MSC_CfgDesc);
return USBD_CDC_MSC_CfgDesc;
case USBD_MODE_CDC_HID:
default:
*length = sizeof(USBD_CDC_HID_CfgDesc);
return USBD_CDC_HID_CfgDesc;
}
}
uint8_t *USBD_CDC_MSC_HID_GetDeviceQualifierDescriptor (uint16_t *length) {
*length = sizeof(USBD_CDC_MSC_HID_DeviceQualifierDesc);
return USBD_CDC_MSC_HID_DeviceQualifierDesc;
}
uint8_t USBD_CDC_RegisterInterface(USBD_HandleTypeDef *pdev, USBD_CDC_ItfTypeDef *fops) {
if (fops == NULL) {
return USBD_FAIL;
} else {
CDC_fops = fops;
return USBD_OK;
}
}
/**
* @brief USBD_CDC_SetTxBuffer
* @param pdev: device instance
* @param pbuff: Tx Buffer
* @retval status
*/
uint8_t USBD_CDC_SetTxBuffer (USBD_HandleTypeDef *pdev,
uint8_t *pbuff,
uint16_t length)
{
CDC_ClassData.TxBuffer = pbuff;
CDC_ClassData.TxLength = length;
return USBD_OK;
}
/**
* @brief USBD_CDC_SetRxBuffer
* @param pdev: device instance
* @param pbuff: Rx Buffer
* @retval status
*/
uint8_t USBD_CDC_SetRxBuffer (USBD_HandleTypeDef *pdev,
uint8_t *pbuff)
{
CDC_ClassData.RxBuffer = pbuff;
return USBD_OK;
}
/**
* @brief USBD_CDC_DataOut
* Data received on non-control Out endpoint
* @param pdev: device instance
* @param epnum: endpoint number
* @retval status
*/
uint8_t USBD_CDC_TransmitPacket(USBD_HandleTypeDef *pdev) {
if(CDC_ClassData.TxState == 0) {
/* Transmit next packet */
USBD_LL_Transmit(pdev,
CDC_IN_EP,
CDC_ClassData.TxBuffer,
CDC_ClassData.TxLength);
/* Tx Transfer in progress */
CDC_ClassData.TxState = 1;
return USBD_OK;
}
else
{
return USBD_BUSY;
}
}
/**
* @brief USBD_CDC_ReceivePacket
* prepare OUT Endpoint for reception
* @param pdev: device instance
* @retval status
*/
uint8_t USBD_CDC_ReceivePacket(USBD_HandleTypeDef *pdev) {
// Suspend or Resume USB Out process
if (pdev->dev_speed == USBD_SPEED_HIGH) {
return USBD_FAIL;
}
// Prepare Out endpoint to receive next packet */
USBD_LL_PrepareReceive(pdev,
CDC_OUT_EP,
CDC_ClassData.RxBuffer,
CDC_DATA_OUT_PACKET_SIZE);
return USBD_OK;
}
uint8_t USBD_MSC_RegisterStorage(USBD_HandleTypeDef *pdev, USBD_StorageTypeDef *fops) {
if (fops == NULL) {
return USBD_FAIL;
} else {
MSC_fops = fops;
pdev->pUserData = fops; // MSC uses pUserData because SCSI and BOT reference it
return USBD_OK;
}
}
uint8_t USBD_HID_SendReport(USBD_HandleTypeDef *pdev, uint8_t *report, uint16_t len) {
if (pdev->dev_state == USBD_STATE_CONFIGURED) {
if (HID_ClassData.state == HID_IDLE) {
HID_ClassData.state = HID_BUSY;
USBD_LL_Transmit(pdev, hid_in_ep, report, len);
}
}
return USBD_OK;
}
// CDC + MSC interface class callbacks structure
USBD_ClassTypeDef USBD_CDC_MSC_HID = {
USBD_CDC_MSC_HID_Init,
USBD_CDC_MSC_HID_DeInit,
USBD_CDC_MSC_HID_Setup,
NULL, // EP0_TxSent
USBD_CDC_MSC_HID_EP0_RxReady,
USBD_CDC_MSC_HID_DataIn,
USBD_CDC_MSC_HID_DataOut,
NULL, // SOF
stmhal: Fix USB MSC so that it unmounts correctly on Mac OS X. Mac OS X sends a SCSI command to remove the medium when it unmounts a drive. If this command is not honoured, then OS X will automatically remount the drive, making it impossible to eject. This patch disables the USB MSC when the right SCSI command is sent.
2014-04-15 14:56:32 -04:00
NULL, // IsoINIncomplete
NULL, // IsoOUTIncomplete
stmhal: Implement selector for USB device mode; improve boot up. Can now choose at boot up whether the USB device is CDC+MSC or CDC+HID. Choice is made by an option in boot.py, with default being CDC+MSC. HID+MSC is not currently supported, but should be easy to implement. Boot up now has ability to change the reset mode: hold down USR switch while booting and LEDs will count from 1 to 7 to indicate the boot mode. Release USR when correct mode is selected. Current modes are 1 (normal boot), 2 (safe mode), 3 (reset FS mode).
2014-03-29 20:00:15 -04:00
USBD_CDC_MSC_HID_GetCfgDesc,
USBD_CDC_MSC_HID_GetCfgDesc,
USBD_CDC_MSC_HID_GetCfgDesc,
USBD_CDC_MSC_HID_GetDeviceQualifierDescriptor,
};
Reference in New Issue Copy Permalink