From f7cf8cdf27a016093df65c0de7167685e407d014 Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Sat, 5 Sep 2020 14:28:58 +0700
Subject: defer xfer_isr to xfer_cb

---
 src/class/cdc/cdc_host.c | 2 +-
 src/class/cdc/cdc_host.h | 2 +-
 src/class/hid/hid_host.c | 2 +-
 src/class/hid/hid_host.h | 2 +-
 src/class/msc/msc_host.c | 2 +-
 src/class/msc/msc_host.h | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'src/class')

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index e62f47b72..23e342134 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -209,7 +209,7 @@ bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
   return true;
 }
 
-void cdch_isr(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
+void cdch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
 {
   (void) ep_addr;
   tuh_cdc_xfer_isr( dev_addr, event, 0, xferred_bytes );
diff --git a/src/class/cdc/cdc_host.h b/src/class/cdc/cdc_host.h
index 306420ce4..0e2820fef 100644
--- a/src/class/cdc/cdc_host.h
+++ b/src/class/cdc/cdc_host.h
@@ -113,7 +113,7 @@ void tuh_cdc_xfer_isr(uint8_t dev_addr, xfer_result_t event, cdc_pipeid_t pipe_i
 //--------------------------------------------------------------------+
 void cdch_init(void);
 bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length);
-void cdch_isr(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
+void cdch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
 void cdch_close(uint8_t dev_addr);
 
 #ifdef __cplusplus
diff --git a/src/class/hid/hid_host.c b/src/class/hid/hid_host.c
index 378278cc3..e17bfc9e5 100644
--- a/src/class/hid/hid_host.c
+++ b/src/class/hid/hid_host.c
@@ -232,7 +232,7 @@ bool hidh_open_subtask(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t c
   return true;
 }
 
-void hidh_isr(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
+void 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
 
diff --git a/src/class/hid/hid_host.h b/src/class/hid/hid_host.h
index 2e7f52674..54542de55 100644
--- a/src/class/hid/hid_host.h
+++ b/src/class/hid/hid_host.h
@@ -197,7 +197,7 @@ void tuh_hid_generic_isr(uint8_t dev_addr, xfer_result_t event);
 //--------------------------------------------------------------------+
 void hidh_init(void);
 bool hidh_open_subtask(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length);
-void hidh_isr(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
+void hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
 void hidh_close(uint8_t dev_addr);
 
 #ifdef __cplusplus
diff --git a/src/class/msc/msc_host.c b/src/class/msc/msc_host.c
index 539e98376..b129d538f 100644
--- a/src/class/msc/msc_host.c
+++ b/src/class/msc/msc_host.c
@@ -383,7 +383,7 @@ bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
   return true;
 }
 
-void msch_isr(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
+void msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
 {
   msch_interface_t* p_msc = &msch_data[dev_addr-1];
   if ( ep_addr == p_msc->ep_in )
diff --git a/src/class/msc/msc_host.h b/src/class/msc/msc_host.h
index 959294adf..3eb45e6fc 100644
--- a/src/class/msc/msc_host.h
+++ b/src/class/msc/msc_host.h
@@ -193,7 +193,7 @@ typedef struct
 
 void msch_init(void);
 bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length);
-void msch_isr(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
+void msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
 void msch_close(uint8_t dev_addr);
 
 #ifdef __cplusplus
-- 
cgit v1.3.1


From 9531e47d10915b652c2c5cff9ef2956889639f93 Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Sat, 5 Sep 2020 14:59:07 +0700
Subject: update example to test with mouse

---
 examples/host/cdc_msc_hid/src/main.c | 97 ++++++++++++++++++++++++++++++------
 src/class/hid/hid_host.c             |  5 +-
 2 files changed, 85 insertions(+), 17 deletions(-)

(limited to 'src/class')

diff --git a/examples/host/cdc_msc_hid/src/main.c b/examples/host/cdc_msc_hid/src/main.c
index 4200cc5e0..bbaac8644 100644
--- a/examples/host/cdc_msc_hid/src/main.c
+++ b/examples/host/cdc_msc_hid/src/main.c
@@ -111,6 +111,7 @@ void cdc_task(void)
 //--------------------------------------------------------------------+
 #if CFG_TUH_HID_KEYBOARD
 
+CFG_TUSB_MEM_SECTION static hid_keyboard_report_t usb_keyboard_report;
 uint8_t const keycode2ascii[128][2] =  { HID_KEYCODE_TO_ASCII };
 
 // look up new key in previous keys
@@ -153,21 +154,6 @@ static inline void process_kbd_report(hid_keyboard_report_t const *p_new_report)
   prev_report = *p_new_report;
 }
 
-CFG_TUSB_MEM_SECTION static hid_keyboard_report_t usb_keyboard_report;
-
-void hid_task(void)
-{
-  uint8_t const addr = 1;
-  if ( tuh_hid_keyboard_is_mounted(addr) )
-  {
-    if ( !tuh_hid_keyboard_is_busy(addr) )
-    {
-      process_kbd_report(&usb_keyboard_report);
-      tuh_hid_keyboard_get_report(addr, &usb_keyboard_report);
-    }
-  }
-}
-
 void tuh_hid_keyboard_mounted_cb(uint8_t dev_addr)
 {
   // application set-up
@@ -192,6 +178,58 @@ void tuh_hid_keyboard_isr(uint8_t dev_addr, xfer_result_t event)
 #endif
 
 #if CFG_TUH_HID_MOUSE
+
+CFG_TUSB_MEM_SECTION static hid_mouse_report_t usb_mouse_report;
+
+void cursor_movement(int8_t x, int8_t y, int8_t wheel)
+{
+  //------------- X -------------//
+  if ( x < 0)
+  {
+    printf(ANSI_CURSOR_BACKWARD(%d), (-x)); // move left
+  }else if ( x > 0)
+  {
+    printf(ANSI_CURSOR_FORWARD(%d), x); // move right
+  }else { }
+
+  //------------- Y -------------//
+  if ( y < 0)
+  {
+    printf(ANSI_CURSOR_UP(%d), (-y)); // move up
+  }else if ( y > 0)
+  {
+    printf(ANSI_CURSOR_DOWN(%d), y); // move down
+  }else { }
+
+  //------------- wheel -------------//
+  if (wheel < 0)
+  {
+    printf(ANSI_SCROLL_UP(%d), (-wheel)); // scroll up
+  }else if (wheel > 0)
+  {
+    printf(ANSI_SCROLL_DOWN(%d), wheel); // scroll down
+  }else { }
+}
+
+static inline void process_mouse_report(hid_mouse_report_t const * p_report)
+{
+  static hid_mouse_report_t prev_report = { 0 };
+
+  //------------- button state  -------------//
+  uint8_t button_changed_mask = p_report->buttons ^ prev_report.buttons;
+  if ( button_changed_mask & p_report->buttons)
+  {
+    printf(" %c%c%c ",
+       p_report->buttons & MOUSE_BUTTON_LEFT   ? 'L' : '-',
+       p_report->buttons & MOUSE_BUTTON_MIDDLE ? 'M' : '-',
+       p_report->buttons & MOUSE_BUTTON_RIGHT  ? 'R' : '-');
+  }
+
+  //------------- cursor movement -------------//
+  cursor_movement(p_report->x, p_report->y, p_report->wheel);
+}
+
+
 void tuh_hid_mouse_mounted_cb(uint8_t dev_addr)
 {
   // application set-up
@@ -212,6 +250,35 @@ void tuh_hid_mouse_isr(uint8_t dev_addr, xfer_result_t event)
 }
 #endif
 
+
+
+void hid_task(void)
+{
+  uint8_t const addr = 1;
+
+#if CFG_TUH_HID_KEYBOARD
+  if ( tuh_hid_keyboard_is_mounted(addr) )
+  {
+    if ( !tuh_hid_keyboard_is_busy(addr) )
+    {
+      process_kbd_report(&usb_keyboard_report);
+      tuh_hid_keyboard_get_report(addr, &usb_mouse_report);
+    }
+  }
+#endif
+
+#if CFG_TUH_HID_MOUSE
+  if ( tuh_hid_mouse_is_mounted(addr) )
+  {
+    if ( !tuh_hid_mouse_is_busy(addr) )
+    {
+      process_mouse_report(&usb_mouse_report);
+      tuh_hid_mouse_get_report(addr, &usb_mouse_report);
+    }
+  }
+#endif
+}
+
 //--------------------------------------------------------------------+
 // tinyusb callbacks
 //--------------------------------------------------------------------+
diff --git a/src/class/hid/hid_host.c b/src/class/hid/hid_host.c
index e17bfc9e5..d9ed1f651 100644
--- a/src/class/hid/hid_host.c
+++ b/src/class/hid/hid_host.c
@@ -173,7 +173,8 @@ bool hidh_open_subtask(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t c
   tusb_desc_endpoint_t const * p_endpoint_desc = (tusb_desc_endpoint_t const *) p_desc;
   TU_ASSERT(TUSB_DESC_ENDPOINT == p_endpoint_desc->bDescriptorType, TUSB_ERROR_INVALID_PARA);
 
-  //------------- SET IDLE (0) request -------------//
+  // SET IDLE = 0 request
+  // Device can stall if not support this request
   tusb_control_request_t request = {
         .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_INTERFACE, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_OUT },
         .bRequest = HID_REQ_CONTROL_SET_IDLE,
@@ -181,7 +182,7 @@ bool hidh_open_subtask(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t c
         .wIndex = p_interface_desc->bInterfaceNumber,
         .wLength = 0
   };
-  TU_ASSERT( usbh_control_xfer( dev_addr, &request, NULL ) );
+  usbh_control_xfer( dev_addr, &request, NULL ); // TODO stall is valid
 
 #if 0
   //------------- Get Report Descriptor TODO HID parser -------------//
-- 
cgit v1.3.1


From 15ad585e674f14e247aa7e5f42fb84f90f14be8b Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Sun, 6 Sep 2020 11:49:00 +0700
Subject: replacing hcd_pipe_xfer by usbh_edpt_xfer

---
 hw/bsp/ea4088qs/ea4088qs.c | 15 +++++++++++----
 src/class/hid/hid_host.c   |  2 +-
 src/host/ehci/ehci.c       | 15 ++++++++++++++-
 src/host/hub.c             |  4 ++--
 src/host/ohci/ohci.c       | 24 ++++++++++++++++++++++--
 src/host/usbh.c            |  6 ++++++
 src/host/usbh.h            |  2 ++
 7 files changed, 58 insertions(+), 10 deletions(-)

(limited to 'src/class')

diff --git a/hw/bsp/ea4088qs/ea4088qs.c b/hw/bsp/ea4088qs/ea4088qs.c
index f164526d7..b25f9101c 100644
--- a/hw/bsp/ea4088qs/ea4088qs.c
+++ b/hw/bsp/ea4088qs/ea4088qs.c
@@ -98,6 +98,11 @@ void SystemInit(void)
 
   Chip_IOCON_Init(LPC_IOCON);
   Chip_IOCON_SetPinMuxing(LPC_IOCON, pinmuxing, sizeof(pinmuxing) / sizeof(PINMUX_GRP_T));
+
+	/* CPU clock source starts with IRC */
+	/* Enable PBOOST for CPU clock over 100MHz */
+	Chip_SYSCTL_EnableBoost();
+
   Chip_SetupXtalClocking();
 }
 
@@ -130,13 +135,15 @@ void board_init(void)
   Chip_USB_Init();
 
   enum {
-    USBCLK  = 0x1B // Host + Device + OTG + AHB
+    USBCLK_DEVCIE = 0x12, // AHB + Device
+    USBCLK_HOST = 0x19 ,  // AHB + OTG + Host
+    USBCLK_ALL  = 0x1B    // Host + Device + OTG + AHB
   };
 
-  LPC_USB->OTGClkCtrl = USBCLK;
-  while ( (LPC_USB->OTGClkSt & USBCLK) != USBCLK ) {}
+  LPC_USB->OTGClkCtrl = USBCLK_ALL;
+  while ( (LPC_USB->OTGClkSt & USBCLK_ALL) != USBCLK_ALL ) {}
 
-  // USB1 = host, USB2 = device
+  // set portfunc: USB1 = host, USB2 = device
   LPC_USB->StCtrl = 0x3;
 }
 
diff --git a/src/class/hid/hid_host.c b/src/class/hid/hid_host.c
index d9ed1f651..5ea8cc7e9 100644
--- a/src/class/hid/hid_host.c
+++ b/src/class/hid/hid_host.c
@@ -71,7 +71,7 @@ tusb_error_t hidh_interface_get_report(uint8_t dev_addr, void * report, hidh_int
   TU_VERIFY(report, TUSB_ERROR_INVALID_PARA);
   TU_ASSERT(!hcd_edpt_busy(dev_addr, p_hid->ep_in), TUSB_ERROR_INTERFACE_IS_BUSY);
 
-  TU_ASSERT( hcd_pipe_xfer(dev_addr, p_hid->ep_in, report, p_hid->report_size, true) ) ;
+  TU_ASSERT( usbh_edpt_xfer(dev_addr, p_hid->ep_in, report, p_hid->report_size) ) ;
 
   return TUSB_ERROR_NONE;
 }
diff --git a/src/host/ehci/ehci.c b/src/host/ehci/ehci.c
index 3c02086c9..23c8ea9ee 100644
--- a/src/host/ehci/ehci.c
+++ b/src/host/ehci/ehci.c
@@ -328,7 +328,20 @@ bool hcd_edpt_xfer(uint8_t rhport, uint8_t dev_addr, uint8_t ep_addr, uint8_t *
     qhd->qtd_overlay.next.address = (uint32_t) qtd;
   }else
   {
-    // TODO implement later
+    ehci_qhd_t *p_qhd = qhd_get_from_addr(dev_addr, ep_addr);
+    ehci_qtd_t *p_qtd = qtd_find_free();
+    TU_ASSERT(p_qtd);
+
+    qtd_init(p_qtd, buffer, buflen);
+    p_qtd->pid = p_qhd->pid;
+
+    // Insert TD to QH
+    qtd_insert_to_qhd(p_qhd, p_qtd);
+
+    p_qhd->p_qtd_list_tail->int_on_complete = 1;
+
+    // attach head QTD to QHD start transferring
+    p_qhd->qtd_overlay.next.address = (uint32_t) p_qhd->p_qtd_list_head;
   }
 
   return true;
diff --git a/src/host/hub.c b/src/host/hub.c
index db1ca0786..abec20d06 100644
--- a/src/host/hub.c
+++ b/src/host/hub.c
@@ -167,8 +167,8 @@ bool hub_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf
     TU_ASSERT( usbh_control_xfer( dev_addr, &request, NULL ) );
   }
 
-  //------------- Queue the initial Status endpoint transfer -------------//
-  TU_ASSERT( hcd_pipe_xfer(dev_addr, hub_data[dev_addr-1].ep_status, &hub_data[dev_addr-1].status_change, 1, true) );
+  // Queue notification status endpoint
+  TU_ASSERT( usbh_edpt_xfer(dev_addr, hub_data[dev_addr-1].ep_status, &hub_data[dev_addr-1].status_change, 1) );
 
   return true;
 }
diff --git a/src/host/ohci/ohci.c b/src/host/ohci/ohci.c
index 87da374d5..d9bbfc8c6 100644
--- a/src/host/ohci/ohci.c
+++ b/src/host/ohci/ohci.c
@@ -306,6 +306,11 @@ bool hcd_setup_send(uint8_t rhport, uint8_t dev_addr, uint8_t const setup_packet
   return true;
 }
 
+// TODO move around
+static ohci_ed_t * ed_from_addr(uint8_t dev_addr, uint8_t ep_addr);
+static ohci_gtd_t * gtd_find_free(void);
+static void td_insert_to_ed(ohci_ed_t* p_ed, ohci_gtd_t * p_gtd);
+
 bool hcd_edpt_xfer(uint8_t rhport, uint8_t dev_addr, uint8_t ep_addr, uint8_t * buffer, uint16_t buflen)
 {
   (void) rhport;
@@ -329,6 +334,21 @@ bool hcd_edpt_xfer(uint8_t rhport, uint8_t dev_addr, uint8_t ep_addr, uint8_t *
     p_ed->td_head.address = (uint32_t) p_data;
 
     OHCI_REG->command_status_bit.control_list_filled = 1;
+  }else
+  {
+    ohci_ed_t * p_ed = ed_from_addr(dev_addr, ep_addr);
+    ohci_gtd_t* p_gtd = gtd_find_free();
+
+    TU_ASSERT(p_gtd);
+
+    gtd_init(p_gtd, buffer, buflen);
+    p_gtd->index = p_ed-ohci_data.ed_pool;
+    p_gtd->delay_interrupt = OHCI_INT_ON_COMPLETE_YES;
+
+    td_insert_to_ed(p_ed, p_gtd);
+
+    tusb_xfer_type_t xfer_type = ed_get_xfer_type( ed_from_addr(dev_addr, ep_addr) );
+    if (TUSB_XFER_BULK == xfer_type) OHCI_REG->command_status_bit.bulk_list_filled = 1;
   }
 
   return true;
@@ -337,7 +357,7 @@ bool hcd_edpt_xfer(uint8_t rhport, uint8_t dev_addr, uint8_t ep_addr, uint8_t *
 //--------------------------------------------------------------------+
 // BULK/INT/ISO PIPE API
 //--------------------------------------------------------------------+
-static inline ohci_ed_t * ed_from_addr(uint8_t dev_addr, uint8_t ep_addr)
+static ohci_ed_t * ed_from_addr(uint8_t dev_addr, uint8_t ep_addr)
 {
   if ( tu_edpt_number(ep_addr) == 0 ) return &ohci_data.control[dev_addr].ed;
 
@@ -355,7 +375,7 @@ static inline ohci_ed_t * ed_from_addr(uint8_t dev_addr, uint8_t ep_addr)
   return NULL;
 }
 
-static inline ohci_ed_t * ed_find_free(void)
+static ohci_ed_t * ed_find_free(void)
 {
   ohci_ed_t* ed_pool = ohci_data.ed_pool;
 
diff --git a/src/host/usbh.c b/src/host/usbh.c
index f669cac05..da35340ce 100644
--- a/src/host/usbh.c
+++ b/src/host/usbh.c
@@ -208,6 +208,12 @@ bool usbh_control_xfer (uint8_t dev_addr, tusb_control_request_t* request, uint8
   return true;
 }
 
+bool usbh_edpt_xfer(uint8_t dev_addr, uint8_t ep_addr, uint8_t * buffer, uint16_t total_bytes)
+{
+  usbh_device_t* dev = &_usbh_devices[dev_addr];
+  return hcd_edpt_xfer(dev->rhport, dev_addr, ep_addr, buffer, total_bytes);
+}
+
 bool usbh_pipe_control_open(uint8_t dev_addr, uint8_t max_packet_size)
 {
   osal_semaphore_reset( _usbh_devices[dev_addr].control.sem_hdl );
diff --git a/src/host/usbh.h b/src/host/usbh.h
index 1774666f1..10e0c21be 100644
--- a/src/host/usbh.h
+++ b/src/host/usbh.h
@@ -105,6 +105,8 @@ TU_ATTR_WEAK void tuh_umount_cb(uint8_t dev_addr);
 bool usbh_control_xfer (uint8_t dev_addr, tusb_control_request_t* request, uint8_t* data);
 bool usbh_edpt_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_endpoint_t const * ep_desc);
 
+bool usbh_edpt_xfer(uint8_t dev_addr, uint8_t ep_addr, uint8_t * buffer, uint16_t total_bytes);
+
 #ifdef __cplusplus
  }
 #endif
-- 
cgit v1.3.1


From b3e81673c0582a07a764981604a560ee3d310ef9 Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Sun, 6 Sep 2020 12:11:07 +0700
Subject: change xfer_cb return type from void to bool

---
 src/class/cdc/cdc_host.c | 3 ++-
 src/class/cdc/cdc_host.h | 2 +-
 src/class/hid/hid_host.c | 8 +++++---
 src/class/hid/hid_host.h | 2 +-
 src/class/msc/msc_host.c | 6 +++++-
 src/class/msc/msc_host.h | 2 +-
 src/host/hub.c           | 4 +++-
 src/host/hub.h           | 2 +-
 src/host/usbh.c          | 4 ++--
 src/host/usbh.h          | 7 +++++--
 10 files changed, 26 insertions(+), 14 deletions(-)

(limited to 'src/class')

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 23e342134..ae1eef8a7 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -209,10 +209,11 @@ bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
   return true;
 }
 
-void cdch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
+bool cdch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
 {
   (void) ep_addr;
   tuh_cdc_xfer_isr( dev_addr, event, 0, xferred_bytes );
+  return true;
 }
 
 void cdch_close(uint8_t dev_addr)
diff --git a/src/class/cdc/cdc_host.h b/src/class/cdc/cdc_host.h
index 0e2820fef..f28a0a713 100644
--- a/src/class/cdc/cdc_host.h
+++ b/src/class/cdc/cdc_host.h
@@ -113,7 +113,7 @@ void tuh_cdc_xfer_isr(uint8_t dev_addr, xfer_result_t event, cdc_pipeid_t pipe_i
 //--------------------------------------------------------------------+
 void cdch_init(void);
 bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length);
-void cdch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
+bool cdch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
 void cdch_close(uint8_t dev_addr);
 
 #ifdef __cplusplus
diff --git a/src/class/hid/hid_host.c b/src/class/hid/hid_host.c
index 5ea8cc7e9..6002ead3c 100644
--- a/src/class/hid/hid_host.c
+++ b/src/class/hid/hid_host.c
@@ -233,7 +233,7 @@ bool hidh_open_subtask(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t c
   return true;
 }
 
-void hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
+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
 
@@ -241,7 +241,7 @@ void hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
   if ( ep_addr == keyboardh_data[dev_addr-1].ep_in )
   {
     tuh_hid_keyboard_isr(dev_addr, event);
-    return;
+    return true;
   }
 #endif
 
@@ -249,13 +249,15 @@ void hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
   if ( ep_addr == mouseh_data[dev_addr-1].ep_in )
   {
     tuh_hid_mouse_isr(dev_addr, event);
-    return;
+    return true;
   }
 #endif
 
 #if CFG_TUSB_HOST_HID_GENERIC
 
 #endif
+
+  return true;
 }
 
 void hidh_close(uint8_t dev_addr)
diff --git a/src/class/hid/hid_host.h b/src/class/hid/hid_host.h
index 54542de55..324dad203 100644
--- a/src/class/hid/hid_host.h
+++ b/src/class/hid/hid_host.h
@@ -197,7 +197,7 @@ void tuh_hid_generic_isr(uint8_t dev_addr, xfer_result_t event);
 //--------------------------------------------------------------------+
 void hidh_init(void);
 bool hidh_open_subtask(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length);
-void hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
+bool hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
 void hidh_close(uint8_t dev_addr);
 
 #ifdef __cplusplus
diff --git a/src/class/msc/msc_host.c b/src/class/msc/msc_host.c
index b129d538f..f47bbd163 100644
--- a/src/class/msc/msc_host.c
+++ b/src/class/msc/msc_host.c
@@ -336,6 +336,7 @@ bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
 
   enum { SCSI_XFER_TIMEOUT = 2000 };
   //------------- SCSI Inquiry -------------//
+  TU_LOG2("SCSI Inquiry\r\n");
   tusbh_msc_inquiry(dev_addr, 0, msch_buffer);
   TU_ASSERT( osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT) );
 
@@ -343,6 +344,7 @@ bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
   memcpy(p_msc->product_id, ((scsi_inquiry_resp_t*) msch_buffer)->product_id, 16);
 
   //------------- SCSI Read Capacity 10 -------------//
+  TU_LOG2("SCSI Read Capacity 10\r\n");
   tusbh_msc_read_capacity10(dev_addr, 0, msch_buffer);
   TU_ASSERT( osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT));
 
@@ -383,7 +385,7 @@ bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
   return true;
 }
 
-void msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
+bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
 {
   msch_interface_t* p_msc = &msch_data[dev_addr-1];
   if ( ep_addr == p_msc->ep_in )
@@ -396,6 +398,8 @@ void msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
       osal_semaphore_post(msch_sem_hdl, true);
     }
   }
+
+  return true;
 }
 
 void msch_close(uint8_t dev_addr)
diff --git a/src/class/msc/msc_host.h b/src/class/msc/msc_host.h
index 3eb45e6fc..a32134215 100644
--- a/src/class/msc/msc_host.h
+++ b/src/class/msc/msc_host.h
@@ -193,7 +193,7 @@ typedef struct
 
 void msch_init(void);
 bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length);
-void msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
+bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
 void msch_close(uint8_t dev_addr);
 
 #ifdef __cplusplus
diff --git a/src/host/hub.c b/src/host/hub.c
index abec20d06..ed96713e2 100644
--- a/src/host/hub.c
+++ b/src/host/hub.c
@@ -175,7 +175,7 @@ bool hub_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf
 
 // is the response of interrupt endpoint polling
 #include "usbh_hcd.h" // FIXME remove
-void hub_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
+bool hub_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
 {
   (void) xferred_bytes; // TODO can be more than 1 for hub with lots of ports
   (void) ep_addr;
@@ -227,6 +227,8 @@ void hub_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32
     // TODO [HUB] check if hub is still plugged before polling status endpoint since failed usually mean hub unplugged
 //    TU_ASSERT ( hub_status_pipe_queue(dev_addr) );
   }
+
+  return true;
 }
 
 void hub_close(uint8_t dev_addr)
diff --git a/src/host/hub.h b/src/host/hub.h
index 71dd39b8d..f00f13de7 100644
--- a/src/host/hub.h
+++ b/src/host/hub.h
@@ -182,7 +182,7 @@ bool hub_status_pipe_queue(uint8_t dev_addr);
 //--------------------------------------------------------------------+
 void hub_init(void);
 bool hub_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length);
-void hub_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
+bool hub_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
 void hub_close(uint8_t dev_addr);
 
 #ifdef __cplusplus
diff --git a/src/host/usbh.c b/src/host/usbh.c
index da35340ce..a7f6397cd 100644
--- a/src/host/usbh.c
+++ b/src/host/usbh.c
@@ -48,7 +48,7 @@
   #define DRIVER_NAME(_name)
 #endif
 
-static host_class_driver_t const usbh_class_drivers[] =
+static usbh_class_driver_t const usbh_class_drivers[] =
 {
   #if CFG_TUH_CDC
     {
@@ -442,7 +442,7 @@ bool enum_task(hcd_event_t* event)
   dev0->state    = TUSB_DEVICE_STATE_UNPLUG;
 
   //------------- connected/disconnected directly with roothub -------------//
-  if ( dev0->hub_addr == 0)
+  if (dev0->hub_addr == 0)
   {
     // wait until device is stable. Increase this if the first 8 bytes is failed to get
     osal_task_delay(POWER_STABLE_DELAY);
diff --git a/src/host/usbh.h b/src/host/usbh.h
index 10e0c21be..91afb90a3 100644
--- a/src/host/usbh.h
+++ b/src/host/usbh.h
@@ -60,9 +60,9 @@ typedef struct {
 
   void (* const init) (void);
   bool (* const open)(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const * itf_desc, uint16_t* outlen);
-  void (* const xfer_cb) (uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t len);
+  bool (* const xfer_cb) (uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
   void (* const close) (uint8_t);
-} host_class_driver_t;
+} usbh_class_driver_t;
 //--------------------------------------------------------------------+
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
@@ -107,6 +107,9 @@ bool usbh_edpt_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_endpoint_t const
 
 bool usbh_edpt_xfer(uint8_t dev_addr, uint8_t ep_addr, uint8_t * buffer, uint16_t total_bytes);
 
+
+bool tuh_control_xfer (uint8_t dev_addr, tusb_control_request_t const* request, uint8_t* buffer, uint16_t buflen);
+
 #ifdef __cplusplus
  }
 #endif
-- 
cgit v1.3.1


From 66a10ec9c8042a48053b4af67a932f3cfe9470c2 Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Mon, 7 Sep 2020 15:19:20 +0700
Subject: rework usbh control transfer

use series of complete callback instead of blocking semaphore, which is
more noOS friendly. still working with hid host
---
 examples/host/cdc_msc_hid/Makefile                 |   3 +-
 .../host/cdc_msc_hid/ses/lpc18xx/lpc18xx.emProject |   1 +
 src/class/hid/hid_host.c                           |  22 +-
 src/common/tusb_types.h                            |   4 +-
 src/host/usbh.c                                    | 299 ++++++++++++++++++---
 src/host/usbh.h                                    |   9 +-
 src/host/usbh_control.c                            | 135 ++++++++++
 src/host/usbh_hcd.h                                |  11 +-
 8 files changed, 435 insertions(+), 49 deletions(-)
 create mode 100644 src/host/usbh_control.c

(limited to 'src/class')

diff --git a/examples/host/cdc_msc_hid/Makefile b/examples/host/cdc_msc_hid/Makefile
index 35de0a9a0..b49c4c75c 100644
--- a/examples/host/cdc_msc_hid/Makefile
+++ b/examples/host/cdc_msc_hid/Makefile
@@ -16,8 +16,9 @@ SRC_C += \
 	src/class/cdc/cdc_host.c \
 	src/class/hid/hid_host.c \
 	src/class/msc/msc_host.c \
-	src/host/usbh.c \
 	src/host/hub.c \
+	src/host/usbh.c \
+	src/host/usbh_control.c \
 	src/host/ehci/ehci.c \
 	src/host/ohci/ohci.c \
 	src/portable/nxp/lpc18_43/hcd_lpc18_43.c \
diff --git a/examples/host/cdc_msc_hid/ses/lpc18xx/lpc18xx.emProject b/examples/host/cdc_msc_hid/ses/lpc18xx/lpc18xx.emProject
index 2b5538957..271076b5c 100644
--- a/examples/host/cdc_msc_hid/ses/lpc18xx/lpc18xx.emProject
+++ b/examples/host/cdc_msc_hid/ses/lpc18xx/lpc18xx.emProject
@@ -23,6 +23,7 @@
       debug_target_connection="J-Link"
       gcc_entry_point="Reset_Handler"
       linker_memory_map_file="$(ProjectDir)/LPC1857_MemoryMap.xml"
+      linker_printf_width_precision_supported="Yes"
       linker_section_placement_file="$(ProjectDir)/flash_placement.xml"
       macros="DeviceFamily=LPC1800;DeviceSubFamily=LPC185x;Target=LPC1857;Placement=Flash;rootDir=../../../../..;lpcDir=../../../../../hw/mcu/nxp/lpcopen/lpc18xx/lpc_chip_18xx"
       package_dependencies="LPC1800"
diff --git a/src/class/hid/hid_host.c b/src/class/hid/hid_host.c
index 6002ead3c..5058191f4 100644
--- a/src/class/hid/hid_host.c
+++ b/src/class/hid/hid_host.c
@@ -175,14 +175,22 @@ bool hidh_open_subtask(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t c
 
   // SET IDLE = 0 request
   // Device can stall if not support this request
-  tusb_control_request_t request = {
-        .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_INTERFACE, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_OUT },
-        .bRequest = HID_REQ_CONTROL_SET_IDLE,
-        .wValue = 0, // idle_rate = 0
-        .wIndex = p_interface_desc->bInterfaceNumber,
-        .wLength = 0
+  tusb_control_request_t const request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_INTERFACE,
+      .type      = TUSB_REQ_TYPE_CLASS,
+      .direction = TUSB_DIR_OUT
+    },
+    .bRequest = HID_REQ_CONTROL_SET_IDLE,
+    .wValue   = 0, // idle_rate = 0
+    .wIndex   = p_interface_desc->bInterfaceNumber,
+    .wLength  = 0
   };
-  usbh_control_xfer( dev_addr, &request, NULL ); // TODO stall is valid
+
+  // stall is a valid response for SET_IDLE, therefore we could ignore result of this request
+  tuh_control_xfer(dev_addr, &request, NULL, NULL);
 
 #if 0
   //------------- Get Report Descriptor TODO HID parser -------------//
diff --git a/src/common/tusb_types.h b/src/common/tusb_types.h
index 70d0db942..d6b6ea627 100644
--- a/src/common/tusb_types.h
+++ b/src/common/tusb_types.h
@@ -276,6 +276,8 @@ typedef struct TU_ATTR_PACKED
   uint8_t  bNumConfigurations ; ///< Number of possible configurations.
 } tusb_desc_device_t;
 
+TU_VERIFY_STATIC( sizeof(tusb_desc_device_t) == 18, "size is not correct");
+
 // USB Binary Device Object Store (BOS) Descriptor
 typedef struct TU_ATTR_PACKED
 {
@@ -431,7 +433,7 @@ typedef struct TU_ATTR_PACKED{
   uint16_t wLength;
 } tusb_control_request_t;
 
-TU_VERIFY_STATIC( sizeof(tusb_control_request_t) == 8, "mostly compiler option issue");
+TU_VERIFY_STATIC( sizeof(tusb_control_request_t) == 8, "size is not correct");
 
 // TODO move to somewhere suitable
 static inline uint8_t bm_request_type(uint8_t direction, uint8_t type, uint8_t recipient)
diff --git a/src/host/usbh.c b/src/host/usbh.c
index a7f6397cd..592eac267 100644
--- a/src/host/usbh.c
+++ b/src/host/usbh.c
@@ -108,6 +108,11 @@ static usbh_class_driver_t const usbh_class_drivers[] =
 
 enum { USBH_CLASS_DRIVER_COUNT = TU_ARRAY_SIZE(usbh_class_drivers) };
 
+enum { RESET_DELAY = 500 };  // 200 USB specs say only 50ms but many devices require much longer
+
+enum { CONFIG_NUM = 1 }; // default to use configuration 1
+
+
 //--------------------------------------------------------------------+
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
@@ -125,6 +130,9 @@ CFG_TUSB_MEM_SECTION TU_ATTR_ALIGNED(4) static uint8_t _usbh_ctrl_buf[CFG_TUSB_H
 //------------- Helper Function Prototypes -------------//
 static inline uint8_t get_new_address(void);
 
+// from usbh_control.c
+extern bool usbh_control_xfer_cb (uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
+
 //--------------------------------------------------------------------+
 // PUBLIC API (Parameter Verification is required)
 //--------------------------------------------------------------------+
@@ -281,23 +289,21 @@ void hcd_event_xfer_complete(uint8_t dev_addr, uint8_t ep_addr, uint32_t xferred
 //    usbh_devices[ pipe_hdl.dev_addr ].control.xferred_bytes = xferred_bytes; not yet neccessary
     osal_semaphore_post( dev->control.sem_hdl, true ); // FIXME post within ISR
   }
-  else
+
+  hcd_event_t event =
   {
-    hcd_event_t event =
+    .rhport   = 0, // TODO correct rhport
+    .event_id = HCD_EVENT_XFER_COMPLETE,
+    .dev_addr = dev_addr,
+    .xfer_complete =
     {
-      .rhport = 0,
-      .event_id = HCD_EVENT_XFER_COMPLETE,
-      .dev_addr = dev_addr,
-      .xfer_complete =
-      {
-        .ep_addr = ep_addr,
-        .result = result,
-        .len = xferred_bytes
-      }
-    };
+      .ep_addr = ep_addr,
+      .result  = result,
+      .len     = xferred_bytes
+    }
+  };
 
-    hcd_event_handler(&event, in_isr);
-  }
+  hcd_event_handler(&event, in_isr);
 }
 
 void hcd_event_device_attach(uint8_t rhport, bool in_isr)
@@ -373,8 +379,6 @@ static bool parse_configuration_descriptor(uint8_t dev_addr, tusb_desc_configura
   uint8_t const* p_desc = (uint8_t const*) desc_cfg;
   p_desc = tu_desc_next(p_desc);
 
-  TU_LOG2_MEM(desc_cfg, desc_cfg->wTotalLength, 0);
-
   // parse each interfaces
   while( p_desc < _usbh_ctrl_buf + desc_cfg->wTotalLength )
   {
@@ -426,16 +430,226 @@ static bool parse_configuration_descriptor(uint8_t dev_addr, tusb_desc_configura
   return true;
 }
 
-bool enum_task(hcd_event_t* event)
+static bool enum_set_config_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
+{
+  TU_LOG2_LOCATION();
+  TU_ASSERT(XFER_RESULT_SUCCESS == result);
+
+  TU_LOG2("Device configured\r\n");
+  usbh_device_t* dev = &_usbh_devices[dev_addr];
+  dev->state = TUSB_DEVICE_STATE_CONFIGURED;
+
+  // Parse configuration & set up drivers
+  parse_configuration_descriptor(dev_addr, (tusb_desc_configuration_t*) _usbh_ctrl_buf);
+
+  return true;
+}
+
+static bool enum_get_config_desc_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
 {
-  enum {
-    POWER_STABLE_DELAY = 100,
-    RESET_DELAY        = 500, // 200 USB specs say only 50ms but many devices require much longer
+  TU_ASSERT(XFER_RESULT_SUCCESS == result);
+
+  TU_LOG2("Set Configuration Descriptor\r\n");
+  tusb_control_request_t const new_request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_DEVICE,
+      .type      = TUSB_REQ_TYPE_STANDARD,
+      .direction = TUSB_DIR_OUT
+    },
+    .bRequest = TUSB_REQ_SET_CONFIGURATION,
+    .wValue   = CONFIG_NUM,
+    .wIndex   = 0,
+    .wLength  = 0
   };
 
+  TU_ASSERT( tuh_control_xfer(dev_addr, &new_request, NULL, enum_set_config_complete) );
+
+  return true;
+}
+
+static bool enum_get_9byte_config_desc_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
+{
+  TU_ASSERT(XFER_RESULT_SUCCESS == result);
+
+  // TODO not enough buffer to hold configuration descriptor
+  tusb_desc_configuration_t const * desc_config = (tusb_desc_configuration_t const*) _usbh_ctrl_buf;
+  uint16_t total_len;
+
+  // Use offsetof to avoid pointer to the odd/misaligned address
+  memcpy(&total_len, (uint8_t*) desc_config + offsetof(tusb_desc_configuration_t, wTotalLength), 2);
+
+  TU_ASSERT(total_len <= CFG_TUSB_HOST_ENUM_BUFFER_SIZE);
+
+  //Get full configuration descriptor
+  tusb_control_request_t const new_request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_DEVICE,
+      .type      = TUSB_REQ_TYPE_STANDARD,
+      .direction = TUSB_DIR_IN
+    },
+    .bRequest = TUSB_REQ_GET_DESCRIPTOR,
+    .wValue   = (TUSB_DESC_CONFIGURATION << 8) | (CONFIG_NUM - 1),
+    .wIndex   = 0,
+    .wLength  = total_len
+  };
+
+  TU_ASSERT( tuh_control_xfer(dev_addr, &new_request, _usbh_ctrl_buf, enum_get_config_desc_complete) );
+
+  return true;
+}
+
+static bool enum_get_device_desc_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
+{
+  TU_ASSERT(XFER_RESULT_SUCCESS == result);
+
+  tusb_desc_device_t const * desc_device = (tusb_desc_device_t const*) _usbh_ctrl_buf;
+  usbh_device_t* dev = &_usbh_devices[dev_addr];
+
+  dev->vendor_id  = desc_device->idVendor;
+  dev->product_id = desc_device->idProduct;
+
+//  if (tuh_attach_cb) tuh_attach_cb((tusb_desc_device_t*) _usbh_ctrl_buf);
+
+  TU_LOG2("Get 9 bytes of Configuration Descriptor\r\n");
+  tusb_control_request_t const new_request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_DEVICE,
+      .type      = TUSB_REQ_TYPE_STANDARD,
+      .direction = TUSB_DIR_IN
+    },
+    .bRequest = TUSB_REQ_GET_DESCRIPTOR,
+    .wValue   = (TUSB_DESC_CONFIGURATION << 8) | (CONFIG_NUM - 1),
+    .wIndex   = 0,
+    .wLength  = 9
+  };
+
+  TU_ASSERT( tuh_control_xfer(dev_addr, &new_request, _usbh_ctrl_buf, enum_get_9byte_config_desc_complete) );
+
+  return true;
+}
+
+// After SET_ADDRESS is complete
+static bool enum_set_address_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
+{
+  TU_ASSERT(0 == dev_addr);
+  TU_ASSERT(XFER_RESULT_SUCCESS == result);
+
+  uint8_t const new_addr = (uint8_t const) request->wValue;
+
+  usbh_device_t* new_dev = &_usbh_devices[new_addr];
+  new_dev->addressed = 1;
+
+  // TODO close device 0, may not be needed
   usbh_device_t* dev0 = &_usbh_devices[0];
-  tusb_control_request_t request;
+  hcd_device_close(dev0->rhport, 0);
+  dev0->state = TUSB_DEVICE_STATE_UNPLUG;
+
+  // open control pipe for new address
+  TU_ASSERT ( usbh_pipe_control_open(new_addr, new_dev->ep0_packet_size) );
+
+  // Get full device descriptor
+  tusb_control_request_t const new_request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_DEVICE,
+      .type      = TUSB_REQ_TYPE_STANDARD,
+      .direction = TUSB_DIR_IN
+    },
+    .bRequest = TUSB_REQ_GET_DESCRIPTOR,
+    .wValue   = TUSB_DESC_DEVICE << 8,
+    .wIndex   = 0,
+    .wLength  = sizeof(tusb_desc_device_t)
+  };
 
+  TU_ASSERT(tuh_control_xfer(new_addr, &new_request, _usbh_ctrl_buf, enum_get_device_desc_complete));
+
+  return true;
+}
+
+// After Get Device Descriptor of Address 0
+static bool enum_get_dev0_devic_desc_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
+{
+  TU_ASSERT(0 == dev_addr);
+
+  usbh_device_t* dev0 = &_usbh_devices[0];
+
+  if (XFER_RESULT_SUCCESS != result)
+  {
+#if CFG_TUH_HUB
+    // TODO remove, waiting for next data on status pipe
+    if (dev0->hub_addr != 0) hub_status_pipe_queue( dev0->hub_addr);
+#endif
+
+    return false;
+  }
+
+  // Reset device again before Set Address
+  TU_LOG2("Port reset \r\n");
+
+  if (dev0->hub_addr == 0)
+  {
+    // connected directly to roothub
+    hcd_port_reset( dev0->rhport ); // reset port after 8 byte descriptor
+    osal_task_delay(RESET_DELAY);
+  }
+#if CFG_TUH_HUB
+  else
+  {
+    // FIXME hub_port_reset use usbh_control_xfer
+    if ( hub_port_reset(dev0->hub_addr, dev0->hub_port) )
+    {
+      osal_task_delay(RESET_DELAY);
+
+      // Acknowledge Port Reset Change if Reset Successful
+      hub_port_clear_feature(dev0->hub_addr, dev0->hub_port, HUB_FEATURE_PORT_RESET_CHANGE);
+    }
+
+    (void) hub_status_pipe_queue( dev0->hub_addr ); // done with hub, waiting for next data on status pipe
+  }
+#endif // CFG_TUH_HUB
+
+  // Set Address
+  TU_LOG2("Set Address \r\n");
+  uint8_t const new_addr = get_new_address();
+  TU_ASSERT(new_addr <= CFG_TUSB_HOST_DEVICE_MAX); // TODO notify application we reach max devices
+
+  usbh_device_t* new_dev = &_usbh_devices[new_addr];
+  new_dev->rhport  = dev0->rhport;
+  new_dev->hub_addr = dev0->hub_addr;
+  new_dev->hub_port = dev0->hub_port;
+  new_dev->speed    = dev0->speed;
+  new_dev->connected = 1;
+  new_dev->ep0_packet_size = ((tusb_desc_device_t*) _usbh_ctrl_buf)->bMaxPacketSize0;
+
+  tusb_control_request_t const new_request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_DEVICE,
+      .type      = TUSB_REQ_TYPE_STANDARD,
+      .direction = TUSB_DIR_OUT
+    },
+    .bRequest = TUSB_REQ_SET_ADDRESS,
+    .wValue   = new_addr,
+    .wIndex   = 0,
+    .wLength  = 0
+  };
+
+  TU_ASSERT(tuh_control_xfer(0, &new_request, NULL, enum_set_address_complete));
+
+  return true;
+}
+
+bool enum_task(hcd_event_t* event)
+{
+  usbh_device_t* dev0 = &_usbh_devices[0];
   dev0->rhport   = event->rhport; // TODO refractor integrate to device_pool
   dev0->hub_addr = event->connection.hub_addr;
   dev0->hub_port = event->connection.hub_port;
@@ -445,14 +659,11 @@ bool enum_task(hcd_event_t* event)
   if (dev0->hub_addr == 0)
   {
     // wait until device is stable. Increase this if the first 8 bytes is failed to get
-    osal_task_delay(POWER_STABLE_DELAY);
+    osal_task_delay(RESET_DELAY);
 
     // device unplugged while delaying
     if ( !hcd_port_connect_status(dev0->rhport) ) return true;
 
-    hcd_port_reset( dev0->rhport ); // port must be reset to have correct speed operation
-    osal_task_delay(RESET_DELAY);
-
     dev0->speed = hcd_port_speed_get( dev0->rhport );
   }
 #if CFG_TUH_HUB
@@ -460,8 +671,9 @@ bool enum_task(hcd_event_t* event)
   else
   {
     // TODO wait for PORT reset change instead
-    osal_task_delay(POWER_STABLE_DELAY);
+    osal_task_delay(RESET_DELAY);
 
+    // FIXME hub API use usbh_control_xfer
     hub_port_status_response_t port_status;
     TU_VERIFY_HDLR( hub_port_get_status(dev0->hub_addr, dev0->hub_port, &port_status), hub_status_pipe_queue( dev0->hub_addr) );
 
@@ -479,19 +691,27 @@ bool enum_task(hcd_event_t* event)
   }
 #endif // CFG_TUH_HUB
 
+  // TODO probably doesn't need to open/close each enumeration
   TU_ASSERT( usbh_pipe_control_open(0, 8) );
 
   //------------- Get first 8 bytes of device descriptor to get Control Endpoint Size -------------//
   TU_LOG2("Get 8 byte of Device Descriptor\r\n");
-  request = (tusb_control_request_t ) {
-        .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_DEVICE, .type = TUSB_REQ_TYPE_STANDARD, .direction = TUSB_DIR_IN },
-        .bRequest = TUSB_REQ_GET_DESCRIPTOR,
-        .wValue = TUSB_DESC_DEVICE << 8,
-        .wIndex = 0,
-        .wLength = 8
+  tusb_control_request_t const request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_DEVICE,
+      .type      = TUSB_REQ_TYPE_STANDARD,
+      .direction = TUSB_DIR_IN
+    },
+    .bRequest = TUSB_REQ_GET_DESCRIPTOR,
+    .wValue   = TUSB_DESC_DEVICE << 8,
+    .wIndex   = 0,
+    .wLength  = 8
   };
-  bool is_ok = usbh_control_xfer(0, &request, _usbh_ctrl_buf);
+  TU_ASSERT(tuh_control_xfer(0, &request, _usbh_ctrl_buf, enum_get_dev0_devic_desc_complete));
 
+#if 0
   //------------- Reset device again before Set Address -------------//
   TU_LOG2("Port reset \r\n");
 
@@ -526,6 +746,14 @@ bool enum_task(hcd_event_t* event)
   uint8_t const new_addr = get_new_address();
   TU_ASSERT(new_addr <= CFG_TUSB_HOST_DEVICE_MAX); // TODO notify application we reach max devices
 
+  usbh_device_t* new_dev = &_usbh_devices[new_addr];
+  new_dev->rhport  = dev0->rhport;
+  new_dev->hub_addr = dev0->hub_addr;
+  new_dev->hub_port = dev0->hub_port;
+  new_dev->speed    = dev0->speed;
+  new_dev->connected = 1;
+  new_dev->ep0_packet_size = ((tusb_desc_device_t*) _usbh_ctrl_buf)->bMaxPacketSize0;
+
   request = (tusb_control_request_t ) {
         .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_DEVICE, .type = TUSB_REQ_TYPE_STANDARD, .direction = TUSB_DIR_OUT },
         .bRequest = TUSB_REQ_SET_ADDRESS,
@@ -533,7 +761,7 @@ bool enum_task(hcd_event_t* event)
         .wIndex = 0,
         .wLength = 0
   };
-  TU_ASSERT(usbh_control_xfer(0, &request, NULL));
+  TU_ASSERT(tuh_control_xfer(0, &request, NULL, enum_set_address_complete));
 
   //------------- update port info & close control pipe of addr0 -------------//
   usbh_device_t* new_dev = &_usbh_devices[new_addr];
@@ -613,6 +841,7 @@ bool enum_task(hcd_event_t* event)
 
   // Invoke callback if available
   if (tuh_mount_cb) tuh_mount_cb(new_addr);
+#endif
 
   return true;
 }
@@ -679,7 +908,7 @@ void tuh_task(void)
 
         if ( 0 == epnum )
         {
-          // TODO control transfer
+          usbh_control_xfer_cb(event.dev_addr, ep_addr, event.xfer_complete.result, event.xfer_complete.len);
         }else
         {
           uint8_t drv_id = dev->ep2drv[epnum][ep_dir];
diff --git a/src/host/usbh.h b/src/host/usbh.h
index 91afb90a3..814770722 100644
--- a/src/host/usbh.h
+++ b/src/host/usbh.h
@@ -63,6 +63,8 @@ typedef struct {
   bool (* const xfer_cb) (uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
   void (* const close) (uint8_t);
 } usbh_class_driver_t;
+
+typedef bool (*tuh_control_complete_cb_t)(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result);
 //--------------------------------------------------------------------+
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
@@ -87,10 +89,12 @@ static inline bool tuh_device_is_configured(uint8_t dev_addr)
   return tuh_device_get_state(dev_addr) == TUSB_DEVICE_STATE_CONFIGURED;
 }
 
+bool tuh_control_xfer (uint8_t dev_addr, tusb_control_request_t const* request, void* buffer, tuh_control_complete_cb_t complete_cb);
+
 //--------------------------------------------------------------------+
 // APPLICATION CALLBACK
 //--------------------------------------------------------------------+
-TU_ATTR_WEAK uint8_t tuh_attach_cb (tusb_desc_device_t const *desc_device);
+//TU_ATTR_WEAK uint8_t tuh_attach_cb (tusb_desc_device_t const *desc_device);
 
 /** Callback invoked when device is mounted (configured) */
 TU_ATTR_WEAK void tuh_mount_cb (uint8_t dev_addr);
@@ -107,9 +111,6 @@ bool usbh_edpt_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_endpoint_t const
 
 bool usbh_edpt_xfer(uint8_t dev_addr, uint8_t ep_addr, uint8_t * buffer, uint16_t total_bytes);
 
-
-bool tuh_control_xfer (uint8_t dev_addr, tusb_control_request_t const* request, uint8_t* buffer, uint16_t buflen);
-
 #ifdef __cplusplus
  }
 #endif
diff --git a/src/host/usbh_control.c b/src/host/usbh_control.c
new file mode 100644
index 000000000..595c011f5
--- /dev/null
+++ b/src/host/usbh_control.c
@@ -0,0 +1,135 @@
+/* 
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2020, Ha Thach (tinyusb.org)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * This file is part of the TinyUSB stack.
+ */
+
+#include "tusb_option.h"
+
+#if TUSB_OPT_HOST_ENABLED
+
+#include "tusb.h"
+#include "usbh_hcd.h"
+
+enum
+{
+  STAGE_SETUP,
+  STAGE_DATA,
+  STAGE_ACK
+};
+
+typedef struct
+{
+  tusb_control_request_t request TU_ATTR_ALIGNED(4);
+
+  uint8_t stage;
+  uint8_t* buffer;
+  tuh_control_complete_cb_t complete_cb;
+} usbh_control_xfer_t;
+
+static usbh_control_xfer_t _ctrl_xfer;
+
+//CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN
+//static uint8_t _tuh_ctrl_buf[CFG_TUSB_HOST_ENUM_BUFFER_SIZE];
+
+//--------------------------------------------------------------------+
+// MACRO TYPEDEF CONSTANT ENUM DECLARATION
+//--------------------------------------------------------------------+
+
+bool tuh_control_xfer (uint8_t dev_addr, tusb_control_request_t const* request, void* buffer, tuh_control_complete_cb_t complete_cb)
+{
+  usbh_device_t* dev = &_usbh_devices[dev_addr];
+  const uint8_t rhport = dev->rhport;
+
+  _ctrl_xfer.request     = (*request);
+  _ctrl_xfer.buffer      = buffer;
+  _ctrl_xfer.stage       = STAGE_SETUP;
+  _ctrl_xfer.complete_cb = complete_cb;
+
+  TU_LOG2("Control Setup: ");
+  TU_LOG2_VAR(request);
+  TU_LOG2("\r\n");
+
+  // Send setup packet
+  TU_ASSERT( hcd_setup_send(rhport, dev_addr, (uint8_t const*) &_ctrl_xfer.request) );
+
+  return true;
+}
+
+static void _xfer_complete(uint8_t dev_addr, xfer_result_t result)
+{
+  if (_ctrl_xfer.complete_cb) _ctrl_xfer.complete_cb(dev_addr, &_ctrl_xfer.request, result);
+}
+
+bool usbh_control_xfer_cb (uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
+{
+  usbh_device_t* dev = &_usbh_devices[dev_addr];
+  const uint8_t rhport = dev->rhport;
+
+  tusb_control_request_t const * request = &_ctrl_xfer.request;
+
+  if (XFER_RESULT_SUCCESS != result)
+  {
+    TU_LOG2("Control failed: result = %d\r\n", result);
+
+    // terminate transfer if any stage failed
+    _xfer_complete(dev_addr, result);
+  }else
+  {
+    switch(_ctrl_xfer.stage)
+    {
+      case STAGE_SETUP:
+        _ctrl_xfer.stage = STAGE_DATA;
+        if (request->wLength)
+        {
+          // Note: initial data toggle is always 1
+          hcd_edpt_xfer(rhport, dev_addr, tu_edpt_addr(0, request->bmRequestType_bit.direction), _ctrl_xfer.buffer, request->wLength);
+          return true;
+        }
+      __attribute__((fallthrough));
+
+      case STAGE_DATA:
+        _ctrl_xfer.stage = STAGE_ACK;
+
+        if (request->wLength)
+        {
+          TU_LOG2("Control data:\r\n");
+          TU_LOG2_MEM(_ctrl_xfer.buffer, request->wLength, 2);
+        }
+
+        // data toggle is always 1
+        hcd_edpt_xfer(rhport, dev_addr, tu_edpt_addr(0, 1-request->bmRequestType_bit.direction), NULL, 0);
+      break;
+
+      case STAGE_ACK:
+        _xfer_complete(dev_addr, result);
+      break;
+
+      default: return false;
+    }
+  }
+
+  return true;
+}
+
+#endif
diff --git a/src/host/usbh_hcd.h b/src/host/usbh_hcd.h
index 435af96bb..f203f3baa 100644
--- a/src/host/usbh_hcd.h
+++ b/src/host/usbh_hcd.h
@@ -53,11 +53,20 @@ typedef struct {
   //------------- device descriptor -------------//
   uint16_t vendor_id;
   uint16_t product_id;
+  uint8_t  ep0_packet_size;
 
   //------------- configuration descriptor -------------//
-  uint8_t interface_count; // bNumInterfaces alias
+  // uint8_t interface_count; // bNumInterfaces alias
 
   //------------- device -------------//
+  struct TU_ATTR_PACKED
+  {
+    uint8_t connected    : 1;
+    uint8_t addressed    : 1;
+    uint8_t configured   : 1;
+    uint8_t suspended    : 1;
+  };
+
   volatile uint8_t state;             // device state, value from enum tusbh_device_state_t
 
   //------------- control pipe -------------//
-- 
cgit v1.3.1


From 9c07a2a4e23e4d82e3cbb28e92bf1234e4a6ce09 Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Tue, 13 Oct 2020 00:07:51 +0700
Subject: rework msc host

- msc host enum is now async
- implement async tuh_msc_scsi_command() / tuh_msc_request_sense() /
tuh_msc_test_unit_ready()
---
 examples/host/cdc_msc_hid/src/msc_app.c |  15 +-
 src/class/msc/msc_host.c                | 407 ++++++++++++++++++--------------
 src/class/msc/msc_host.h                |  75 ++----
 src/host/usbh_control.c                 |   1 -
 4 files changed, 252 insertions(+), 246 deletions(-)

(limited to 'src/class')

diff --git a/examples/host/cdc_msc_hid/src/msc_app.c b/examples/host/cdc_msc_hid/src/msc_app.c
index 62bd961c1..53f0e6ac2 100644
--- a/examples/host/cdc_msc_hid/src/msc_app.c
+++ b/examples/host/cdc_msc_hid/src/msc_app.c
@@ -38,6 +38,7 @@ void tuh_msc_mounted_cb(uint8_t dev_addr)
   printf("A MassStorage device is mounted\r\n");
 
   //------------- Disk Information -------------//
+#if 0
   // SCSI VendorID[8] & ProductID[16] from Inquiry Command
   uint8_t const* p_vendor  = tuh_msc_get_vendor_name(dev_addr);
   uint8_t const* p_product = tuh_msc_get_product_name(dev_addr);
@@ -47,6 +48,7 @@ void tuh_msc_mounted_cb(uint8_t dev_addr)
   putchar(' ');
   for(uint8_t i=0; i<16; i++) putchar(p_product[i]);
   putchar('\n');
+#endif
 
   uint32_t last_lba = 0;
   uint32_t block_size = 0;
@@ -103,12 +105,11 @@ void tuh_msc_unmounted_cb(uint8_t dev_addr)
 //  }
 }
 
-// invoked ISR context
-void tuh_msc_isr(uint8_t dev_addr, xfer_result_t event, uint32_t xferred_bytes)
-{
-  (void) dev_addr;
-  (void) event;
-  (void) xferred_bytes;
-}
+//void tuh_msc_scsi_complete_cb(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw)
+//{
+//  (void) dev_addr;
+//  (void) cbw;
+//  (void) csw;
+//}
 
 #endif
diff --git a/src/class/msc/msc_host.c b/src/class/msc/msc_host.c
index f47bbd163..e8bed989c 100644
--- a/src/class/msc/msc_host.c
+++ b/src/class/msc/msc_host.c
@@ -37,19 +37,41 @@
 //--------------------------------------------------------------------+
 // MACRO CONSTANT TYPEDEF
 //--------------------------------------------------------------------+
-CFG_TUSB_MEM_SECTION static msch_interface_t msch_data[CFG_TUSB_HOST_DEVICE_MAX];
+enum
+{
+  MSC_STAGE_IDLE = 0,
+  MSC_STAGE_CMD,
+  MSC_STAGE_DATA,
+  MSC_STAGE_STATUS,
+};
+
+typedef struct
+{
+  uint8_t  itf_num;
+  uint8_t  ep_in;
+  uint8_t  ep_out;
+
+  uint8_t  max_lun;
+
+  scsi_read_capacity10_resp_t capacity;
+
+  volatile bool is_initialized;
+  uint8_t vendor_id[8];
+  uint8_t product_id[16];
+
+  uint8_t stage;
+  void*   buffer;
+  tuh_msc_complete_cb_t complete_cb;
+
+  msc_cbw_t cbw;
+  msc_csw_t csw;
+}msch_interface_t;
 
-//------------- Initalization Data -------------//
-static osal_semaphore_def_t msch_sem_def;
-static osal_semaphore_t msch_sem_hdl;
+CFG_TUSB_MEM_SECTION static msch_interface_t msch_data[CFG_TUSB_HOST_DEVICE_MAX];
 
 // buffer used to read scsi information when mounted, largest response data currently is inquiry
 CFG_TUSB_MEM_SECTION TU_ATTR_ALIGNED(4) static uint8_t msch_buffer[sizeof(scsi_inquiry_resp_t)];
 
-//--------------------------------------------------------------------+
-// INTERNAL OBJECT & FUNCTION DECLARATION
-//--------------------------------------------------------------------+
-
 //--------------------------------------------------------------------+
 // PUBLIC API
 //--------------------------------------------------------------------+
@@ -65,25 +87,17 @@ bool tuh_msc_is_busy(uint8_t dev_addr)
           hcd_edpt_busy(dev_addr, msch_data[dev_addr-1].ep_in);
 }
 
-uint8_t const* tuh_msc_get_vendor_name(uint8_t dev_addr)
+bool tuh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint32_t* p_block_size)
 {
-  return msch_data[dev_addr-1].is_initialized ? msch_data[dev_addr-1].vendor_id : NULL;
-}
+  msch_interface_t* p_msc = &msch_data[dev_addr-1];
 
-uint8_t const* tuh_msc_get_product_name(uint8_t dev_addr)
-{
-  return msch_data[dev_addr-1].is_initialized ? msch_data[dev_addr-1].product_id : NULL;
-}
+  if ( !p_msc->is_initialized ) return false;
+  TU_ASSERT(p_last_lba != NULL && p_block_size != NULL);
 
-tusb_error_t tuh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint32_t* p_block_size)
-{
-  if ( !msch_data[dev_addr-1].is_initialized )   return TUSB_ERROR_MSCH_DEVICE_NOT_MOUNTED;
-  TU_ASSERT(p_last_lba != NULL && p_block_size != NULL, TUSB_ERROR_INVALID_PARA);
+  (*p_last_lba)   = p_msc->capacity.last_lba;
+  (*p_block_size) = p_msc->capacity.block_size;
 
-  (*p_last_lba)   = msch_data[dev_addr-1].last_lba;
-  (*p_block_size) = (uint32_t) msch_data[dev_addr-1].block_size;
-
-  return TUSB_ERROR_NONE;
+  return true;
 }
 
 //--------------------------------------------------------------------+
@@ -92,30 +106,27 @@ tusb_error_t tuh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint32
 static inline void msc_cbw_add_signature(msc_cbw_t *p_cbw, uint8_t lun)
 {
   p_cbw->signature  = MSC_CBW_SIGNATURE;
-  p_cbw->tag        = 0xCAFECAFE;
+  p_cbw->tag        = 0x54555342; // TUSB
   p_cbw->lun        = lun;
 }
 
-static tusb_error_t msch_command_xfer(uint8_t dev_addr, msch_interface_t * p_msch, void* p_buffer)
+bool tuh_msc_scsi_command(uint8_t dev_addr, msc_cbw_t const* cbw, void* data, tuh_msc_complete_cb_t complete_cb)
 {
-  if ( NULL != p_buffer)
-  { // there is data phase
-    if (p_msch->cbw.dir & TUSB_DIR_IN_MASK)
-    {
-      TU_ASSERT( hcd_pipe_xfer(dev_addr, p_msch->ep_out, (uint8_t*) &p_msch->cbw, sizeof(msc_cbw_t), false), TUSB_ERROR_FAILED );
-      TU_ASSERT( hcd_pipe_queue_xfer(dev_addr, p_msch->ep_in , p_buffer, p_msch->cbw.total_bytes), TUSB_ERROR_FAILED );
-    }else
-    {
-      TU_ASSERT( hcd_pipe_queue_xfer(dev_addr, p_msch->ep_out, (uint8_t*) &p_msch->cbw, sizeof(msc_cbw_t)), TUSB_ERROR_FAILED );
-      TU_ASSERT( hcd_pipe_xfer(dev_addr, p_msch->ep_out , p_buffer, p_msch->cbw.total_bytes, false), TUSB_ERROR_FAILED );
-    }
-  }
+  msch_interface_t* p_msc = &msch_data[dev_addr-1];
 
-  TU_ASSERT( hcd_pipe_xfer(dev_addr, p_msch->ep_in , (uint8_t*) &p_msch->csw, sizeof(msc_csw_t), true), TUSB_ERROR_FAILED);
+  // TODO claim endpoint
 
-  return TUSB_ERROR_NONE;
+  p_msc->cbw = *cbw;
+  p_msc->stage = MSC_STAGE_CMD;
+  p_msc->buffer = data;
+  p_msc->complete_cb = complete_cb;
+
+  TU_ASSERT(usbh_edpt_xfer(dev_addr, p_msc->ep_out, (uint8_t*) &p_msc->cbw, sizeof(msc_cbw_t)));
+
+  return true;
 }
 
+#if 0
 tusb_error_t tusbh_msc_inquiry(uint8_t dev_addr, uint8_t lun, uint8_t *p_data)
 {
   msch_interface_t* p_msch = &msch_data[dev_addr-1];
@@ -127,7 +138,7 @@ tusb_error_t tusbh_msc_inquiry(uint8_t dev_addr, uint8_t lun, uint8_t *p_data)
   p_msch->cbw.cmd_len    = sizeof(scsi_inquiry_t);
 
   //------------- SCSI command -------------//
-  scsi_inquiry_t cmd_inquiry =
+  scsi_inquiry_t const cmd_inquiry =
   {
       .cmd_code     = SCSI_CMD_INQUIRY,
       .alloc_length = sizeof(scsi_inquiry_resp_t)
@@ -135,88 +146,51 @@ tusb_error_t tusbh_msc_inquiry(uint8_t dev_addr, uint8_t lun, uint8_t *p_data)
 
   memcpy(p_msch->cbw.command, &cmd_inquiry, p_msch->cbw.cmd_len);
 
-  TU_ASSERT_ERR ( msch_command_xfer(dev_addr, p_msch, p_data) );
-
-  return TUSB_ERROR_NONE;
-}
-
-tusb_error_t tusbh_msc_read_capacity10(uint8_t dev_addr, uint8_t lun, uint8_t *p_data)
-{
-  msch_interface_t* p_msch = &msch_data[dev_addr-1];
-
-  //------------- Command Block Wrapper -------------//
-  msc_cbw_add_signature(&p_msch->cbw, lun);
-  p_msch->cbw.total_bytes = sizeof(scsi_read_capacity10_resp_t);
-  p_msch->cbw.dir        = TUSB_DIR_IN_MASK;
-  p_msch->cbw.cmd_len    = sizeof(scsi_read_capacity10_t);
-
-  //------------- SCSI command -------------//
-  scsi_read_capacity10_t cmd_read_capacity10 =
-  {
-      .cmd_code                 = SCSI_CMD_READ_CAPACITY_10,
-      .lba                      = 0,
-      .partial_medium_indicator = 0
-  };
-
-  memcpy(p_msch->cbw.command, &cmd_read_capacity10, p_msch->cbw.cmd_len);
-
-  TU_ASSERT_ERR ( msch_command_xfer(dev_addr, p_msch, p_data) );
+  TU_ASSERT_ERR ( send_cbw(dev_addr, p_msch, p_data) );
 
   return TUSB_ERROR_NONE;
 }
+#endif
 
-tusb_error_t tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, uint8_t *p_data)
+bool tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun,  tuh_msc_complete_cb_t complete_cb)
 {
-  (void) lun; // TODO [MSCH] multiple lun support
-
-  msch_interface_t* p_msch = &msch_data[dev_addr-1];
-
-  //------------- Command Block Wrapper -------------//
-  p_msch->cbw.total_bytes = 18;
-  p_msch->cbw.dir        = TUSB_DIR_IN_MASK;
-  p_msch->cbw.cmd_len    = sizeof(scsi_request_sense_t);
+  msc_cbw_t cbw = { 0 };
+  msc_cbw_add_signature(&cbw, lun);
 
-  //------------- SCSI command -------------//
-  scsi_request_sense_t cmd_request_sense =
-  {
-      .cmd_code     = SCSI_CMD_REQUEST_SENSE,
-      .alloc_length = 18
-  };
+  cbw.total_bytes = 0; // Number of bytes
+  cbw.dir        = TUSB_DIR_OUT;
+  cbw.cmd_len    = sizeof(scsi_test_unit_ready_t);
+  cbw.command[0] = SCSI_CMD_TEST_UNIT_READY;
+  cbw.command[1] = lun; // according to wiki TODO need verification
 
-  memcpy(p_msch->cbw.command, &cmd_request_sense, p_msch->cbw.cmd_len);
+  TU_ASSERT(tuh_msc_scsi_command(dev_addr, &cbw, NULL, complete_cb));
 
-  TU_ASSERT_ERR ( msch_command_xfer(dev_addr, p_msch, p_data) );
-
-  return TUSB_ERROR_NONE;
+  return true;
 }
 
-tusb_error_t tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun,  msc_csw_t * p_csw)
+bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void *resposne, tuh_msc_complete_cb_t complete_cb)
 {
-  msch_interface_t* p_msch = &msch_data[dev_addr-1];
+  msc_cbw_t cbw = { 0 };
+  msc_cbw_add_signature(&cbw, lun);
 
-  //------------- Command Block Wrapper -------------//
-  msc_cbw_add_signature(&p_msch->cbw, lun);
-
-  p_msch->cbw.total_bytes = 0; // Number of bytes
-  p_msch->cbw.dir        = TUSB_DIR_OUT;
-  p_msch->cbw.cmd_len    = sizeof(scsi_test_unit_ready_t);
+  cbw.total_bytes = 18; // TODO sense response
+  cbw.dir        = TUSB_DIR_IN_MASK;
+  cbw.cmd_len    = sizeof(scsi_request_sense_t);
 
-  //------------- SCSI command -------------//
-  scsi_test_unit_ready_t cmd_test_unit_ready =
+  scsi_request_sense_t const cmd_request_sense =
   {
-      .cmd_code = SCSI_CMD_TEST_UNIT_READY,
-      .lun      = lun // according to wiki
+    .cmd_code     = SCSI_CMD_REQUEST_SENSE,
+    .alloc_length = 18
   };
 
-  memcpy(p_msch->cbw.command, &cmd_test_unit_ready, p_msch->cbw.cmd_len);
+  memcpy(cbw.command, &cmd_request_sense, cbw.cmd_len);
 
-  // TODO MSCH refractor test uinit ready
-  TU_ASSERT( hcd_pipe_xfer(dev_addr, p_msch->ep_out, (uint8_t*) &p_msch->cbw, sizeof(msc_cbw_t), false), TUSB_ERROR_FAILED );
-  TU_ASSERT( hcd_pipe_xfer(dev_addr, p_msch->ep_in , (uint8_t*) p_csw, sizeof(msc_csw_t), true), TUSB_ERROR_FAILED );
+  TU_ASSERT(tuh_msc_scsi_command(dev_addr, &cbw, resposne, complete_cb));
 
-  return TUSB_ERROR_NONE;
+  return true;
 }
 
+#if 0
 tusb_error_t  tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void * p_buffer, uint32_t lba, uint16_t block_count)
 {
   msch_interface_t* p_msch = &msch_data[dev_addr-1];
@@ -229,7 +203,7 @@ tusb_error_t  tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void * p_buffer, uin
   p_msch->cbw.cmd_len    = sizeof(scsi_read10_t);
 
   //------------- SCSI command -------------//
-  scsi_read10_t cmd_read10 =
+  scsi_read10_t cmd_read10 =msch_sem_hdl
   {
       .cmd_code    = SCSI_CMD_READ_10,
       .lba         = tu_htonl(lba),
@@ -238,7 +212,7 @@ tusb_error_t  tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void * p_buffer, uin
 
   memcpy(p_msch->cbw.command, &cmd_read10, p_msch->cbw.cmd_len);
 
-  TU_ASSERT_ERR ( msch_command_xfer(dev_addr, p_msch, p_buffer));
+  TU_ASSERT_ERR ( send_cbw(dev_addr, p_msch, p_buffer));
 
   return TUSB_ERROR_NONE;
 }
@@ -264,10 +238,11 @@ tusb_error_t tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffe
 
   memcpy(p_msch->cbw.command, &cmd_write10, p_msch->cbw.cmd_len);
 
-  TU_ASSERT_ERR ( msch_command_xfer(dev_addr, p_msch, (void*) p_buffer));
+  TU_ASSERT_ERR ( send_cbw(dev_addr, p_msch, (void*) p_buffer));
 
   return TUSB_ERROR_NONE;
 }
+#endif
 
 //--------------------------------------------------------------------+
 // CLASS-USBH API (don't require to verify parameters)
@@ -275,9 +250,75 @@ tusb_error_t tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffe
 void msch_init(void)
 {
   tu_memclr(msch_data, sizeof(msch_interface_t)*CFG_TUSB_HOST_DEVICE_MAX);
-  msch_sem_hdl = osal_semaphore_create(&msch_sem_def);
 }
 
+
+void msch_close(uint8_t dev_addr)
+{
+  tu_memclr(&msch_data[dev_addr-1], sizeof(msch_interface_t));
+  tuh_msc_unmounted_cb(dev_addr); // invoke Application Callback
+}
+
+static bool get_csw(uint8_t dev_addr, msch_interface_t * p_msc)
+{
+  p_msc->stage = MSC_STAGE_STATUS;
+  TU_ASSERT(usbh_edpt_xfer(dev_addr, p_msc->ep_in, (uint8_t*) &p_msc->csw, sizeof(msc_csw_t)));
+  return true;
+}
+
+bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
+{
+  msch_interface_t* p_msc = &msch_data[dev_addr-1];
+  msc_cbw_t const * cbw = &p_msc->cbw;
+  msc_csw_t       * csw = &p_msc->csw;
+
+  switch (p_msc->stage)
+  {
+    case MSC_STAGE_CMD:
+      // Must be Command Block
+      TU_ASSERT(ep_addr == p_msc->ep_out &&  event == XFER_RESULT_SUCCESS && xferred_bytes == sizeof(msc_cbw_t));
+
+      if ( cbw->total_bytes && p_msc->buffer )
+      {
+        // Data stage if any
+        p_msc->stage = MSC_STAGE_DATA;
+
+        uint8_t const ep_data = (cbw->dir & TUSB_DIR_IN_MASK) ? p_msc->ep_in : p_msc->ep_out;
+        TU_ASSERT(usbh_edpt_xfer(dev_addr, ep_data, p_msc->buffer, cbw->total_bytes));
+      }else
+      {
+        // Status stage
+        get_csw(dev_addr, p_msc);
+      }
+    break;
+
+    case MSC_STAGE_DATA:
+      get_csw(dev_addr, p_msc);
+    break;
+
+    case MSC_STAGE_STATUS:
+      // SCSI op is complete
+      p_msc->stage = MSC_STAGE_IDLE;
+
+      if (p_msc->complete_cb) p_msc->complete_cb(dev_addr, cbw, csw);
+    break;
+
+    // unknown state
+    default: break;
+  }
+
+  return true;
+}
+
+//--------------------------------------------------------------------+
+// MSC Enumeration
+//--------------------------------------------------------------------+
+
+static bool open_get_maxlun_complete (uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result);
+static bool open_test_unit_ready_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw);
+static bool open_request_sense_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw);
+static bool open_read_capacity10_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw);
+
 bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length)
 {
   TU_VERIFY (MSC_SUBCLASS_SCSI == itf_desc->bInterfaceSubClass &&
@@ -311,30 +352,52 @@ bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
 
   //------------- Get Max Lun -------------//
   TU_LOG2("MSC Get Max Lun\r\n");
-  tusb_control_request_t request = {
-        .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_INTERFACE, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_IN },
-        .bRequest = MSC_REQ_GET_MAX_LUN,
-        .wValue = 0,
-        .wIndex = p_msc->itf_num,
-        .wLength = 1
+  tusb_control_request_t request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_INTERFACE,
+      .type      = TUSB_REQ_TYPE_CLASS,
+      .direction = TUSB_DIR_IN
+    },
+    .bRequest = MSC_REQ_GET_MAX_LUN,
+    .wValue   = 0,
+    .wIndex   = p_msc->itf_num,
+    .wLength  = 1
   };
-  // TODO STALL means zero
-  TU_ASSERT( usbh_control_xfer( dev_addr, &request, msch_buffer ) );
-  p_msc->max_lun = msch_buffer[0];
+  TU_ASSERT(tuh_control_xfer(dev_addr, &request, msch_buffer, open_get_maxlun_complete));
 
-#if 0
-  //------------- Reset -------------//
-  request = (tusb_control_request_t) {
-        .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_INTERFACE, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_OUT },
-        .bRequest = MSC_REQ_RESET,
-        .wValue = 0,
-        .wIndex = p_msc->itf_num,
-        .wLength = 0
+  return true;
+}
+
+static bool open_get_maxlun_complete (uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
+{
+  (void) request;
+
+  msch_interface_t* p_msc = &msch_data[dev_addr-1];
+
+  // STALL means zero
+  p_msc->max_lun = (XFER_RESULT_SUCCESS == result) ? msch_buffer[0] : 0;
+
+  // MSCU Reset
+#if 0 // not really needed
+  tusb_control_request_t const new_request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_INTERFACE,
+      .type      = TUSB_REQ_TYPE_CLASS,
+      .direction = TUSB_DIR_OUT
+    },
+    .bRequest = MSC_REQ_RESET,
+    .wValue   = 0,
+    .wIndex   = p_msc->itf_num,
+    .wLength  = 0
   };
-  TU_ASSERT( usbh_control_xfer( dev_addr, &request, NULL ) );
+  TU_ASSERT( usbh_control_xfer( dev_addr, &new_request, NULL ) );
 #endif
 
-  enum { SCSI_XFER_TIMEOUT = 2000 };
+#if 0
   //------------- SCSI Inquiry -------------//
   TU_LOG2("SCSI Inquiry\r\n");
   tusbh_msc_inquiry(dev_addr, 0, msch_buffer);
@@ -342,77 +405,63 @@ bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
 
   memcpy(p_msc->vendor_id , ((scsi_inquiry_resp_t*) msch_buffer)->vendor_id , 8);
   memcpy(p_msc->product_id, ((scsi_inquiry_resp_t*) msch_buffer)->product_id, 16);
+#endif
 
-  //------------- SCSI Read Capacity 10 -------------//
-  TU_LOG2("SCSI Read Capacity 10\r\n");
-  tusbh_msc_read_capacity10(dev_addr, 0, msch_buffer);
-  TU_ASSERT( osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT));
+  // TODO multiple LUN support
+  TU_LOG2("SCSI Test Unit Ready\r\n");
+  tuh_msc_test_unit_ready(dev_addr, 0, open_test_unit_ready_complete);
 
-  // NOTE: my toshiba thumb-drive stall the first Read Capacity and require the sequence
-  // Read Capacity --> Stalled --> Clear Stall --> Request Sense --> Read Capacity (2) to work
-  if ( hcd_edpt_stalled(dev_addr, p_msc->ep_in) )
+  return true;
+}
+
+static bool open_test_unit_ready_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw)
+{
+  if (csw->status == 0)
   {
-    // clear stall TODO abstract clear stall function
-    request = (tusb_control_request_t) {
-      .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_ENDPOINT, .type = TUSB_REQ_TYPE_STANDARD, .direction = TUSB_DIR_OUT },
-          .bRequest = TUSB_REQ_CLEAR_FEATURE,
-          .wValue = 0,
-          .wIndex = p_msc->ep_in,
-          .wLength = 0
-    };
-
-    TU_ASSERT(usbh_control_xfer( dev_addr, &request, NULL ));
-
-    hcd_edpt_clear_stall(dev_addr, p_msc->ep_in);
-    TU_ASSERT( osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT) ); // wait for SCSI status
-
-    //------------- SCSI Request Sense -------------//
-    (void) tuh_msc_request_sense(dev_addr, 0, msch_buffer);
-    TU_ASSERT(osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT));
-
-    //------------- Re-read SCSI Read Capactity -------------//
-    tusbh_msc_read_capacity10(dev_addr, 0, msch_buffer);
-    TU_ASSERT(osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT));
-  }
+    TU_LOG2("SCSI Read Capacity 10\r\n");
 
-  p_msc->last_lba   = tu_ntohl( ((scsi_read_capacity10_resp_t*)msch_buffer)->last_lba );
-  p_msc->block_size = (uint16_t) tu_ntohl( ((scsi_read_capacity10_resp_t*)msch_buffer)->block_size );
+    msch_interface_t* p_msc = &msch_data[dev_addr-1];
+    msc_cbw_t new_cbw = { 0 };
 
-  p_msc->is_initialized = true;
+    msc_cbw_add_signature(&new_cbw, cbw->lun);
+    new_cbw.total_bytes = sizeof(scsi_read_capacity10_resp_t);
+    new_cbw.dir        = TUSB_DIR_IN_MASK;
+    new_cbw.cmd_len    = sizeof(scsi_read_capacity10_t);
+    new_cbw.command[0] = SCSI_CMD_READ_CAPACITY_10;
 
-  tuh_msc_mounted_cb(dev_addr);
+    TU_ASSERT(tuh_msc_scsi_command(dev_addr, &new_cbw, &p_msc->capacity, open_read_capacity10_complete));
+  }else
+  {
+    // Note: During enumeration, some device fails Test Unit Ready and require a few retries
+    // with Request Sense to start working !!
+    // TODO limit number of retries
+    TU_ASSERT(tuh_msc_request_sense(dev_addr, cbw->lun, msch_buffer, open_request_sense_complete));
+  }
 
   return true;
 }
 
-bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
+static bool open_request_sense_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw)
 {
-  msch_interface_t* p_msc = &msch_data[dev_addr-1];
-  if ( ep_addr == p_msc->ep_in )
-  {
-    if (p_msc->is_initialized)
-    {
-      tuh_msc_isr(dev_addr, event, xferred_bytes);
-    }else
-    { // still initializing under open subtask
-      osal_semaphore_post(msch_sem_hdl, true);
-    }
-  }
-
+  TU_ASSERT(tuh_msc_test_unit_ready(dev_addr, cbw->lun, open_test_unit_ready_complete));
   return true;
 }
 
-void msch_close(uint8_t dev_addr)
+static bool open_read_capacity10_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw)
 {
-  tu_memclr(&msch_data[dev_addr-1], sizeof(msch_interface_t));
-  osal_semaphore_reset(msch_sem_hdl);
+  TU_ASSERT(csw->status == 0);
 
-  tuh_msc_unmounted_cb(dev_addr); // invoke Application Callback
-}
+  msch_interface_t* p_msc = &msch_data[dev_addr-1];
 
-//--------------------------------------------------------------------+
-// INTERNAL & HELPER
-//--------------------------------------------------------------------+
+  // Note: Block size and last LBA are big-endian
+  p_msc->capacity.last_lba = tu_ntohl(p_msc->capacity.last_lba);
+  p_msc->capacity.block_size = tu_ntohl(p_msc->capacity.block_size);
 
+  // Enumeration is complete
+  p_msc->is_initialized = true; // open complete TODO remove
+  tuh_msc_mounted_cb(dev_addr);
+
+  return true;
+}
 
 #endif
diff --git a/src/class/msc/msc_host.h b/src/class/msc/msc_host.h
index a32134215..03231d17f 100644
--- a/src/class/msc/msc_host.h
+++ b/src/class/msc/msc_host.h
@@ -40,6 +40,9 @@
  * \defgroup MSC_Host Host
  *  The interface API includes status checking function, data transferring function and callback functions
  *  @{ */
+
+typedef bool (*tuh_msc_complete_cb_t)(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw);
+
 //--------------------------------------------------------------------+
 // MASS STORAGE Application API
 //--------------------------------------------------------------------+
@@ -60,23 +63,9 @@ bool          tuh_msc_is_mounted(uint8_t dev_addr);
  */
 bool          tuh_msc_is_busy(uint8_t dev_addr);
 
-/** \brief      Get SCSI vendor's name of MassStorage device
- * \param[in]   dev_addr device address
- * \return      pointer to vendor's name or NULL if specified device does not support MassStorage
- * \note        SCSI vendor's name is 8-byte length field in \ref scsi_inquiry_data_t. During enumeration, the stack has already
- *              retrieved (via SCSI INQUIRY) and store this information internally. There is no need for application to re-send SCSI INQUIRY
- *              command or allocate buffer for this.
- */
-uint8_t const* tuh_msc_get_vendor_name(uint8_t dev_addr);
+bool tuh_msc_scsi_command(uint8_t dev_addr, msc_cbw_t const* cbw, void* data, tuh_msc_complete_cb_t complete_cb);
 
-/** \brief      Get SCSI product's name of MassStorage device
- * \param[in]   dev_addr device address
- * \return      pointer to product's name or NULL if specified device does not support MassStorage
- * \note        SCSI product's name is 16-byte length field in \ref scsi_inquiry_data_t. During enumeration, the stack has already
- *              retrieved (via SCSI INQUIRY) and store this information internally. There is no need for application to re-send SCSI INQUIRY
- *              command or allocate buffer for this.
- */
-uint8_t const* tuh_msc_get_product_name(uint8_t dev_addr);
+bool tuh_msc_scsi_inquiry(uint8_t dev_addr, uint8_t lun, void* response, uint32_t len);
 
 /** \brief      Get SCSI Capacity of MassStorage device
  * \param[in]   dev_addr device address
@@ -87,8 +76,10 @@ uint8_t const* tuh_msc_get_product_name(uint8_t dev_addr);
  *              retrieved (via SCSI READ CAPACITY 10) and store this information internally. There is no need for application
  *              to re-send SCSI READ CAPACITY 10 command
  */
-tusb_error_t tuh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint32_t* p_block_size);
 
+bool tuh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint32_t* p_block_size);
+
+#if 0
 /** \brief 			Perform SCSI READ 10 command to read data from MassStorage device
  * \param[in]		dev_addr	device address
  * \param[in]		lun       Targeted Logical Unit
@@ -116,29 +107,25 @@ tusb_error_t tuh_msc_read10 (uint8_t dev_addr, uint8_t lun, void * p_buffer, uin
  * \note        This function is non-blocking and returns immediately. The result of USB transfer will be reported by the interface's callback function
  */
 tusb_error_t tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffer, uint32_t lba, uint16_t block_count);
+#endif
 
 /** \brief 			Perform SCSI REQUEST SENSE command, used to retrieve sense data from MassStorage device
  * \param[in]		dev_addr	device address
  * \param[in]		lun       Targeted Logical Unit
  * \param[in]	  p_data    Buffer to store response's data from device. Must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)
- * \retval      TUSB_ERROR_NONE on success
- * \retval      TUSB_ERROR_INTERFACE_IS_BUSY if the interface is already transferring data with device
- * \retval      TUSB_ERROR_DEVICE_NOT_READY if device is not yet configured (by SET CONFIGURED request)
- * \retval      TUSB_ERROR_INVALID_PARA if input parameters are not correct
- * \note        This function is non-blocking and returns immediately. The result of USB transfer will be reported by the interface's callback function
+ * \note        This function is non-blocking and returns immediately.
+ *              Callback is invoked when command is complete
  */
-tusb_error_t tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, uint8_t *p_data);
+bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void *resposne, tuh_msc_complete_cb_t complete_cb);
 
 /** \brief 			Perform SCSI TEST UNIT READY command to test if MassStorage device is ready
  * \param[in]		dev_addr	device address
  * \param[in]		lun       Targeted Logical Unit
- * \retval      TUSB_ERROR_NONE on success
- * \retval      TUSB_ERROR_INTERFACE_IS_BUSY if the interface is already transferring data with device
- * \retval      TUSB_ERROR_DEVICE_NOT_READY if device is not yet configured (by SET CONFIGURED request)
- * \retval      TUSB_ERROR_INVALID_PARA if input parameters are not correct
- * \note        This function is non-blocking and returns immediately. The result of USB transfer will be reported by the interface's callback function
+ * \note        This function is non-blocking and returns immediately.
+ *              Callback is invoked when command is complete
  */
-tusb_error_t tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, msc_csw_t * p_csw); // TODO to be refractor
+bool tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, tuh_msc_complete_cb_t complete_cb);
+
 
 //tusb_error_t  tusbh_msc_scsi_send(uint8_t dev_addr, uint8_t lun, bool is_direction_in,
 //                                  uint8_t const * p_command, uint8_t cmd_len,
@@ -157,39 +144,9 @@ void tuh_msc_mounted_cb(uint8_t dev_addr);
  */
 void tuh_msc_unmounted_cb(uint8_t dev_addr);
 
-/** \brief      Callback function that is invoked when an transferring event occurred
- * \param[in]		dev_addr	Address of device
- * \param[in]   event an value from \ref xfer_result_t
- * \param[in]   xferred_bytes Number of bytes transferred via USB bus
- * \note        event can be one of following
- *              - XFER_RESULT_SUCCESS : previously scheduled transfer completes successfully.
- *              - XFER_RESULT_FAILED   : previously scheduled transfer encountered a transaction error.
- *              - XFER_RESULT_STALLED : previously scheduled transfer is stalled by device.
- * \note
- */
-void tuh_msc_isr(uint8_t dev_addr, xfer_result_t event, uint32_t xferred_bytes);
-
-
 //--------------------------------------------------------------------+
 // Internal Class Driver API
 //--------------------------------------------------------------------+
-typedef struct
-{
-  uint8_t  itf_num;
-  uint8_t  ep_in;
-  uint8_t  ep_out;
-
-  uint8_t  max_lun;
-  uint16_t block_size;
-  uint32_t last_lba; // last logical block address
-
-  volatile bool is_initialized;
-  uint8_t vendor_id[8];
-  uint8_t product_id[16];
-
-  msc_cbw_t cbw;
-  msc_csw_t csw;
-}msch_interface_t;
 
 void msch_init(void);
 bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length);
diff --git a/src/host/usbh_control.c b/src/host/usbh_control.c
index 70800eba6..de55bd5e1 100644
--- a/src/host/usbh_control.c
+++ b/src/host/usbh_control.c
@@ -88,7 +88,6 @@ bool usbh_control_xfer_cb (uint8_t dev_addr, uint8_t ep_addr, xfer_result_t resu
   (void) ep_addr;
   (void) xferred_bytes;
 
-
   usbh_device_t* dev = &_usbh_devices[dev_addr];
   const uint8_t rhport = dev->rhport;
 
-- 
cgit v1.3.1


From 437ccac6968b9c31446756c49524f7306ef2acd8 Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Tue, 13 Oct 2020 13:23:33 +0700
Subject: implement tuh_msc_scsi_inquiry() / tuh_msc_read_capacity() /
 tuh_msc_get_maxlun()

---
 examples/host/cdc_msc_hid/src/msc_app.c   |  62 ++++++++++----
 examples/obsolete/host/src/msc_host_app.c |   2 +-
 src/class/msc/msc_host.c                  | 131 +++++++++++-------------------
 src/class/msc/msc_host.h                  |   6 +-
 4 files changed, 96 insertions(+), 105 deletions(-)

(limited to 'src/class')

diff --git a/examples/host/cdc_msc_hid/src/msc_app.c b/examples/host/cdc_msc_hid/src/msc_app.c
index 53f0e6ac2..a45fba737 100644
--- a/examples/host/cdc_msc_hid/src/msc_app.c
+++ b/examples/host/cdc_msc_hid/src/msc_app.c
@@ -30,31 +30,59 @@
 //--------------------------------------------------------------------+
 // MACRO TYPEDEF CONSTANT ENUM DECLARATION
 //--------------------------------------------------------------------+
+static scsi_inquiry_resp_t inquiry_resp;
+static scsi_read_capacity10_resp_t capacity_resp;
 
+uint32_t block_size;
+uint32_t block_count;
+
+bool capacity_complete_cb(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw)
+{
+  (void) dev_addr;
+  (void) cbw;
+
+  if (csw->status != 0)
+  {
+    printf("Read Capacity (10) failed\r\n");
+    return false;
+  }
+
+  // Capacity response field: Block size and Last LBA are both Big-Endian
+  block_count = tu_ntohl(capacity_resp.last_lba) + 1;
+  block_size = tu_ntohl(capacity_resp.block_size);
+
+  printf("Disk Size: %lu MB\r\n", block_count / ((1024*1024)/block_size));
+  printf("Block Count = %lu, Block Size: %lu\r\n", block_count, block_size);
+
+  return true;
+}
+
+bool inquiry_complete_cb(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw)
+{
+  if (csw->status != 0)
+  {
+    printf("Inquiry failed\r\n");
+    return false;
+  }
+
+  // Print out Vendor ID, Product ID and Rev
+  printf("%.8s %.16s rev %.4s\r\n", inquiry_resp.vendor_id, inquiry_resp.product_id, inquiry_resp.product_rev);
+
+  // Read capacity of device
+  tuh_msc_read_capacity(dev_addr, cbw->lun, &capacity_resp, capacity_complete_cb);
+
+  return true;
+}
 
 //------------- IMPLEMENTATION -------------//
 void tuh_msc_mounted_cb(uint8_t dev_addr)
 {
   printf("A MassStorage device is mounted\r\n");
 
-  //------------- Disk Information -------------//
-#if 0
-  // SCSI VendorID[8] & ProductID[16] from Inquiry Command
-  uint8_t const* p_vendor  = tuh_msc_get_vendor_name(dev_addr);
-  uint8_t const* p_product = tuh_msc_get_product_name(dev_addr);
-
-  for(uint8_t i=0; i<8; i++) putchar(p_vendor[i]);
-
-  putchar(' ');
-  for(uint8_t i=0; i<16; i++) putchar(p_product[i]);
-  putchar('\n');
-#endif
+  block_size = block_count = 0;
 
-  uint32_t last_lba = 0;
-  uint32_t block_size = 0;
-  tuh_msc_get_capacity(dev_addr, &last_lba, &block_size);
-  printf("Disk Size: %ld MB\r\n", (last_lba+1)/ ((1024*1024)/block_size) );
-  printf("LBA 0-0x%lX  Block Size: %ld\r\n", last_lba, block_size);
+  uint8_t const lun = 0;
+  tuh_msc_scsi_inquiry(dev_addr, lun, &inquiry_resp, inquiry_complete_cb);
 //
 //  //------------- file system (only 1 LUN support) -------------//
 //  uint8_t phy_disk = dev_addr-1;
diff --git a/examples/obsolete/host/src/msc_host_app.c b/examples/obsolete/host/src/msc_host_app.c
index 77747b536..8afb6ede8 100644
--- a/examples/obsolete/host/src/msc_host_app.c
+++ b/examples/obsolete/host/src/msc_host_app.c
@@ -64,7 +64,7 @@ void tuh_msc_mounted_cb(uint8_t dev_addr)
   putchar('\n');
 
   uint32_t last_lba, block_size;
-  tuh_msc_get_capacity(dev_addr, &last_lba, &block_size);
+  tuh_msc_read_capacity(dev_addr, &last_lba, &block_size);
   printf("Disk Size: %d MB\n", (last_lba+1)/ ((1024*1024)/block_size) );
   printf("LBA 0-0x%X  Block Size: %d\n", last_lba, block_size);
 
diff --git a/src/class/msc/msc_host.c b/src/class/msc/msc_host.c
index e8bed989c..7a46b6866 100644
--- a/src/class/msc/msc_host.c
+++ b/src/class/msc/msc_host.c
@@ -53,11 +53,7 @@ typedef struct
 
   uint8_t  max_lun;
 
-  scsi_read_capacity10_resp_t capacity;
-
   volatile bool is_initialized;
-  uint8_t vendor_id[8];
-  uint8_t product_id[16];
 
   uint8_t stage;
   void*   buffer;
@@ -75,6 +71,11 @@ CFG_TUSB_MEM_SECTION TU_ATTR_ALIGNED(4) static uint8_t msch_buffer[sizeof(scsi_i
 //--------------------------------------------------------------------+
 // PUBLIC API
 //--------------------------------------------------------------------+
+uint8_t tuh_msc_get_maxlun(uint8_t dev_addr)
+{
+  return msch_data[dev_addr-1].max_lun;
+}
+
 bool tuh_msc_is_mounted(uint8_t dev_addr)
 {
   return  tuh_device_is_configured(dev_addr) && // is configured can be omitted
@@ -87,19 +88,6 @@ bool tuh_msc_is_busy(uint8_t dev_addr)
           hcd_edpt_busy(dev_addr, msch_data[dev_addr-1].ep_in);
 }
 
-bool tuh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint32_t* p_block_size)
-{
-  msch_interface_t* p_msc = &msch_data[dev_addr-1];
-
-  if ( !p_msc->is_initialized ) return false;
-  TU_ASSERT(p_last_lba != NULL && p_block_size != NULL);
-
-  (*p_last_lba)   = p_msc->capacity.last_lba;
-  (*p_block_size) = p_msc->capacity.block_size;
-
-  return true;
-}
-
 //--------------------------------------------------------------------+
 // PUBLIC API: SCSI COMMAND
 //--------------------------------------------------------------------+
@@ -126,33 +114,46 @@ bool tuh_msc_scsi_command(uint8_t dev_addr, msc_cbw_t const* cbw, void* data, tu
   return true;
 }
 
-#if 0
-tusb_error_t tusbh_msc_inquiry(uint8_t dev_addr, uint8_t lun, uint8_t *p_data)
+bool tuh_msc_read_capacity(uint8_t dev_addr, uint8_t lun, scsi_read_capacity10_resp_t* response, tuh_msc_complete_cb_t complete_cb)
 {
-  msch_interface_t* p_msch = &msch_data[dev_addr-1];
+  msch_interface_t* p_msc = &msch_data[dev_addr-1];
+  if ( !p_msc->is_initialized ) return false;
 
-  //------------- Command Block Wrapper -------------//
-  msc_cbw_add_signature(&p_msch->cbw, lun);
-  p_msch->cbw.total_bytes = sizeof(scsi_inquiry_resp_t);
-  p_msch->cbw.dir        = TUSB_DIR_IN_MASK;
-  p_msch->cbw.cmd_len    = sizeof(scsi_inquiry_t);
+  msc_cbw_t cbw = { 0 };
+
+  msc_cbw_add_signature(&cbw, lun);
+  cbw.total_bytes = sizeof(scsi_read_capacity10_resp_t);
+  cbw.dir        = TUSB_DIR_IN_MASK;
+  cbw.cmd_len    = sizeof(scsi_read_capacity10_t);
+  cbw.command[0] = SCSI_CMD_READ_CAPACITY_10;
+
+  TU_ASSERT(tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb));
+
+  return true;
+}
+
+bool tuh_msc_scsi_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t* response, tuh_msc_complete_cb_t complete_cb)
+{
+  msc_cbw_t cbw = { 0 };
+
+  msc_cbw_add_signature(&cbw, lun);
+  cbw.total_bytes = sizeof(scsi_inquiry_resp_t);
+  cbw.dir         = TUSB_DIR_IN_MASK;
+  cbw.cmd_len     = sizeof(scsi_inquiry_t);
 
-  //------------- SCSI command -------------//
   scsi_inquiry_t const cmd_inquiry =
   {
-      .cmd_code     = SCSI_CMD_INQUIRY,
-      .alloc_length = sizeof(scsi_inquiry_resp_t)
+    .cmd_code     = SCSI_CMD_INQUIRY,
+    .alloc_length = sizeof(scsi_inquiry_resp_t)
   };
+  memcpy(cbw.command, &cmd_inquiry, cbw.cmd_len);
 
-  memcpy(p_msch->cbw.command, &cmd_inquiry, p_msch->cbw.cmd_len);
-
-  TU_ASSERT_ERR ( send_cbw(dev_addr, p_msch, p_data) );
+  TU_ASSERT(tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb));
 
-  return TUSB_ERROR_NONE;
+  return true;
 }
-#endif
 
-bool tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun,  tuh_msc_complete_cb_t complete_cb)
+bool tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, tuh_msc_complete_cb_t complete_cb)
 {
   msc_cbw_t cbw = { 0 };
   msc_cbw_add_signature(&cbw, lun);
@@ -252,20 +253,12 @@ void msch_init(void)
   tu_memclr(msch_data, sizeof(msch_interface_t)*CFG_TUSB_HOST_DEVICE_MAX);
 }
 
-
 void msch_close(uint8_t dev_addr)
 {
   tu_memclr(&msch_data[dev_addr-1], sizeof(msch_interface_t));
   tuh_msc_unmounted_cb(dev_addr); // invoke Application Callback
 }
 
-static bool get_csw(uint8_t dev_addr, msch_interface_t * p_msc)
-{
-  p_msc->stage = MSC_STAGE_STATUS;
-  TU_ASSERT(usbh_edpt_xfer(dev_addr, p_msc->ep_in, (uint8_t*) &p_msc->csw, sizeof(msc_csw_t)));
-  return true;
-}
-
 bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
 {
   msch_interface_t* p_msc = &msch_data[dev_addr-1];
@@ -288,12 +281,15 @@ bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
       }else
       {
         // Status stage
-        get_csw(dev_addr, p_msc);
+        p_msc->stage = MSC_STAGE_STATUS;
+        TU_ASSERT(usbh_edpt_xfer(dev_addr, p_msc->ep_in, (uint8_t*) &p_msc->csw, sizeof(msc_csw_t)));
       }
     break;
 
     case MSC_STAGE_DATA:
-      get_csw(dev_addr, p_msc);
+      // Status stage
+      p_msc->stage = MSC_STAGE_STATUS;
+      TU_ASSERT(usbh_edpt_xfer(dev_addr, p_msc->ep_in, (uint8_t*) &p_msc->csw, sizeof(msc_csw_t)));
     break;
 
     case MSC_STAGE_STATUS:
@@ -317,7 +313,6 @@ bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
 static bool open_get_maxlun_complete (uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result);
 static bool open_test_unit_ready_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw);
 static bool open_request_sense_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw);
-static bool open_read_capacity10_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw);
 
 bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length)
 {
@@ -331,9 +326,7 @@ bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
 
   for(uint32_t i=0; i<2; i++)
   {
-    TU_ASSERT(TUSB_DESC_ENDPOINT == ep_desc->bDescriptorType);
-    TU_ASSERT(TUSB_XFER_BULK == ep_desc->bmAttributes.xfer);
-
+    TU_ASSERT(TUSB_DESC_ENDPOINT == ep_desc->bDescriptorType && TUSB_XFER_BULK == ep_desc->bmAttributes.xfer);
     TU_ASSERT(usbh_edpt_open(rhport, dev_addr, ep_desc));
 
     if ( tu_edpt_dir(ep_desc->bEndpointAddress) == TUSB_DIR_IN )
@@ -378,6 +371,7 @@ static bool open_get_maxlun_complete (uint8_t dev_addr, tusb_control_request_t c
 
   // STALL means zero
   p_msc->max_lun = (XFER_RESULT_SUCCESS == result) ? msch_buffer[0] : 0;
+  p_msc->max_lun++; // MAX LUN is minus 1 by specs
 
   // MSCU Reset
 #if 0 // not really needed
@@ -397,16 +391,6 @@ static bool open_get_maxlun_complete (uint8_t dev_addr, tusb_control_request_t c
   TU_ASSERT( usbh_control_xfer( dev_addr, &new_request, NULL ) );
 #endif
 
-#if 0
-  //------------- SCSI Inquiry -------------//
-  TU_LOG2("SCSI Inquiry\r\n");
-  tusbh_msc_inquiry(dev_addr, 0, msch_buffer);
-  TU_ASSERT( osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT) );
-
-  memcpy(p_msc->vendor_id , ((scsi_inquiry_resp_t*) msch_buffer)->vendor_id , 8);
-  memcpy(p_msc->product_id, ((scsi_inquiry_resp_t*) msch_buffer)->product_id, 16);
-#endif
-
   // TODO multiple LUN support
   TU_LOG2("SCSI Test Unit Ready\r\n");
   tuh_msc_test_unit_ready(dev_addr, 0, open_test_unit_ready_complete);
@@ -418,18 +402,11 @@ static bool open_test_unit_ready_complete(uint8_t dev_addr, msc_cbw_t const* cbw
 {
   if (csw->status == 0)
   {
-    TU_LOG2("SCSI Read Capacity 10\r\n");
-
     msch_interface_t* p_msc = &msch_data[dev_addr-1];
-    msc_cbw_t new_cbw = { 0 };
-
-    msc_cbw_add_signature(&new_cbw, cbw->lun);
-    new_cbw.total_bytes = sizeof(scsi_read_capacity10_resp_t);
-    new_cbw.dir        = TUSB_DIR_IN_MASK;
-    new_cbw.cmd_len    = sizeof(scsi_read_capacity10_t);
-    new_cbw.command[0] = SCSI_CMD_READ_CAPACITY_10;
 
-    TU_ASSERT(tuh_msc_scsi_command(dev_addr, &new_cbw, &p_msc->capacity, open_read_capacity10_complete));
+    // Unit is ready, Enumeration is complete
+    p_msc->is_initialized = true; // open complete TODO remove
+    tuh_msc_mounted_cb(dev_addr);
   }else
   {
     // Note: During enumeration, some device fails Test Unit Ready and require a few retries
@@ -442,25 +419,9 @@ static bool open_test_unit_ready_complete(uint8_t dev_addr, msc_cbw_t const* cbw
 }
 
 static bool open_request_sense_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw)
-{
-  TU_ASSERT(tuh_msc_test_unit_ready(dev_addr, cbw->lun, open_test_unit_ready_complete));
-  return true;
-}
-
-static bool open_read_capacity10_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw)
 {
   TU_ASSERT(csw->status == 0);
-
-  msch_interface_t* p_msc = &msch_data[dev_addr-1];
-
-  // Note: Block size and last LBA are big-endian
-  p_msc->capacity.last_lba = tu_ntohl(p_msc->capacity.last_lba);
-  p_msc->capacity.block_size = tu_ntohl(p_msc->capacity.block_size);
-
-  // Enumeration is complete
-  p_msc->is_initialized = true; // open complete TODO remove
-  tuh_msc_mounted_cb(dev_addr);
-
+  TU_ASSERT(tuh_msc_test_unit_ready(dev_addr, cbw->lun, open_test_unit_ready_complete));
   return true;
 }
 
diff --git a/src/class/msc/msc_host.h b/src/class/msc/msc_host.h
index 03231d17f..63b4753b1 100644
--- a/src/class/msc/msc_host.h
+++ b/src/class/msc/msc_host.h
@@ -63,9 +63,11 @@ bool          tuh_msc_is_mounted(uint8_t dev_addr);
  */
 bool          tuh_msc_is_busy(uint8_t dev_addr);
 
+uint8_t tuh_msc_get_maxlun(uint8_t dev_addr);
+
 bool tuh_msc_scsi_command(uint8_t dev_addr, msc_cbw_t const* cbw, void* data, tuh_msc_complete_cb_t complete_cb);
 
-bool tuh_msc_scsi_inquiry(uint8_t dev_addr, uint8_t lun, void* response, uint32_t len);
+bool tuh_msc_scsi_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t* response, tuh_msc_complete_cb_t complete_cb);
 
 /** \brief      Get SCSI Capacity of MassStorage device
  * \param[in]   dev_addr device address
@@ -77,7 +79,7 @@ bool tuh_msc_scsi_inquiry(uint8_t dev_addr, uint8_t lun, void* response, uint32_
  *              to re-send SCSI READ CAPACITY 10 command
  */
 
-bool tuh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint32_t* p_block_size);
+bool tuh_msc_read_capacity(uint8_t dev_addr, uint8_t lun, scsi_read_capacity10_resp_t* response, tuh_msc_complete_cb_t complete_cb);
 
 #if 0
 /** \brief 			Perform SCSI READ 10 command to read data from MassStorage device
-- 
cgit v1.3.1


From d92d1a03ca2df69856f02c64ae88d805d60ad088 Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Tue, 13 Oct 2020 13:45:22 +0700
Subject: clean up

---
 src/class/msc/msc_host.c | 97 +++++++++++++++++++++++++-----------------------
 src/class/msc/msc_host.h |  5 ++-
 2 files changed, 55 insertions(+), 47 deletions(-)

(limited to 'src/class')

diff --git a/src/class/msc/msc_host.c b/src/class/msc/msc_host.c
index 7a46b6866..8bf240ac7 100644
--- a/src/class/msc/msc_host.c
+++ b/src/class/msc/msc_host.c
@@ -53,7 +53,7 @@ typedef struct
 
   uint8_t  max_lun;
 
-  volatile bool is_initialized;
+  volatile bool mounted;
 
   uint8_t stage;
   void*   buffer;
@@ -68,24 +68,32 @@ CFG_TUSB_MEM_SECTION static msch_interface_t msch_data[CFG_TUSB_HOST_DEVICE_MAX]
 // buffer used to read scsi information when mounted, largest response data currently is inquiry
 CFG_TUSB_MEM_SECTION TU_ATTR_ALIGNED(4) static uint8_t msch_buffer[sizeof(scsi_inquiry_resp_t)];
 
+static inline msch_interface_t* get_itf(uint8_t dev_addr)
+{
+  return &msch_data[dev_addr-1];
+}
+
 //--------------------------------------------------------------------+
 // PUBLIC API
 //--------------------------------------------------------------------+
 uint8_t tuh_msc_get_maxlun(uint8_t dev_addr)
 {
-  return msch_data[dev_addr-1].max_lun;
+  msch_interface_t* p_msc = get_itf(dev_addr);
+  return p_msc->max_lun;
 }
 
-bool tuh_msc_is_mounted(uint8_t dev_addr)
+bool tuh_msc_mounted(uint8_t dev_addr)
 {
-  return  tuh_device_is_configured(dev_addr) && // is configured can be omitted
-          msch_data[dev_addr-1].is_initialized;
+  msch_interface_t* p_msc = get_itf(dev_addr);
+
+  // is configured can be omitted
+  return tuh_device_is_configured(dev_addr) && p_msc->mounted;
 }
 
 bool tuh_msc_is_busy(uint8_t dev_addr)
 {
-  return  msch_data[dev_addr-1].is_initialized &&
-          hcd_edpt_busy(dev_addr, msch_data[dev_addr-1].ep_in);
+  msch_interface_t* p_msc = get_itf(dev_addr);
+  return p_msc->mounted && hcd_edpt_busy(dev_addr, p_msc->ep_in);
 }
 
 //--------------------------------------------------------------------+
@@ -100,7 +108,8 @@ static inline void msc_cbw_add_signature(msc_cbw_t *p_cbw, uint8_t lun)
 
 bool tuh_msc_scsi_command(uint8_t dev_addr, msc_cbw_t const* cbw, void* data, tuh_msc_complete_cb_t complete_cb)
 {
-  msch_interface_t* p_msc = &msch_data[dev_addr-1];
+  msch_interface_t* p_msc = get_itf(dev_addr);
+  TU_VERIFY(p_msc->mounted);
 
   // TODO claim endpoint
 
@@ -116,8 +125,8 @@ bool tuh_msc_scsi_command(uint8_t dev_addr, msc_cbw_t const* cbw, void* data, tu
 
 bool tuh_msc_read_capacity(uint8_t dev_addr, uint8_t lun, scsi_read_capacity10_resp_t* response, tuh_msc_complete_cb_t complete_cb)
 {
-  msch_interface_t* p_msc = &msch_data[dev_addr-1];
-  if ( !p_msc->is_initialized ) return false;
+  msch_interface_t* p_msc = get_itf(dev_addr);
+  if ( !p_msc->mounted ) return false;
 
   msc_cbw_t cbw = { 0 };
 
@@ -127,9 +136,7 @@ bool tuh_msc_read_capacity(uint8_t dev_addr, uint8_t lun, scsi_read_capacity10_r
   cbw.cmd_len    = sizeof(scsi_read_capacity10_t);
   cbw.command[0] = SCSI_CMD_READ_CAPACITY_10;
 
-  TU_ASSERT(tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb));
-
-  return true;
+  return tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb);
 }
 
 bool tuh_msc_scsi_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t* response, tuh_msc_complete_cb_t complete_cb)
@@ -148,9 +155,7 @@ bool tuh_msc_scsi_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t* re
   };
   memcpy(cbw.command, &cmd_inquiry, cbw.cmd_len);
 
-  TU_ASSERT(tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb));
-
-  return true;
+  return tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb);
 }
 
 bool tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, tuh_msc_complete_cb_t complete_cb)
@@ -164,9 +169,7 @@ bool tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, tuh_msc_complete_cb_
   cbw.command[0] = SCSI_CMD_TEST_UNIT_READY;
   cbw.command[1] = lun; // according to wiki TODO need verification
 
-  TU_ASSERT(tuh_msc_scsi_command(dev_addr, &cbw, NULL, complete_cb));
-
-  return true;
+  return tuh_msc_scsi_command(dev_addr, &cbw, NULL, complete_cb);
 }
 
 bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void *resposne, tuh_msc_complete_cb_t complete_cb)
@@ -186,12 +189,11 @@ bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void *resposne, tuh_ms
 
   memcpy(cbw.command, &cmd_request_sense, cbw.cmd_len);
 
-  TU_ASSERT(tuh_msc_scsi_command(dev_addr, &cbw, resposne, complete_cb));
-
-  return true;
+  return tuh_msc_scsi_command(dev_addr, &cbw, resposne, complete_cb);
 }
 
 #if 0
+
 tusb_error_t  tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void * p_buffer, uint32_t lba, uint16_t block_count)
 {
   msch_interface_t* p_msch = &msch_data[dev_addr-1];
@@ -245,6 +247,27 @@ tusb_error_t tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffe
 }
 #endif
 
+#if 0
+// MSC interface Reset (not used now)
+bool tuh_msc_reset(uint8_t dev_addr)
+{
+  tusb_control_request_t const new_request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_INTERFACE,
+      .type      = TUSB_REQ_TYPE_CLASS,
+      .direction = TUSB_DIR_OUT
+    },
+    .bRequest = MSC_REQ_RESET,
+    .wValue   = 0,
+    .wIndex   = p_msc->itf_num,
+    .wLength  = 0
+  };
+  TU_ASSERT( usbh_control_xfer( dev_addr, &new_request, NULL ) );
+}
+#endif
+
 //--------------------------------------------------------------------+
 // CLASS-USBH API (don't require to verify parameters)
 //--------------------------------------------------------------------+
@@ -261,7 +284,7 @@ void msch_close(uint8_t dev_addr)
 
 bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
 {
-  msch_interface_t* p_msc = &msch_data[dev_addr-1];
+  msch_interface_t* p_msc = get_itf(dev_addr);
   msc_cbw_t const * cbw = &p_msc->cbw;
   msc_csw_t       * csw = &p_msc->csw;
 
@@ -319,7 +342,7 @@ bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
   TU_VERIFY (MSC_SUBCLASS_SCSI == itf_desc->bInterfaceSubClass &&
              MSC_PROTOCOL_BOT  == itf_desc->bInterfaceProtocol);
 
-  msch_interface_t* p_msc = &msch_data[dev_addr-1];
+  msch_interface_t* p_msc = get_itf(dev_addr);
 
   //------------- Open Data Pipe -------------//
   tusb_desc_endpoint_t const * ep_desc = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
@@ -358,7 +381,7 @@ bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
     .wIndex   = p_msc->itf_num,
     .wLength  = 1
   };
-  TU_ASSERT(tuh_control_xfer(dev_addr, &request, msch_buffer, open_get_maxlun_complete));
+  TU_ASSERT(tuh_control_xfer(dev_addr, &request, &p_msc->max_lun, open_get_maxlun_complete));
 
   return true;
 }
@@ -367,30 +390,12 @@ static bool open_get_maxlun_complete (uint8_t dev_addr, tusb_control_request_t c
 {
   (void) request;
 
-  msch_interface_t* p_msc = &msch_data[dev_addr-1];
+  msch_interface_t* p_msc = get_itf(dev_addr);
 
   // STALL means zero
   p_msc->max_lun = (XFER_RESULT_SUCCESS == result) ? msch_buffer[0] : 0;
   p_msc->max_lun++; // MAX LUN is minus 1 by specs
 
-  // MSCU Reset
-#if 0 // not really needed
-  tusb_control_request_t const new_request =
-  {
-    .bmRequestType_bit =
-    {
-      .recipient = TUSB_REQ_RCPT_INTERFACE,
-      .type      = TUSB_REQ_TYPE_CLASS,
-      .direction = TUSB_DIR_OUT
-    },
-    .bRequest = MSC_REQ_RESET,
-    .wValue   = 0,
-    .wIndex   = p_msc->itf_num,
-    .wLength  = 0
-  };
-  TU_ASSERT( usbh_control_xfer( dev_addr, &new_request, NULL ) );
-#endif
-
   // TODO multiple LUN support
   TU_LOG2("SCSI Test Unit Ready\r\n");
   tuh_msc_test_unit_ready(dev_addr, 0, open_test_unit_ready_complete);
@@ -402,10 +407,10 @@ static bool open_test_unit_ready_complete(uint8_t dev_addr, msc_cbw_t const* cbw
 {
   if (csw->status == 0)
   {
-    msch_interface_t* p_msc = &msch_data[dev_addr-1];
+    msch_interface_t* p_msc = get_itf(dev_addr);
 
     // Unit is ready, Enumeration is complete
-    p_msc->is_initialized = true; // open complete TODO remove
+    p_msc->mounted = true;
     tuh_msc_mounted_cb(dev_addr);
   }else
   {
diff --git a/src/class/msc/msc_host.h b/src/class/msc/msc_host.h
index 63b4753b1..827311063 100644
--- a/src/class/msc/msc_host.h
+++ b/src/class/msc/msc_host.h
@@ -51,7 +51,10 @@ typedef bool (*tuh_msc_complete_cb_t)(uint8_t dev_addr, msc_cbw_t const* cbw, ms
  * \retval      true if device supports
  * \retval      false if device does not support or is not mounted
  */
-bool          tuh_msc_is_mounted(uint8_t dev_addr);
+
+// Check if device supports MassStorage interface.
+// This function true after tuh_msc_mounted_cb() and false after tuh_msc_unmounted_cb()
+bool tuh_msc_mounted(uint8_t dev_addr);
 
 /** \brief      Check if the interface is currently busy or not
  * \param[in]   dev_addr device address
-- 
cgit v1.3.1


From 3623f578a4b9c75b61b1c7a7d0c0c3ff2440e690 Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Tue, 13 Oct 2020 14:00:25 +0700
Subject: more clean up

---
 src/class/msc/msc_host.c |  5 ++--
 src/class/msc/msc_host.h | 60 ++++++++++++------------------------------------
 src/host/usbh.c          |  5 +++-
 3 files changed, 22 insertions(+), 48 deletions(-)

(limited to 'src/class')

diff --git a/src/class/msc/msc_host.c b/src/class/msc/msc_host.c
index 8bf240ac7..83423cfc7 100644
--- a/src/class/msc/msc_host.c
+++ b/src/class/msc/msc_host.c
@@ -109,7 +109,7 @@ static inline void msc_cbw_add_signature(msc_cbw_t *p_cbw, uint8_t lun)
 bool tuh_msc_scsi_command(uint8_t dev_addr, msc_cbw_t const* cbw, void* data, tuh_msc_complete_cb_t complete_cb)
 {
   msch_interface_t* p_msc = get_itf(dev_addr);
-  TU_VERIFY(p_msc->mounted);
+  // TU_VERIFY(p_msc->mounted); // TODO part of the enumeration also use scsi command
 
   // TODO claim endpoint
 
@@ -278,7 +278,8 @@ void msch_init(void)
 
 void msch_close(uint8_t dev_addr)
 {
-  tu_memclr(&msch_data[dev_addr-1], sizeof(msch_interface_t));
+  msch_interface_t* p_msc = get_itf(dev_addr);
+  tu_memclr(p_msc, sizeof(msch_interface_t));
   tuh_msc_unmounted_cb(dev_addr); // invoke Application Callback
 }
 
diff --git a/src/class/msc/msc_host.h b/src/class/msc/msc_host.h
index 827311063..06b1067cc 100644
--- a/src/class/msc/msc_host.h
+++ b/src/class/msc/msc_host.h
@@ -44,13 +44,8 @@
 typedef bool (*tuh_msc_complete_cb_t)(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw);
 
 //--------------------------------------------------------------------+
-// MASS STORAGE Application API
+// Application API
 //--------------------------------------------------------------------+
-/** \brief      Check if device supports MassStorage interface or not
- * \param[in]   dev_addr    device address
- * \retval      true if device supports
- * \retval      false if device does not support or is not mounted
- */
 
 // Check if device supports MassStorage interface.
 // This function true after tuh_msc_mounted_cb() and false after tuh_msc_unmounted_cb()
@@ -66,22 +61,24 @@ bool tuh_msc_mounted(uint8_t dev_addr);
  */
 bool          tuh_msc_is_busy(uint8_t dev_addr);
 
+// Get Max Lun
 uint8_t tuh_msc_get_maxlun(uint8_t dev_addr);
 
+// Carry out a full SCSI command (cbw, data, csw) in non-blocking manner.
+// `complete_cb` callback is invoked when SCSI op is complete.
+// return true if success, false if there is already pending operation.
 bool tuh_msc_scsi_command(uint8_t dev_addr, msc_cbw_t const* cbw, void* data, tuh_msc_complete_cb_t complete_cb);
 
+// Carry out SCSI INQUIRY command in non-blocking manner.
 bool tuh_msc_scsi_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t* response, tuh_msc_complete_cb_t complete_cb);
 
-/** \brief      Get SCSI Capacity of MassStorage device
- * \param[in]   dev_addr device address
- * \param[out]  p_last_lba Last Logical Block Address of device
- * \param[out]  p_block_size Block Size of device in bytes
- * \retval      pointer to product's name or NULL if specified device does not support MassStorage
- * \note        MassStorage's capacity can be computed by last LBA x block size (in bytes). During enumeration, the stack has already
- *              retrieved (via SCSI READ CAPACITY 10) and store this information internally. There is no need for application
- *              to re-send SCSI READ CAPACITY 10 command
- */
+// Carry out SCSI REQUEST SENSE (10) command in non-blocking manner.
+bool tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, tuh_msc_complete_cb_t complete_cb);
+
+// Carry out SCSI REQUEST SENSE (10) command in non-blocking manner.
+bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void *resposne, tuh_msc_complete_cb_t complete_cb);
 
+// Carry out SCSI READ CAPACITY (10) command in non-blocking manner.
 bool tuh_msc_read_capacity(uint8_t dev_addr, uint8_t lun, scsi_read_capacity10_resp_t* response, tuh_msc_complete_cb_t complete_cb);
 
 #if 0
@@ -114,39 +111,12 @@ tusb_error_t tuh_msc_read10 (uint8_t dev_addr, uint8_t lun, void * p_buffer, uin
 tusb_error_t tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffer, uint32_t lba, uint16_t block_count);
 #endif
 
-/** \brief 			Perform SCSI REQUEST SENSE command, used to retrieve sense data from MassStorage device
- * \param[in]		dev_addr	device address
- * \param[in]		lun       Targeted Logical Unit
- * \param[in]	  p_data    Buffer to store response's data from device. Must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)
- * \note        This function is non-blocking and returns immediately.
- *              Callback is invoked when command is complete
- */
-bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void *resposne, tuh_msc_complete_cb_t complete_cb);
-
-/** \brief 			Perform SCSI TEST UNIT READY command to test if MassStorage device is ready
- * \param[in]		dev_addr	device address
- * \param[in]		lun       Targeted Logical Unit
- * \note        This function is non-blocking and returns immediately.
- *              Callback is invoked when command is complete
- */
-bool tuh_msc_test_unit_ready(uint8_t dev_addr, uint8_t lun, tuh_msc_complete_cb_t complete_cb);
-
-
-//tusb_error_t  tusbh_msc_scsi_send(uint8_t dev_addr, uint8_t lun, bool is_direction_in,
-//                                  uint8_t const * p_command, uint8_t cmd_len,
-//                                  uint8_t * p_response, uint32_t resp_len);
-
 //------------- Application Callback -------------//
-/** \brief 			Callback function that will be invoked when a device with MassStorage interface is mounted
- * \param[in]	  dev_addr Address of newly mounted device
- * \note        This callback should be used by Application to set-up interface-related data
- */
+
+// Invoked when a device with MassStorage interface is mounted
 void tuh_msc_mounted_cb(uint8_t dev_addr);
 
-/** \brief 			Callback function that will be invoked when a device with MassStorage interface is unmounted
- * \param[in] 	dev_addr Address of newly unmounted device
- * \note        This callback should be used by Application to tear-down interface-related data
- */
+// Invoked when a device with MassStorage interface is unmounted
 void tuh_msc_unmounted_cb(uint8_t dev_addr);
 
 //--------------------------------------------------------------------+
diff --git a/src/host/usbh.c b/src/host/usbh.c
index 595024b9c..7d1201aa4 100644
--- a/src/host/usbh.c
+++ b/src/host/usbh.c
@@ -880,9 +880,12 @@ static bool parse_configuration_descriptor(uint8_t dev_addr, tusb_desc_configura
         }
         else
         {
+          TU_LOG2("%s open\r\n", driver->name);
+
           uint16_t itf_len = 0;
 
-          TU_LOG2("%s open\r\n", driver->name);
+          // TODO class driver can perform control transfer when opening which is
+          // non-blocking --> need a way to coordinate composite device
           TU_ASSERT( driver->open(dev->rhport, dev_addr, desc_itf, &itf_len) );
           TU_ASSERT( itf_len >= sizeof(tusb_desc_interface_t) );
           p_desc += itf_len;
-- 
cgit v1.3.1


From e029d6d7263f4a848c5150a567512f3990358b3f Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Sun, 1 Nov 2020 17:46:46 +0700
Subject: added host set_config driver

to resolve control conflict with SET_CONFIGURE for class driver
- open will be called to open endpoint only
- set_config called later to initialized class driver
---
 src/class/hid/hid_host.c | 91 +++++++++++++++++++++++++++++-------------------
 src/class/hid/hid_host.h |  1 +
 src/class/msc/msc_host.c | 32 +++++++++++------
 src/class/msc/msc_host.h |  1 +
 src/host/usbh.c          | 46 +++++++++++++++++++-----
 src/host/usbh.h          | 12 ++++---
 src/host/usbh_hcd.h      |  3 +-
 7 files changed, 126 insertions(+), 60 deletions(-)

(limited to 'src/class')

diff --git a/src/class/hid/hid_host.c b/src/class/hid/hid_host.c
index 5058191f4..a96eb6276 100644
--- a/src/class/hid/hid_host.c
+++ b/src/class/hid/hid_host.c
@@ -173,39 +173,6 @@ bool hidh_open_subtask(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t c
   tusb_desc_endpoint_t const * p_endpoint_desc = (tusb_desc_endpoint_t const *) p_desc;
   TU_ASSERT(TUSB_DESC_ENDPOINT == p_endpoint_desc->bDescriptorType, TUSB_ERROR_INVALID_PARA);
 
-  // SET IDLE = 0 request
-  // Device can stall if not support this request
-  tusb_control_request_t const request =
-  {
-    .bmRequestType_bit =
-    {
-      .recipient = TUSB_REQ_RCPT_INTERFACE,
-      .type      = TUSB_REQ_TYPE_CLASS,
-      .direction = TUSB_DIR_OUT
-    },
-    .bRequest = HID_REQ_CONTROL_SET_IDLE,
-    .wValue   = 0, // idle_rate = 0
-    .wIndex   = p_interface_desc->bInterfaceNumber,
-    .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);
-
-#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
-
   if ( HID_SUBCLASS_BOOT == p_interface_desc->bInterfaceSubClass )
   {
     #if CFG_TUH_HID_KEYBOARD
@@ -213,7 +180,6 @@ bool hidh_open_subtask(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t c
     {
       TU_ASSERT( hidh_interface_open(rhport, dev_addr, p_interface_desc->bInterfaceNumber, p_endpoint_desc, &keyboardh_data[dev_addr-1]) );
       TU_LOG2_HEX(keyboardh_data[dev_addr-1].ep_in);
-      tuh_hid_keyboard_mounted_cb(dev_addr);
     } else
     #endif
 
@@ -222,7 +188,6 @@ bool hidh_open_subtask(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t c
     {
       TU_ASSERT ( hidh_interface_open(rhport, dev_addr, p_interface_desc->bInterfaceNumber, p_endpoint_desc, &mouseh_data[dev_addr-1]) );
       TU_LOG2_HEX(mouseh_data[dev_addr-1].ep_in);
-      tuh_hid_mouse_mounted_cb(dev_addr);
     } else
     #endif
 
@@ -241,6 +206,62 @@ bool hidh_open_subtask(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t c
   return true;
 }
 
+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
+
+#if 0
+  // SET IDLE = 0 request
+  // Device can stall if not support this request
+  tusb_control_request_t const request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_INTERFACE,
+      .type      = TUSB_REQ_TYPE_CLASS,
+      .direction = TUSB_DIR_OUT
+    },
+    .bRequest = HID_REQ_CONTROL_SET_IDLE,
+    .wValue   = 0, // idle_rate = 0
+    .wIndex   = p_interface_desc->bInterfaceNumber,
+    .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);
+
+#if CFG_TUH_HID_KEYBOARD
+  if ( keyboardh_data[dev_addr-1].itf_num == itf_num)
+  {
+    tuh_hid_keyboard_mounted_cb(dev_addr);
+  }
+#endif
+
+#if CFG_TUH_HID_MOUSE
+  if ( mouseh_data[dev_addr-1].ep_in == itf_num )
+  {
+    tuh_hid_mouse_mounted_cb(dev_addr);
+  }
+#endif
+
+  return true;
+}
+
 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
diff --git a/src/class/hid/hid_host.h b/src/class/hid/hid_host.h
index 324dad203..5c77398f8 100644
--- a/src/class/hid/hid_host.h
+++ b/src/class/hid/hid_host.h
@@ -197,6 +197,7 @@ void tuh_hid_generic_isr(uint8_t dev_addr, xfer_result_t event);
 //--------------------------------------------------------------------+
 void hidh_init(void);
 bool hidh_open_subtask(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length);
+bool hidh_set_config(uint8_t dev_addr, uint8_t itf_num);
 bool hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
 void hidh_close(uint8_t dev_addr);
 
diff --git a/src/class/msc/msc_host.c b/src/class/msc/msc_host.c
index 83423cfc7..02ca81e77 100644
--- a/src/class/msc/msc_host.c
+++ b/src/class/msc/msc_host.c
@@ -334,9 +334,9 @@ bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
 // MSC Enumeration
 //--------------------------------------------------------------------+
 
-static bool open_get_maxlun_complete (uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result);
-static bool open_test_unit_ready_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw);
-static bool open_request_sense_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw);
+static bool config_get_maxlun_complete (uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result);
+static bool config_test_unit_ready_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw);
+static bool config_request_sense_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw);
 
 bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length)
 {
@@ -367,6 +367,14 @@ bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
   p_msc->itf_num = itf_desc->bInterfaceNumber;
   (*p_length) += sizeof(tusb_desc_interface_t) + 2*sizeof(tusb_desc_endpoint_t);
 
+  return true;
+}
+
+bool msch_set_config(uint8_t dev_addr, uint8_t itf_num)
+{
+  msch_interface_t* p_msc = get_itf(dev_addr);
+  TU_ASSERT(p_msc->itf_num == itf_num);
+
   //------------- Get Max Lun -------------//
   TU_LOG2("MSC Get Max Lun\r\n");
   tusb_control_request_t request =
@@ -379,15 +387,15 @@ bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
     },
     .bRequest = MSC_REQ_GET_MAX_LUN,
     .wValue   = 0,
-    .wIndex   = p_msc->itf_num,
+    .wIndex   = itf_num,
     .wLength  = 1
   };
-  TU_ASSERT(tuh_control_xfer(dev_addr, &request, &p_msc->max_lun, open_get_maxlun_complete));
+  TU_ASSERT(tuh_control_xfer(dev_addr, &request, &p_msc->max_lun, config_get_maxlun_complete));
 
   return true;
 }
 
-static bool open_get_maxlun_complete (uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
+static bool config_get_maxlun_complete (uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
 {
   (void) request;
 
@@ -399,17 +407,19 @@ static bool open_get_maxlun_complete (uint8_t dev_addr, tusb_control_request_t c
 
   // TODO multiple LUN support
   TU_LOG2("SCSI Test Unit Ready\r\n");
-  tuh_msc_test_unit_ready(dev_addr, 0, open_test_unit_ready_complete);
+  tuh_msc_test_unit_ready(dev_addr, 0, config_test_unit_ready_complete);
 
   return true;
 }
 
-static bool open_test_unit_ready_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw)
+static bool config_test_unit_ready_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw)
 {
   if (csw->status == 0)
   {
     msch_interface_t* p_msc = get_itf(dev_addr);
 
+    usbh_driver_set_config_complete(dev_addr, p_msc->itf_num);
+
     // Unit is ready, Enumeration is complete
     p_msc->mounted = true;
     tuh_msc_mounted_cb(dev_addr);
@@ -418,16 +428,16 @@ static bool open_test_unit_ready_complete(uint8_t dev_addr, msc_cbw_t const* cbw
     // Note: During enumeration, some device fails Test Unit Ready and require a few retries
     // with Request Sense to start working !!
     // TODO limit number of retries
-    TU_ASSERT(tuh_msc_request_sense(dev_addr, cbw->lun, msch_buffer, open_request_sense_complete));
+    TU_ASSERT(tuh_msc_request_sense(dev_addr, cbw->lun, msch_buffer, config_request_sense_complete));
   }
 
   return true;
 }
 
-static bool open_request_sense_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw)
+static bool config_request_sense_complete(uint8_t dev_addr, msc_cbw_t const* cbw, msc_csw_t const* csw)
 {
   TU_ASSERT(csw->status == 0);
-  TU_ASSERT(tuh_msc_test_unit_ready(dev_addr, cbw->lun, open_test_unit_ready_complete));
+  TU_ASSERT(tuh_msc_test_unit_ready(dev_addr, cbw->lun, config_test_unit_ready_complete));
   return true;
 }
 
diff --git a/src/class/msc/msc_host.h b/src/class/msc/msc_host.h
index 06b1067cc..5913350b8 100644
--- a/src/class/msc/msc_host.h
+++ b/src/class/msc/msc_host.h
@@ -125,6 +125,7 @@ void tuh_msc_unmounted_cb(uint8_t dev_addr);
 
 void msch_init(void);
 bool msch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length);
+bool msch_set_config(uint8_t dev_addr, uint8_t itf_num);
 bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
 void msch_close(uint8_t dev_addr);
 
diff --git a/src/host/usbh.c b/src/host/usbh.c
index 7d1201aa4..3e321652b 100644
--- a/src/host/usbh.c
+++ b/src/host/usbh.c
@@ -67,6 +67,7 @@ static usbh_class_driver_t const usbh_class_drivers[] =
       .class_code = TUSB_CLASS_MSC,
       .init       = msch_init,
       .open       = msch_open,
+      .set_config = msch_set_config,
       .xfer_cb    = msch_xfer_cb,
       .close      = msch_close
     },
@@ -78,6 +79,7 @@ static usbh_class_driver_t const usbh_class_drivers[] =
       .class_code = TUSB_CLASS_HID,
       .init       = hidh_init,
       .open       = hidh_open_subtask,
+      .set_config = hidh_set_config,
       .xfer_cb    = hidh_xfer_cb,
       .close      = hidh_close
     },
@@ -308,6 +310,7 @@ bool usbh_edpt_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_endpoint_t const
     usbh_device_t* dev = &_usbh_devices[dev_addr];
 
     // new endpoints belongs to latest interface (last valid value)
+    // TODO FIXME not true with ISO
     uint8_t drvid = 0xff;
     for(uint8_t i=0; i < sizeof(dev->itf2drv); i++)
     {
@@ -525,6 +528,31 @@ static uint8_t get_new_address(void)
   return CFG_TUSB_HOST_DEVICE_MAX+1;
 }
 
+void usbh_driver_set_config_complete(uint8_t dev_addr, uint8_t itf_num)
+{
+  usbh_device_t* dev = &_usbh_devices[dev_addr];
+
+  for(itf_num++; itf_num < sizeof(dev->itf2drv); itf_num++)
+  {
+    // continue with next valid interface
+    uint8_t const drv_id = dev->itf2drv[itf_num];
+    if (drv_id != 0xff)
+    {
+      usbh_class_driver_t const * driver = &usbh_class_drivers[drv_id];
+      TU_LOG2("%s set config itf = %u\r\n", driver->name, itf_num);
+      driver->set_config(dev_addr, itf_num);
+      break;
+    }
+  }
+
+  // all interface are configured
+  if (itf_num == sizeof(dev->itf2drv))
+  {
+    // Invoke callback if available
+    if (tuh_mount_cb) tuh_mount_cb(dev_addr);
+  }
+}
+
 //--------------------------------------------------------------------+
 // Enumeration Process
 // is a lengthy process with a seires of control transfer to configure
@@ -783,6 +811,7 @@ static bool enum_get_9byte_config_desc_complete(uint8_t dev_addr, tusb_control_r
     .wValue   = (TUSB_DESC_CONFIGURATION << 8) | (CONFIG_NUM - 1),
     .wIndex   = 0,
     .wLength  = total_len
+
   };
 
   TU_ASSERT( tuh_control_xfer(dev_addr, &new_request, _usbh_ctrl_buf, enum_get_config_desc_complete) );
@@ -795,6 +824,10 @@ static bool enum_get_config_desc_complete(uint8_t dev_addr, tusb_control_request
   (void) request;
   TU_ASSERT(XFER_RESULT_SUCCESS == result);
 
+  // Parse configuration & set up drivers
+  // Driver open aren't allowed to make any usb transfer yet
+  parse_configuration_descriptor(dev_addr, (tusb_desc_configuration_t*) _usbh_ctrl_buf);
+
   TU_LOG2("Set Configuration Descriptor\r\n");
   tusb_control_request_t const new_request =
   {
@@ -825,12 +858,10 @@ static bool enum_set_config_complete(uint8_t dev_addr, tusb_control_request_t co
   dev->configured = 1;
   dev->state = TUSB_DEVICE_STATE_CONFIGURED;
 
-  // Parse configuration & set up drivers
-  // TODO driver open still use usbh_control_xfer
-  parse_configuration_descriptor(dev_addr, (tusb_desc_configuration_t*) _usbh_ctrl_buf);
-
-  // Invoke callback if available
-  if (tuh_mount_cb) tuh_mount_cb(dev_addr);
+  // Start the Set Configuration process for interfaces (itf = 0xff)
+  // Since driver can perform control transfer within its set_config, this is done asynchronously.
+  // The process continue with next interface when class driver complete its sequence with usbh_driver_set_config_complete()
+  usbh_driver_set_config_complete(dev_addr, 0xff);
 
   return true;
 }
@@ -883,9 +914,6 @@ static bool parse_configuration_descriptor(uint8_t dev_addr, tusb_desc_configura
           TU_LOG2("%s open\r\n", driver->name);
 
           uint16_t itf_len = 0;
-
-          // TODO class driver can perform control transfer when opening which is
-          // non-blocking --> need a way to coordinate composite device
           TU_ASSERT( driver->open(dev->rhport, dev_addr, desc_itf, &itf_len) );
           TU_ASSERT( itf_len >= sizeof(tusb_desc_interface_t) );
           p_desc += itf_len;
diff --git a/src/host/usbh.h b/src/host/usbh.h
index fde1dd11c..19ab72f54 100644
--- a/src/host/usbh.h
+++ b/src/host/usbh.h
@@ -58,10 +58,11 @@ typedef struct {
 
   uint8_t class_code;
 
-  void (* const init) (void);
-  bool (* const open)(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const * itf_desc, uint16_t* outlen);
-  bool (* const xfer_cb) (uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
-  void (* const close) (uint8_t);
+  void (* const init       )(void);
+  bool (* const open       )(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const * itf_desc, uint16_t* outlen);
+  bool (* const set_config )(uint8_t dev_addr, uint8_t itf_num);
+  bool (* const xfer_cb    )(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes);
+  void (* const close      )(uint8_t dev_addr);
 } usbh_class_driver_t;
 
 typedef bool (*tuh_control_complete_cb_t)(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result);
@@ -105,6 +106,7 @@ TU_ATTR_WEAK void tuh_umount_cb(uint8_t dev_addr);
 
 //--------------------------------------------------------------------+
 // CLASS-USBH & INTERNAL API
+// TODO move to usbh_pvt.h
 //--------------------------------------------------------------------+
 
 bool usbh_edpt_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_endpoint_t const * ep_desc);
@@ -116,6 +118,8 @@ bool usbh_edpt_claim(uint8_t dev_addr, uint8_t ep_addr);
 
 bool usbh_control_xfer (uint8_t dev_addr, tusb_control_request_t* request, uint8_t* data); // TODO remove later
 
+void usbh_driver_set_config_complete(uint8_t dev_addr, uint8_t itf_num);
+
 #ifdef __cplusplus
  }
 #endif
diff --git a/src/host/usbh_hcd.h b/src/host/usbh_hcd.h
index 20348eed1..79b547fb3 100644
--- a/src/host/usbh_hcd.h
+++ b/src/host/usbh_hcd.h
@@ -47,6 +47,8 @@
 //--------------------------------------------------------------------+
 // USBH-HCD common data structure
 //--------------------------------------------------------------------+
+
+// TODO move to usbh.c
 typedef struct {
   //------------- port -------------//
   uint8_t rhport;
@@ -95,7 +97,6 @@ typedef struct {
     // TODO merge ep2drv here, 4-bit should be sufficient
   }ep_status[CFG_TUH_EP_MAX][2];
 
-
 // Mutex for claiming endpoint, only needed when using with preempted RTOS
 #if CFG_TUSB_OS != OPT_OS_NONE
   osal_mutex_def_t mutexdef;
-- 
cgit v1.3.1


From 14461beffa4f2e12bc37d523701be65fabd0d8ce Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Mon, 2 Nov 2020 09:19:34 +0700
Subject: remove legacy blocking usbh_control_xfer()

reworking cdc host driver
---
 src/class/cdc/cdc_host.c | 50 +++++++++++++++++++++++++++++++++---------------
 src/class/cdc/cdc_host.h | 13 +++++++++++++
 src/host/usbh.c          | 48 +---------------------------------------------
 src/host/usbh_hcd.h      | 10 ----------
 4 files changed, 49 insertions(+), 72 deletions(-)

(limited to 'src/class')

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index ae1eef8a7..a897fb58a 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -51,9 +51,14 @@ typedef struct {
 //--------------------------------------------------------------------+
 static cdch_data_t cdch_data[CFG_TUSB_HOST_DEVICE_MAX];
 
+static inline cdch_data_t* get_itf(uint8_t dev_addr)
+{
+  return &cdch_data[dev_addr-1];
+}
+
 bool tuh_cdc_mounted(uint8_t dev_addr)
 {
-  cdch_data_t* cdc = &cdch_data[dev_addr-1];
+  cdch_data_t* cdc = get_itf(dev_addr);
   return cdc->ep_in && cdc->ep_out;
 }
 
@@ -61,7 +66,7 @@ bool tuh_cdc_is_busy(uint8_t dev_addr, cdc_pipeid_t pipeid)
 {
   if ( !tuh_cdc_mounted(dev_addr) ) return false;
 
-  cdch_data_t const * p_cdc = &cdch_data[dev_addr-1];
+  cdch_data_t const * p_cdc = get_itf(dev_addr);
 
   switch (pipeid)
   {
@@ -111,6 +116,27 @@ bool tuh_cdc_receive(uint8_t dev_addr, void * p_buffer, uint32_t length, bool is
   return hcd_pipe_xfer(dev_addr, ep_in, p_buffer, length, is_notify);
 }
 
+bool tuh_cdc_set_control_line_state(uint8_t dev_addr, bool dtr, bool rts, tuh_control_complete_cb_t complete_cb)
+{
+  cdch_data_t const * p_cdc = get_itf(dev_addr);
+  tusb_control_request_t const request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_INTERFACE,
+      .type      = TUSB_REQ_TYPE_CLASS,
+      .direction = TUSB_DIR_OUT
+    },
+    .bRequest = CDC_REQUEST_SET_CONTROL_LINE_STATE,
+    .wValue   = (rts ? 2 : 0) | (dtr ? 1 : 0),
+    .wIndex   = p_cdc->itf_num,
+    .wLength  = 0
+  };
+
+  TU_ASSERT( tuh_control_xfer(dev_addr, &request, NULL, complete_cb) );
+  return true;
+}
+
 //--------------------------------------------------------------------+
 // USBH-CLASS DRIVER API
 //--------------------------------------------------------------------+
@@ -132,7 +158,7 @@ bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
   cdch_data_t * p_cdc;
 
   p_desc = tu_desc_next(itf_desc);
-  p_cdc  = &cdch_data[dev_addr-1];
+  p_cdc  = get_itf(dev_addr);
 
   p_cdc->itf_num   = itf_desc->bInterfaceNumber;
   p_cdc->itf_protocol = itf_desc->bInterfaceProtocol; // TODO 0xff is consider as rndis candidate, other is virtual Com
@@ -194,18 +220,12 @@ bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *it
     }
   }
 
-  // FIXME move to seperate API : connect
-  tusb_control_request_t request =
-  {
-    .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_INTERFACE, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_OUT },
-    .bRequest = CDC_REQUEST_SET_CONTROL_LINE_STATE,
-    .wValue = 0x03, // dtr on, cst on
-    .wIndex = p_cdc->itf_num,
-    .wLength = 0
-  };
-
-  TU_ASSERT( usbh_control_xfer(dev_addr, &request, NULL) );
+  return true;
+}
 
+bool cdch_set_config(uint8_t dev_addr, uint8_t itf_num)
+{
+  (void) dev_addr; (void) itf_num;
   return true;
 }
 
@@ -218,7 +238,7 @@ bool cdch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
 
 void cdch_close(uint8_t dev_addr)
 {
-  cdch_data_t * p_cdc = &cdch_data[dev_addr-1];
+  cdch_data_t * p_cdc = get_itf(dev_addr);
   tu_memclr(p_cdc, sizeof(cdch_data_t));
 }
 
diff --git a/src/class/cdc/cdc_host.h b/src/class/cdc/cdc_host.h
index f28a0a713..66c2f0727 100644
--- a/src/class/cdc/cdc_host.h
+++ b/src/class/cdc/cdc_host.h
@@ -44,6 +44,18 @@
  * \defgroup   CDC_Serial_Host Host
  * @{ */
 
+bool tuh_cdc_set_control_line_state(uint8_t dev_addr, bool dtr, bool rts, tuh_control_complete_cb_t complete_cb);
+
+static inline bool tuh_cdc_connect(uint8_t dev_addr, tuh_control_complete_cb_t complete_cb)
+{
+  return tuh_cdc_set_control_line_state(dev_addr, true, true, complete_cb);
+}
+
+static inline bool tuh_cdc_disconnect(uint8_t dev_addr, tuh_control_complete_cb_t complete_cb)
+{
+  return tuh_cdc_set_control_line_state(dev_addr, false, false, complete_cb);
+}
+
 /** \brief 			Check if device support CDC Serial interface or not
  * \param[in]		dev_addr	device address
  * \retval      true if device supports
@@ -113,6 +125,7 @@ void tuh_cdc_xfer_isr(uint8_t dev_addr, xfer_result_t event, cdc_pipeid_t pipe_i
 //--------------------------------------------------------------------+
 void cdch_init(void);
 bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length);
+bool cdch_set_config(uint8_t dev_addr, uint8_t itf_num);
 bool cdch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
 void cdch_close(uint8_t dev_addr);
 
diff --git a/src/host/usbh.c b/src/host/usbh.c
index 61db0d8b0..e7347ff56 100644
--- a/src/host/usbh.c
+++ b/src/host/usbh.c
@@ -56,6 +56,7 @@ static usbh_class_driver_t const usbh_class_drivers[] =
       .class_code = TUSB_CLASS_CDC,
       .init       = cdch_init,
       .open       = cdch_open,
+      .set_config = cdch_set_config,
       .xfer_cb    = cdch_xfer_cb,
       .close      = cdch_close
     },
@@ -174,9 +175,6 @@ bool tuh_init(void)
   {
     usbh_device_t * const dev = &_usbh_devices[i];
 
-    dev->control.sem_hdl = osal_semaphore_create(&dev->control.sem_def);
-    TU_ASSERT(dev->control.sem_hdl != NULL);
-
 #if CFG_TUSB_OS != OPT_OS_NONE
     dev->mutex = osal_mutex_create(&dev->mutexdef);
     TU_ASSERT(dev->mutex);
@@ -199,38 +197,6 @@ bool tuh_init(void)
   return true;
 }
 
-//------------- USBH control transfer -------------//
-
-// TODO remove
-bool usbh_control_xfer (uint8_t dev_addr, tusb_control_request_t* request, uint8_t* data)
-{
-  usbh_device_t* dev = &_usbh_devices[dev_addr];
-  const uint8_t rhport = dev->rhport;
-
-  dev->control.request = *request;
-  dev->control.pipe_status = 0;
-
-  // Setup Stage
-  hcd_setup_send(rhport, dev_addr, (uint8_t*) &dev->control.request);
-  TU_VERIFY(osal_semaphore_wait(dev->control.sem_hdl, OSAL_TIMEOUT_NORMAL));
-
-  // Data stage : first data toggle is always 1
-  if ( request->wLength )
-  {
-    hcd_edpt_xfer(rhport, dev_addr, tu_edpt_addr(0, request->bmRequestType_bit.direction), data, request->wLength);
-    TU_VERIFY(osal_semaphore_wait(dev->control.sem_hdl, OSAL_TIMEOUT_NORMAL));
-  }
-
-  // Status : data toggle is always 1
-  hcd_edpt_xfer(rhport, dev_addr, tu_edpt_addr(0, 1-request->bmRequestType_bit.direction), NULL, 0);
-  TU_VERIFY(osal_semaphore_wait(dev->control.sem_hdl, OSAL_TIMEOUT_NORMAL));
-
-  if ( XFER_RESULT_STALLED == dev->control.pipe_status ) return false;
-  if ( XFER_RESULT_FAILED == dev->control.pipe_status ) return false;
-
-  return true;
-}
-
 bool usbh_edpt_claim(uint8_t dev_addr, uint8_t ep_addr)
 {
   uint8_t const epnum = tu_edpt_number(ep_addr);
@@ -291,9 +257,6 @@ bool usbh_edpt_xfer(uint8_t dev_addr, uint8_t ep_addr, uint8_t * buffer, uint16_
 
 bool usbh_pipe_control_open(uint8_t dev_addr, uint8_t max_packet_size)
 {
-  osal_semaphore_reset( _usbh_devices[dev_addr].control.sem_hdl );
-  //osal_mutex_reset( usbh_devices[dev_addr].control.mutex_hdl );
-      
   tusb_desc_endpoint_t ep0_desc =
   {
     .bLength          = sizeof(tusb_desc_endpoint_t),
@@ -349,15 +312,6 @@ void hcd_event_handler(hcd_event_t const* event, bool in_isr)
 // interrupt caused by a TD (with IOC=1) in pipe of class class_code
 void hcd_event_xfer_complete(uint8_t dev_addr, uint8_t ep_addr, uint32_t xferred_bytes, xfer_result_t result, bool in_isr)
 {
-  usbh_device_t* dev = &_usbh_devices[ dev_addr ];
-
-  if (0 == tu_edpt_number(ep_addr))
-  {
-    dev->control.pipe_status = result;
-//    usbh_devices[ pipe_hdl.dev_addr ].control.xferred_bytes = xferred_bytes; not yet neccessary
-    osal_semaphore_post( dev->control.sem_hdl, true ); // FIXME post within ISR
-  }
-
   hcd_event_t event =
   {
     .rhport   = 0, // TODO correct rhport
diff --git a/src/host/usbh_hcd.h b/src/host/usbh_hcd.h
index dd0616704..abc7fd250 100644
--- a/src/host/usbh_hcd.h
+++ b/src/host/usbh_hcd.h
@@ -75,16 +75,6 @@ typedef struct {
 
   volatile uint8_t state;             // device state, value from enum tusbh_device_state_t
 
-  //------------- control pipe -------------//
-  struct {
-    volatile uint8_t pipe_status;
-//    uint8_t xferred_bytes; TODO not yet necessary
-    tusb_control_request_t request;
-
-    osal_semaphore_def_t sem_def;
-    osal_semaphore_t sem_hdl;  // used to synchronize with HCD when control xfer complete
-  } control;
-
   uint8_t itf2drv[16];  // map interface number to driver (0xff is invalid)
   uint8_t ep2drv[CFG_TUH_EP_MAX][2]; // map endpoint to driver ( 0xff is invalid )
 
-- 
cgit v1.3.1