ESP32-S3 HID + CDC. WIndows says Device Descriptor Request Failed

[Ugobyte]

Operating System

Windows 11

Commit SHA

None

Board

ESp32-S3

Firmware

I'm using: "espressif/esp_tinyusb^1.7.6~1"
From: https://components.espressif.com/components/espressif/esp_tinyusb/versions/1.7.6~1/changelog?language=en

What happened ?

Hello friends,
I'm using VSCode + ESP-IDF v5.5.
I want to create a USB device that functions as USB CDC and USB HID.

I have a function that looks like this:
CommunicationUSBClass.Initialize("CompanyName", "ProductName", SerialNumber, PID, VID, *reportDescriptor, reportDescriptorLeght).

However, when I plug my ESP32-S3 into Windows, Windows USB device installing pops up and tells me "Device Descriptor Request Failed".
What am doing wrong please?

How to reproduce ?

Here is my code. I couldn't use the <> code function. So here it is in plain text:
#include "tusb.h"
#include "esp_log.h"
#include "tinyusb.h"
#include "tusb_cdc_acm.h"

// Declare static variables
std::atomic CommunicationUSBClass::IsUSBConnectionActive;
std::atomic CommunicationUSBClass::DebugTest;
tusb_desc_device_t CommunicationUSBClass::DescriptorDevice;
uint8_t CommunicationUSBClass::HIDDeviceReport[512];
uint16_t CommunicationUSBClass::DescriptorString[32];
std::string CommunicationUSBClass::CompanyName;
std::string CommunicationUSBClass::ProductName;
std::string CommunicationUSBClass::ProductSerialNumber;
uint16_t CommunicationUSBClass::ProductVID;
uint16_t CommunicationUSBClass::ProductPID;

uint8_t CommunicationUSBClass::DescriptorConfiguration[] =
{
// ----- Configuration Descriptor -----
0x09, // bLength
0x02, // bDescriptorType = CONFIGURATION
0x00, 0x00, // wTotalLength (LSB, MSB) — will be set later
0x03, // bNumInterfaces (CDC Control, CDC Data, HID)
0x01, // bConfigurationValue
0x00, // iConfiguration
0xC0, // bmAttributes: self-powered
0x32, // bMaxPower: 100 mA

// ----- Interface 0: CDC Control -----
0x09, 0x04,             // bLength, bDescriptorType = INTERFACE
0x00,                   // bInterfaceNumber
0x00,                   // bAlternateSetting
0x01,                   // bNumEndpoints
0x02,                   // bInterfaceClass = Communications (CDC)
0x02,                   // bInterfaceSubClass = Abstract Control Model
0x01,                   // bInterfaceProtocol = AT commands (V.25ter)
0x00,                   // iInterface

// CDC Header Functional Descriptor
0x05, 0x24, 0x00,       // bLength, bDescriptorType = CS_INTERFACE, bDescriptorSubType = Header
0x10, 0x01,             // bcdCDC = 1.10

// CDC Call Management Functional Descriptor
0x05, 0x24, 0x01,       // bLength, bDescriptorType = CS_INTERFACE, Call Management
0x00,                   // bmCapabilities
0x01,                   // bDataInterface

// CDC ACM Functional Descriptor
0x04, 0x24, 0x02, 0x02, // bLength, bDescriptorType, bDescriptorSubType = ACM, bmCapabilities

// CDC Union Functional Descriptor
0x05, 0x24, 0x06,       // bLength, bDescriptorType, Union
0x00,                   // bMasterInterface
0x01,                   // bSlaveInterface0

// Endpoint (Interrupt IN) for CDC Control
0x07, 0x05,
0x81,                   // Endpoint Address (IN, EP1)
0x03,                   // bmAttributes = Interrupt
0x08, 0x00,             // wMaxPacketSize = 8 bytes
0x10,                   // bInterval (ms)

// ----- Interface 1: CDC Data -----
0x09, 0x04,             // bLength, bDescriptorType = INTERFACE
0x01,                   // bInterfaceNumber
0x00,                   // bAlternateSetting
0x02,                   // bNumEndpoints
0x0A,                   // bInterfaceClass = CDC Data
0x00,                   // bInterfaceSubClass
0x00,                   // bInterfaceProtocol
0x00,                   // iInterface

// Endpoint (Bulk OUT)
0x07, 0x05,
0x02,                   // Endpoint Address (OUT, EP2)
0x02,                   // bmAttributes = Bulk
0x40, 0x00,             // wMaxPacketSize = 64 bytes
0x00,                   // bInterval

// Endpoint (Bulk IN)
0x07, 0x05,
0x82,                   // Endpoint Address (IN, EP2)
0x02,                   // bmAttributes = Bulk
0x40, 0x00,             // wMaxPacketSize = 64 bytes
0x00,                   // bInterval

// ----- Interface 2: HID -----
0x09, 0x04,             // bLength, bDescriptorType = INTERFACE
0x02,                   // bInterfaceNumber
0x00,                   // bAlternateSetting
0x01,                   // bNumEndpoints
0x03,                   // bInterfaceClass = HID
0x00,                   // bInterfaceSubClass = None
0x00,                   // bInterfaceProtocol = None
0x00,                   // iInterface

// HID Descriptor
0x09, 0x21,             // bLength, bDescriptorType = HID
0x11, 0x01,             // bcdHID = 1.11
0x00,                   // bCountryCode
0x01,                   // bNumDescriptors (1 report descriptor)
0x22,                   // bDescriptorType = Report
0x00, 0x00,             // wDescriptorLength (LSB, MSB) — set at runtime

// Endpoint (Interrupt IN) for HID
0x07, 0x05,
0x83,                   // Endpoint Address (IN, EP3)
0x03,                   // bmAttributes = Interrupt
0x40, 0x00,             // wMaxPacketSize = 64 bytes
0x01                    // bInterval (1 ms)

};

CommunicationUSBClass::CommunicationUSBClass()
:
Initialized(false)
{

}

CommunicationUSBClass::~CommunicationUSBClass()
{

}

bool CommunicationUSBClass::Initialize(std::string companyName, std::string productName,
std::string productSerialNumber,uint16_t productVID, uint16_t productPID,
const uint8_t* hidDeviceReport, uint16_t hidDeviceReportLength)
{
if(!Initialized)
{

    // Assing values
    CompanyName = companyName;
    ProductName = productName;
    ProductSerialNumber = productSerialNumber;
    ProductVID = productVID;
    ProductPID = productPID;

    // Copy HID report.
    memcpy(HIDDeviceReport, hidDeviceReport, hidDeviceReportLength);
    
    // 1. Patch HID report length (LSB first)
    DescriptorConfiguration[ // find index of wDescriptorLength LSB
    9  // config desc
    + 9 + 5 + 5 + 4 + 5 + 7 // CDC control interface + functional descriptors + endpoint
    + 9 + 7 + 7              // CDC data interface + endpoints
    + 9 + 6                   // HID interface (9) + first 6 bytes of HID descriptor
   ] = (uint8_t) hidDeviceReportLength;//(uint8_t)(hidDeviceReportLength & 0xFF);

   DescriptorConfiguration[ // MSB
    9 + 9 + 5 + 5 + 4 + 5 + 7
    + 9 + 7 + 7
    + 9 + 7
   ] = (uint8_t) (hidDeviceReportLength >> 8);//(uint8_t)((hidDeviceReportLength >> 8) & 0xFF);

   // 2. Patch wTotalLength in configuration descriptor
   uint16_t total_len = sizeof(DescriptorConfiguration);
   DescriptorConfiguration[2] = (uint8_t)(total_len & 0xFF);
   DescriptorConfiguration[3] = (uint8_t)((total_len >> 8) & 0xFF);

    // Set up Device descriptor.
    const tusb_desc_device_t DescriptorDevice =
    {
        .bLength             = sizeof(tusb_desc_device_t),
        .bDescriptorType     = TUSB_DESC_DEVICE,
        .bcdUSB              = 0x0200,
        .bDeviceClass        = 0x00,// Defined at interface level 
        .bDeviceSubClass     = 0x00,
        .bDeviceProtocol     = 0x00,
        .bMaxPacketSize0     = CFG_TUD_ENDPOINT0_SIZE,
        .idVendor            = ProductVID,
        .idProduct           = ProductPID,
        .bcdDevice           = 0x0100,
        .iManufacturer       = 1, // index in string table
        .iProduct            = 2,
        .iSerialNumber       = 3,
        .bNumConfigurations  = 1
    };

          

    BaseType_t taskCreationResult = pdFAIL;
    taskCreationResult = xTaskCreatePinnedToCore(InitializeThreadTask, "USBThread", 4096, this, 1, nullptr, PRO_CPU_NUM);
    Initialized = (taskCreationResult == pdPASS);       

}
return Initialized;

}

void CommunicationUSBClass::InitializeThreadTask(void *pvParameters)
{
CommunicationUSBClass *thisInstance = static_cast<CommunicationUSBClass *>(pvParameters);
thisInstance->LoopTask();
}

void CommunicationUSBClass::LoopTask()
{
tusb_init();

while(true)
{     
    DebugTest = false;
    tud_task();
    DebugTest = true; 
    // Do some stuff with CDC  like read incoming data
    // Do some stuff with HID like send keyboard data.
    vTaskDelay(pdMS_TO_TICKS(1));             
}

}

/**-- TinyUSB callbacks -- /
uint8_t const * CommunicationUSBClass::tud_descriptor_device_cb()
{
DebugTest = true;
return (uint8_t const) &DescriptorDevice;
}

uint8_t const * CommunicationUSBClass::tud_descriptor_configuration_cb(uint8_t index)
{
(void) index;
return DescriptorConfiguration;
}

uint16_t const * CommunicationUSBClass::tud_descriptor_string_cb(uint8_t index, uint16_t langid)
{
(void) langid;

static uint16_t DescriptorString[64]; // Enough for 31 UTF-16 chars + prefix

if (index == 0)
{
    // Supported language = English (0x0409)
    DescriptorString[0] = (TUSB_DESC_STRING << 8) | (2 * 1 + 2); // Length = 4 bytes
    DescriptorString[1] = 0x0409;
    return DescriptorString;
}

const char* str = nullptr;
switch(index) 
{
    case 1: str = CompanyName.c_str(); break;
    case 2: str = ProductName.c_str(); break;
    case 3: str = ProductSerialNumber.c_str(); break;
    default: return nullptr;  // Unsupported string index
}

// Convert ASCII string to UTF-16 (zero-extend each char)
uint8_t chr_count = 0;
while(str[chr_count] && chr_count < 31) 
{
    DescriptorString[1 + chr_count] = (uint16_t)str[chr_count]; // zero-extend to UTF-16
    chr_count++;
}

DescriptorString[0] = (TUSB_DESC_STRING << 8) | (2 * (chr_count + 1)); // Length in bytes

return DescriptorString;

}

void CommunicationUSBClass::tud_mount_cb(void)
{
IsUSBConnectionActive.store(true, std::memory_order_relaxed);
}

void CommunicationUSBClass::tud_umount_cb(void)
{
IsUSBConnectionActive.store(false, std::memory_order_relaxed);
}

void CommunicationUSBClass::tud_resume_cb(void)
{
IsUSBConnectionActive.store(true, std::memory_order_relaxed);
}

void CommunicationUSBClass::tud_suspend_cb(bool remote_wakeup_en)
{
IsUSBConnectionActive.store(false, std::memory_order_relaxed);
}

void CommunicationUSBClass::tud_cdc_rx_cb(uint8_t itf)
{
}

uint8_t const * CommunicationUSBClass::tud_hid_descriptor_report_cb(uint8_t instance)
{
(void) instance;
return HIDDeviceReport;
}

// Called when Host PC requests for a report.
uint16_t CommunicationUSBClass::tud_hid_get_report_cb(uint8_t itf, uint8_t report_id,
hid_report_type_t report_type,
uint8_t* buffer, uint16_t reqlen)
{
(void) itf;
(void) report_id;
(void) report_type;

for (uint16_t i = 0; i < reqlen; i++) {
    buffer[i] = 0;
}
return reqlen;

}

// Called when we receive a report from the Host PC.
void CommunicationUSBClass::tud_hid_set_report_cb(uint8_t itf, uint8_t report_id,
hid_report_type_t report_type,
uint8_t const* buffer, uint16_t bufsize)
{
(void) itf;
(void) report_id;
(void) report_type;
(void) buffer;
(void) bufsize;
}

/* C functions for TinyUSB */
extern "C"
{
// Device descriptor callback
uint8_t const * tud_descriptor_device_cb(void)
{

    return CommunicationUSBClass::tud_descriptor_device_cb();
}

// Configuration descriptor callback
uint8_t const * tud_descriptor_configuration_cb(uint8_t index)
{
    return CommunicationUSBClass::tud_descriptor_configuration_cb(index);
}

// String descriptor callback
uint16_t const * tud_descriptor_string_cb(uint8_t index, uint16_t langid)
{
    return CommunicationUSBClass::tud_descriptor_string_cb(index, langid);
}

// HID report descriptor callback
uint8_t const * tud_hid_descriptor_report_cb(uint8_t instance)
{
    return CommunicationUSBClass::tud_hid_descriptor_report_cb(instance);
}

// HID get report callback
uint16_t tud_hid_get_report_cb(uint8_t itf, uint8_t report_id,
                            hid_report_type_t report_type,
                            uint8_t* buffer, uint16_t reqlen)
{
    return CommunicationUSBClass::tud_hid_get_report_cb(itf, report_id, report_type, buffer, reqlen);
}

// HID set report callback
void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id,
                        hid_report_type_t report_type,
                        uint8_t const* buffer, uint16_t bufsize)
{
    CommunicationUSBClass::tud_hid_set_report_cb(itf, report_id, report_type, buffer, bufsize);
}

// CDC RX callback
void tud_cdc_rx_cb(uint8_t itf)
{
    CommunicationUSBClass::tud_cdc_rx_cb(itf);
}

// Optional others (mount, unmount, suspend, resume) if needed...
void tud_mount_cb(void)
{
    CommunicationUSBClass::tud_mount_cb();
}

void tud_umount_cb(void)
{
    CommunicationUSBClass::tud_umount_cb();
}

void tud_suspend_cb(bool remote_wakeup_en)
{
    CommunicationUSBClass::tud_suspend_cb(remote_wakeup_en);
}

void tud_resume_cb(void)
{
    CommunicationUSBClass::tud_resume_cb();
}

} // extern

/**

• @brief
• @note
  */
  bool CommunicationUSBClass::IsUSBConnected(void)
  {
  return true;
  }

Debug Log as txt file (LOG/CFG_TUSB_DEBUG=2)

"Device Descriptor Request Failed"

Screenshots

No response

I have checked existing issues, discussion and documentation

• I confirm I have checked existing issues, discussion and documentation.