github
/
micropython
mirror of https://github.com/micropython/micropython.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

stm32/usb: Add config options to disable USB MSC and/or HID. 

The new configurations MICROPY_HW_USB_MSC and MICROPY_HW_USB_HID can be
used by a board to enabled or disable MSC and/or HID.  They are both
enabled by default.
pull/4904/head
Damien George 5 years ago
parent
154062d9cb
commit
f302f784e9
10 changed files with 145 additions and 12 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 9
      ports/stm32/main.c
  2. 4
      ports/stm32/modpyb.c
  3. 8
      ports/stm32/mpconfigboard_common.h
  4. 33
      ports/stm32/usb.c
  5. 4
      ports/stm32/usbd_hid_interface.c
  6. 4
      ports/stm32/usbd_msc_interface.c
  7. 6
      ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid.h
  8. 81
      ports/stm32/usbdev/class/src/usbd_cdc_msc_hid.c
  9. 4
      ports/stm32/usbdev/class/src/usbd_msc_bot.c
  10. 4
      ports/stm32/usbdev/class/src/usbd_msc_scsi.c

9
ports/stm32/main.c
View File

@ -658,7 +658,14 @@ soft_reset:
#if MICROPY_HW_ENABLE_USB
// init USB device to default setting if it was not already configured
if (!(pyb_usb_flags & PYB_USB_FLAG_USB_MODE_CALLED)) {
pyb_usb_dev_init(pyb_usb_dev_detect(), USBD_VID, USBD_PID_CDC_MSC, USBD_MODE_CDC_MSC, 0, NULL, NULL);
#if MICROPY_HW_USB_MSC
const uint16_t pid = USBD_PID_CDC_MSC;
const uint8_t mode = USBD_MODE_CDC_MSC;
#else
const uint16_t pid = USBD_PID_CDC;
const uint8_t mode = USBD_MODE_CDC;
#endif
pyb_usb_dev_init(pyb_usb_dev_detect(), USBD_VID, pid, mode, 0, NULL, NULL);
}
#endif

4
ports/stm32/modpyb.c
View File

@ -161,10 +161,12 @@ STATIC const mp_rom_map_elem_t pyb_module_globals_table[] = {
#if MICROPY_HW_ENABLE_USB
{ MP_ROM_QSTR(MP_QSTR_usb_mode), MP_ROM_PTR(&pyb_usb_mode_obj) },
#if MICROPY_HW_USB_HID
{ MP_ROM_QSTR(MP_QSTR_hid_mouse), MP_ROM_PTR(&pyb_usb_hid_mouse_obj) },
{ MP_ROM_QSTR(MP_QSTR_hid_keyboard), MP_ROM_PTR(&pyb_usb_hid_keyboard_obj) },
{ MP_ROM_QSTR(MP_QSTR_USB_VCP), MP_ROM_PTR(&pyb_usb_vcp_type) },
{ MP_ROM_QSTR(MP_QSTR_USB_HID), MP_ROM_PTR(&pyb_usb_hid_type) },
#endif
{ MP_ROM_QSTR(MP_QSTR_USB_VCP), MP_ROM_PTR(&pyb_usb_vcp_type) },
#if MICROPY_PY_PYB_LEGACY
// these 2 are deprecated; use USB_VCP.isconnected and USB_HID.send instead
{ MP_ROM_QSTR(MP_QSTR_have_cdc), MP_ROM_PTR(&pyb_have_cdc_obj) },

8
ports/stm32/mpconfigboard_common.h
View File

@ -273,10 +273,16 @@
#define MICROPY_HW_MAX_CAN (1)
#endif
// Configure maximum number of CDC VCP interfaces
// Configure maximum number of CDC VCP interfaces, and whether MSC/HID are supported
#ifndef MICROPY_HW_USB_CDC_NUM
#define MICROPY_HW_USB_CDC_NUM (1)
#endif
#ifndef MICROPY_HW_USB_MSC
#define MICROPY_HW_USB_MSC (MICROPY_HW_ENABLE_USB)
#endif
#ifndef MICROPY_HW_USB_HID
#define MICROPY_HW_USB_HID (MICROPY_HW_ENABLE_USB)
#endif
// Pin definition header file
#define MICROPY_PIN_DEFS_PORT_H "pin_defs_stm32.h"

33
ports/stm32/usb.c
View File

@ -67,12 +67,15 @@ typedef struct _usb_device_t {
USBD_HandleTypeDef hUSBDDevice;
usbd_cdc_msc_hid_state_t usbd_cdc_msc_hid_state;
usbd_cdc_itf_t usbd_cdc_itf[MICROPY_HW_USB_CDC_NUM];
#if MICROPY_HW_USB_HID
usbd_hid_itf_t usbd_hid_itf;
#endif
} usb_device_t;
usb_device_t usb_device = {0};
pyb_usb_storage_medium_t pyb_usb_storage_medium = PYB_USB_STORAGE_MEDIUM_NONE;
#if MICROPY_HW_USB_HID
// predefined hid mouse data
STATIC const mp_obj_str_t pyb_usb_hid_mouse_desc_obj = {
{&mp_type_bytes},
@ -110,6 +113,7 @@ const mp_rom_obj_tuple_t pyb_usb_hid_keyboard_obj = {
MP_ROM_PTR(&pyb_usb_hid_keyboard_desc_obj),
},
};
#endif
void pyb_usb_init0(void) {
for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
@ -160,7 +164,9 @@ bool pyb_usb_dev_init(int dev_id, uint16_t vid, uint16_t pid, uint8_t mode, size
for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
usb_dev->usbd_cdc_msc_hid_state.cdc[i] = &usb_dev->usbd_cdc_itf[i].base;
}
#if MICROPY_HW_USB_HID
usb_dev->usbd_cdc_msc_hid_state.hid = &usb_dev->usbd_hid_itf.base;
#endif
usbd->pClassData = &usb_dev->usbd_cdc_msc_hid_state;
// configure the VID, PID and the USBD mode (interfaces it will expose)
@ -170,6 +176,7 @@ bool pyb_usb_dev_init(int dev_id, uint16_t vid, uint16_t pid, uint8_t mode, size
return false;
}
#if MICROPY_HW_USB_MSC
// Configure the MSC interface
const void *msc_unit_default[1];
if (msc_n == 0) {
@ -188,6 +195,7 @@ bool pyb_usb_dev_init(int dev_id, uint16_t vid, uint16_t pid, uint8_t mode, size
}
usbd_msc_init_lu(msc_n, msc_unit);
USBD_MSC_RegisterStorage(&usb_dev->usbd_cdc_msc_hid_state, (USBD_StorageTypeDef*)&usbd_msc_fops);
#endif
// start the USB device
USBD_LL_Init(usbd, (mode & USBD_MODE_HIGH_SPEED) != 0);
@ -255,14 +263,29 @@ usbd_cdc_itf_t *usb_vcp_get(int idx) {
*/
STATIC mp_obj_t pyb_usb_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
enum { ARG_mode, ARG_port, ARG_vid, ARG_pid, ARG_msc, ARG_hid, ARG_high_speed };
enum {
ARG_mode, ARG_port, ARG_vid, ARG_pid,
#if MICROPY_HW_USB_MSC
ARG_msc,
#endif
#if MICROPY_HW_USB_HID
ARG_hid,
#endif
#if USBD_SUPPORT_HS_MODE
ARG_high_speed
#endif
};
static const mp_arg_t allowed_args[] = {
{ MP_QSTR_mode, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_none_obj)} },
{ MP_QSTR_port, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
{ MP_QSTR_vid, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = USBD_VID} },
{ MP_QSTR_pid, MP_ARG_KW_ONLY | MP_ARG_INT, {.u_int = -1} },
#if MICROPY_HW_USB_MSC
{ MP_QSTR_msc, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&mp_const_empty_tuple_obj)} },
#endif
#if MICROPY_HW_USB_HID
{ MP_QSTR_hid, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_rom_obj = MP_ROM_PTR(&pyb_usb_hid_mouse_obj)} },
#endif
#if USBD_SUPPORT_HS_MODE
{ MP_QSTR_high_speed, MP_ARG_KW_ONLY | MP_ARG_BOOL, {.u_bool = false} },
#endif
@ -381,6 +404,7 @@ STATIC mp_obj_t pyb_usb_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
// Get MSC logical units
size_t msc_n = 0;
const void *msc_unit[USBD_MSC_MAX_LUN];
#if MICROPY_HW_USB_MSC
if (mode & USBD_MODE_IFACE_MSC) {
mp_obj_t *items;
mp_obj_get_array(args[ARG_msc].u_obj, &msc_n, &items);
@ -403,9 +427,11 @@ STATIC mp_obj_t pyb_usb_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
}
}
}
#endif
// get hid info if user selected such a mode
USBD_HID_ModeInfoTypeDef hid_info;
#if MICROPY_HW_USB_HID
if (mode & USBD_MODE_IFACE_HID) {
mp_obj_t *items;
mp_obj_get_array_fixed_n(args[ARG_hid].u_obj, 5, &items);
@ -421,6 +447,7 @@ STATIC mp_obj_t pyb_usb_mode(size_t n_args, const mp_obj_t *pos_args, mp_map_t *
// need to keep a copy of this so report_desc does not get GC'd
MP_STATE_PORT(pyb_hid_report_desc) = items[4];
}
#endif
#if USBD_SUPPORT_HS_MODE
if (args[ARG_high_speed].u_bool) {
@ -713,6 +740,8 @@ const mp_obj_type_t pyb_usb_vcp_type = {
/******************************************************************************/
// MicroPython bindings for USB HID
#if MICROPY_HW_USB_HID
typedef struct _pyb_usb_hid_obj_t {
mp_obj_base_t base;
usb_device_t *usb_dev;
@ -841,6 +870,8 @@ const mp_obj_type_t pyb_usb_hid_type = {
.locals_dict = (mp_obj_dict_t*)&pyb_usb_hid_locals_dict,
};
#endif // MICROPY_HW_USB_HID
/******************************************************************************/
// code for experimental USB OTG support

4
ports/stm32/usbd_hid_interface.c
View File

@ -42,6 +42,8 @@
#include "irq.h"
#include "usb.h"
#if MICROPY_HW_USB_HID
uint8_t *usbd_hid_init(usbd_hid_state_t *hid_in) {
usbd_hid_itf_t *hid = (usbd_hid_itf_t*)hid_in;
@ -107,3 +109,5 @@ int usbd_hid_rx(usbd_hid_itf_t *hid, size_t len, uint8_t *buf, uint32_t timeout)
// Success, return number of bytes read
return read_len;
}
#endif // MICROPY_HW_USB_HID

4
ports/stm32/usbd_msc_interface.c
View File

@ -33,6 +33,8 @@
#include "storage.h"
#include "sdcard.h"
#if MICROPY_HW_USB_MSC
// This flag is needed to support removal of the medium, so that the USB drive
// can be unmounted and won't be remounted automatically.
#define FLAGS_STARTED (0x01)
@ -342,3 +344,5 @@ const USBD_StorageTypeDef usbd_msc_fops = {
usbd_msc_Write,
usbd_msc_GetMaxLun,
};
#endif // MICROPY_HW_USB_MSC

6
ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid.h
View File

@ -120,7 +120,9 @@ typedef struct _usbd_cdc_msc_hid_state_t {
uint8_t usbd_mode;
uint8_t usbd_config_desc_size;
#if MICROPY_HW_USB_MSC
USBD_MSC_BOT_HandleTypeDef MSC_BOT_ClassData;
#endif
// RAM to hold the current descriptors, which we configure on the fly
__ALIGN_BEGIN uint8_t usbd_device_desc[USB_LEN_DEV_DESC] __ALIGN_END;
@ -128,7 +130,9 @@ typedef struct _usbd_cdc_msc_hid_state_t {
__ALIGN_BEGIN uint8_t usbd_config_desc[MAX_TEMPLATE_CONFIG_DESC_SIZE] __ALIGN_END;
usbd_cdc_state_t *cdc[MICROPY_HW_USB_CDC_NUM];
#if MICROPY_HW_USB_HID
usbd_hid_state_t *hid;
#endif
} usbd_cdc_msc_hid_state_t;
extern const uint8_t USBD_MSC_Mode_Sense6_Data[4];
@ -176,9 +180,11 @@ uint8_t USBD_GetMode(usbd_cdc_msc_hid_state_t *usbd);
uint8_t USBD_CDC_ReceivePacket(usbd_cdc_state_t *cdc, uint8_t *buf);
uint8_t USBD_CDC_TransmitPacket(usbd_cdc_state_t *cdc, size_t len, const uint8_t *buf);
#if MICROPY_HW_USB_MSC
static inline void USBD_MSC_RegisterStorage(usbd_cdc_msc_hid_state_t *usbd, USBD_StorageTypeDef *fops) {
usbd->MSC_BOT_ClassData.bdev_ops = fops;
}
#endif
uint8_t USBD_HID_ReceivePacket(usbd_hid_state_t *usbd, uint8_t *buf);
int USBD_HID_CanSendReport(usbd_hid_state_t *usbd);

81
ports/stm32/usbdev/class/src/usbd_cdc_msc_hid.c
View File

@ -148,6 +148,7 @@ static const uint8_t head_desc_data[HEAD_DESC_SIZE] = {
CONFIG_DESC_MAXPOWER, // bMaxPower
};
#if MICROPY_HW_USB_MSC
// USB MSC partial configuration descriptor
static const uint8_t msc_class_desc_data[MSC_CLASS_DESC_SIZE] = {
//==========================================================================
@ -183,6 +184,7 @@ static const uint8_t msc_class_desc_data[MSC_CLASS_DESC_SIZE] = {
HIBYTE(MSC_FS_MAX_PACKET),
0x00, // bInterval: ignore for Bulk transfer
};
#endif
// USB CDC partial configuration descriptor
static const uint8_t cdc_class_desc_data[CDC_CLASS_DESC_SIZE] = {
@ -276,6 +278,7 @@ static const uint8_t cdc_class_desc_data[CDC_CLASS_DESC_SIZE] = {
0x00, // bInterval: ignore for Bulk transfer
};
#if MICROPY_HW_USB_HID
// USB HID partial configuration descriptor
static const uint8_t hid_class_desc_data[HID_CLASS_DESC_SIZE] = {
//==========================================================================
@ -399,6 +402,7 @@ __ALIGN_BEGIN const uint8_t USBD_HID_KEYBOARD_ReportDesc[USBD_HID_KEYBOARD_REPOR
0x81, 0x00, // Input (Data, Array), ;Key arrays (6 bytes)
0xC0 // End Collection
};
#endif
static void make_head_desc(uint8_t *dest, uint16_t len, uint8_t num_itf) {
memcpy(dest, head_desc_data, sizeof(head_desc_data));
@ -407,10 +411,12 @@ static void make_head_desc(uint8_t *dest, uint16_t len, uint8_t num_itf) {
dest[4] = num_itf; // bNumInterfaces
}
#if MICROPY_HW_USB_MSC
static size_t make_msc_desc(uint8_t *dest) {
memcpy(dest, msc_class_desc_data, sizeof(msc_class_desc_data));
return sizeof(msc_class_desc_data);
}
#endif
static size_t make_cdc_desc(uint8_t *dest, int need_iad, uint8_t iface_num) {
if (need_iad) {
@ -441,6 +447,7 @@ static size_t make_cdc_desc_ep(uint8_t *dest, int need_iad, uint8_t iface_num, u
}
#endif
#if MICROPY_HW_USB_HID
static size_t make_hid_desc(uint8_t *dest, USBD_HID_ModeInfoTypeDef *hid_info) {
memcpy(dest, hid_class_desc_data, sizeof(hid_class_desc_data));
dest[HID_DESC_OFFSET_SUBCLASS] = hid_info->subclass;
@ -454,6 +461,7 @@ static size_t make_hid_desc(uint8_t *dest, USBD_HID_ModeInfoTypeDef *hid_info) {
dest[HID_DESC_OFFSET_POLLING_INTERVAL_OUT] = hid_info->polling_interval;
return sizeof(hid_class_desc_data);
}
#endif
// return the saved usb mode
uint8_t USBD_GetMode(usbd_cdc_msc_hid_state_t *usbd) {
@ -469,6 +477,7 @@ int USBD_SelectMode(usbd_cdc_msc_hid_state_t *usbd, uint32_t mode, USBD_HID_Mode
uint8_t *d = usbd->usbd_config_desc;
uint8_t num_itf = 0;
switch (usbd->usbd_mode & USBD_MODE_IFACE_MASK) {
#if MICROPY_HW_USB_MSC
case USBD_MODE_MSC:
n += make_msc_desc(d + n);
num_itf = 1;
@ -480,6 +489,7 @@ int USBD_SelectMode(usbd_cdc_msc_hid_state_t *usbd, uint32_t mode, USBD_HID_Mode
usbd->cdc[0]->iface_num = CDC_IFACE_NUM_WITH_MSC;
num_itf = 3;
break;
#endif
#if MICROPY_HW_USB_CDC_NUM >= 2
case USBD_MODE_CDC2: {
@ -491,6 +501,7 @@ int USBD_SelectMode(usbd_cdc_msc_hid_state_t *usbd, uint32_t mode, USBD_HID_Mode
break;
}
#if MICROPY_HW_USB_MSC
case USBD_MODE_CDC2_MSC: {
n += make_msc_desc(d + n);
n += make_cdc_desc(d + n, 1, CDC_IFACE_NUM_WITH_MSC);
@ -501,6 +512,7 @@ int USBD_SelectMode(usbd_cdc_msc_hid_state_t *usbd, uint32_t mode, USBD_HID_Mode
break;
}
#endif
#endif
#if MICROPY_HW_USB_CDC_NUM >= 3
case USBD_MODE_CDC3: {
@ -514,6 +526,7 @@ int USBD_SelectMode(usbd_cdc_msc_hid_state_t *usbd, uint32_t mode, USBD_HID_Mode
break;
}
#if MICROPY_HW_USB_MSC
case USBD_MODE_CDC3_MSC: {
n += make_msc_desc(d + n);
n += make_cdc_desc(d + n, 1, CDC_IFACE_NUM_WITH_MSC);
@ -526,7 +539,9 @@ int USBD_SelectMode(usbd_cdc_msc_hid_state_t *usbd, uint32_t mode, USBD_HID_Mode
break;
}
#endif
#endif
#if MICROPY_HW_USB_HID
case USBD_MODE_CDC_HID:
usbd->hid->desc = d + n;
n += make_hid_desc(d + n, hid_info);
@ -538,6 +553,7 @@ int USBD_SelectMode(usbd_cdc_msc_hid_state_t *usbd, uint32_t mode, USBD_HID_Mode
usbd->hid->report_desc = hid_info->report_desc;
num_itf = 3;
break;
#endif
case USBD_MODE_CDC:
n += make_cdc_desc(d + n, 0, CDC_IFACE_NUM_ALONE);
@ -609,6 +625,7 @@ static uint8_t USBD_CDC_MSC_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx) {
}
}
#if MICROPY_HW_USB_MSC
if (usbd->usbd_mode & USBD_MODE_IFACE_MSC) {
// MSC component
@ -629,7 +646,9 @@ static uint8_t USBD_CDC_MSC_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx) {
// Init the BOT layer
MSC_BOT_Init(pdev);
}
#endif
#if MICROPY_HW_USB_HID
if (usbd->usbd_mode & USBD_MODE_IFACE_HID) {
// HID component
@ -656,6 +675,7 @@ static uint8_t USBD_CDC_MSC_HID_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx) {
usbd->hid->state = HID_IDLE;
}
#endif
return 0;
}
@ -676,6 +696,7 @@ static uint8_t USBD_CDC_MSC_HID_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
}
}
#if MICROPY_HW_USB_MSC
if (usbd->usbd_mode & USBD_MODE_IFACE_MSC) {
// MSC component
@ -686,7 +707,9 @@ static uint8_t USBD_CDC_MSC_HID_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
// DeInit the BOT layer
MSC_BOT_DeInit(pdev);
}
#endif
#if MICROPY_HW_USB_HID
if (usbd->usbd_mode & USBD_MODE_IFACE_HID) {
// HID component
@ -694,6 +717,7 @@ static uint8_t USBD_CDC_MSC_HID_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
USBD_LL_CloseEP(pdev, usbd->hid->in_ep);
USBD_LL_CloseEP(pdev, usbd->hid->out_ep);
}
#endif
return 0;
}
@ -725,11 +749,17 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
switch (req->bmRequest & USB_REQ_RECIPIENT_MASK) {
case USB_REQ_RECIPIENT_INTERFACE: {
uint16_t iface = req->wIndex;
#if MICROPY_HW_USB_MSC
if ((mode & USBD_MODE_IFACE_MSC) && iface == MSC_IFACE_NUM_WITH_CDC) {
recipient = USBD_MODE_MSC;
} else if ((mode & USBD_MODE_IFACE_HID) && iface == usbd->hid->iface_num) {
} else
#endif
#if MICROPY_HW_USB_HID
if ((mode & USBD_MODE_IFACE_HID) && iface == usbd->hid->iface_num) {
recipient = USBD_MODE_HID;
} else {
} else
#endif
{
for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
if ((mode & USBD_MODE_IFACE_CDC(i)) && iface == usbd->cdc[i]->iface_num) {
recipient = USBD_MODE_CDC;
@ -742,11 +772,17 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
}
case USB_REQ_RECIPIENT_ENDPOINT: {
uint8_t ep = req->wIndex & 0x7f;
#if MICROPY_HW_USB_MSC
if ((mode & USBD_MODE_IFACE_MSC) && ep == MSC_OUT_EP) {
recipient = USBD_MODE_MSC;
} else if ((mode & USBD_MODE_IFACE_HID) && ep == usbd->hid->out_ep) {
} else
#endif
#if MICROPY_HW_USB_HID
if ((mode & USBD_MODE_IFACE_HID) && ep == usbd->hid->out_ep) {
recipient = USBD_MODE_HID;
} else {
} else
#endif
{
for (int i = 0; i < MICROPY_HW_USB_CDC_NUM; ++i) {
if ((mode & USBD_MODE_IFACE_CDC(i)) && (ep == CDC_OUT_EP(i) || ep == (CDC_CMD_EP(i) & 0x7f))) {
recipient = USBD_MODE_CDC;
@ -786,7 +822,9 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
// Transfer the command to the interface layer
return usbd_cdc_control(cdc, req->bRequest, NULL, req->wValue);
}
} else if (recipient == USBD_MODE_MSC) {
}
#if MICROPY_HW_USB_MSC
if (recipient == USBD_MODE_MSC) {
switch (req->bRequest) {
case BOT_GET_MAX_LUN:
if ((req->wValue == 0) && (req->wLength == 1) && ((req->bmRequest & 0x80) == 0x80)) {
@ -811,7 +849,10 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
USBD_CtlError(pdev, req);
return USBD_FAIL;
}
} else if (recipient == USBD_MODE_HID) {
}
#endif
#if MICROPY_HW_USB_HID
if (recipient == USBD_MODE_HID) {
switch (req->bRequest) {
case HID_REQ_SET_PROTOCOL:
usbd->hid->ctl_protocol = (uint8_t)(req->wValue);
@ -834,9 +875,11 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
return USBD_FAIL;
}
}
#endif
break;
case USB_REQ_TYPE_STANDARD:
#if MICROPY_HW_USB_MSC
if (recipient == USBD_MODE_MSC) {
switch (req->bRequest) {
case USB_REQ_GET_INTERFACE :
@ -864,7 +907,10 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
MSC_BOT_CplClrFeature(pdev, (uint8_t)req->wIndex);
break;
}
} else if (recipient == USBD_MODE_HID) {
}
#endif
#if MICROPY_HW_USB_HID
if (recipient == USBD_MODE_HID) {
switch (req->bRequest) {
case USB_REQ_GET_DESCRIPTOR: {
uint16_t len = 0;
@ -890,6 +936,7 @@ static uint8_t USBD_CDC_MSC_HID_Setup(USBD_HandleTypeDef *pdev, USBD_SetupReqTyp
break;
}
}
#endif
break;
}
return USBD_OK;
@ -922,17 +969,21 @@ static uint8_t USBD_CDC_MSC_HID_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
}
}
#if MICROPY_HW_USB_MSC
if ((usbd->usbd_mode & USBD_MODE_IFACE_MSC) && epnum == (MSC_IN_EP & 0x7f)) {
MSC_BOT_DataIn(pdev, epnum);
return USBD_OK;
}
#endif
#if MICROPY_HW_USB_HID
if ((usbd->usbd_mode & USBD_MODE_IFACE_HID) && epnum == (usbd->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 */
usbd->hid->state = HID_IDLE;
return USBD_OK;
}
#endif
return USBD_OK;
}
@ -948,15 +999,19 @@ static uint8_t USBD_CDC_MSC_HID_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum)
}
}
#if MICROPY_HW_USB_MSC
if ((usbd->usbd_mode & USBD_MODE_IFACE_MSC) && epnum == (MSC_OUT_EP & 0x7f)) {
MSC_BOT_DataOut(pdev, epnum);
return USBD_OK;
}
#endif
#if MICROPY_HW_USB_HID
if ((usbd->usbd_mode & USBD_MODE_IFACE_HID) && epnum == (usbd->hid->out_ep & 0x7f)) {
size_t len = USBD_LL_GetRxDataSize(pdev, epnum);
return usbd_hid_receive(usbd->hid, len);
}
#endif
return USBD_OK;
}
@ -985,6 +1040,7 @@ static uint8_t *USBD_CDC_MSC_HID_GetCfgDesc(USBD_HandleTypeDef *pdev, uint16_t *
uint8_t *cdc_desc[MICROPY_HW_USB_CDC_NUM] = {0};
uint8_t *msc_desc = NULL;
switch (usbd->usbd_mode & USBD_MODE_IFACE_MASK) {
#if MICROPY_HW_USB_MSC
case USBD_MODE_MSC:
msc_desc = usbd->usbd_config_desc + MSC_TEMPLATE_MSC_DESC_OFFSET;
break;
@ -993,6 +1049,7 @@ static uint8_t *USBD_CDC_MSC_HID_GetCfgDesc(USBD_HandleTypeDef *pdev, uint16_t *
cdc_desc[0] = usbd->usbd_config_desc + CDC_MSC_TEMPLATE_CDC_DESC_OFFSET;
msc_desc = usbd->usbd_config_desc + CDC_MSC_TEMPLATE_MSC_DESC_OFFSET;
break;
#endif
#if MICROPY_HW_USB_CDC_NUM >= 2
case USBD_MODE_CDC2:
@ -1000,12 +1057,14 @@ static uint8_t *USBD_CDC_MSC_HID_GetCfgDesc(USBD_HandleTypeDef *pdev, uint16_t *
cdc_desc[1] = usbd->usbd_config_desc + CDC2_TEMPLATE_CDC2_DESC_OFFSET;
break;
#if MICROPY_HW_USB_MSC
case USBD_MODE_CDC2_MSC:
cdc_desc[0] = usbd->usbd_config_desc + CDC2_MSC_TEMPLATE_CDC_DESC_OFFSET;
cdc_desc[1] = usbd->usbd_config_desc + CDC2_MSC_TEMPLATE_CDC2_DESC_OFFSET;
msc_desc = usbd->usbd_config_desc + CDC2_MSC_TEMPLATE_MSC_DESC_OFFSET;
break;
#endif
#endif
#if MICROPY_HW_USB_CDC_NUM >= 3
case USBD_MODE_CDC3:
@ -1014,6 +1073,7 @@ static uint8_t *USBD_CDC_MSC_HID_GetCfgDesc(USBD_HandleTypeDef *pdev, uint16_t *
cdc_desc[2] = usbd->usbd_config_desc + CDC3_TEMPLATE_CDC3_DESC_OFFSET;
break;
#if MICROPY_HW_USB_MSC
case USBD_MODE_CDC3_MSC:
cdc_desc[0] = usbd->usbd_config_desc + CDC3_MSC_TEMPLATE_CDC_DESC_OFFSET;
cdc_desc[1] = usbd->usbd_config_desc + CDC3_MSC_TEMPLATE_CDC2_DESC_OFFSET;
@ -1021,10 +1081,13 @@ static uint8_t *USBD_CDC_MSC_HID_GetCfgDesc(USBD_HandleTypeDef *pdev, uint16_t *
msc_desc = usbd->usbd_config_desc + CDC3_MSC_TEMPLATE_MSC_DESC_OFFSET;
break;
#endif
#endif
#if MICROPY_HW_USB_HID
case USBD_MODE_CDC_HID:
cdc_desc[0] = usbd->usbd_config_desc + CDC_HID_TEMPLATE_CDC_DESC_OFFSET;
break;
#endif
case USBD_MODE_CDC:
cdc_desc[0] = usbd->usbd_config_desc + CDC_TEMPLATE_CDC_DESC_OFFSET;
@ -1091,6 +1154,8 @@ uint8_t USBD_CDC_ReceivePacket(usbd_cdc_state_t *cdc, uint8_t *buf) {
return USBD_OK;
}
#if MICROPY_HW_USB_HID
// prepare OUT endpoint for reception
uint8_t USBD_HID_ReceivePacket(usbd_hid_state_t *hid, uint8_t *buf) {
// Suspend or Resume USB Out process
@ -1149,6 +1214,8 @@ uint8_t USBD_HID_ClearNAK(usbd_hid_state_t *hid) {
return USBD_OK;
}
#endif
// CDC/MSC/HID interface class callback structure
const USBD_ClassTypeDef USBD_CDC_MSC_HID = {
USBD_CDC_MSC_HID_Init,

4
ports/stm32/usbdev/class/src/usbd_msc_bot.c
View File

@ -31,6 +31,8 @@
#include "usbd_cdc_msc_hid.h"
#include "usbd_ioreq.h"
#if MICROPY_HW_USB_MSC
/** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
* @{
*/
@ -404,4 +406,6 @@ void MSC_BOT_CplClrFeature (USBD_HandleTypeDef *pdev, uint8_t epnum)
* @}
*/
#endif // MICROPY_HW_USB_MSC
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

4
ports/stm32/usbdev/class/src/usbd_msc_scsi.c
View File

@ -30,7 +30,7 @@
#include "usbd_msc_scsi.h"
#include "usbd_cdc_msc_hid.h"
#if MICROPY_HW_USB_MSC
/** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
* @{
@ -789,4 +789,6 @@ static int8_t SCSI_ProcessWrite (USBD_HandleTypeDef *pdev, uint8_t lun)
* @}
*/
#endif // MICROPY_HW_USB_MSC
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

Write Preview
Loading…
Cancel
Save