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.

10 files changed, 145 insertions, 12 deletions

diff --git a/ports/stm32/main.c b/ports/stm32/main.c
index c05781432..14ea4e644 100644
--- a/ports/stm32/main.c
+++ b/ports/stm32/main.c
@@ -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
 
diff --git a/ports/stm32/modpyb.c b/ports/stm32/modpyb.c
index c3e60caeb..139defc53 100644
--- a/ports/stm32/modpyb.c
+++ b/ports/stm32/modpyb.c
@@ -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) },
diff --git a/ports/stm32/mpconfigboard_common.h b/ports/stm32/mpconfigboard_common.h
index 94a86ca92..63d423802 100644
--- a/ports/stm32/mpconfigboard_common.h
+++ b/ports/stm32/mpconfigboard_common.h
@@ -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"
diff --git a/ports/stm32/usb.c b/ports/stm32/usb.c
index 51e6e7a39..2d1f6084f 100644
--- a/ports/stm32/usb.c
+++ b/ports/stm32/usb.c
@@ -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
 
diff --git a/ports/stm32/usbd_hid_interface.c b/ports/stm32/usbd_hid_interface.c
index 3ffc0b425..033d83ea6 100644
--- a/ports/stm32/usbd_hid_interface.c
+++ b/ports/stm32/usbd_hid_interface.c
@@ -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
diff --git a/ports/stm32/usbd_msc_interface.c b/ports/stm32/usbd_msc_interface.c
index aa2b381a0..7f563004b 100644
--- a/ports/stm32/usbd_msc_interface.c
+++ b/ports/stm32/usbd_msc_interface.c
@@ -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
diff --git a/ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid.h b/ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid.h
index c41908d25..a01e75bed 100644
--- a/ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid.h
+++ b/ports/stm32/usbdev/class/inc/usbd_cdc_msc_hid.h
@@ -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);
diff --git a/ports/stm32/usbdev/class/src/usbd_cdc_msc_hid.c b/ports/stm32/usbdev/class/src/usbd_cdc_msc_hid.c
index 627fb054c..32ce4ca87 100644
--- a/ports/stm32/usbdev/class/src/usbd_cdc_msc_hid.c
+++ b/ports/stm32/usbdev/class/src/usbd_cdc_msc_hid.c
@@ -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,
diff --git a/ports/stm32/usbdev/class/src/usbd_msc_bot.c b/ports/stm32/usbdev/class/src/usbd_msc_bot.c
index d20f7a8dc..44a74a660 100644
--- a/ports/stm32/usbdev/class/src/usbd_msc_bot.c
+++ b/ports/stm32/usbdev/class/src/usbd_msc_bot.c
@@ -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****/
diff --git a/ports/stm32/usbdev/class/src/usbd_msc_scsi.c b/ports/stm32/usbdev/class/src/usbd_msc_scsi.c
index 26556bb48..d0413b758 100644
--- a/ports/stm32/usbdev/class/src/usbd_msc_scsi.c
+++ b/ports/stm32/usbdev/class/src/usbd_msc_scsi.c
@@ -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****/