Generic inout not working as expected in a multi interface device

[PhunderDev]

Hi, I have been loosing my mind for the past week or so. Basically I have a pi pico with tinyusb and I want it to work as a keyboard+consumer control but also would like to be able to communicate with it via my software, the issue is when I created and experimented a lot with node-hid I realized that there is something wrong with my setup and that for some reason the callback does not seem to be receiving the entire buffer I tried to send, for instance this is the buffer I would send:
Sent to Report ID 3, of length 64: [
3, 1, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]

and this is my 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)
{
  //Confirm the function is triggered
  (*ledStrip).fill(WS2812::RGB(255, 255, 255));


  // check report id
  if (buffer[0] == REPORT_ID_GENERIC_INOUT) {
    if(bufsize == 64) {
      for (int i = 0; i < sizeof(buffer); i++) {
        if(i == 0) continue;
        (*ledStrip).setPixelColor(buffer[i], WS2812::RGB(0, 255, 0));  // Red to indicate active communication
      }
    }
    (*ledStrip).show();
    tud_hid_report(report_id, buffer, bufsize);
  }
}

and after the function has been triggered, only the leds of indexes 1, 2 and 3 would light up, no matter how many I would specify in the report, it would always be limited to reading the first 4 positions of the report and then never even send back the report.
From what I have tried so far:

• sending the report from the device using multiple other report id's
• sending buffer without the padding zeros
• sending a buffer of length 65 instead of 64
• Making the generic inout the first interface

the code seemed to work when I used the example descriptor, but then the issue of adding the rest of the hid interfaces arose and I am not sure what to do about it as there is minimal to no information from what I've found on how to make these 2 work together. Here is the rest of my scripts:

usb_descriptors.c:

#include "bsp/board_api.h"
#include "tusb.h"
#include "usb_descriptors.h"

#define _PID_MAP(itf, n)  ( (CFG_TUD_##itf) << (n) )
#define USB_PID           (0x4000 | _PID_MAP(CDC, 0) | _PID_MAP(MSC, 1) | _PID_MAP(HID, 2) | \
                           _PID_MAP(MIDI, 3) | _PID_MAP(VENDOR, 4) )

#define USB_VID   0xCafe
#define USB_BCD   0x0200

//--------------------------------------------------------------------+
// Device Descriptors
//--------------------------------------------------------------------+
tusb_desc_device_t const desc_device =
{
    .bLength            = sizeof(tusb_desc_device_t),
    .bDescriptorType    = TUSB_DESC_DEVICE,
    .bcdUSB             = USB_BCD,
    .bDeviceClass       = 0x00,
    .bDeviceSubClass    = 0x00,
    .bDeviceProtocol    = 0x00,
    .bMaxPacketSize0    = CFG_TUD_ENDPOINT0_SIZE,

    .idVendor           = USB_VID,
    .idProduct          = USB_PID,
    .bcdDevice          = 0x0100,

    .iManufacturer      = 0x01,
    .iProduct           = 0x02,
    .iSerialNumber      = 0x03,

    .bNumConfigurations = 0x01
};

// Invoked when received GET DEVICE DESCRIPTOR
uint8_t const * tud_descriptor_device_cb(void)
{
  return (uint8_t const *) &desc_device;
}

//--------------------------------------------------------------------+
// HID Report Descriptor
//--------------------------------------------------------------------+

uint8_t const desc_hid_report1[] =
{
  TUD_HID_REPORT_DESC_KEYBOARD(HID_REPORT_ID(REPORT_ID_KEYBOARD)),
  TUD_HID_REPORT_DESC_CONSUMER(HID_REPORT_ID(REPORT_ID_CONSUMER_CONTROL))
};

uint8_t const desc_hid_report2[] =
{
  TUD_HID_REPORT_DESC_GENERIC_INOUT(CFG_TUD_HID_EP_BUFSIZE, HID_REPORT_ID(REPORT_ID_GENERIC_INOUT)),
};

// Invoked when received GET HID REPORT DESCRIPTOR
uint8_t const * tud_hid_descriptor_report_cb(uint8_t itf)
{
  if (itf == ITF_NUM_HID1)
  {
    return desc_hid_report1;
  }
  else if (itf == ITF_NUM_HID2)
  {
    return desc_hid_report2;
  }

  return NULL;
}

//--------------------------------------------------------------------+
// Configuration Descriptor
//--------------------------------------------------------------------+

#define  CONFIG_TOTAL_LEN  (TUD_CONFIG_DESC_LEN + TUD_HID_DESC_LEN + TUD_HID_INOUT_DESC_LEN)

#define EPNUM_HID1      0x81
#define EPNUM_HID2_OUT   0x82
#define EPNUM_HID2_IN  0x01

uint8_t const desc_configuration[] =
{
  TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),

  // Interface number, string index, protocol, report descriptor len, EP In address, size & polling interval
  TUD_HID_DESCRIPTOR(ITF_NUM_HID1, 4, HID_ITF_PROTOCOL_NONE, sizeof(desc_hid_report1), EPNUM_HID1, CFG_TUD_HID_EP_BUFSIZE, 10),

  TUD_HID_INOUT_DESCRIPTOR(ITF_NUM_HID2, 5, HID_ITF_PROTOCOL_NONE, sizeof(desc_hid_report2), EPNUM_HID2_OUT, EPNUM_HID2_IN, CFG_TUD_HID_EP_BUFSIZE, 10)
};

// Invoked when received GET CONFIGURATION DESCRIPTOR
uint8_t const * tud_descriptor_configuration_cb(uint8_t index)
{
  (void) index; // for multiple configurations
  return desc_configuration;
}

//--------------------------------------------------------------------+
// String Descriptors
//--------------------------------------------------------------------+

enum {
  STRID_LANGID = 0,
  STRID_MANUFACTURER,
  STRID_PRODUCT,
  STRID_SERIAL,
};

char const *string_desc_arr[] =
{
  (const char[]) { 0x09, 0x04 }, // 0: is supported language is English (0x0409)
  "PhunderDev",                  // 1: Manufacturer
  "PhunderDev Numpad",           // 2: Product
  NULL,                          // 3: Serials will use unique ID if possible
  "Keyboard Interface",          // 4: Interface 1 String
  "Communication Interface",     // 5: Interface 2 String
};

static uint16_t _desc_str[32 + 1];

uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
  (void) langid;
  size_t chr_count;

  switch ( index ) {
    case STRID_LANGID:
      memcpy(&_desc_str[1], string_desc_arr[0], 2);
      chr_count = 1;
      break;

    case STRID_SERIAL:
      chr_count = board_usb_get_serial(_desc_str + 1, 32);
      break;

    default:
      if ( !(index < sizeof(string_desc_arr) / sizeof(string_desc_arr[0])) ) return NULL;

      const char *str = string_desc_arr[index];
      chr_count = strlen(str);
      size_t const max_count = sizeof(_desc_str) / sizeof(_desc_str[0]) - 1;
      if ( chr_count > max_count ) chr_count = max_count;

      for ( size_t i = 0; i < chr_count; i++ ) {
        _desc_str[1 + i] = str[i];
      }
      break;
  }

  _desc_str[0] = (uint16_t) ((TUSB_DESC_STRING << 8) | (2 * chr_count + 2));

  return _desc_str;
}

usb_descriptors.h:

#ifndef USB_DESCRIPTORS_H_
#define USB_DESCRIPTORS_H_

enum
{
  REPORT_ID_KEYBOARD = 1,
  REPORT_ID_CONSUMER_CONTROL,
  REPORT_ID_GENERIC_INOUT
};

enum
{
  ITF_NUM_HID1,
  ITF_NUM_HID2,
  ITF_NUM_TOTAL
};

#endif /* USB_DESCRIPTORS_H_ */

and in case it helps here is a report I read using wireshark that describes what the hid report I send from my node script looks like:

USB URB
    [Source: host]
    [Destination: 1.21.1]
    USBPcap pseudoheader length: 27
    IRP ID: 0xffff8a8a313e1010
    IRP USBD_STATUS: USBD_STATUS_SUCCESS (0x00000000)
    URB Function: URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER (0x0009)
    IRP information: 0x00, Direction: FDO -> PDO
    URB bus id: 1
    Device address: 21
    Endpoint: 0x01, Direction: OUT
    URB transfer type: URB_INTERRUPT (0x01)
    Packet Data Length: 65
    [Response in: 135792]
    [bInterfaceClass: HID (0x03)]
HID Data: 0301020304050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
    Report ID: 0x03
    Vendor Data: 01
    Padding: 020304050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000