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 ++++++++++++++++++++++++++++++------
 1 file changed, 82 insertions(+), 15 deletions(-)

(limited to 'examples/host/cdc_msc_hid/src')

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
 //--------------------------------------------------------------------+
-- 
cgit v1.3.1


From 828f720207d4ded25ed533ea6c52da49c799b476 Mon Sep 17 00:00:00 2001
From: hathach <thach@tinyusb.org>
Date: Sat, 5 Sep 2020 20:20:45 +0700
Subject: refactor hub class

- separate connect/disconnect handling
- hub work with full speed, but doesn't seem to work with Low speed
device (with mcb1800)
- need to update msc host after migrating from isr to xfer_cb (blocked
at inquiry)
---
 examples/host/cdc_msc_hid/src/tusb_config.h |   2 +-
 src/host/ehci/ehci.c                        |   2 +-
 src/host/hcd.h                              |   3 +-
 src/host/hub.c                              | 110 +++++++++++++---------------
 src/host/hub.h                              |  34 ++++-----
 src/host/usbh.c                             | 106 +++++++++++----------------
 6 files changed, 117 insertions(+), 140 deletions(-)

(limited to 'examples/host/cdc_msc_hid/src')

diff --git a/examples/host/cdc_msc_hid/src/tusb_config.h b/examples/host/cdc_msc_hid/src/tusb_config.h
index 6604623b1..d8cf993be 100644
--- a/examples/host/cdc_msc_hid/src/tusb_config.h
+++ b/examples/host/cdc_msc_hid/src/tusb_config.h
@@ -69,7 +69,7 @@
 // CONFIGURATION
 //--------------------------------------------------------------------
 
-#define CFG_TUH_HUB                 0
+#define CFG_TUH_HUB                 1
 #define CFG_TUH_CDC                 1
 #define CFG_TUH_HID_KEYBOARD        1
 #define CFG_TUH_HID_MOUSE           1
diff --git a/src/host/ehci/ehci.c b/src/host/ehci/ehci.c
index c2d5ebf7b..13e9b0edc 100644
--- a/src/host/ehci/ehci.c
+++ b/src/host/ehci/ehci.c
@@ -533,7 +533,7 @@ static void async_list_xfer_complete_isr(ehci_qhd_t * const async_head)
 
 static void period_list_xfer_complete_isr(uint8_t hostid, uint8_t interval_ms)
 {
-  uint8_t max_loop = 0;
+  uint16_t max_loop = 0;
   uint32_t const period_1ms_addr = (uint32_t) get_period_head(hostid, 1);
   ehci_link_t next_item = * get_period_head(hostid, interval_ms);
 
diff --git a/src/host/hcd.h b/src/host/hcd.h
index eebf2c801..ba3035300 100644
--- a/src/host/hcd.h
+++ b/src/host/hcd.h
@@ -55,10 +55,11 @@ typedef struct
 
   union
   {
+    // Attach, Remove
     struct {
       uint8_t hub_addr;
       uint8_t hub_port;
-    } attach, remove;
+    } connection;
 
     // XFER_COMPLETE
     struct {
diff --git a/src/host/hub.c b/src/host/hub.c
index f88056c92..db1ca0786 100644
--- a/src/host/hub.c
+++ b/src/host/hub.c
@@ -33,6 +33,8 @@
 //--------------------------------------------------------------------+
 #include "hub.h"
 
+extern void osal_task_delay(uint32_t msec); // TODO remove
+
 //--------------------------------------------------------------------+
 // MACRO CONSTANT TYPEDEF
 //--------------------------------------------------------------------+
@@ -53,7 +55,7 @@ TU_ATTR_ALIGNED(4) CFG_TUSB_MEM_SECTION static uint8_t hub_enum_buffer[sizeof(de
 //--------------------------------------------------------------------+
 // HUB
 //--------------------------------------------------------------------+
-bool hub_port_clear_feature_subtask(uint8_t hub_addr, uint8_t hub_port, uint8_t feature)
+bool hub_port_clear_feature(uint8_t hub_addr, uint8_t hub_port, uint8_t feature)
 {
   TU_ASSERT(HUB_FEATURE_PORT_CONNECTION_CHANGE <= feature && feature <= HUB_FEATURE_PORT_RESET_CHANGE);
 
@@ -65,33 +67,35 @@ bool hub_port_clear_feature_subtask(uint8_t hub_addr, uint8_t hub_port, uint8_t
           .wLength = 0
   };
 
-  //------------- Clear Port Feature request -------------//
   TU_ASSERT( usbh_control_xfer( hub_addr, &request, NULL ) );
+  return true;
+}
 
-  //------------- Get Port Status to check if feature is cleared -------------//
-  request = (tusb_control_request_t ) {
-        .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_OTHER, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_IN },
-        .bRequest = HUB_REQUEST_GET_STATUS,
-        .wValue = 0,
-        .wIndex = hub_port,
-        .wLength = 4
+bool hub_port_get_status(uint8_t hub_addr, uint8_t hub_port, hub_port_status_response_t* resp)
+{
+  tusb_control_request_t request =
+  {
+    .bmRequestType_bit =
+    {
+      .recipient = TUSB_REQ_RCPT_OTHER,
+      .type      = TUSB_REQ_TYPE_CLASS,
+      .direction = TUSB_DIR_IN
+    },
+
+    .bRequest = HUB_REQUEST_GET_STATUS,
+    .wValue   = 0,
+    .wIndex   = hub_port,
+    .wLength  = 4
   };
 
   TU_ASSERT( usbh_control_xfer( hub_addr, &request, hub_enum_buffer ) );
 
-  //------------- Check if feature is cleared -------------//
-  hub_port_status_response_t * p_port_status;
-  p_port_status = (hub_port_status_response_t *) hub_enum_buffer;
-
-  TU_ASSERT( !tu_bit_test(p_port_status->status_change.value, feature-16)  );
-
+  memcpy(resp, hub_enum_buffer, sizeof(hub_port_status_response_t));
   return true;
 }
 
-bool hub_port_reset_subtask(uint8_t hub_addr, uint8_t hub_port)
+bool hub_port_reset(uint8_t hub_addr, uint8_t hub_port)
 {
-  enum { RESET_DELAY = 200 }; // USB specs say only 50ms but many devices require much longer
-
   //------------- Set Port Reset -------------//
   tusb_control_request_t request = {
           .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_OTHER, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_OUT },
@@ -102,37 +106,9 @@ bool hub_port_reset_subtask(uint8_t hub_addr, uint8_t hub_port)
   };
 
   TU_ASSERT( usbh_control_xfer( hub_addr, &request, NULL ) );
-
-  osal_task_delay(RESET_DELAY); // TODO Hub wait for Status Endpoint on Reset Change
-
-  //------------- Get Port Status to check if port is enabled, powered and reset_change -------------//
-  request = (tusb_control_request_t ) {
-        .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_OTHER, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_IN },
-        .bRequest = HUB_REQUEST_GET_STATUS,
-        .wValue = 0,
-        .wIndex = hub_port,
-        .wLength = 4
-  };
-
-  TU_ASSERT( usbh_control_xfer( hub_addr, &request, hub_enum_buffer ) );
-
-  hub_port_status_response_t * p_port_status;
-  p_port_status = (hub_port_status_response_t *) hub_enum_buffer;
-
-  TU_ASSERT ( p_port_status->status_change.reset && p_port_status->status_current.connect_status &&
-              p_port_status->status_current.port_power && p_port_status->status_current.port_enable);
-
   return true;
 }
 
-// can only get the speed RIGHT AFTER hub_port_reset_subtask call
-tusb_speed_t hub_port_get_speed(void)
-{
-  hub_port_status_response_t * p_port_status = (hub_port_status_response_t *) hub_enum_buffer;
-  return (p_port_status->status_current.high_speed_device_attached) ? TUSB_SPEED_HIGH :
-         (p_port_status->status_current.low_speed_device_attached ) ? TUSB_SPEED_LOW  : TUSB_SPEED_FULL;
-}
-
 //--------------------------------------------------------------------+
 // CLASS-USBH API (don't require to verify parameters)
 //--------------------------------------------------------------------+
@@ -199,31 +175,49 @@ 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 event, uint32_t xferred_bytes)
+void 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;
 
   usbh_hub_t * p_hub = &hub_data[dev_addr-1];
 
-  if ( event == XFER_RESULT_SUCCESS )
+  if ( result == XFER_RESULT_SUCCESS )
   {
+    TU_LOG2("Port Status Change = 0x%02X\r\n", p_hub->status_change);
     for (uint8_t port=1; port <= p_hub->port_number; port++)
     {
       // TODO HUB ignore bit0 hub_status_change
       if ( tu_bit_test(p_hub->status_change, port) )
       {
-        hcd_event_t event =
-        {
-          .rhport = _usbh_devices[dev_addr].rhport,
-          .event_id = HCD_EVENT_DEVICE_ATTACH
-        };
-
-        event.attach.hub_addr = dev_addr;
-        event.attach.hub_port = port;
+        hub_port_status_response_t port_status;
+        hub_port_get_status(dev_addr, port, &port_status);
 
-        hcd_event_handler(&event, true);
-        break; // TODO handle one port at a time, next port if any will be handled in the next cycle
+        // Connection change
+        if (port_status.change.connection)
+        {
+          // Port is powered and enabled
+          //TU_VERIFY(port_status.status_current.port_power && port_status.status_current.port_enable, );
+
+          // Acknowledge Port Connection Change
+          hub_port_clear_feature(dev_addr, port, HUB_FEATURE_PORT_CONNECTION_CHANGE);
+
+          // Reset port if attach event
+          if ( port_status.status.connection ) hub_port_reset(dev_addr, port);
+
+          hcd_event_t event =
+          {
+            .rhport     = _usbh_devices[dev_addr].rhport,
+            .event_id   = port_status.status.connection ? HCD_EVENT_DEVICE_ATTACH : HCD_EVENT_DEVICE_REMOVE,
+            .connection =
+            {
+              .hub_addr = dev_addr,
+              .hub_port = port
+            }
+          };
+
+          hcd_event_handler(&event, true);
+        }
       }
     }
     // NOTE: next status transfer is queued by usbh.c after handling this request
diff --git a/src/host/hub.h b/src/host/hub.h
index 8f307190b..71dd39b8d 100644
--- a/src/host/hub.h
+++ b/src/host/hub.h
@@ -142,7 +142,7 @@ typedef struct {
     };
 
     uint16_t value;
-  } status, status_change;
+  } status, change;
 } hub_status_response_t;
 
 TU_VERIFY_STATIC( sizeof(hub_status_response_t) == 4, "size is not correct");
@@ -151,30 +151,30 @@ TU_VERIFY_STATIC( sizeof(hub_status_response_t) == 4, "size is not correct");
 typedef struct {
   union {
     struct TU_ATTR_PACKED {
-      uint16_t connect_status             : 1;
-      uint16_t port_enable                : 1;
-      uint16_t suspend                    : 1;
-      uint16_t over_current               : 1;
-      uint16_t reset                      : 1;
-
-      uint16_t                            : 3;
-      uint16_t port_power                 : 1;
-      uint16_t low_speed_device_attached  : 1;
-      uint16_t high_speed_device_attached : 1;
-      uint16_t port_test_mode             : 1;
-      uint16_t port_indicator_control     : 1;
+      uint16_t connection             : 1;
+      uint16_t port_enable            : 1;
+      uint16_t suspend                : 1;
+      uint16_t over_current           : 1;
+      uint16_t reset                  : 1;
+
+      uint16_t                        : 3;
+      uint16_t port_power             : 1;
+      uint16_t low_speed              : 1;
+      uint16_t high_speed             : 1;
+      uint16_t port_test_mode         : 1;
+      uint16_t port_indicator_control : 1;
       uint16_t : 0;
     };
 
     uint16_t value;
-  } status_current, status_change;
+  } status, change;
 } hub_port_status_response_t;
 
 TU_VERIFY_STATIC( sizeof(hub_port_status_response_t) == 4, "size is not correct");
 
-bool hub_port_reset_subtask(uint8_t hub_addr, uint8_t hub_port);
-bool hub_port_clear_feature_subtask(uint8_t hub_addr, uint8_t hub_port, uint8_t feature);
-tusb_speed_t hub_port_get_speed(void);
+bool hub_port_reset(uint8_t hub_addr, uint8_t hub_port);
+bool hub_port_get_status(uint8_t hub_addr, uint8_t hub_port, hub_port_status_response_t* resp);
+bool hub_port_clear_feature(uint8_t hub_addr, uint8_t hub_port, uint8_t feature);
 bool hub_status_pipe_queue(uint8_t dev_addr);
 
 //--------------------------------------------------------------------+
diff --git a/src/host/usbh.c b/src/host/usbh.c
index 2e1fed5e3..fd0e9ee18 100644
--- a/src/host/usbh.c
+++ b/src/host/usbh.c
@@ -137,7 +137,7 @@ tusb_device_state_t tuh_device_get_state (uint8_t const dev_addr)
   return (tusb_device_state_t) _usbh_devices[dev_addr].state;
 }
 
-static inline void osal_task_delay(uint32_t msec)
+void osal_task_delay(uint32_t msec)
 {
   (void) msec;
 
@@ -305,8 +305,8 @@ void hcd_event_device_attach(uint8_t rhport, bool in_isr)
     .event_id = HCD_EVENT_DEVICE_ATTACH
   };
 
-  event.attach.hub_addr = 0;
-  event.attach.hub_port = 0;
+  event.connection.hub_addr = 0;
+  event.connection.hub_port = 0;
 
   hcd_event_handler(&event, in_isr);
 }
@@ -319,8 +319,8 @@ void hcd_event_device_remove(uint8_t hostid, bool in_isr)
     .event_id = HCD_EVENT_DEVICE_REMOVE
   };
 
-  event.attach.hub_addr = 0;
-  event.attach.hub_port = 0;
+  event.connection.hub_addr = 0;
+  event.connection.hub_port = 0;
 
   hcd_event_handler(&event, in_isr);
 }
@@ -434,78 +434,44 @@ bool enum_task(hcd_event_t* event)
   tusb_control_request_t request;
 
   dev0->rhport   = event->rhport; // TODO refractor integrate to device_pool
-  dev0->hub_addr = event->attach.hub_addr;
-  dev0->hub_port = event->attach.hub_port;
+  dev0->hub_addr = event->connection.hub_addr;
+  dev0->hub_port = event->connection.hub_port;
   dev0->state    = TUSB_DEVICE_STATE_UNPLUG;
 
   //------------- connected/disconnected directly with roothub -------------//
   if ( dev0->hub_addr == 0)
   {
-    if( hcd_port_connect_status(dev0->rhport) )
-    {
-      TU_LOG2("Device connect \r\n");
-
-      // connection event
-      osal_task_delay(POWER_STABLE_DELAY); // wait until device is stable. Increase this if the first 8 bytes is failed to get
-
-      // exit if device unplugged while delaying
-      if ( !hcd_port_connect_status(dev0->rhport) ) return true;
+    // wait until device is stable. Increase this if the first 8 bytes is failed to get
+    osal_task_delay(POWER_STABLE_DELAY);
 
-      hcd_port_reset( dev0->rhport ); // port must be reset to have correct speed operation
-      osal_task_delay(RESET_DELAY);
+    // device unplugged while delaying
+    if ( !hcd_port_connect_status(dev0->rhport) ) return true;
 
-      dev0->speed = hcd_port_speed_get( dev0->rhport );
-    }
-    else
-    {
-      TU_LOG2("Device disconnect \r\n");
+    hcd_port_reset( dev0->rhport ); // port must be reset to have correct speed operation
+    osal_task_delay(RESET_DELAY);
 
-      // disconnection event
-      usbh_device_unplugged(dev0->rhport, 0, 0);
-      return true; // restart task
-    }
+    dev0->speed = hcd_port_speed_get( dev0->rhport );
   }
 #if CFG_TUH_HUB
   //------------- connected/disconnected via hub -------------//
   else
   {
-    //------------- Get Port Status -------------//
-    request = (tusb_control_request_t ) {
-          .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_OTHER, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_IN },
-          .bRequest = HUB_REQUEST_GET_STATUS,
-          .wValue = 0,
-          .wIndex = dev0->hub_port,
-          .wLength = 4
-    };
-    // TODO hub refractor
-    TU_VERIFY_HDLR( usbh_control_xfer( dev0->hub_addr, &request, _usbh_ctrl_buf ), hub_status_pipe_queue( dev0->hub_addr) );
+    // TODO wait for PORT reset change instead
+    osal_task_delay(POWER_STABLE_DELAY);
 
-    // Acknowledge Port Connection Change
-    hub_port_clear_feature_subtask(dev0->hub_addr, dev0->hub_port, HUB_FEATURE_PORT_CONNECTION_CHANGE);
+    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) );
 
-    hub_port_status_response_t * p_port_status;
-    p_port_status = ((hub_port_status_response_t *) _usbh_ctrl_buf);
+    // device unplugged while delaying
+    if ( !port_status.status.connection ) return true;
 
-    if ( ! p_port_status->status_change.connect_status )   return true; // only handle connection change
+    dev0->speed = (port_status.status.high_speed) ? TUSB_SPEED_HIGH :
+                  (port_status.status.low_speed ) ? TUSB_SPEED_LOW  : TUSB_SPEED_FULL;
 
-    if ( ! p_port_status->status_current.connect_status )
+    // Acknowledge Port Reset Change
+    if (port_status.change.reset)
     {
-      // Disconnection event
-      usbh_device_unplugged(dev0->rhport, dev0->hub_addr, dev0->hub_port);
-
-      (void) hub_status_pipe_queue( dev0->hub_addr ); // done with hub, waiting for next data on status pipe
-      return true; // restart task
-    }
-    else
-    {
-      // Connection Event
-      TU_VERIFY_HDLR(hub_port_reset_subtask(dev0->hub_addr, dev0->hub_port),
-                     hub_status_pipe_queue( dev0->hub_addr) ); // TODO hub refractor
-
-      dev0->speed = hub_port_get_speed();
-
-      // Acknowledge Port Reset Change
-      hub_port_clear_feature_subtask(dev0->hub_addr, dev0->hub_port, HUB_FEATURE_PORT_RESET_CHANGE);
+      hub_port_clear_feature(dev0->hub_addr, dev0->hub_port, HUB_FEATURE_PORT_RESET_CHANGE);
     }
   }
 #endif // CFG_TUH_HUB
@@ -540,10 +506,12 @@ bool enum_task(hcd_event_t* event)
     // connected via a hub
     TU_VERIFY_HDLR(is_ok, hub_status_pipe_queue( dev0->hub_addr) ); // TODO hub refractor
 
-    if ( hub_port_reset_subtask(dev0->hub_addr, dev0->hub_port) )
+    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_subtask(dev0->hub_addr, dev0->hub_port, HUB_FEATURE_PORT_RESET_CHANGE);
+      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
@@ -676,10 +644,24 @@ void tuh_task(void)
     switch (event.event_id)
     {
       case HCD_EVENT_DEVICE_ATTACH:
-      case HCD_EVENT_DEVICE_REMOVE:
+        TU_LOG2("USBH DEVICE ATTACH\r\n");
         enum_task(&event);
       break;
 
+      case HCD_EVENT_DEVICE_REMOVE:
+        TU_LOG2("USBH DEVICE REMOVED\r\n");
+        usbh_device_unplugged(event.rhport, event.connection.hub_addr, event.connection.hub_port);
+
+        #if CFG_TUH_HUB
+        // TODO remove
+        if ( event.connection.hub_addr != 0)
+        {
+          // done with hub, waiting for next data on status pipe
+          (void) hub_status_pipe_queue( event.connection.hub_addr );
+        }
+        #endif
+      break;
+
       case HCD_EVENT_XFER_COMPLETE:
       {
         usbh_device_t* dev = &_usbh_devices[event.dev_addr];
-- 
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 'examples/host/cdc_msc_hid/src')

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 'examples/host/cdc_msc_hid/src')

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