Is there any way to respond to Get_Report requests over the control endpoint without modifying the source code?

[justinjradi]

Hi. I noticed that in hid_device.c, tud_control_xfer is called after tud_hid_get_report_cb is called. As I understand, that means that if you want to respond to a Get_Report request over the control endpoint, just implementing the callback would result in two responses for one request. I can only think of two ways around this:

1. Modify hid_device.c to not send the control transfer and implement the response in the callback.
2. Implement the response in hid_device.c.

Either way, both methods involve modifying hid_device.c. Is there any way to do this without modfying the source code?

If it's helpful, here's what hidd_control_xfer_cb in hid_device.c looks after taking the second route. My modification is under the class-specific request section:

bool hidd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const *request)
{
  TU_VERIFY(request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE);

  uint8_t const hid_itf = get_index_by_itfnum((uint8_t)request->wIndex);
  TU_VERIFY(hid_itf < CFG_TUD_HID);

  hidd_interface_t *p_hid = &_hidd_itf[hid_itf];

  if (request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD) {
    //------------- STD Request -------------//
    if (stage == CONTROL_STAGE_SETUP) {
      uint8_t const desc_type = tu_u16_high(request->wValue);
      // uint8_t const desc_index = tu_u16_low (request->wValue);

      if (request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_HID) {
        TU_VERIFY(p_hid->hid_descriptor);
        TU_VERIFY(tud_control_xfer(rhport, request, (void *)(uintptr_t)p_hid->hid_descriptor, p_hid->hid_descriptor->bLength));
      } else if (request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_REPORT) {
        uint8_t const *desc_report = tud_hid_descriptor_report_cb(hid_itf);
        tud_control_xfer(rhport, request, (void *)(uintptr_t)desc_report, p_hid->report_desc_len);
      } else {
        return false; // stall unsupported request
      }
    }
  } else if (request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS) {
    //------------- Class Specific Request -------------//
    switch (request->bRequest) {
    case HID_REQ_CONTROL_GET_REPORT:
      if (stage == CONTROL_STAGE_SETUP) {
        uint8_t const report_type = tu_u16_high(request->wValue);
        uint8_t const report_id = tu_u16_low(request->wValue);

        uint8_t *report_buf = p_hid->ctrl_buf;
        uint16_t req_len = tu_min16(request->wLength, CFG_TUD_HID_EP_BUFSIZE);

        uint16_t xferlen = 0;

        // If host request a specific Report ID, add ID to as 1 byte of response
        if ((report_id != HID_REPORT_TYPE_INVALID) && (req_len > 1)) {
          *report_buf++ = report_id;
          req_len--;

          xferlen++;
        }

        // Modification: Respond to Get_Report feature requests over control endpoint
        if (report_type == HID_REPORT_TYPE_FEATURE)
        {
        	uint8_t* report;
        	uint8_t report_len = 0;
        	switch (report_id)
        	{
        		case REPORTID_RES_MULTIPLIER:
        			uint8_t res_multiplier_report[1] = {0x05};		// Sets scroll_multiplier and pan_multiplier both to 1
        			report = (uint8_t*) res_multiplier_report;
        			report_len = 1;
        			break;
        	}
        	if (report_len != 0)
        	{
          	for (int i = 0; i < report_len; i++)
          	{
          		*report_buf++ = report[i];
          		xferlen++;
          	}
        	}
        }
        // End modification

        xferlen += tud_hid_get_report_cb(hid_itf, report_id, (hid_report_type_t)report_type, report_buf, req_len);
        TU_ASSERT(xferlen > 0);
        tud_control_xfer(rhport, request, p_hid->ctrl_buf, xferlen);
      }
      break;

    case HID_REQ_CONTROL_SET_REPORT:
      if (stage == CONTROL_STAGE_SETUP) {
        TU_VERIFY(request->wLength <= sizeof(p_hid->ctrl_buf));
        tud_control_xfer(rhport, request, p_hid->ctrl_buf, request->wLength);
      } else if (stage == CONTROL_STAGE_ACK) {
        uint8_t const report_type = tu_u16_high(request->wValue);
        uint8_t const report_id = tu_u16_low(request->wValue);

        uint8_t const *report_buf = p_hid->ctrl_buf;
        uint16_t report_len = tu_min16(request->wLength, CFG_TUD_HID_EP_BUFSIZE);

        // If host request a specific Report ID, extract report ID in buffer before invoking callback
        if ((report_id != HID_REPORT_TYPE_INVALID) && (report_len > 1) && (report_id == report_buf[0])) {
          report_buf++;
          report_len--;
        }

        tud_hid_set_report_cb(hid_itf, report_id, (hid_report_type_t)report_type, report_buf, report_len);
      }
      break;

    case HID_REQ_CONTROL_SET_IDLE:
      if (stage == CONTROL_STAGE_SETUP) {
        p_hid->idle_rate = tu_u16_high(request->wValue);
        if (tud_hid_set_idle_cb) {
          // stall request if callback return false
          TU_VERIFY(tud_hid_set_idle_cb(hid_itf, p_hid->idle_rate));
        }

        tud_control_status(rhport, request);
      }
      break;

    case HID_REQ_CONTROL_GET_IDLE:
      if (stage == CONTROL_STAGE_SETUP) {
        // TODO idle rate of report
        tud_control_xfer(rhport, request, &p_hid->idle_rate, 1);
      }
      break;

    case HID_REQ_CONTROL_GET_PROTOCOL:
      if (stage == CONTROL_STAGE_SETUP) {
        tud_control_xfer(rhport, request, &p_hid->protocol_mode, 1);
      }
      break;

    case HID_REQ_CONTROL_SET_PROTOCOL:
      if (stage == CONTROL_STAGE_SETUP) {
        tud_control_status(rhport, request);
      } else if (stage == CONTROL_STAGE_ACK) {
        p_hid->protocol_mode = (uint8_t)request->wValue;
        if (tud_hid_set_protocol_cb) {
          tud_hid_set_protocol_cb(hid_itf, p_hid->protocol_mode);
        }
      }
      break;

    default:
      return false; // stall unsupported request
    }
  } else {
    return false; // stall unsupported request
  }

  return true;
}