mirror
/
micropython
kopia lustrzana https://github.com/micropython/micropython
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

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 2019-07-16 14:39:21 +10:00
rodzic 154062d9cb
commit f302f784e9
10 zmienionych plików z 145 dodań i 12 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

9
ports/stm32/main.c
Wyświetl plik

@ -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
Wyświetl plik

@ -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
Wyświetl plik

@ -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
Wyświetl plik

@ -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
Wyświetl plik

@ -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
Wyświetl plik

@ -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
Wyświetl plik

@ -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
Wyświetl plik

@ -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
Wyświetl plik

@ -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
Wyświetl plik

@ -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****/