feature(esp_tinyusb): Added test for usb device class reconfiguration

Author: roma-jam

device/esp_tinyusb/test_app/main/test_bvalid_sig.c

@@ -68,7 +68,7 @@ void test_bvalid_sig_umount_cb(void)
     dev_umounted++;
 }
 
-TEST_CASE("bvalid_signal", "[esp_tinyusb][usb_device]")
+TEST_CASE("bvalid_signal", "[usb_device]")
 {
     unsigned int rounds = DEVICE_DETACH_TEST_ROUNDS;
 

device/esp_tinyusb/test_app/main/test_descriptors_config.c

@@ -104,7 +104,7 @@ void test_descriptors_config_umount_cb(void)
 
 }
 
-TEST_CASE("descriptors_config_all_default", "[esp_tinyusb][usb_device]")
+TEST_CASE("descriptors_config_all_default", "[usb_device]")
 {
     TEST_ASSERT_EQUAL(true, __test_prep());
     // Install TinyUSB driver
@@ -125,7 +125,7 @@ TEST_CASE("descriptors_config_all_default", "[esp_tinyusb][usb_device]")
     __test_free();
 }
 
-TEST_CASE("descriptors_config_device", "[esp_tinyusb][usb_device]")
+TEST_CASE("descriptors_config_device", "[usb_device]")
 {
     TEST_ASSERT_EQUAL(true, __test_prep());
     // Install TinyUSB driver
@@ -146,7 +146,7 @@ TEST_CASE("descriptors_config_device", "[esp_tinyusb][usb_device]")
     __test_free();
 }
 
-TEST_CASE("descriptors_config_device_and_config", "[esp_tinyusb][usb_device]")
+TEST_CASE("descriptors_config_device_and_config", "[usb_device]")
 {
     TEST_ASSERT_EQUAL(true, __test_prep());
     // Install TinyUSB driver
@@ -168,7 +168,7 @@ TEST_CASE("descriptors_config_device_and_config", "[esp_tinyusb][usb_device]")
 }
 
 #if (TUD_OPT_HIGH_SPEED)
-TEST_CASE("descriptors_config_device_and_fs_config_only", "[esp_tinyusb][usb_device]")
+TEST_CASE("descriptors_config_device_and_fs_config_only", "[usb_device]")
 {
     TEST_ASSERT_EQUAL(true, __test_prep());
     // Install TinyUSB driver
@@ -187,7 +187,7 @@ TEST_CASE("descriptors_config_device_and_fs_config_only", "[esp_tinyusb][usb_dev
     __test_free();
 }
 
-TEST_CASE("descriptors_config_device_and_hs_config_only", "[esp_tinyusb][usb_device]")
+TEST_CASE("descriptors_config_device_and_hs_config_only", "[usb_device]")
 {
     TEST_ASSERT_EQUAL(true, __test_prep());
     // Install TinyUSB driver
@@ -206,7 +206,7 @@ TEST_CASE("descriptors_config_device_and_hs_config_only", "[esp_tinyusb][usb_dev
     __test_free();
 }
 
-TEST_CASE("descriptors_config_all_configured", "[esp_tinyusb][usb_device]")
+TEST_CASE("descriptors_config_all_configured", "[usb_device]")
 {
     TEST_ASSERT_EQUAL(true, __test_prep());
     // Install TinyUSB driver
@@ -226,4 +226,259 @@ TEST_CASE("descriptors_config_all_configured", "[esp_tinyusb][usb_device]")
 }
 #endif // TUD_OPT_HIGH_SPEED
 
+//
+// HID Class device configuration
+//
+#define TUSB_HID_CONFIG_DESC_TOTAL_LEN      (TUD_CONFIG_DESC_LEN + CFG_TUD_HID * TUD_HID_DESC_LEN)
+
+static const tusb_desc_device_t test_hid_class_dev_desc = {
+    .bLength = sizeof(tusb_desc_device_t),
+    .bDescriptorType = TUSB_DESC_DEVICE,
+    .bcdUSB = 0x0210,       // 2.10
+    .bDeviceClass = TUSB_CLASS_UNSPECIFIED,
+    .bDeviceSubClass = 0,
+    .bDeviceProtocol = 0,
+    .bMaxPacketSize0 = 64,
+    .idVendor = 0x413C,     // Dell Computer Corp
+    .idProduct = 0x301A,    // Dell MS116 Optical Mouse
+    .bcdDevice = 0x0100,    // 1.00
+    .iManufacturer = 1,
+    .iProduct = 2,
+    .iSerialNumber = 3,
+    .bNumConfigurations = 1,
+};
+
+const uint8_t test_hid_report_descriptor[] = {
+    TUD_HID_REPORT_DESC_KEYBOARD(HID_REPORT_ID(HID_ITF_PROTOCOL_KEYBOARD)),
+    TUD_HID_REPORT_DESC_MOUSE(HID_REPORT_ID(HID_ITF_PROTOCOL_MOUSE))
+};
+
+const char *test_hid_string_descriptor[5] = {
+    (char[]){0x09, 0x04},  // 0: is supported language is English (0x0409)
+    "Espressif",             // 1: Manufacturer
+    "USB Test HID Class",      // 2: Product
+    "123456",              // 3: Serials, should use chip ID
+    "Test HID Interface",  // 4: HID
+};
+
+static const uint8_t test_hid_fs_configuration_descriptor[] = {
+    // Configuration number, interface count, string index, total length, attribute, power in mA
+    TUD_CONFIG_DESCRIPTOR(1, 1, 0, TUSB_HID_CONFIG_DESC_TOTAL_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
+    TUD_HID_DESCRIPTOR(0, 4, false, sizeof(test_hid_report_descriptor), 0x81, 16, 10),
+};
+
+
+#if (TUD_OPT_HIGH_SPEED)
+static uint8_t const test_hid_hs_configuration_descriptor[] = {
+    // Config number, interface count, string index, total length, attribute, power in mA
+    // Configuration number, interface count, string index, total length, attribute, power in mA
+    TUD_CONFIG_DESCRIPTOR(1, 1, 0, TUSB_HID_CONFIG_DESC_TOTAL_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
+
+    // Interface number, string index, boot protocol, report descriptor len, EP In address, size & polling interval
+    TUD_HID_DESCRIPTOR(0, 4, false, sizeof(test_hid_report_descriptor), 0x81, 16, 10),
+};
+#endif // TUD_OPT_HIGH_SPEED
+
+uint8_t const *tud_hid_descriptor_report_cb(uint8_t instance)
+{
+    return test_hid_report_descriptor;
+}
+
+uint16_t tud_hid_get_report_cb(uint8_t instance, uint8_t report_id, hid_report_type_t report_type, uint8_t *buffer, uint16_t reqlen)
+{
+    return 0;
+}
+
+void tud_hid_set_report_cb(uint8_t instance, uint8_t report_id, hid_report_type_t report_type, uint8_t const *buffer, uint16_t bufsize)
+{
+
+}
+
+//
+// CDC Class 1x Interface
+//
+#define TUSB_CDC_CONFIG_DESC_TOTAL_LEN      (TUD_CONFIG_DESC_LEN + 1 * TUD_CDC_DESC_LEN)
+
+const tusb_desc_device_t test_cdc_class_dev_desc = {
+    .bLength = sizeof(tusb_desc_device_t),
+    .bDescriptorType = TUSB_DESC_DEVICE,
+    .bcdUSB = 0x0200,
+    .bDeviceClass = TUSB_CLASS_MISC,
+    .bDeviceSubClass = MISC_SUBCLASS_COMMON,
+    .bDeviceProtocol = MISC_PROTOCOL_IAD,
+    .bMaxPacketSize0 = 64,
+    .idVendor = 0x0001,
+    .idProduct = 0x0002,
+    .bcdDevice = 0x0000,
+    .iManufacturer = 0x01,
+    .iProduct = 0x02,
+    .iSerialNumber = 0x03,
+    .bNumConfigurations = 0x01
+};
+
+const char *test_cdc_string_descriptor[5] = {
+    (char[]){0x09, 0x04},  // 0: is supported language is English (0x0409)
+    "Espressif",             // 1: Manufacturer
+    "USB Test CDC Class",      // 2: Product
+    "123456",              // 3: Serials, should use chip ID
+    "Test CDC Interface",  // 4: CDC
+};
+
+static const uint8_t test_cdc_fs_configuration_descriptor[] = {
+    // Configuration number, interface count, string index, total length, attribute, power in mA
+    TUD_CONFIG_DESCRIPTOR(1, 1, 0, TUSB_CDC_CONFIG_DESC_TOTAL_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
+    TUD_CDC_DESCRIPTOR(0, 4, 0x81, 8, 0x02, 0x82, 64),
+};
+
+//
+// MSC Class
+//
+#define TUSB_MSC_CONFIG_DESC_TOTAL_LEN      (TUD_CONFIG_DESC_LEN + TUD_MSC_DESC_LEN)
+
+
+const tusb_desc_device_t test_msc_class_dev_desc = {
+    .bLength = sizeof(tusb_desc_device_t),
+    .bDescriptorType = TUSB_DESC_DEVICE,
+    .bcdUSB = 0x0210,       // 2.10
+    .bDeviceClass = TUSB_CLASS_MSC,
+    .bDeviceSubClass = 0,
+    .bDeviceProtocol = 0,
+    .bMaxPacketSize0 = 64,
+    .idVendor = 0x0781,     // SanDisk Corp
+    .idProduct = 0x5595,
+    .bcdDevice = 0x0100,    // 1.00
+    .iManufacturer = 0x01,
+    .iProduct = 0x02,
+    .iSerialNumber = 0x03,
+    .bNumConfigurations = 0x01
+};
+
+const char *test_msc_string_descriptor[4] = {
+    (char[]){0x09, 0x04},  // 0: is supported language is English (0x0409)
+    "Espressif",             // 1: Manufacturer
+    "USB Test MSC Class",    // 2: Product
+    NULL,                   // 3: NULL
+};
+
+static const uint8_t test_msc_fs_configuration_descriptor[] = {
+    // Configuration number, interface count, string index, total length, attribute, power in mA
+    TUD_CONFIG_DESCRIPTOR(1, 1, 0, TUSB_MSC_CONFIG_DESC_TOTAL_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
+    TUD_MSC_DESCRIPTOR(1, 0, 0x01, 0x81, 64),
+};
+
+bool tud_msc_test_unit_ready_cb(uint8_t lun)
+{
+    (void) lun;
+    // Our device doesn't have any media for testing purpose
+    return false;
+}
+
+void tud_msc_capacity_cb(uint8_t lun, uint32_t *block_count, uint16_t *block_size)
+{
+    (void) lun;
+    *block_count = 0;
+    *block_size  = 0;
+}
+
+void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t product_id[16], uint8_t product_rev[4])
+{
+    (void) lun;
+    const char vid[] = "USB";
+    const char pid[] = "MSC Class";
+    const char rev[] = "0.1";
+
+    memcpy(vendor_id, vid, strlen(vid));
+    memcpy(product_id, pid, strlen(pid));
+    memcpy(product_rev, rev, strlen(rev));
+}
+
+int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba, uint32_t offset, void *buffer, uint32_t bufsize)
+{
+    return 0;
+}
+
+int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba, uint32_t offset, uint8_t *buffer, uint32_t bufsize)
+{
+    return 0;
+}
+
+int32_t tud_msc_scsi_cb(uint8_t lun, uint8_t const scsi_cmd[16], void *buffer, uint16_t bufsize)
+{
+    return 0;
+}
+
+//
+// Configuration array
+//
+
+enum {
+    TEST_CFG_HID_CLASS = 0,
+    TEST_CFG_CDC_CLASS,
+    TEST_CFG_MSC_CLASS,
+};
+
+const tinyusb_config_t tusb_cfg[] = {
+    // HID Class
+    {
+        .external_phy = false,
+        .device_descriptor = &test_hid_class_dev_desc,
+        .string_descriptor = test_hid_string_descriptor,
+        .string_descriptor_count = sizeof(test_hid_string_descriptor) / sizeof(test_hid_string_descriptor[0]),
+        .configuration_descriptor = test_hid_fs_configuration_descriptor,
+#if (TUD_OPT_HIGH_SPEED)
+        .hs_configuration_descriptor = test_hid_hs_configuration_descriptor,
+#endif // TUD_OPT_HIGH_SPEED
+    },
+    // CDC Class
+    {
+        .external_phy = false,
+        .device_descriptor = &test_cdc_class_dev_desc,
+        .string_descriptor = test_cdc_string_descriptor,
+        .string_descriptor_count = sizeof(test_cdc_string_descriptor) / sizeof(test_cdc_string_descriptor[0]),
+        .configuration_descriptor = test_cdc_fs_configuration_descriptor,
+#if (TUD_OPT_HIGH_SPEED)
+        .hs_configuration_descriptor = test_cdc_hs_configuration_descriptor,
+#endif // TUD_OPT_HIGH_SPEED
+    },
+    //  MSC Class
+    {
+        .external_phy = false,
+        .device_descriptor = &test_msc_class_dev_desc,
+        .string_descriptor = test_msc_string_descriptor,
+        .string_descriptor_count = sizeof(test_msc_string_descriptor) / sizeof(test_msc_string_descriptor[0]),
+        .configuration_descriptor = test_msc_fs_configuration_descriptor,
+#if (TUD_OPT_HIGH_SPEED)
+        .hs_configuration_descriptor = test_msc_hs_configuration_descriptor,
+#endif // TUD_OPT_HIGH_SPEED
+    },
+};
+
+
+TEST_CASE("device_class_reconfiguration", "[usb_device]")
+{
+    TEST_ASSERT_EQUAL(true, __test_prep());
+    // Install HID Class only
+    TEST_ASSERT_EQUAL(ESP_OK, tinyusb_driver_install(&tusb_cfg[TEST_CFG_HID_CLASS]));
+    // Wait for mounted callback
+    TEST_ASSERT_EQUAL(ESP_OK, __test_wait_conn());
+    // Cleanup
+    TEST_ASSERT_EQUAL(ESP_OK, tinyusb_driver_uninstall());
+
+    // Install CDC Class only
+    TEST_ASSERT_EQUAL(ESP_OK, tinyusb_driver_install(&tusb_cfg[TEST_CFG_CDC_CLASS]));
+    // Wait for mounted callback
+    TEST_ASSERT_EQUAL(ESP_OK, __test_wait_conn());
+    // Cleanup
+    TEST_ASSERT_EQUAL(ESP_OK, tinyusb_driver_uninstall());
+
+    // Install MSC Class only
+    TEST_ASSERT_EQUAL(ESP_OK, tinyusb_driver_install(&tusb_cfg[TEST_CFG_MSC_CLASS]));
+    // Wait for mounted callback
+    TEST_ASSERT_EQUAL(ESP_OK, __test_wait_conn());
+    // Cleanup
+    TEST_ASSERT_EQUAL(ESP_OK, tinyusb_driver_uninstall());
+
+    __test_free();
+}
+
 #endif // SOC_USB_OTG_SUPPORTED

device/esp_tinyusb/test_app/pytest_usb_device.py

@@ -1,9 +1,9 @@
 # Configure TinyUSB, it will be used to mock USB devices
 CONFIG_TINYUSB=y
-CONFIG_TINYUSB_MSC_ENABLED=n
+CONFIG_TINYUSB_MSC_ENABLED=y
 CONFIG_TINYUSB_CDC_ENABLED=y
 CONFIG_TINYUSB_CDC_COUNT=2
-CONFIG_TINYUSB_HID_COUNT=0
+CONFIG_TINYUSB_HID_COUNT=1
 
 # Disable watchdogs, they'd get triggered during unity interactive menu
 CONFIG_ESP_INT_WDT=n