Merge pull request #280 from adafruit/multiple-hid-instances

hathach · web-flow · commit 6546b4c08c07 · 2023-04-13T00:18:42.000+07:00
enable multiple HID instances support, change CFG_TUD_HID=2 for all ports
diff --git a/src/arduino/hid/Adafruit_USBD_HID.cpp b/src/arduino/hid/Adafruit_USBD_HID.cpp
@@ -32,28 +32,32 @@
 #define EPIN 0x80
 
 uint8_t const _ascii2keycode[128][2] = {HID_ASCII_TO_KEYCODE};
+static Adafruit_USBD_HID *_hid_instances[CFG_TUD_HID] = {0};
 
-// TODO multiple instances
-static Adafruit_USBD_HID *_hid_dev = NULL;
+uint8_t Adafruit_USBD_HID::_instance_count = 0;
 
 #ifdef ARDUINO_ARCH_ESP32
 static uint16_t hid_load_descriptor(uint8_t *dst, uint8_t *itf) {
   // uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB HID");
 
-  TU_VERIFY(_hid_dev);
+  uint8_t const inst_count = Adafruit_USBD_HID::getInstanceCount();
+  TU_VERIFY(inst_count > 0, 0);
+
+  Adafruit_USBD_HID *p_hid = _hid_instances[inst_count - 1];
+  TU_VERIFY(p_hid);
 
   uint8_t ep_in = tinyusb_get_free_in_endpoint();
   TU_VERIFY(ep_in != 0);
   ep_in |= 0x80;
 
   uint8_t ep_out = 0;
-  if (_hid_dev->isOutEndpointEnabled()) {
+  if (p_hid->isOutEndpointEnabled()) {
     ep_out = tinyusb_get_free_out_endpoint();
     TU_VERIFY(ep_out != 0);
   }
 
   uint16_t const desc_len =
-      _hid_dev->makeItfDesc(*itf, dst, TUD_HID_INOUT_DESC_LEN, ep_in, ep_out);
+      p_hid->makeItfDesc(*itf, dst, TUD_HID_INOUT_DESC_LEN, ep_in, ep_out);
 
   *itf += 1;
   return desc_len;
@@ -68,6 +72,7 @@ Adafruit_USBD_HID::Adafruit_USBD_HID(void)
 Adafruit_USBD_HID::Adafruit_USBD_HID(uint8_t const *desc_report, uint16_t len,
                                      uint8_t protocol, uint8_t interval_ms,
                                      bool has_out_endpoint) {
+  _instance = INVALID_INSTANCE;
   _interval_ms = interval_ms;
   _protocol = protocol;
 
@@ -82,7 +87,13 @@ Adafruit_USBD_HID::Adafruit_USBD_HID(uint8_t const *desc_report, uint16_t len,
 
 #ifdef ARDUINO_ARCH_ESP32
   // ESP32 requires setup configuration descriptor within constructor
-  _hid_dev = this;
+  if (_instance_count >= CFG_TUD_HID) {
+    return;
+  }
+
+  _instance = _instance_count++;
+  _hid_instances[_instance] = this;
+
   uint16_t const desc_len = getInterfaceDescriptor(0, NULL, 0);
   tinyusb_enable_interface(USB_INTERFACE_HID, desc_len, hid_load_descriptor);
 #endif
@@ -158,31 +169,40 @@ uint16_t Adafruit_USBD_HID::getInterfaceDescriptor(uint8_t itfnum, uint8_t *buf,
 }
 
 bool Adafruit_USBD_HID::begin(void) {
+  if (isValid()) {
+    return true;
+  }
+
+  if (_instance_count >= CFG_TUD_HID) {
+    return false;
+  }
+
   if (!TinyUSBDevice.addInterface(*this)) {
     return false;
   }
+  _instance = _instance_count++;
+  _hid_instances[_instance] = this;
 
-  _hid_dev = this;
   return true;
 }
 
-bool Adafruit_USBD_HID::ready(void) { return tud_hid_ready(); }
+bool Adafruit_USBD_HID::ready(void) { return tud_hid_n_ready(_instance); }
 
 bool Adafruit_USBD_HID::sendReport(uint8_t report_id, void const *report,
                                    uint8_t len) {
-  return tud_hid_report(report_id, report, len);
+  return tud_hid_n_report(_instance, report_id, report, len);
 }
 
 bool Adafruit_USBD_HID::sendReport8(uint8_t report_id, uint8_t num) {
-  return tud_hid_report(report_id, &num, sizeof(num));
+  return tud_hid_n_report(_instance, report_id, &num, sizeof(num));
 }
 
 bool Adafruit_USBD_HID::sendReport16(uint8_t report_id, uint16_t num) {
-  return tud_hid_report(report_id, &num, sizeof(num));
+  return tud_hid_n_report(_instance, report_id, &num, sizeof(num));
 }
 
 bool Adafruit_USBD_HID::sendReport32(uint8_t report_id, uint32_t num) {
-  return tud_hid_report(report_id, &num, sizeof(num));
+  return tud_hid_n_report(_instance, report_id, &num, sizeof(num));
 }
 
 //------------- TinyUSB callbacks -------------//
@@ -192,13 +212,13 @@ extern "C" {
 // Application return pointer to descriptor, whose contents must exist long
 // enough for transfer to complete
 uint8_t const *tud_hid_descriptor_report_cb(uint8_t itf) {
-  (void)itf;
+  Adafruit_USBD_HID *p_hid = _hid_instances[itf];
 
-  if (!_hid_dev) {
+  if (!p_hid) {
     return NULL;
   }
 
-  return _hid_dev->_desc_report;
+  return p_hid->_desc_report;
 }
 
 // Invoked when received GET_REPORT control request
@@ -207,27 +227,27 @@ uint8_t const *tud_hid_descriptor_report_cb(uint8_t itf) {
 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) {
-  (void)itf;
+  Adafruit_USBD_HID *p_hid = _hid_instances[itf];
 
-  if (!(_hid_dev && _hid_dev->_get_report_cb)) {
+  if (!(p_hid && p_hid->_get_report_cb)) {
     return 0;
   }
 
-  return _hid_dev->_get_report_cb(report_id, report_type, buffer, reqlen);
+  return p_hid->_get_report_cb(report_id, report_type, buffer, reqlen);
 }
 
 // Invoked when received SET_REPORT control request or
 // received data on OUT endpoint ( Report ID = 0, Type = 0 )
 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) {
-  (void)itf;
+  Adafruit_USBD_HID *p_hid = _hid_instances[itf];
 
-  if (!(_hid_dev && _hid_dev->_set_report_cb)) {
+  if (!(p_hid && p_hid->_set_report_cb)) {
     return;
   }
 
-  _hid_dev->_set_report_cb(report_id, report_type, buffer, bufsize);
+  p_hid->_set_report_cb(report_id, report_type, buffer, bufsize);
 }
 
 } // extern "C"
@@ -238,7 +258,7 @@ void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id,
 
 bool Adafruit_USBD_HID::keyboardReport(uint8_t report_id, uint8_t modifier,
                                        uint8_t keycode[6]) {
-  return tud_hid_keyboard_report(report_id, modifier, keycode);
+  return tud_hid_n_keyboard_report(_instance, report_id, modifier, keycode);
 }
 
 bool Adafruit_USBD_HID::keyboardPress(uint8_t report_id, char ch) {
@@ -251,11 +271,11 @@ bool Adafruit_USBD_HID::keyboardPress(uint8_t report_id, char ch) {
   }
   keycode[0] = _ascii2keycode[uch][1];
 
-  return tud_hid_keyboard_report(report_id, modifier, keycode);
+  return tud_hid_n_keyboard_report(_instance, report_id, modifier, keycode);
 }
 
 bool Adafruit_USBD_HID::keyboardRelease(uint8_t report_id) {
-  return tud_hid_keyboard_report(report_id, 0, NULL);
+  return tud_hid_n_keyboard_report(_instance, report_id, 0, NULL);
 }
 
 //--------------------------------------------------------------------+
@@ -268,24 +288,27 @@ bool Adafruit_USBD_HID::mouseReport(uint8_t report_id, uint8_t buttons,
   // cache mouse button for other API such as move, scroll
   _mouse_button = buttons;
 
-  return tud_hid_mouse_report(report_id, buttons, x, y, vertical, horizontal);
+  return tud_hid_n_mouse_report(_instance, report_id, buttons, x, y, vertical,
+                                horizontal);
 }
 
 bool Adafruit_USBD_HID::mouseMove(uint8_t report_id, int8_t x, int8_t y) {
-  return tud_hid_mouse_report(report_id, _mouse_button, x, y, 0, 0);
+  return tud_hid_n_mouse_report(_instance, report_id, _mouse_button, x, y, 0,
+                                0);
 }
 
 bool Adafruit_USBD_HID::mouseScroll(uint8_t report_id, int8_t scroll,
                                     int8_t pan) {
-  return tud_hid_mouse_report(report_id, _mouse_button, 0, 0, scroll, pan);
+  return tud_hid_n_mouse_report(_instance, report_id, _mouse_button, 0, 0,
+                                scroll, pan);
 }
 
 bool Adafruit_USBD_HID::mouseButtonPress(uint8_t report_id, uint8_t buttons) {
-  return tud_hid_mouse_report(report_id, buttons, 0, 0, 0, 0);
+  return tud_hid_n_mouse_report(_instance, report_id, buttons, 0, 0, 0, 0);
 }
 
 bool Adafruit_USBD_HID::mouseButtonRelease(uint8_t report_id) {
-  return tud_hid_mouse_report(report_id, 0, 0, 0, 0, 0);
+  return tud_hid_n_mouse_report(_instance, report_id, 0, 0, 0, 0, 0);
 }
 
 #endif // CFG_TUD_ENABLED
diff --git a/src/arduino/hid/Adafruit_USBD_HID.h b/src/arduino/hid/Adafruit_USBD_HID.h
@@ -37,6 +37,9 @@ class Adafruit_USBD_HID : public Adafruit_USBD_Interface {
                                         uint8_t const *buffer,
                                         uint16_t bufsize);
 
+  enum { INVALID_INSTANCE = 0xffu };
+  static uint8_t getInstanceCount(void) { return _instance_count; }
+
   Adafruit_USBD_HID(void);
   Adafruit_USBD_HID(uint8_t const *desc_report, uint16_t len,
                     uint8_t protocol = HID_ITF_PROTOCOL_NONE,
@@ -53,6 +56,7 @@ class Adafruit_USBD_HID : public Adafruit_USBD_Interface {
                          set_report_callback_t set_report);
 
   bool begin(void);
+  bool isValid(void) { return _instance != INVALID_INSTANCE; }
 
   bool ready(void);
   bool sendReport(uint8_t report_id, void const *report, uint8_t len);
@@ -84,6 +88,9 @@ class Adafruit_USBD_HID : public Adafruit_USBD_Interface {
                        uint8_t ep_in, uint8_t ep_out);
 
 private:
+  static uint8_t _instance_count;
+
+  uint8_t _instance;
   uint8_t _interval_ms;
   uint8_t _protocol;
   bool _out_endpoint;
diff --git a/src/arduino/ports/nrf/tusb_config_nrf.h b/src/arduino/ports/nrf/tusb_config_nrf.h
@@ -57,7 +57,7 @@ extern "C" {
 //------------- CLASS -------------//
 #define CFG_TUD_CDC 1
 #define CFG_TUD_MSC 1
-#define CFG_TUD_HID 1
+#define CFG_TUD_HID 2
 #define CFG_TUD_MIDI 1
 #define CFG_TUD_VENDOR 1
 
diff --git a/src/arduino/ports/rp2040/tusb_config_rp2040.h b/src/arduino/ports/rp2040/tusb_config_rp2040.h
@@ -63,7 +63,7 @@ extern "C" {
 
 #define CFG_TUD_CDC 1
 #define CFG_TUD_MSC 1
-#define CFG_TUD_HID 1
+#define CFG_TUD_HID 2
 #define CFG_TUD_MIDI 1
 #define CFG_TUD_VENDOR 1
 
diff --git a/src/arduino/ports/samd/tusb_config_samd.h b/src/arduino/ports/samd/tusb_config_samd.h
@@ -62,7 +62,7 @@ extern "C" {
 //------------- CLASS -------------//
 #define CFG_TUD_CDC 1
 #define CFG_TUD_MSC 1
-#define CFG_TUD_HID 1
+#define CFG_TUD_HID 2
 #define CFG_TUD_MIDI 1
 #define CFG_TUD_VENDOR 1
 
