reworking host hid API

2 files changed, 190 insertions, 146 deletions

diff --git a/src/class/hid/hid_host.c b/src/class/hid/hid_host.c
index dae20b305..a5aa33c2c 100644
--- a/src/class/hid/hid_host.c
+++ b/src/class/hid/hid_host.c
@@ -50,6 +50,7 @@ typedef struct
   uint8_t ep_in;
   uint8_t ep_out;
 
+  uint8_t  report_desc_type;
   uint16_t report_desc_len;
 
   bool     valid;
@@ -75,42 +76,51 @@ typedef struct
 
 typedef struct
 {
-  uint8_t inst_count;
-  hidh_interface_t instance[CFG_TUH_HID];
+  uint8_t itf_count;
+  hidh_interface_t interface[CFG_TUH_HID];
 } hidh_device_t;
 
 static hidh_device_t _hidh_dev[CFG_TUSB_HOST_DEVICE_MAX-1];
 
-#if 0
-CFG_TUSB_MEM_SECTION uint8_t report_descriptor[256];
-#endif
+CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN uint8_t _report_desc_buf[256];
 
+// Get Device by address
 TU_ATTR_ALWAYS_INLINE static inline hidh_device_t* get_dev(uint8_t dev_addr)
 {
   return &_hidh_dev[dev_addr-1];
 }
 
-TU_ATTR_ALWAYS_INLINE static inline hidh_interface_t* get_instance(uint8_t dev_addr, uint8_t inst)
+// Get Interface by instance number
+TU_ATTR_ALWAYS_INLINE static inline hidh_interface_t* get_instance(uint8_t dev_addr, uint8_t instance)
 {
-  return &_hidh_dev[dev_addr-1].instance[inst];
+  return &_hidh_dev[dev_addr-1].interface[instance];
 }
 
+// Get Interface by interface number
+static hidh_interface_t* get_interface(uint8_t dev_addr, uint8_t itf)
+{
+  for(uint8_t inst=0; inst<CFG_TUH_HID; inst++)
+  {
+    hidh_interface_t* hid = get_instance(dev_addr, inst);
+
+    if ( (hid->itf_num == itf) && (hid->ep_in != 0) ) return hid;
+  }
+
+  return NULL;
+}
 
 //--------------------------------------------------------------------+
-// HID Interface common functions
+// Application API
 //--------------------------------------------------------------------+
-static inline bool hidh_interface_open(uint8_t rhport, uint8_t dev_addr, uint8_t interface_number, tusb_desc_endpoint_t const *desc_ep, hidh_interface_t *p_hid)
+uint8_t tuh_n_hid_instance_count(uint8_t daddr)
 {
-  TU_ASSERT( usbh_edpt_open(rhport, dev_addr, desc_ep) );
-
-  p_hid->itf_num     = interface_number;
-  p_hid->ep_in       = desc_ep->bEndpointAddress;
-  p_hid->report_size = desc_ep->wMaxPacketSize.size; // TODO get size from report descriptor
-  p_hid->valid       = true;
-
-  return true;
+  return get_dev(daddr)->itf_count;
 }
 
+//--------------------------------------------------------------------+
+// HID Interface common functions
+//--------------------------------------------------------------------+
+
 static inline void hidh_interface_close(hidh_interface_t *p_hid)
 {
   tu_memclr(p_hid, sizeof(hidh_interface_t));
@@ -123,7 +133,7 @@ tusb_error_t hidh_interface_get_report(uint8_t dev_addr, void * report, hidh_int
   // TODO change to use is configured function
   TU_ASSERT(TUSB_DEVICE_STATE_CONFIGURED == tuh_device_get_state(dev_addr), TUSB_ERROR_DEVICE_NOT_READY);
   TU_VERIFY(report, TUSB_ERROR_INVALID_PARA);
-  TU_ASSERT(!hcd_edpt_busy(dev_addr, p_hid->ep_in), TUSB_ERROR_INTERFACE_IS_BUSY);
+  TU_VERIFY(!hcd_edpt_busy(dev_addr, p_hid->ep_in), TUSB_ERROR_INTERFACE_IS_BUSY);
 
   TU_ASSERT( usbh_edpt_xfer(dev_addr, p_hid->ep_in, report, p_hid->report_size) ) ;
 
@@ -134,10 +144,9 @@ tusb_error_t hidh_interface_get_report(uint8_t dev_addr, void * report, hidh_int
 // KEYBOARD
 //--------------------------------------------------------------------+
 
-bool tuh_hid_keyboard_mounted(uint8_t dev_addr)
+bool tuh_n_hid_n_keyboard_mounted(uint8_t dev_addr, uint8_t instance)
 {
-  uint8_t itf = 0;
-  hidh_interface_t* hid_itf = get_instance(dev_addr, itf);
+  hidh_interface_t* hid_itf = get_instance(dev_addr, instance);
 
   // TODO check rid_keyboard
   return tuh_device_is_configured(dev_addr) && (hid_itf->ep_in != 0);
@@ -153,13 +162,12 @@ tusb_error_t tuh_hid_keyboard_get_report(uint8_t dev_addr, void* buffer)
 
 bool tuh_hid_keyboard_is_busy(uint8_t dev_addr)
 {
-  uint8_t itf = 0;
-  hidh_interface_t* hid_itf = get_instance(dev_addr, itf);
+  uint8_t instance = 0;
+  hidh_interface_t* hid_itf = get_instance(dev_addr, instance);
 
-  return  tuh_hid_keyboard_mounted(dev_addr) && hcd_edpt_busy(dev_addr, hid_itf->ep_in);
+  return tuh_n_hid_n_keyboard_mounted(dev_addr, instance) && hcd_edpt_busy(dev_addr, hid_itf->ep_in);
 }
 
-
 //--------------------------------------------------------------------+
 // MOUSE
 //--------------------------------------------------------------------+
@@ -191,17 +199,63 @@ tusb_error_t tuh_hid_mouse_get_report(uint8_t dev_addr, void * report)
 
 
 //--------------------------------------------------------------------+
-// CLASS-USBH API (don't require to verify parameters)
+// USBH API
 //--------------------------------------------------------------------+
 void hidh_init(void)
 {
   tu_memclr(_hidh_dev, sizeof(_hidh_dev));
+}
+
+bool hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
+{
+  (void) xferred_bytes; // TODO may need to use this para later
+
+//  uint8_t itf = 0;
+//  hidh_interface_t* hid_itf = &_hidh_itf[itf];
+
+#if CFG_TUH_HID_KEYBOARD
+//  if ( ep_addr == keyboardh_data[dev_addr-1].ep_in )
+//  {
+//    tuh_hid_keyboard_isr(dev_addr, event);
+//    return true;
+//  }
+#endif
 
 #if CFG_TUH_HID_MOUSE
-  tu_memclr(&mouseh_data, sizeof(hidh_interface_t)*CFG_TUSB_HOST_DEVICE_MAX);
+//  if ( ep_addr == mouseh_data[dev_addr-1].ep_in )
+//  {
+//    tuh_hid_mouse_isr(dev_addr, event);
+//    return true;
+//  }
 #endif
+
+  return true;
 }
 
+void hidh_close(uint8_t dev_addr)
+{
+  uint8_t itf = 0;
+  hidh_interface_t* hid_itf = get_instance(dev_addr, itf);
+
+  if (tuh_hid_unmounted_cb) tuh_hid_unmounted_cb(dev_addr);
+  hidh_interface_close(hid_itf);
+
+#if CFG_TUH_HID_MOUSE
+  if( mouseh_data[dev_addr-1].ep_in != 0 )
+  {
+    hidh_interface_close(&mouseh_data[dev_addr-1]);
+    tuh_hid_mouse_unmounted_cb( dev_addr );
+  }
+#endif
+}
+
+//--------------------------------------------------------------------+
+// Enumeration
+//--------------------------------------------------------------------+
+
+static bool config_set_idle_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result);
+static bool config_get_report_desc_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result);
+
 bool hidh_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *desc_itf, uint16_t *p_length)
 {
   TU_VERIFY(TUSB_CLASS_HID == desc_itf->bInterfaceClass);
@@ -216,50 +270,59 @@ bool hidh_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *de
   // not enough interface, try to increase CFG_TUH_HID
   // TODO multiple devices
   hidh_device_t* hid_dev = get_dev(dev_addr);
-  TU_ASSERT(hid_dev->inst_count < CFG_TUH_HID);
-
-  hidh_interface_t* hid_itf = get_instance(dev_addr, hid_dev->inst_count);
-  hid_dev->inst_count++;
-
-  hid_itf->itf_num = desc_itf->bInterfaceNumber;
-  hid_itf->boot_mode = false; // default is report mode
-  hid_itf->report_desc_len = tu_unaligned_read16(&desc_hid->wReportLength);
+  TU_ASSERT(hid_dev->itf_count < CFG_TUH_HID);
 
   //------------- Endpoint Descriptor -------------//
   p_desc = tu_desc_next(p_desc);
   tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) p_desc;
   TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType);
 
+  // TODO also open endpoint OUT
+  TU_ASSERT( usbh_edpt_open(rhport, dev_addr, desc_ep) );
+
+  hidh_interface_t* hid_itf = get_instance(dev_addr, hid_dev->itf_count);
+  hid_dev->itf_count++;
+
+  hid_itf->itf_num     = desc_itf->bInterfaceNumber;
+  hid_itf->ep_in       = desc_ep->bEndpointAddress;
+  hid_itf->report_size = desc_ep->wMaxPacketSize.size; // TODO get size from report descriptor
+  hid_itf->valid       = true;
+
+  TU_LOG2_HEX(hid_itf->ep_in);
+
+  // Assume bNumDescriptors = 1
+  hid_itf->report_desc_type = desc_hid->bReportType;
+  hid_itf->report_desc_len = tu_unaligned_read16(&desc_hid->wReportLength);
+
+  hid_itf->boot_mode = false; // default is report mode
   if ( HID_SUBCLASS_BOOT == desc_itf->bInterfaceSubClass )
   {
     hid_itf->boot_protocol = desc_itf->bInterfaceProtocol;
 
-    #if CFG_TUH_HID_KEYBOARD
     if ( HID_PROTOCOL_KEYBOARD == desc_itf->bInterfaceProtocol)
     {
-      TU_ASSERT( hidh_interface_open(rhport, dev_addr, desc_itf->bInterfaceNumber, desc_ep, hid_itf) );
-      TU_LOG2_HEX(hid_itf->ep_in);
-
+      // TODO boot protocol may still have more report in report mode
       hid_itf->report_count = 1;
 
       hid_itf->reports[0].usage_page = HID_USAGE_PAGE_DESKTOP;
       hid_itf->reports[0].usage = HID_USAGE_DESKTOP_KEYBOARD;
       hid_itf->reports[0].in_len = 8;
       hid_itf->reports[0].out_len = 1;
-    } else
-    #endif
-
-    #if CFG_TUH_HID_MOUSE
-    if ( HID_PROTOCOL_MOUSE == desc_itf->bInterfaceProtocol)
+    }
+    else if ( HID_PROTOCOL_MOUSE == desc_itf->bInterfaceProtocol)
     {
-      TU_ASSERT ( hidh_interface_open(rhport, dev_addr, desc_itf->bInterfaceNumber, desc_ep, &mouseh_data[dev_addr-1]) );
-      TU_LOG2_HEX(mouseh_data[dev_addr-1].ep_in);
-    } else
-    #endif
+      // TODO boot protocol may still have more report in report mode
+      hid_itf->report_count = 1;
 
+      hid_itf->reports[0].usage_page = HID_USAGE_PAGE_DESKTOP;
+      hid_itf->reports[0].usage = HID_USAGE_DESKTOP_MOUSE;
+      hid_itf->reports[0].in_len = 8;
+      hid_itf->reports[0].out_len = 1;
+    }
+    else
     {
-      // Not supported protocol
-      return false;
+      // Unknown protocol
+      TU_ASSERT(false);
     }
   }
 
@@ -270,23 +333,11 @@ bool hidh_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *de
 
 bool hidh_set_config(uint8_t dev_addr, uint8_t itf_num)
 {
-#if 0
-  //------------- Get Report Descriptor TODO HID parser -------------//
-  if ( p_desc_hid->bNumDescriptors )
-  {
-    STASK_INVOKE(
-        usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_STANDARD, TUSB_REQ_RCPT_INTERFACE),
-                                   TUSB_REQ_GET_DESCRIPTOR, (p_desc_hid->bReportType << 8), 0,
-                                   p_desc_hid->wReportLength, report_descriptor ),
-        error
-    );
-    (void) error; // if error in getting report descriptor --> treating like there is none
-  }
-#endif
+  // Idle rate = 0 mean only report when there is changes
+  uint16_t const idle_rate = 0;
 
-#if 0
-  // SET IDLE = 0 request
-  // Device can stall if not support this request
+  // SET IDLE request, device can stall if not support this request
+  TU_LOG2("Set Idle \r\n");
   tusb_control_request_t const request =
   {
     .bmRequestType_bit =
@@ -296,76 +347,65 @@ bool hidh_set_config(uint8_t dev_addr, uint8_t itf_num)
       .direction = TUSB_DIR_OUT
     },
     .bRequest = HID_REQ_CONTROL_SET_IDLE,
-    .wValue   = 0, // idle_rate = 0
-    .wIndex   = p_interface_desc->bInterfaceNumber,
+    .wValue   = idle_rate,
+    .wIndex   = itf_num,
     .wLength  = 0
   };
 
-  // stall is a valid response for SET_IDLE, therefore we could ignore result of this request
-  tuh_control_xfer(dev_addr, &request, NULL, NULL);
-#endif
-
-  usbh_driver_set_config_complete(dev_addr, itf_num);
-
-//  uint8_t itf = 0;
-//  hidh_interface_t* hid_itf = &_hidh_itf[itf];
-
-
-  if (itf_num == 0 ) {
-  if (tuh_hid_mounted_cb) tuh_hid_mounted_cb(dev_addr);
-  }
-
-#if CFG_TUH_HID_MOUSE
-  if (( mouseh_data[dev_addr-1].ep_in == itf_num ) &&  mouseh_data[dev_addr-1].valid)
-  {
-    tuh_hid_mouse_mounted_cb(dev_addr);
-  }
-#endif
+  TU_ASSERT( tuh_control_xfer(dev_addr, &request, NULL, config_set_idle_complete) );
 
   return true;
 }
 
-bool hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
+bool config_set_idle_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
 {
-  (void) xferred_bytes; // TODO may need to use this para later
+  // Stall is a valid response for SET_IDLE, therefore we could ignore its result
+  (void) result;
 
-//  uint8_t itf = 0;
-//  hidh_interface_t* hid_itf = &_hidh_itf[itf];
+  uint8_t const itf_num = (uint8_t) request->wIndex;
 
-#if CFG_TUH_HID_KEYBOARD
-//  if ( ep_addr == keyboardh_data[dev_addr-1].ep_in )
-//  {
-//    tuh_hid_keyboard_isr(dev_addr, event);
-//    return true;
-//  }
-#endif
+  hidh_interface_t* hid_itf = get_interface(dev_addr, itf_num);
 
-#if CFG_TUH_HID_MOUSE
-  if ( ep_addr == mouseh_data[dev_addr-1].ep_in )
+  // Get Report Descriptor
+  // using usbh enumeration buffer since report descriptor can be very long
+  TU_ASSERT( hid_itf->report_desc_len <= CFG_TUH_ENUMERATION_BUFSZIE );
+
+  TU_LOG2("HID Get Report Descriptor\r\n");
+  tusb_control_request_t const new_request =
   {
-    tuh_hid_mouse_isr(dev_addr, event);
-    return true;
-  }
-#endif
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_INTERFACE,
+      .type      = TUSB_REQ_TYPE_STANDARD,
+      .direction = TUSB_DIR_IN
+    },
+    .bRequest = TUSB_REQ_GET_DESCRIPTOR,
+    .wValue   = tu_u16(hid_itf->report_desc_type, 0),
+    .wIndex   = itf_num,
+    .wLength  = hid_itf->report_desc_len
+  };
 
+  TU_ASSERT(tuh_control_xfer(dev_addr, &new_request, usbh_get_enum_buf(), config_get_report_desc_complete));
   return true;
 }
 
-void hidh_close(uint8_t dev_addr)
+bool config_get_report_desc_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
 {
-  uint8_t itf = 0;
-  hidh_interface_t* hid_itf = get_instance(dev_addr, itf);
+  TU_ASSERT(XFER_RESULT_SUCCESS == result);
+  uint8_t const itf_num = (uint8_t) request->wIndex;
+  hidh_interface_t* hid_itf = get_interface(dev_addr, itf_num);
 
-  if (tuh_hid_unmounted_cb) tuh_hid_unmounted_cb(dev_addr);
-  hidh_interface_close(hid_itf);
+  if (tuh_hid_descriptor_report_cb) tuh_hid_descriptor_report_cb(dev_addr, hid_itf->itf_num, usbh_get_enum_buf(), request->wLength);
 
-#if CFG_TUH_HID_MOUSE
-  if( mouseh_data[dev_addr-1].ep_in != 0 )
-  {
-    hidh_interface_close(&mouseh_data[dev_addr-1]);
-    tuh_hid_mouse_unmounted_cb( dev_addr );
-  }
-#endif
+  // TODO Report descriptor parser
+
+  // enumeration is complete
+  if (tuh_hid_mounted_cb) tuh_hid_mounted_cb(dev_addr);
+
+  // notify usbh that driver enumeration is complete
+  usbh_driver_set_config_complete(dev_addr, itf_num);
+
+  return true;
 }
 
 #endif
diff --git a/src/class/hid/hid_host.h b/src/class/hid/hid_host.h
index 10ecc457f..98c652338 100644
--- a/src/class/hid/hid_host.h
+++ b/src/class/hid/hid_host.h
@@ -46,22 +46,51 @@
 #define CFG_TUH_HID_REPORT_MAX 4
 #endif
 
+#ifndef CFG_TUH_HID_REPORT_DESCRIPTOR_BUFSIZE
+#define CFG_TUH_HID_REPORT_DESCRIPTOR_BUFSIZE 256
+#endif
+
 //--------------------------------------------------------------------+
-// Application API (Multiple Instances)
-// CFG_TUH_HID > 1
+// Application API (Multiple devices)
+// Note:
+//  - tud_n   : is multiple devices API
+//  - class_n : is multiple instances API
 //--------------------------------------------------------------------+
 
+// Get the number of HID instances
+uint8_t tuh_n_hid_instance_count(uint8_t daddr);
+
+// Check if HID instance support keyboard
+bool tuh_n_hid_n_keyboard_mounted(uint8_t daddr, uint8_t instance);
+
+
 
 //--------------------------------------------------------------------+
-// Application API (Single Instance)
+// Application API (Single device)
 //--------------------------------------------------------------------+
 
-// tuh_hid_instance_count()
+// Get the number of HID instances
+TU_ATTR_ALWAYS_INLINE static inline
+uint8_t tuh_hid_instance_count(void)
+{
+  return tuh_n_hid_instance_count(1);
+}
+
 //bool tuh_hid_get_report(uint8_t dev_addr, uint8_t report_id, void * p_report, uint8_t len);
 
+//--------------------------------------------------------------------+
+// Callbacks (Weak is optional)
+//--------------------------------------------------------------------+
+
+// Invoked when report descriptor is received
+// Note: enumeration is still not complete yet
+TU_ATTR_WEAK void tuh_hid_descriptor_report_cb(uint8_t daddr, uint8_t instance, uint8_t const* report_desc, uint16_t desc_len);
+
 TU_ATTR_WEAK void tuh_hid_mounted_cb(uint8_t dev_addr);
 TU_ATTR_WEAK void tuh_hid_unmounted_cb(uint8_t dev_addr);
 
+
+
 //--------------------------------------------------------------------+
 // KEYBOARD Application API
 //--------------------------------------------------------------------+
@@ -193,31 +222,6 @@ void tuh_hid_mouse_mounted_cb(uint8_t dev_addr);
  */
 void tuh_hid_mouse_unmounted_cb(uint8_t dev_addr);
 
-/** @} */ // Mouse_Host
-/** @} */ // ClassDriver_HID_Mouse
-
-//--------------------------------------------------------------------+
-// GENERIC Application API
-//--------------------------------------------------------------------+
-/** \addtogroup ClassDriver_HID_Generic Generic (not supported yet)
- *  @{ */
-
-/** \defgroup Generic_Host Host
- *  The interface API includes status checking function, data transferring function and callback functions
- *  @{ */
-
-bool          tuh_hid_generic_is_mounted(uint8_t dev_addr);
-tusb_error_t  tuh_hid_generic_get_report(uint8_t dev_addr, void* p_report, bool int_on_complete);
-tusb_error_t  tuh_hid_generic_set_report(uint8_t dev_addr, void* p_report, bool int_on_complete);
-tusb_interface_status_t tuh_hid_generic_get_status(uint8_t dev_addr);
-tusb_interface_status_t tuh_hid_generic_set_status(uint8_t dev_addr);
-
-//------------- Application Callback -------------//
-void tuh_hid_generic_isr(uint8_t dev_addr, xfer_result_t event);
-
-/** @} */ // Generic_Host
-/** @} */ // ClassDriver_HID_Generic
-
 //--------------------------------------------------------------------+
 // Internal Class Driver API
 //--------------------------------------------------------------------+