refactor(usb): Split test device descriptors from mock class files

Previously, descriptors of the test devices were stored direclty in the mock device files (e.g., "mock_[hid|msc].[h|c]"). This commit splits out the device descriptors to separate files (e.g., "dev_[hid|msc].c") along with getter functions. Users that want to run the tests locally on a different device simply need to update the "dev_[hid|msc].c" file for their device.
2026-10-02 03:00:34 +03:00 · 2024-06-09 12:19:53 +08:00
parent edd41c24c3
commit 6ead402d15
24 changed files with 1123 additions and 516 deletions
@@ -8,8 +8,6 @@

 typedef struct {
    int num_ctrl_xfer_to_send;
-    uint16_t idVendor;
-    uint16_t idProduct;
 } ctrl_client_test_param_t;

 void ctrl_client_async_seq_task(void *arg);
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Apache-2.0
 */
@@ -11,6 +11,7 @@
 #include "esp_err.h"
 #include "esp_log.h"
 #include "test_usb_common.h"
+#include "dev_msc.h"
 #include "ctrl_client.h"
 #include "usb/usb_host.h"
 #include "unity.h"
@@ -47,14 +48,19 @@ typedef enum {
 } test_stage_t;

 typedef struct {
+    // Test parameters
    ctrl_client_test_param_t test_param;
+    // MSC device info
+    uint8_t dev_addr;
+    usb_speed_t dev_speed;
+    // Client variables
+    usb_host_client_handle_t client_hdl;
+    usb_device_handle_t dev_hdl;
+    // Test state
    test_stage_t cur_stage;
    test_stage_t next_stage;
    uint8_t num_xfer_done;
    uint8_t num_xfer_sent;
-    uint8_t dev_addr_to_open;
-    usb_host_client_handle_t client_hdl;
-    usb_device_handle_t dev_hdl;
    const usb_config_desc_t *config_desc_cached;
 } ctrl_client_obj_t;

@@ -79,7 +85,7 @@ static void ctrl_client_event_cb(const usb_host_client_event_msg_t *event_msg, v
    case USB_HOST_CLIENT_EVENT_NEW_DEV:
        TEST_ASSERT_EQUAL(TEST_STAGE_WAIT_CONN, ctrl_obj->cur_stage);
        ctrl_obj->next_stage = TEST_STAGE_DEV_OPEN;
-        ctrl_obj->dev_addr_to_open = event_msg->new_dev.address;
+        ctrl_obj->dev_addr = event_msg->new_dev.address;
        break;
    default:
        abort();    // Should never occur in this test
@@ -133,16 +139,21 @@ void ctrl_client_async_seq_task(void *arg)
        case TEST_STAGE_DEV_OPEN: {
            ESP_LOGD(CTRL_CLIENT_TAG, "Open");
            // Open the device
-            TEST_ASSERT_EQUAL_MESSAGE(ESP_OK, usb_host_device_open(ctrl_obj.client_hdl, ctrl_obj.dev_addr_to_open, &ctrl_obj.dev_hdl), "Failed to open the device");
+            TEST_ASSERT_EQUAL_MESSAGE(ESP_OK, usb_host_device_open(ctrl_obj.client_hdl, ctrl_obj.dev_addr, &ctrl_obj.dev_hdl), "Failed to open the device");
+            // Get device info to get device speed
+            usb_device_info_t dev_info;
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_device_info(ctrl_obj.dev_hdl, &dev_info));
+            ctrl_obj.dev_speed = dev_info.speed;
            // Target our transfers to the device
            for (int i = 0; i < NUM_TRANSFER_OBJ; i++) {
                ctrl_xfer[i]->device_handle = ctrl_obj.dev_hdl;
            }
-            // Check the VID/PID of the opened device
+            // Check that the device descriptor matches our expected MSC device
            const usb_device_desc_t *device_desc;
+            const usb_device_desc_t *device_desc_ref = dev_msc_get_dev_desc(ctrl_obj.dev_speed);
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_get_device_descriptor(ctrl_obj.dev_hdl, &device_desc));
-            TEST_ASSERT_EQUAL(ctrl_obj.test_param.idVendor, device_desc->idVendor);
-            TEST_ASSERT_EQUAL(ctrl_obj.test_param.idProduct, device_desc->idProduct);
+            TEST_ASSERT_EQUAL(device_desc_ref->bLength, device_desc->bLength);
+            TEST_ASSERT_EQUAL_MEMORY_MESSAGE(device_desc_ref, device_desc, sizeof(usb_device_desc_t), "Device descriptors do not match.");
            // Cache the active configuration descriptor for later comparison
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_get_active_config_descriptor(ctrl_obj.dev_hdl, &ctrl_obj.config_desc_cached));
            ctrl_obj.next_stage = TEST_STAGE_CTRL_XFER;
@@ -12,8 +12,6 @@ typedef struct {
    int num_sectors_to_read;
    int num_sectors_per_xfer;
    uint32_t msc_scsi_xfer_tag;
-    uint16_t idVendor;
-    uint16_t idProduct;
 } msc_client_test_param_t;

 void msc_client_async_seq_task(void *arg);
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Apache-2.0
 */
@@ -13,8 +13,10 @@
 #include "esp_err.h"
 #include "esp_log.h"
 #include "mock_msc.h"
+#include "dev_msc.h"
 #include "test_usb_common.h"
 #include "msc_client.h"
+#include "usb/usb_types_ch9.h"
 #include "usb/usb_host.h"
 #include "unity.h"

@@ -47,12 +49,18 @@ typedef enum {
 } test_stage_t;

 typedef struct {
+    // Test parameters
    msc_client_test_param_t test_param;
-    test_stage_t cur_stage;
-    test_stage_t next_stage;
-    uint8_t dev_addr_to_open;
+    // MSC device info
+    const dev_msc_info_t *dev_info;
+    usb_speed_t dev_speed;
+    uint8_t dev_addr;
+    // Client variables
    usb_host_client_handle_t client_hdl;
    usb_device_handle_t dev_hdl;
+    // Test state
+    test_stage_t cur_stage;
+    test_stage_t next_stage;
    int num_data_transfers;
    int event_count;
 } msc_client_obj_t;
@@ -100,7 +108,7 @@ static void msc_client_event_cb(const usb_host_client_event_msg_t *event_msg, vo
    case USB_HOST_CLIENT_EVENT_NEW_DEV:
        TEST_ASSERT_EQUAL(TEST_STAGE_WAIT_CONN, msc_obj->cur_stage);
        msc_obj->next_stage = TEST_STAGE_DEV_OPEN;
-        msc_obj->dev_addr_to_open = event_msg->new_dev.address;
+        msc_obj->dev_addr = event_msg->new_dev.address;
        break;
    case USB_HOST_CLIENT_EVENT_DEV_GONE:
        msc_obj->event_count++;
@@ -118,13 +126,17 @@ static void msc_client_event_cb(const usb_host_client_event_msg_t *event_msg, vo
 void msc_client_async_dconn_task(void *arg)
 {
    msc_client_obj_t msc_obj;
+    // Initialize test params
    memcpy(&msc_obj.test_param, arg, sizeof(msc_client_test_param_t));
-    msc_obj.cur_stage = TEST_STAGE_WAIT_CONN;
-    msc_obj.next_stage = TEST_STAGE_WAIT_CONN;
-    msc_obj.dev_addr_to_open = 0;
+    // Initialize MSC device info
+    msc_obj.dev_info = dev_msc_get_info();
+    // Initialize client variables
    msc_obj.client_hdl = NULL;
    msc_obj.dev_hdl = NULL;
-    msc_obj.num_data_transfers = msc_obj.test_param.num_sectors_per_xfer / MOCK_MSC_SCSI_SECTOR_SIZE;
+    // Initialize test state
+    msc_obj.cur_stage = TEST_STAGE_WAIT_CONN;
+    msc_obj.next_stage = TEST_STAGE_WAIT_CONN;
+    msc_obj.num_data_transfers = msc_obj.test_param.num_sectors_per_xfer / msc_obj.dev_info->scsi_sector_size;
    msc_obj.event_count = 0;

    // Register client
@@ -142,7 +154,7 @@ void msc_client_async_dconn_task(void *arg)
    usb_transfer_t *xfer_out;   // Must be large enough to contain CBW and MSC reset control transfer
    usb_transfer_t *xfer_in[msc_obj.num_data_transfers];   // We manually split the data stage into multiple transfers
    size_t xfer_out_size = MAX(sizeof(mock_msc_bulk_cbw_t), sizeof(usb_setup_packet_t));
-    size_t xfer_in_size = MOCK_MSC_SCSI_SECTOR_SIZE;
+    size_t xfer_in_size = msc_obj.dev_info->scsi_sector_size;
    TEST_ASSERT_EQUAL(ESP_OK, usb_host_transfer_alloc(xfer_out_size, 0, &xfer_out));
    xfer_out->context = (void *)&msc_obj;
    for (int i = 0; i < msc_obj.num_data_transfers; i++) {
@@ -175,7 +187,7 @@ void msc_client_async_dconn_task(void *arg)
        case TEST_STAGE_DEV_OPEN: {
            ESP_LOGD(MSC_CLIENT_TAG, "Open");
            // Open the device
-            TEST_ASSERT_EQUAL(ESP_OK, usb_host_device_open(msc_obj.client_hdl, msc_obj.dev_addr_to_open, &msc_obj.dev_hdl));
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_device_open(msc_obj.client_hdl, msc_obj.dev_addr, &msc_obj.dev_hdl));
            // Target our transfers to the device
            xfer_out->device_handle = msc_obj.dev_hdl;
            xfer_out->callback = msc_reset_cbw_transfer_cb;
@@ -183,13 +195,21 @@ void msc_client_async_dconn_task(void *arg)
                xfer_in[i]->device_handle = msc_obj.dev_hdl;
                xfer_in[i]->callback = msc_data_transfer_cb;
            }
-            // Check the VID/PID of the opened device
+            // Get device info to get device speed
+            usb_device_info_t dev_info;
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_device_info(msc_obj.dev_hdl, &dev_info));
+            msc_obj.dev_speed = dev_info.speed;
+            // Check the device descriptor of the opened device
            const usb_device_desc_t *device_desc;
+            const usb_device_desc_t *device_desc_ref = dev_msc_get_dev_desc(msc_obj.dev_speed);
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_get_device_descriptor(msc_obj.dev_hdl, &device_desc));
-            TEST_ASSERT_EQUAL(msc_obj.test_param.idVendor, device_desc->idVendor);
-            TEST_ASSERT_EQUAL(msc_obj.test_param.idProduct, device_desc->idProduct);
+            TEST_ASSERT_EQUAL(device_desc_ref->bLength, device_desc->bLength);
+            TEST_ASSERT_EQUAL_MEMORY_MESSAGE(device_desc_ref, device_desc, device_desc_ref->bLength, "Device descriptors do not match.");
            // Claim the MSC interface
-            TEST_ASSERT_EQUAL(ESP_OK, usb_host_interface_claim(msc_obj.client_hdl, msc_obj.dev_hdl, MOCK_MSC_SCSI_INTF_NUMBER, MOCK_MSC_SCSI_INTF_ALT_SETTING));
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_interface_claim(msc_obj.client_hdl,
+                                                               msc_obj.dev_hdl,
+                                                               msc_obj.dev_info->bInterfaceNumber,
+                                                               msc_obj.dev_info->bAlternateSetting));
            msc_obj.next_stage = TEST_STAGE_MSC_RESET;
            skip_event_handling = true; // Need to execute TEST_STAGE_MSC_RESET
            break;
@@ -197,7 +217,7 @@ void msc_client_async_dconn_task(void *arg)
        case TEST_STAGE_MSC_RESET: {
            ESP_LOGD(MSC_CLIENT_TAG, "MSC Reset");
            // Send an MSC SCSI interface reset
-            MOCK_MSC_SCSI_REQ_INIT_RESET((usb_setup_packet_t *)xfer_out->data_buffer, MOCK_MSC_SCSI_INTF_NUMBER);
+            MOCK_MSC_SCSI_REQ_INIT_RESET((usb_setup_packet_t *)xfer_out->data_buffer, msc_obj.dev_info->bInterfaceNumber);
            xfer_out->num_bytes = sizeof(usb_setup_packet_t);
            xfer_out->bEndpointAddress = 0;
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_transfer_submit_control(msc_obj.client_hdl, xfer_out));
@@ -206,9 +226,14 @@ void msc_client_async_dconn_task(void *arg)
        }
        case TEST_STAGE_MSC_CBW: {
            ESP_LOGD(MSC_CLIENT_TAG, "CBW");
-            mock_msc_scsi_init_cbw((mock_msc_bulk_cbw_t *)xfer_out->data_buffer, true, 0, msc_obj.test_param.num_sectors_per_xfer, msc_obj.test_param.msc_scsi_xfer_tag);
+            mock_msc_scsi_init_cbw((mock_msc_bulk_cbw_t *)xfer_out->data_buffer,
+                                   true,
+                                   0,
+                                   msc_obj.test_param.num_sectors_per_xfer,
+                                   msc_obj.dev_info->scsi_sector_size,
+                                   msc_obj.test_param.msc_scsi_xfer_tag);
            xfer_out->num_bytes = sizeof(mock_msc_bulk_cbw_t);
-            xfer_out->bEndpointAddress = MOCK_MSC_SCSI_BULK_OUT_EP_ADDR;
+            xfer_out->bEndpointAddress = msc_obj.dev_info->out_up_addr;
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_transfer_submit(xfer_out));
            // Next stage set from transfer callback
            break;
@@ -216,9 +241,11 @@ void msc_client_async_dconn_task(void *arg)
        case TEST_STAGE_MSC_DATA_DCONN: {
            ESP_LOGD(MSC_CLIENT_TAG, "Data and disconnect");
            // Setup the Data IN transfers
+            const usb_ep_desc_t *in_ep_desc = dev_msc_get_in_ep_desc(msc_obj.dev_speed);
+            const int bulk_ep_mps = USB_EP_DESC_GET_MPS(in_ep_desc);
            for (int i = 0; i < msc_obj.num_data_transfers; i++) {
-                xfer_in[i]->num_bytes = usb_round_up_to_mps(MOCK_MSC_SCSI_SECTOR_SIZE, MOCK_MSC_SCSI_BULK_EP_MPS);
-                xfer_in[i]->bEndpointAddress = MOCK_MSC_SCSI_BULK_IN_EP_ADDR;
+                xfer_in[i]->num_bytes = usb_round_up_to_mps(msc_obj.dev_info->scsi_sector_size, bulk_ep_mps);
+                xfer_in[i]->bEndpointAddress = msc_obj.dev_info->in_ep_addr;
            }
            // Submit those transfers
            for (int i = 0; i < msc_obj.num_data_transfers; i++) {
@@ -231,7 +258,7 @@ void msc_client_async_dconn_task(void *arg)
        }
        case TEST_STAGE_DEV_CLOSE: {
            ESP_LOGD(MSC_CLIENT_TAG, "Close");
-            TEST_ASSERT_EQUAL(ESP_OK, usb_host_interface_release(msc_obj.client_hdl, msc_obj.dev_hdl, MOCK_MSC_SCSI_INTF_NUMBER));
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_interface_release(msc_obj.client_hdl, msc_obj.dev_hdl, msc_obj.dev_info->bInterfaceNumber));
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_device_close(msc_obj.client_hdl, msc_obj.dev_hdl));
            dconn_iter++;
            if (dconn_iter < TEST_DCONN_ITERATIONS) {
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Apache-2.0
 */
@@ -12,6 +12,7 @@
 #include "freertos/task.h"
 #include "esp_err.h"
 #include "esp_log.h"
+#include "dev_msc.h"
 #include "mock_msc.h"
 #include "test_usb_common.h"
 #include "msc_client.h"
@@ -48,6 +49,7 @@ typedef struct {
    uint8_t dev_addr_to_open;
    usb_host_client_handle_t client_hdl;
    usb_device_handle_t dev_hdl;
+    usb_speed_t dev_speed;
 } msc_client_obj_t;

 static void msc_client_event_cb(const usb_host_client_event_msg_t *event_msg, void *arg)
@@ -113,16 +115,20 @@ void msc_client_async_enum_task(void *arg)
            // Open the device
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_device_open(msc_obj.client_hdl, msc_obj.dev_addr_to_open, &msc_obj.dev_hdl));
            msc_obj.next_stage = TEST_STAGE_CHECK_DEV_DESC;
+            // Get device info to get device speed
+            usb_device_info_t dev_info;
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_device_info(msc_obj.dev_hdl, &dev_info));
+            msc_obj.dev_speed = dev_info.speed;
            skip_event_handling = true; // Need to execute TEST_STAGE_CHECK_DEV_DESC
            break;
        }
        case TEST_STAGE_CHECK_DEV_DESC: {
            // Check the device descriptor
            const usb_device_desc_t *device_desc;
-            const usb_device_desc_t *device_desc_ref = &mock_msc_scsi_dev_desc;
+            const usb_device_desc_t *device_desc_ref = dev_msc_get_dev_desc(msc_obj.dev_speed);
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_get_device_descriptor(msc_obj.dev_hdl, &device_desc));
            TEST_ASSERT_EQUAL(device_desc_ref->bLength, device_desc->bLength);
-            TEST_ASSERT_EQUAL_MEMORY_MESSAGE(device_desc_ref, device_desc, device_desc_ref->bLength, "Device descriptors do not match.");
+            TEST_ASSERT_EQUAL_MEMORY_MESSAGE(device_desc_ref, device_desc, sizeof(usb_device_desc_t), "Device descriptors do not match.");
            msc_obj.next_stage = TEST_STAGE_CHECK_CONFIG_DESC;
            skip_event_handling = true; // Need to execute TEST_STAGE_CHECK_CONFIG_DESC
            break;
@@ -131,10 +137,10 @@ void msc_client_async_enum_task(void *arg)
        case TEST_STAGE_CHECK_CONFIG_DESC: {
            // Check the configuration descriptor
            const usb_config_desc_t *config_desc;
-            const usb_config_desc_t *config_desc_ref = (const usb_config_desc_t *)mock_msc_scsi_config_desc;
+            const usb_config_desc_t *config_desc_ref = dev_msc_get_config_desc(msc_obj.dev_speed);
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_get_active_config_descriptor(msc_obj.dev_hdl, &config_desc));
            TEST_ASSERT_EQUAL_MESSAGE(config_desc_ref->wTotalLength, config_desc->wTotalLength, "Incorrect length of CFG descriptor");
-            TEST_ASSERT_EQUAL_MEMORY_MESSAGE(config_desc_ref, config_desc, config_desc_ref->wTotalLength, "Configuration descriptors do not match");
+            TEST_ASSERT_EQUAL_MEMORY_MESSAGE(config_desc_ref, config_desc, sizeof(usb_config_desc_t), "Configuration descriptors do not match");
            msc_obj.next_stage = TEST_STAGE_CHECK_STR_DESC;
            skip_event_handling = true; // Need to execute TEST_STAGE_CHECK_STR_DESC
            break;
@@ -143,15 +149,15 @@ void msc_client_async_enum_task(void *arg)
            usb_device_info_t dev_info;
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_device_info(msc_obj.dev_hdl, &dev_info));
            // Check manufacturer string descriptors
-            const usb_str_desc_t *manu_str_desc_ref = (const usb_str_desc_t *)mock_msc_scsi_str_desc_manu;
-            const usb_str_desc_t *product_str_desc_ref = (const usb_str_desc_t *)mock_msc_scsi_str_desc_prod;
-            const usb_str_desc_t *ser_num_str_desc_ref = (const usb_str_desc_t *)mock_msc_scsi_str_desc_ser_num;
+            const usb_str_desc_t *manu_str_desc_ref = dev_msc_get_str_desc_manu();
+            const usb_str_desc_t *product_str_desc_ref = dev_msc_get_str_desc_prod();
+            const usb_str_desc_t *ser_num_str_desc_ref = dev_msc_get_str_desc_ser();
            TEST_ASSERT_EQUAL(manu_str_desc_ref->bLength, dev_info.str_desc_manufacturer->bLength);
            TEST_ASSERT_EQUAL(product_str_desc_ref->bLength, dev_info.str_desc_product->bLength);
            TEST_ASSERT_EQUAL(ser_num_str_desc_ref->bLength, dev_info.str_desc_serial_num->bLength);
            TEST_ASSERT_EQUAL_MEMORY_MESSAGE(manu_str_desc_ref, dev_info.str_desc_manufacturer, manu_str_desc_ref->bLength, "Manufacturer string descriptors do not match.");
            TEST_ASSERT_EQUAL_MEMORY_MESSAGE(product_str_desc_ref, dev_info.str_desc_product, manu_str_desc_ref->bLength, "Product string descriptors do not match.");
-            // TEST_ASSERT_EQUAL_MEMORY_MESSAGE(ser_num_str_desc_ref, dev_info.str_desc_serial_num , manu_str_desc_ref->bLength, "Serial number string descriptors do not match.");
+            TEST_ASSERT_EQUAL_MEMORY_MESSAGE(ser_num_str_desc_ref, dev_info.str_desc_serial_num, manu_str_desc_ref->bLength, "Serial number string descriptors do not match.");
            // Get dev info and compare
            msc_obj.next_stage = TEST_STAGE_DEV_CLOSE;
            skip_event_handling = true; // Need to execute TEST_STAGE_DEV_CLOSE
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Apache-2.0
 */
@@ -14,6 +14,7 @@
 #include "esp_log.h"
 #include "test_usb_common.h"
 #include "mock_msc.h"
+#include "dev_msc.h"
 #include "msc_client.h"
 #include "usb/usb_host.h"
 #include "unity.h"
@@ -46,12 +47,18 @@ typedef enum {
 } test_stage_t;

 typedef struct {
+    // Test parameters
    msc_client_test_param_t test_param;
-    test_stage_t cur_stage;
-    test_stage_t next_stage;
-    uint8_t dev_addr_to_open;
+    // MSC device info
+    const dev_msc_info_t *dev_info;
+    usb_speed_t dev_speed;
+    uint8_t dev_addr;
+    // Client variables
    usb_host_client_handle_t client_hdl;
    usb_device_handle_t dev_hdl;
+    // Test state
+    test_stage_t cur_stage;
+    test_stage_t next_stage;
    int num_sectors_read;
 } msc_client_obj_t;

@@ -76,7 +83,7 @@ static void msc_transfer_cb(usb_transfer_t *transfer)
    case TEST_STAGE_MSC_DATA: {
        // Check MSC SCSI data IN transfer
        TEST_ASSERT_EQUAL_MESSAGE(USB_TRANSFER_STATUS_COMPLETED, transfer->status, "Transfer NOT completed");
-        TEST_ASSERT_EQUAL(MOCK_MSC_SCSI_SECTOR_SIZE * msc_obj->test_param.num_sectors_per_xfer, transfer->actual_num_bytes);
+        TEST_ASSERT_EQUAL(msc_obj->dev_info->scsi_sector_size * msc_obj->test_param.num_sectors_per_xfer, transfer->actual_num_bytes);
        msc_obj->next_stage = TEST_STAGE_MSC_CSW;
        break;
    }
@@ -106,7 +113,7 @@ static void msc_client_event_cb(const usb_host_client_event_msg_t *event_msg, vo
    case USB_HOST_CLIENT_EVENT_NEW_DEV:
        TEST_ASSERT_EQUAL(TEST_STAGE_WAIT_CONN, msc_obj->cur_stage);
        msc_obj->next_stage = TEST_STAGE_DEV_OPEN;
-        msc_obj->dev_addr_to_open = event_msg->new_dev.address;
+        msc_obj->dev_addr = event_msg->new_dev.address;
        break;
    default:
        abort();    // Should never occur in this test
@@ -118,12 +125,17 @@ static void msc_client_event_cb(const usb_host_client_event_msg_t *event_msg, vo
 void msc_client_async_seq_task(void *arg)
 {
    msc_client_obj_t msc_obj;
+    // Initialize test params
    memcpy(&msc_obj.test_param, arg, sizeof(msc_client_test_param_t));
+    // Initialize MSC device info
+    msc_obj.dev_info = dev_msc_get_info();
+    // Initialize client variables
+    msc_obj.client_hdl = NULL;
+    msc_obj.dev_hdl = NULL;
+    // Initialize test state
    msc_obj.cur_stage = TEST_STAGE_WAIT_CONN;
    msc_obj.next_stage = TEST_STAGE_WAIT_CONN;
-    msc_obj.client_hdl = NULL;
-    msc_obj.dev_addr_to_open = 0;
-    msc_obj.dev_hdl = NULL;
+    msc_obj.dev_addr = 0;
    msc_obj.num_sectors_read = 0;

    // Register client
@@ -137,17 +149,10 @@ void msc_client_async_seq_task(void *arg)
    };
    TEST_ASSERT_EQUAL(ESP_OK, usb_host_client_register(&client_config, &msc_obj.client_hdl));

-    // Allocate transfers
-    usb_transfer_t *xfer_out = NULL;    // Must be large enough to contain CBW and MSC reset control transfer
-    usb_transfer_t *xfer_in = NULL;     // Must be large enough to contain CSW and Data
-    size_t out_worst_case_size = MAX(sizeof(mock_msc_bulk_cbw_t), sizeof(usb_setup_packet_t));
-    size_t in_worst_case_size = usb_round_up_to_mps(MAX(MOCK_MSC_SCSI_SECTOR_SIZE * msc_obj.test_param.num_sectors_per_xfer, sizeof(mock_msc_bulk_csw_t)), MOCK_MSC_SCSI_BULK_EP_MPS);
-    TEST_ASSERT_EQUAL(ESP_OK, usb_host_transfer_alloc(out_worst_case_size, 0, &xfer_out));
-    TEST_ASSERT_EQUAL(ESP_OK, usb_host_transfer_alloc(in_worst_case_size, 0, &xfer_in));
-    xfer_out->callback = msc_transfer_cb;
-    xfer_in->callback = msc_transfer_cb;
-    xfer_out->context = (void *)&msc_obj;
-    xfer_in->context = (void *)&msc_obj;
+    // IN MPS and transfers to be set/allocated later (after device connects and MPS is determined)
+    int in_ep_mps = 0;
+    usb_transfer_t *xfer_in = NULL;
+    usb_transfer_t *xfer_out = NULL;

    // Wait to be started by main thread
    ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
@@ -169,17 +174,44 @@ void msc_client_async_seq_task(void *arg)
        case TEST_STAGE_DEV_OPEN: {
            ESP_LOGD(MSC_CLIENT_TAG, "Open");
            // Open the device
-            TEST_ASSERT_EQUAL(ESP_OK, usb_host_device_open(msc_obj.client_hdl, msc_obj.dev_addr_to_open, &msc_obj.dev_hdl));
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_device_open(msc_obj.client_hdl, msc_obj.dev_addr, &msc_obj.dev_hdl));
+            // Get device info to get device speed
+            usb_device_info_t dev_info;
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_device_info(msc_obj.dev_hdl, &dev_info));
+            msc_obj.dev_speed = dev_info.speed;
+            // Check that the device descriptor matches our expected MSC device
+            const usb_device_desc_t *device_desc;
+            const usb_device_desc_t *device_desc_ref = dev_msc_get_dev_desc(msc_obj.dev_speed);
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_get_device_descriptor(msc_obj.dev_hdl, &device_desc));
+            TEST_ASSERT_EQUAL(device_desc_ref->bLength, device_desc->bLength);
+            TEST_ASSERT_EQUAL_MEMORY_MESSAGE(device_desc_ref, device_desc, sizeof(usb_device_desc_t), "Device descriptors do not match.");
+            // Claim the MSC interface
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_interface_claim(msc_obj.client_hdl,
+                                                               msc_obj.dev_hdl,
+                                                               msc_obj.dev_info->bInterfaceNumber,
+                                                               msc_obj.dev_info->bAlternateSetting));
+            /*
+            Allocate transfers
+
+            IN transfer must be large enough to contain CSW and Data
+            OUT transfer must be large enough to contain CBW and MSC reset control transfer
+            */
+            const usb_ep_desc_t *in_ep_desc = dev_msc_get_in_ep_desc(msc_obj.dev_speed);
+            in_ep_mps = USB_EP_DESC_GET_MPS(in_ep_desc);
+            const size_t in_worst_case_size = usb_round_up_to_mps(MAX(msc_obj.dev_info->scsi_sector_size * msc_obj.test_param.num_sectors_per_xfer,
+                                                                      sizeof(mock_msc_bulk_csw_t)),
+                                                                  in_ep_mps);
+            const size_t out_worst_case_size = MAX(sizeof(mock_msc_bulk_cbw_t), sizeof(usb_setup_packet_t));
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_transfer_alloc(out_worst_case_size, 0, &xfer_out));
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_transfer_alloc(in_worst_case_size, 0, &xfer_in));
+            xfer_out->callback = msc_transfer_cb;
+            xfer_in->callback = msc_transfer_cb;
+            xfer_out->context = (void *)&msc_obj;
+            xfer_in->context = (void *)&msc_obj;
            // Target our transfers to the device
            xfer_out->device_handle = msc_obj.dev_hdl;
            xfer_in->device_handle = msc_obj.dev_hdl;
-            // Check the VID/PID of the opened device
-            const usb_device_desc_t *device_desc;
-            TEST_ASSERT_EQUAL(ESP_OK, usb_host_get_device_descriptor(msc_obj.dev_hdl, &device_desc));
-            TEST_ASSERT_EQUAL(msc_obj.test_param.idVendor, device_desc->idVendor);
-            TEST_ASSERT_EQUAL(msc_obj.test_param.idProduct, device_desc->idProduct);
-            // Claim the MSC interface
-            TEST_ASSERT_EQUAL(ESP_OK, usb_host_interface_claim(msc_obj.client_hdl, msc_obj.dev_hdl, MOCK_MSC_SCSI_INTF_NUMBER, MOCK_MSC_SCSI_INTF_ALT_SETTING));
+            // Set next stage
            msc_obj.next_stage = TEST_STAGE_MSC_RESET;
            skip_event_handling = true; // Need to execute TEST_STAGE_MSC_RESET
            break;
@@ -187,7 +219,7 @@ void msc_client_async_seq_task(void *arg)
        case TEST_STAGE_MSC_RESET: {
            ESP_LOGD(MSC_CLIENT_TAG, "MSC Reset");
            // Send an MSC SCSI interface reset
-            MOCK_MSC_SCSI_REQ_INIT_RESET((usb_setup_packet_t *)xfer_out->data_buffer, MOCK_MSC_SCSI_INTF_NUMBER);
+            MOCK_MSC_SCSI_REQ_INIT_RESET((usb_setup_packet_t *)xfer_out->data_buffer, msc_obj.dev_info->bInterfaceNumber);
            xfer_out->num_bytes = sizeof(usb_setup_packet_t);
            xfer_out->bEndpointAddress = 0;
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_transfer_submit_control(msc_obj.client_hdl, xfer_out));
@@ -198,9 +230,14 @@ void msc_client_async_seq_task(void *arg)
        }
        case TEST_STAGE_MSC_CBW: {
            ESP_LOGD(MSC_CLIENT_TAG, "CBW");
-            mock_msc_scsi_init_cbw((mock_msc_bulk_cbw_t *)xfer_out->data_buffer, true, msc_obj.next_stage, msc_obj.test_param.num_sectors_per_xfer, msc_obj.test_param.msc_scsi_xfer_tag);
+            mock_msc_scsi_init_cbw((mock_msc_bulk_cbw_t *)xfer_out->data_buffer,
+                                   true,
+                                   msc_obj.next_stage,
+                                   msc_obj.test_param.num_sectors_per_xfer,
+                                   msc_obj.dev_info->scsi_sector_size,
+                                   msc_obj.test_param.msc_scsi_xfer_tag);
            xfer_out->num_bytes = sizeof(mock_msc_bulk_cbw_t);
-            xfer_out->bEndpointAddress = MOCK_MSC_SCSI_BULK_OUT_EP_ADDR;
+            xfer_out->bEndpointAddress = msc_obj.dev_info->out_up_addr;
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_transfer_submit(xfer_out));
            // Test that an inflight transfer cannot be resubmitted
            TEST_ASSERT_EQUAL(ESP_ERR_NOT_FINISHED, usb_host_transfer_submit(xfer_out));
@@ -209,8 +246,8 @@ void msc_client_async_seq_task(void *arg)
        }
        case TEST_STAGE_MSC_DATA: {
            ESP_LOGD(MSC_CLIENT_TAG, "Data");
-            xfer_in->num_bytes = usb_round_up_to_mps(MOCK_MSC_SCSI_SECTOR_SIZE * msc_obj.test_param.num_sectors_per_xfer, MOCK_MSC_SCSI_BULK_EP_MPS);
-            xfer_in->bEndpointAddress = MOCK_MSC_SCSI_BULK_IN_EP_ADDR;
+            xfer_in->num_bytes = usb_round_up_to_mps(msc_obj.dev_info->scsi_sector_size * msc_obj.test_param.num_sectors_per_xfer, in_ep_mps);
+            xfer_in->bEndpointAddress = msc_obj.dev_info->in_ep_addr;
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_transfer_submit(xfer_in));
            // Test that an inflight transfer cannot be resubmitted
            TEST_ASSERT_EQUAL(ESP_ERR_NOT_FINISHED, usb_host_transfer_submit(xfer_in));
@@ -219,8 +256,8 @@ void msc_client_async_seq_task(void *arg)
        }
        case TEST_STAGE_MSC_CSW: {
            ESP_LOGD(MSC_CLIENT_TAG, "CSW");
-            xfer_in->num_bytes = usb_round_up_to_mps(sizeof(mock_msc_bulk_csw_t), MOCK_MSC_SCSI_BULK_EP_MPS);
-            xfer_in->bEndpointAddress = MOCK_MSC_SCSI_BULK_IN_EP_ADDR;
+            xfer_in->num_bytes = usb_round_up_to_mps(sizeof(mock_msc_bulk_csw_t), in_ep_mps);
+            xfer_in->bEndpointAddress = msc_obj.dev_info->in_ep_addr;
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_transfer_submit(xfer_in));
            // Test that an inflight transfer cannot be resubmitted
            TEST_ASSERT_EQUAL(ESP_ERR_NOT_FINISHED, usb_host_transfer_submit(xfer_in));
@@ -229,7 +266,7 @@ void msc_client_async_seq_task(void *arg)
        }
        case TEST_STAGE_DEV_CLOSE: {
            ESP_LOGD(MSC_CLIENT_TAG, "Close");
-            TEST_ASSERT_EQUAL(ESP_OK, usb_host_interface_release(msc_obj.client_hdl, msc_obj.dev_hdl, MOCK_MSC_SCSI_INTF_NUMBER));
+            TEST_ASSERT_EQUAL(ESP_OK, usb_host_interface_release(msc_obj.client_hdl, msc_obj.dev_hdl, msc_obj.dev_info->bInterfaceNumber));
            TEST_ASSERT_EQUAL(ESP_OK, usb_host_device_close(msc_obj.client_hdl, msc_obj.dev_hdl));
            exit_loop = true;
            break;
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: CC0-1.0
 */
@@ -7,17 +7,16 @@
 #include "unity.h"
 #include "unity_test_runner.h"
 #include "unity_test_utils_memory.h"
-
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "test_usb_common.h"
-#include "mock_msc.h"
+#include "dev_msc.h"
 #include "usb/usb_host.h"

 void setUp(void)
 {
-    mock_msc_scsi_init_reference_descriptors();
    unity_utils_record_free_mem();
+    dev_msc_init();
    test_usb_init_phy();    // Initialize the internal USB PHY and USB Controller for testing
    // Install USB Host
    usb_host_config_t host_config = {
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Apache-2.0
 */
@@ -11,7 +11,7 @@
 #include "esp_err.h"
 #include "esp_intr_alloc.h"
 #include "test_usb_common.h"
-#include "mock_msc.h"
+#include "dev_msc.h"
 #include "msc_client.h"
 #include "ctrl_client.h"
 #include "usb/usb_host.h"
@@ -51,8 +51,6 @@ TEST_CASE("Test USB Host async client (single client)", "[usb_host][full_speed]"
        .num_sectors_to_read = TEST_MSC_NUM_SECTORS_TOTAL,
        .num_sectors_per_xfer = TEST_MSC_NUM_SECTORS_PER_XFER,
        .msc_scsi_xfer_tag = TEST_MSC_SCSI_TAG,
-        .idVendor = MOCK_MSC_SCSI_DEV_ID_VENDOR,
-        .idProduct = MOCK_MSC_SCSI_DEV_ID_PRODUCT,
    };
    TaskHandle_t task_hdl;
    xTaskCreatePinnedToCore(msc_client_async_seq_task, "async", 4096, (void *)&params, 2, &task_hdl, 0);
@@ -101,8 +99,6 @@ TEST_CASE("Test USB Host async client (multi client)", "[usb_host][full_speed]")
        .num_sectors_to_read = TEST_MSC_NUM_SECTORS_TOTAL,
        .num_sectors_per_xfer = TEST_MSC_NUM_SECTORS_PER_XFER,
        .msc_scsi_xfer_tag = TEST_MSC_SCSI_TAG,
-        .idVendor = MOCK_MSC_SCSI_DEV_ID_VENDOR,
-        .idProduct = MOCK_MSC_SCSI_DEV_ID_PRODUCT,
    };
    TaskHandle_t msc_task_hdl;
    xTaskCreatePinnedToCore(msc_client_async_seq_task, "msc", 4096, (void *)&msc_params, 2, &msc_task_hdl, 0);
@@ -111,8 +107,6 @@ TEST_CASE("Test USB Host async client (multi client)", "[usb_host][full_speed]")
    // Create task a control transfer client
    ctrl_client_test_param_t ctrl_params = {
        .num_ctrl_xfer_to_send = TEST_CTRL_NUM_TRANSFERS,
-        .idVendor = MOCK_MSC_SCSI_DEV_ID_VENDOR,
-        .idProduct = MOCK_MSC_SCSI_DEV_ID_PRODUCT,
    };
    TaskHandle_t ctrl_task_hdl;
    xTaskCreatePinnedToCore(ctrl_client_async_seq_task, "ctrl", 4096, (void *)&ctrl_params, 2, &ctrl_task_hdl, 0);
@@ -226,21 +220,35 @@ TEST_CASE("Test USB Host async API", "[usb_host][full_speed][low_speed]")
    TEST_ASSERT_NOT_EQUAL(ESP_OK, usb_host_device_open(client0_hdl, 0, &client0_dev_hdl));

    // Check that the device cannot be opened again by the same client
+    const dev_msc_info_t *dev_info = dev_msc_get_info();
    usb_device_handle_t dummy_dev_hdl;
    TEST_ASSERT_NOT_EQUAL(ESP_OK, usb_host_device_open(client0_hdl, dev_addr, &dummy_dev_hdl));
    TEST_ASSERT_NOT_EQUAL(ESP_OK, usb_host_device_open(client1_hdl, dev_addr, &dummy_dev_hdl));
    printf("Claiming interface\n");
    // Check that both clients cannot claim the same interface
-    TEST_ASSERT_EQUAL(ESP_OK, usb_host_interface_claim(client0_hdl, client0_dev_hdl, MOCK_MSC_SCSI_INTF_NUMBER, MOCK_MSC_SCSI_INTF_ALT_SETTING));
-    TEST_ASSERT_NOT_EQUAL(ESP_OK, usb_host_interface_claim(client1_hdl, client1_dev_hdl, MOCK_MSC_SCSI_INTF_NUMBER, MOCK_MSC_SCSI_INTF_ALT_SETTING));
+    TEST_ASSERT_EQUAL(ESP_OK, usb_host_interface_claim(client0_hdl,
+                                                       client0_dev_hdl,
+                                                       dev_info->bInterfaceNumber,
+                                                       dev_info->bAlternateSetting));
+    TEST_ASSERT_NOT_EQUAL(ESP_OK, usb_host_interface_claim(client1_hdl,
+                                                           client1_dev_hdl,
+                                                           dev_info->bInterfaceNumber,
+                                                           dev_info->bAlternateSetting));
    // Check that client0 cannot claim the same interface multiple times
-    TEST_ASSERT_NOT_EQUAL(ESP_OK, usb_host_interface_claim(client0_hdl, client0_dev_hdl, MOCK_MSC_SCSI_INTF_NUMBER, MOCK_MSC_SCSI_INTF_ALT_SETTING));
+    TEST_ASSERT_NOT_EQUAL(ESP_OK, usb_host_interface_claim(client0_hdl,
+                                                           client0_dev_hdl,
+                                                           dev_info->bInterfaceNumber,
+                                                           dev_info->bAlternateSetting));

    printf("Releasing interface\n");
    // Check that client0 can release the interface
-    TEST_ASSERT_EQUAL(ESP_OK, usb_host_interface_release(client0_hdl, client0_dev_hdl, MOCK_MSC_SCSI_INTF_NUMBER));
+    TEST_ASSERT_EQUAL(ESP_OK, usb_host_interface_release(client0_hdl,
+                                                         client0_dev_hdl,
+                                                         dev_info->bInterfaceNumber));
    // Check that client0 cannot release interface it has not claimed
-    TEST_ASSERT_NOT_EQUAL(ESP_OK, usb_host_interface_release(client0_hdl, client0_dev_hdl, MOCK_MSC_SCSI_INTF_NUMBER));
+    TEST_ASSERT_NOT_EQUAL(ESP_OK, usb_host_interface_release(client0_hdl,
+                                                             client0_dev_hdl,
+                                                             dev_info->bInterfaceNumber));

    // Wait until the device disconnects and the clients receive the event
    test_usb_set_phy_state(false, 0);
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Apache-2.0
 */
@@ -11,6 +11,7 @@
 #include "esp_intr_alloc.h"
 #include "test_usb_common.h"
 #include "mock_msc.h"
+#include "dev_msc.h"
 #include "msc_client.h"
 #include "ctrl_client.h"
 #include "usb/usb_host.h"
@@ -84,12 +85,11 @@ Procedure:
 TEST_CASE("Test USB Host sudden disconnection (single client)", "[usb_host][full_speed]")
 {
    // Create task to run client that communicates with MSC SCSI interface
+    const dev_msc_info_t *dev_info = dev_msc_get_info();
    msc_client_test_param_t params = {
        .num_sectors_to_read = 1,   // Unused by disconnect MSC client
-        .num_sectors_per_xfer = TEST_FORCE_DCONN_NUM_TRANSFERS * MOCK_MSC_SCSI_SECTOR_SIZE,
+        .num_sectors_per_xfer = TEST_FORCE_DCONN_NUM_TRANSFERS * dev_info->scsi_sector_size,
        .msc_scsi_xfer_tag = TEST_MSC_SCSI_TAG,
-        .idVendor = MOCK_MSC_SCSI_DEV_ID_VENDOR,
-        .idProduct = MOCK_MSC_SCSI_DEV_ID_PRODUCT,
    };
    TaskHandle_t task_hdl;
    xTaskCreatePinnedToCore(msc_client_async_dconn_task, "async", 4096, (void *)&params, 2, &task_hdl, 0);