Sending feature report while waiting for report via interrupt causes tinyusb to be stuck?

[elianterelle]

Hi, so first of all, this is probably user error as i know relatively little about the usb protocol and tinyusb, maybe someone can help me here:
I have a USB Hid device (an Elgato Streamdeck) that i want to connect to an rp2040. So the rp2040 acts as a usb host.
The streamdeck sends hid reports when a button is pressed and can be controlled via feature / out reports(brightness, pixel data for the displays,...).
The first issue was, that the streamdeck seems to falsely report itself as a full-speed device with a max packet size of 512 byte, which, from what i can tell, isn't possible. I tried "fixing" this, by adding this between lines 186 and 187 of tusb.c:

  if (max_packet_size >= 512 && speed == TUSB_SPEED_FULL) {
    // Fake Speed for Streamdeck
    speed = TUSB_SPEED_HIGH;
  }

after doing this, the streamdeck gets detectedt by the "hid_device_report" example and button presses are received just fine.
I now proceeded to modify this example to toggle the brightness between 0 and 100 every second by sending a feature report. This works fine, the screen toggles between on and off. Until pressing a button. The report of the button press gets received just fine, but then tuh_hid_set_report returns false when sending the feature report for setting the brightness and subsequent button presses aren't received until resetting the rp2040.
After investigating further(as someone who doesn't know anything about usb), it seems like the transfer didn't complete, which causes the transfer stage to be stuck at something other than CONTROL_STAGE_IDLE, which is why the following feature reports can't be sent.
However i have absolutely no idea how to debug this, maybe someone can point me in the right direction, hopefully my mistake is obvious to someone who knows this a little better than me.

My Code:

/*********************************************************************
 Adafruit invests time and resources providing this open source code,
 please support Adafruit and open-source hardware by purchasing
 products from Adafruit!

 MIT license, check LICENSE for more information
 Copyright (c) 2019 Ha Thach for Adafruit Industries
 All text above, and the splash screen below must be included in
 any redistribution
*********************************************************************/


/* This example demonstrates use of both device and host, where
 * - Device run on native usb controller (controller0)
 * - Host run on bit-banging 2 GPIOs with the help of Pico-PIO-USB library (controller1)
 *
 * Requirements:
 * - [Pico-PIO-USB](https://github.com/sekigon-gonnoc/Pico-PIO-USB) library
 * - 2 consecutive GPIOs: D+ is defined by PIN_PIO_USB_HOST_DP, D- = D+ +1
 * - Provide VBus (5v) and GND for peripheral
 * - CPU Speed must be either 120 or 240 Mhz. Selected via "Menu -> CPU Speed"
 */

// pio-usb is required for rp2040 host
#include "pio_usb.h"
#include "Adafruit_TinyUSB.h"

// Pin D+ for host, D- = D+ + 1
#ifndef PIN_PIO_USB_HOST_DP
#define PIN_PIO_USB_HOST_DP       4
#endif

// Language ID: English
#define LANGUAGE_ID 0x0409

// USB Host object
Adafruit_USBH_Host USBHost;

//--------------------------------------------------------------------+
// Setup and Loop on Core0
//--------------------------------------------------------------------+

void setup()
{
  Serial1.begin(115200);

  Serial.begin(115200);
  //while ( !Serial ) delay(10);   // wait for native usb

  Serial.println("TinyUSB Dual Device Info Example");
}

void loop()
{
}

//--------------------------------------------------------------------+
// Setup and Loop on Core1
//--------------------------------------------------------------------+

void setup1() {
  //while ( !Serial ) delay(10);   // wait for native usb
  Serial.println("Core1 setup to run TinyUSB host with pio-usb");

  // Check for CPU frequency, must be multiple of 120Mhz for bit-banging USB
  uint32_t cpu_hz = clock_get_hz(clk_sys);
  if ( cpu_hz != 120000000UL && cpu_hz != 240000000UL ) {
    while ( !Serial ) delay(10);   // wait for native usb
    Serial.printf("Error: CPU Clock = %lu, PIO USB require CPU clock must be multiple of 120 Mhz\r\n", cpu_hz);
    Serial.printf("Change your CPU Clock to either 120 or 240 Mhz in Menu->CPU Speed \r\n");
    while(1) delay(1);
  }

#ifdef PIN_PIO_USB_HOST_VBUSEN
  pinMode(PIN_PIO_USB_HOST_VBUSEN, OUTPUT);
  digitalWrite(PIN_PIO_USB_HOST_VBUSEN, PIN_PIO_USB_HOST_VBUSEN_STATE);
#endif

  pio_usb_configuration_t pio_cfg = PIO_USB_DEFAULT_CONFIG;
  pio_cfg.pin_dp = PIN_PIO_USB_HOST_DP;
  USBHost.configure_pio_usb(1, &pio_cfg);

  // run host stack on controller (rhport) 1
  // Note: For rp2040 pico-pio-usb, calling USBHost.begin() on core1 will have most of the
  // host bit-banging processing works done in core1 to free up core0 for other works
  USBHost.begin(1);
}

long lastToggle = 0;
byte brightness = 100;
bool streamdeck_mounted = false;
uint8_t streamdeck_addr = 0;
uint8_t streamdeck_instance = 0;

void loop1()
{
  USBHost.task();

  if (streamdeck_mounted && millis() - lastToggle > 1000) {
    Serial.println("toggle");
    lastToggle = millis();
      
    uint8_t rep[] = {
      0x03,
      0x08, brightness, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    }; 

    if (brightness > 0) {
      brightness = 0;
    } else {
      brightness = 100;
    }

    if (!tuh_hid_set_report(streamdeck_addr, streamdeck_instance, 0x00, HID_REPORT_TYPE_FEATURE, rep, sizeof(rep))) {
      Serial.printf("Error: cannot send feature report\r\n");
    } else {
      Serial.print("Sent Feature Report with brightness ");
      Serial.println(brightness);
    }
  };
}

// Invoked when device with hid interface is mounted
// Report descriptor is also available for use.
// tuh_hid_parse_report_descriptor() can be used to parse common/simple enough
// descriptor. Note: if report descriptor length > CFG_TUH_ENUMERATION_BUFSIZE,
// it will be skipped therefore report_desc = NULL, desc_len = 0
void tuh_hid_mount_cb(uint8_t dev_addr, uint8_t instance, uint8_t const *desc_report, uint16_t desc_len) {
  (void)desc_report;
  (void)desc_len;
  uint16_t vid, pid;
  tuh_vid_pid_get(dev_addr, &vid, &pid);

  Serial.printf("HID device address = %d, instance = %d is mounted\r\n", dev_addr, instance);
  Serial.printf("VID = %04x, PID = %04x\r\n", vid, pid);
  if (!tuh_hid_receive_report(dev_addr, instance)) {
    Serial.printf("Error: cannot request to receive report\r\n");
  } else {
    streamdeck_addr = dev_addr;
    streamdeck_instance = instance;
    streamdeck_mounted = true;
  }
}

// Invoked when device with hid interface is un-mounted
void tuh_hid_umount_cb(uint8_t dev_addr, uint8_t instance) {
  Serial.printf("HID device address = %d, instance = %d is unmounted\r\n", dev_addr, instance);
  streamdeck_mounted = false;
}

// Invoked when received report from device via interrupt endpoint
void tuh_hid_report_received_cb(uint8_t dev_addr, uint8_t instance, uint8_t const *report, uint16_t len) {
  Serial.printf("HIDreport : ");
  for (uint16_t i = 0; i < len; i++) {
    Serial.printf("0x%02X ", report[i]);
  }
  Serial.println();

  // continue to request to receive report
  if (!tuh_hid_receive_report(dev_addr, instance)) {
    Serial.printf("Error: cannot request to receive report\r\n");
  }
}

void tuh_hid_set_report_complete_cb(uint8_t dev_addr, uint8_t instance, uint8_t report_id, uint8_t report_type, uint16_t len)
{
  Serial.println("TEST: Set report completed");
  Serial.println(len);
}