nrf5x: refactor device control transfer.

- make control transfer as part of usbd. Class driver must use
usbd_control_ API() instead of dcd_ api.
- change the signature of class driver's control_request
- allow control request complete to stall in staus stage
- move control request parser & handling to usbd.

8 files changed, 181 insertions, 166 deletions

diff --git a/src/class/cdc/cdc_device.c b/src/class/cdc/cdc_device.c
index bc16699f1..d8ade9c7f 100644
--- a/src/class/cdc/cdc_device.c
+++ b/src/class/cdc/cdc_device.c
@@ -45,7 +45,6 @@
 // INCLUDE

 //--------------------------------------------------------------------+

 #include "cdc_device.h"

-#include "device/control.h"

 #include "device/usbd_pvt.h"

 

 //--------------------------------------------------------------------+

@@ -63,7 +62,7 @@ typedef struct
 

   /*------------- From this point, data is not cleared by bus reset -------------*/

   char    wanted_char;

-  CFG_TUSB_MEM_ALIGN cdc_line_coding_t line_coding;

+  cdc_line_coding_t line_coding;

 

   // FIFO

   tu_fifo_t rx_ff;

@@ -199,23 +198,23 @@ void cdcd_init(void)
 

   for(uint8_t i=0; i<CFG_TUD_CDC; i++)

   {

-    cdcd_interface_t* ser = &_cdcd_itf[i];

+    cdcd_interface_t* p_cdc = &_cdcd_itf[i];

 

-    ser->wanted_char = -1;

+    p_cdc->wanted_char = -1;

 

     // default line coding is : stop bit = 1, parity = none, data bits = 8

-    ser->line_coding.bit_rate = 115200;

-    ser->line_coding.stop_bits = 0;

-    ser->line_coding.parity    = 0;

-    ser->line_coding.data_bits = 8;

+    p_cdc->line_coding.bit_rate = 115200;

+    p_cdc->line_coding.stop_bits = 0;

+    p_cdc->line_coding.parity    = 0;

+    p_cdc->line_coding.data_bits = 8;

 

     // config fifo

-    tu_fifo_config(&ser->rx_ff, ser->rx_ff_buf, CFG_TUD_CDC_RX_BUFSIZE, 1, true);

-    tu_fifo_config(&ser->tx_ff, ser->tx_ff_buf, CFG_TUD_CDC_TX_BUFSIZE, 1, false);

+    tu_fifo_config(&p_cdc->rx_ff, p_cdc->rx_ff_buf, CFG_TUD_CDC_RX_BUFSIZE, 1, true);

+    tu_fifo_config(&p_cdc->tx_ff, p_cdc->tx_ff_buf, CFG_TUD_CDC_TX_BUFSIZE, 1, false);

 

 #if CFG_FIFO_MUTEX

-    tu_fifo_config_mutex(&ser->rx_ff, osal_mutex_create(&ser->rx_ff_mutex));

-    tu_fifo_config_mutex(&ser->tx_ff, osal_mutex_create(&ser->tx_ff_mutex));

+    tu_fifo_config_mutex(&p_cdc->rx_ff, osal_mutex_create(&p_cdc->rx_ff_mutex));

+    tu_fifo_config_mutex(&p_cdc->tx_ff, osal_mutex_create(&p_cdc->tx_ff_mutex));

 #endif

   }

 }

@@ -299,57 +298,64 @@ tusb_error_t cdcd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface
   return TUSB_ERROR_NONE;

 }

 

-void cdcd_control_request_complete(uint8_t rhport, tusb_control_request_t const * p_request)

+// Invoked when class request DATA stage is finished.

+// return false to stall control endpoint (e.g Host send non-sense DATA)

+bool cdcd_control_request_complete(uint8_t rhport, tusb_control_request_t const * request)

 {

   //------------- Class Specific Request -------------//

-  if (p_request->bmRequestType_bit.type != TUSB_REQ_TYPE_CLASS) return;

+  TU_VERIFY (request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);

 

   // TODO Support multiple interfaces

   uint8_t const itf = 0;

   cdcd_interface_t* p_cdc = &_cdcd_itf[itf];

 

   // Invoke callback

-  if (CDC_REQUEST_SET_LINE_CODING == p_request->bRequest) {

+  if ( CDC_REQUEST_SET_LINE_CODING == request->bRequest )

+  {

     if ( tud_cdc_line_coding_cb ) tud_cdc_line_coding_cb(itf, &p_cdc->line_coding);

   }

+

+  return true;

 }

 

-tusb_error_t cdcd_control_request(uint8_t rhport, tusb_control_request_t const * p_request, uint16_t bytes_already_sent)

+// Handle class control request

+// return false to stall control endpoint (e.g unsupported request)

+bool cdcd_control_request(uint8_t rhport, tusb_control_request_t const * request)

 {

   //------------- Class Specific Request -------------//

-  if (p_request->bmRequestType_bit.type != TUSB_REQ_TYPE_CLASS) return TUSB_ERROR_DCD_CONTROL_REQUEST_NOT_SUPPORT;

+  TU_ASSERT(request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);

 

   // TODO Support multiple interfaces

   uint8_t const itf = 0;

   cdcd_interface_t* p_cdc = &_cdcd_itf[itf];

 

-  if ((CDC_REQUEST_SET_LINE_CODING == p_request->bRequest) )

-  {

-    uint16_t len = tu_min16(sizeof(cdc_line_coding_t), p_request->wLength);

-    dcd_edpt_xfer(rhport, 0, (uint8_t*) &p_cdc->line_coding, len);

-  }

-  else if ( (CDC_REQUEST_GET_LINE_CODING == p_request->bRequest))

-  {

-    uint16_t len = tu_min16(sizeof(cdc_line_coding_t), p_request->wLength);

-    dcd_edpt_xfer(rhport, TUSB_DIR_IN_MASK, (uint8_t*) &p_cdc->line_coding, len);

-  }

-  else if (CDC_REQUEST_SET_CONTROL_LINE_STATE == p_request->bRequest )

+  switch ( request->bRequest )

   {

-    // CDC PSTN v1.2 section 6.3.12

-    // Bit 0: Indicates if DTE is present or not.

-    //        This signal corresponds to V.24 signal 108/2 and RS-232 signal DTR (Data Terminal Ready)

-    // Bit 1: Carrier control for half-duplex modems.

-    //        This signal corresponds to V.24 signal 105 and RS-232 signal RTS (Request to Send)

-    p_cdc->line_state = (uint8_t) p_request->wValue;

+    case CDC_REQUEST_SET_LINE_CODING:

+      usbd_control_xfer(rhport, request, &p_cdc->line_coding, sizeof(cdc_line_coding_t));

+    break;

 

-    // Invoke callback

-    if ( tud_cdc_line_state_cb) tud_cdc_line_state_cb(itf, BIT_TEST_(p_request->wValue, 0), BIT_TEST_(p_request->wValue, 1));

-  }

-  else

-  {

-    return TUSB_ERROR_FAILED; // stall unsupported request

+    case CDC_REQUEST_GET_LINE_CODING:

+      usbd_control_xfer(rhport, request, &p_cdc->line_coding, sizeof(cdc_line_coding_t));

+    break;

+

+    case CDC_REQUEST_SET_CONTROL_LINE_STATE:

+      // CDC PSTN v1.2 section 6.3.12

+      // Bit 0: Indicates if DTE is present or not.

+      //        This signal corresponds to V.24 signal 108/2 and RS-232 signal DTR (Data Terminal Ready)

+      // Bit 1: Carrier control for half-duplex modems.

+      //        This signal corresponds to V.24 signal 105 and RS-232 signal RTS (Request to Send)

+      p_cdc->line_state = (uint8_t) request->wValue;

+

+      // Invoke callback

+      if ( tud_cdc_line_state_cb) tud_cdc_line_state_cb(itf, BIT_TEST_(request->wValue, 0), BIT_TEST_(request->wValue, 1));

+      usbd_control_status(rhport, request);

+    break;

+

+    default: return false; // stall unsupported request

   }

-  return TUSB_ERROR_NONE;

+

+  return true;

 }

 

 tusb_error_t cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, tusb_event_t event, uint32_t xferred_bytes)

diff --git a/src/class/cdc/cdc_device.h b/src/class/cdc/cdc_device.h
index 9d0b93c6d..749351a54 100644
--- a/src/class/cdc/cdc_device.h
+++ b/src/class/cdc/cdc_device.h
@@ -114,8 +114,8 @@ ATTR_WEAK void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* p_li
 

 void         cdcd_init               (void);

 tusb_error_t cdcd_open               (uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length);

-tusb_error_t cdcd_control_request (uint8_t rhport, tusb_control_request_t const * p_request, uint16_t bytes_already_sent);

-void cdcd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);

+bool cdcd_control_request (uint8_t rhport, tusb_control_request_t const * p_request);

+bool cdcd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);

 tusb_error_t cdcd_xfer_cb            (uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes);

 void         cdcd_reset              (uint8_t rhport);

 

diff --git a/src/class/custom/custom_device.c b/src/class/custom/custom_device.c
index 1b36f1331..cc440fc7e 100644
--- a/src/class/custom/custom_device.c
+++ b/src/class/custom/custom_device.c
@@ -89,9 +89,9 @@ tusb_error_t cusd_open(uint8_t rhport, tusb_desc_interface_t const * p_desc_itf,
   return TUSB_ERROR_NONE;
 }
 
-tusb_error_t cusd_control_request(uint8_t rhport, tusb_control_request_t const * p_request)
+bool cusd_control_request(uint8_t rhport, tusb_control_request_t const * p_request)
 {
-  return TUSB_ERROR_DCD_CONTROL_REQUEST_NOT_SUPPORT;
+  return false;
 }
 
 tusb_error_t cusd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes)
diff --git a/src/class/custom/custom_device.h b/src/class/custom/custom_device.h
index 116c6897d..704c4127b 100644
--- a/src/class/custom/custom_device.h
+++ b/src/class/custom/custom_device.h
@@ -64,8 +64,8 @@
 
 void cusd_init(void);
 tusb_error_t cusd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length);
-tusb_error_t cusd_control_request_st(uint8_t rhport, tusb_control_request_t const * p_request);
-void cusd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);
+bool cusd_control_request_st(uint8_t rhport, tusb_control_request_t const * p_request);
+bool cusd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);
 tusb_error_t cusd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes);
 void cusd_reset(uint8_t rhport);
 #endif
diff --git a/src/class/hid/hid_device.c b/src/class/hid/hid_device.c
index efa602ad6..b5586a488 100644
--- a/src/class/hid/hid_device.c
+++ b/src/class/hid/hid_device.c
@@ -46,7 +46,6 @@
 //--------------------------------------------------------------------+

 #include "common/tusb_common.h"

 #include "hid_device.h"

-#include "device/control.h"

 #include "device/usbd_pvt.h"

 

 //--------------------------------------------------------------------+

@@ -403,110 +402,112 @@ tusb_error_t hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, u
   return TUSB_ERROR_NONE;

 }

 

-tusb_error_t hidd_control_request(uint8_t rhport, tusb_control_request_t const * p_request, uint16_t bytes_already_sent)

+// Handle class control request

+// return false to stall control endpoint (e.g unsupported request)

+bool hidd_control_request(uint8_t rhport, tusb_control_request_t const * p_request)

 {

   hidd_interface_t* p_hid = get_interface_by_itfnum( (uint8_t) p_request->wIndex );

-  TU_ASSERT(p_hid, TUSB_ERROR_FAILED);

+  TU_ASSERT(p_hid);

 

-  //------------- STD Request -------------//

   if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD)

   {

+    //------------- STD Request -------------//

     uint8_t const desc_type  = tu_u16_high(p_request->wValue);

     uint8_t const desc_index = tu_u16_low (p_request->wValue);

     (void) desc_index;

 

     if (p_request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_REPORT)

     {

-      // TODO: Handle zero length packet.

-      uint16_t remaining_bytes = p_hid->desc_len - bytes_already_sent;

-      if (remaining_bytes > 64) {

-          remaining_bytes = 64;

-      }

-      memcpy(_shared_control_buffer, p_hid->desc_report + bytes_already_sent, remaining_bytes);

-

-      dcd_edpt_xfer(rhport, TUSB_DIR_IN_MASK, _shared_control_buffer, remaining_bytes);

+      usbd_control_xfer(rhport, p_request, p_hid->desc_report, p_hid->desc_len);

     }else

     {

-      return TUSB_ERROR_FAILED;

+      return false; // stall unsupported request

     }

   }

-  //------------- Class Specific Request -------------//

   else if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS)

   {

-    if( HID_REQ_CONTROL_GET_REPORT == p_request->bRequest )

+    //------------- Class Specific Request -------------//

+    switch( p_request->bRequest )

     {

-      // wValue = Report Type | Report ID

-      uint8_t const report_type = tu_u16_high(p_request->wValue);

-      uint8_t const report_id   = tu_u16_low(p_request->wValue);

-

-      uint16_t xferlen;

-      if ( p_hid->get_report_cb )

+      case HID_REQ_CONTROL_GET_REPORT:

       {

-        xferlen = p_hid->get_report_cb(report_id, (hid_report_type_t) report_type, p_hid->report_buf, p_request->wLength);

-      }else

+        // wValue = Report Type | Report ID

+        uint8_t const report_type = tu_u16_high(p_request->wValue);

+        uint8_t const report_id   = tu_u16_low(p_request->wValue);

+

+        uint16_t xferlen;

+        if ( p_hid->get_report_cb )

+        {

+          xferlen = p_hid->get_report_cb(report_id, (hid_report_type_t) report_type, p_hid->report_buf, p_request->wLength);

+        }else

+        {

+          // For boot Interface only: re-use report_buf -> report has no change

+          xferlen = p_request->wLength;

+        }

+

+        TU_ASSERT( xferlen > 0 );

+        usbd_control_xfer(rhport, p_request, p_hid->report_buf, xferlen);

+      }

+      break;

+

+      case  HID_REQ_CONTROL_SET_REPORT:

+        usbd_control_xfer(rhport, p_request, p_hid->report_buf, p_request->wLength);

+      break;

+

+      case HID_REQ_CONTROL_SET_IDLE:

+        // TODO idle rate of report

+        p_hid->idle_rate = tu_u16_high(p_request->wValue);

+        usbd_control_status(rhport, p_request);

+      break;

+

+      case HID_REQ_CONTROL_GET_IDLE:

+        // TODO idle rate of report

+        usbd_control_xfer(rhport, p_request, &p_hid->idle_rate, 1);

+      break;

+

+      case HID_REQ_CONTROL_GET_PROTOCOL:

       {

-        // For boot Interface only: re-use report_buf -> report has no change

-        xferlen = p_request->wLength;

+        uint8_t protocol = 1-p_hid->boot_protocol;   // 0 is Boot, 1 is Report protocol

+        usbd_control_xfer(rhport, p_request, &protocol, 1);

       }

+      break;

 

-      TU_ASSERT( xferlen > 0 );

-      dcd_edpt_xfer(rhport, TUSB_DIR_IN_MASK, _shared_control_buffer, xferlen);

-    }

-    else if ( HID_REQ_CONTROL_SET_REPORT == p_request->bRequest )

-    {

-      dcd_edpt_xfer(rhport, 0, _shared_control_buffer, p_request->wLength);

-    }

-    else if (HID_REQ_CONTROL_SET_IDLE == p_request->bRequest)

-    {

-      // TODO idle rate of report

-      p_hid->idle_rate = tu_u16_high(p_request->wValue);

-    }

-    else if (HID_REQ_CONTROL_GET_IDLE == p_request->bRequest)

-    {

-      // TODO idle rate of report

-      _shared_control_buffer[0] = p_hid->idle_rate;

-      dcd_edpt_xfer(rhport, TUSB_DIR_IN_MASK, _shared_control_buffer, 1);

-    }

-    else if (HID_REQ_CONTROL_GET_PROTOCOL == p_request->bRequest )

-    {

-      _shared_control_buffer[0] = 1-p_hid->boot_protocol;   // 0 is Boot, 1 is Report protocol

-      dcd_edpt_xfer(rhport, TUSB_DIR_IN_MASK, _shared_control_buffer, 1);

-    }

-    else if (HID_REQ_CONTROL_SET_PROTOCOL == p_request->bRequest )

-    {

-      p_hid->boot_protocol = 1 - p_request->wValue; // 0 is Boot, 1 is Report protocol

-    }else

-    {

-      return TUSB_ERROR_FAILED;

+      case HID_REQ_CONTROL_SET_PROTOCOL:

+        p_hid->boot_protocol = 1 - p_request->wValue; // 0 is Boot, 1 is Report protocol

+        usbd_control_status(rhport, p_request);

+      break;

+

+      default: return false; // stall unsupported request

     }

   }else

   {

-    return TUSB_ERROR_FAILED;

+    return false; // stall unsupported request

   }

-  return TUSB_ERROR_NONE;

+

+  return true;

 }

 

-void hidd_control_request_complete(uint8_t rhport, tusb_control_request_t const * p_request)

+// Invoked when class request DATA stage is finished.

+// return false to stall control endpoint (e.g Host send non-sense DATA)

+bool hidd_control_request_complete(uint8_t rhport, tusb_control_request_t const * p_request)

 {

   hidd_interface_t* p_hid = get_interface_by_itfnum( (uint8_t) p_request->wIndex );

-  if (p_hid == NULL) {

-      return;

-  }

+  TU_ASSERT(p_hid);

 

-  if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS)

+  if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS &&

+      p_request->bRequest == HID_REQ_CONTROL_SET_REPORT)

   {

-    if ( HID_REQ_CONTROL_SET_REPORT == p_request->bRequest )

-    {

-      // wValue = Report Type | Report ID

-      uint8_t const report_type = tu_u16_high(p_request->wValue);

-      uint8_t const report_id   = tu_u16_low(p_request->wValue);

+    // wValue = Report Type | Report ID

+    uint8_t const report_type = tu_u16_high(p_request->wValue);

+    uint8_t const report_id   = tu_u16_low(p_request->wValue);

 

-      if ( p_hid->set_report_cb )

-      {

-        p_hid->set_report_cb(report_id, (hid_report_type_t) report_type, _shared_control_buffer, p_request->wLength);

-      }

+    if ( p_hid->set_report_cb )

+    {

+      p_hid->set_report_cb(report_id, (hid_report_type_t) report_type, p_hid->report_buf, p_request->wLength);

     }

   }

+

+  return true;

 }

 

 tusb_error_t hidd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes)

diff --git a/src/class/hid/hid_device.h b/src/class/hid/hid_device.h
index 1dc40af57..7f8cd0fa7 100644
--- a/src/class/hid/hid_device.h
+++ b/src/class/hid/hid_device.h
@@ -378,8 +378,8 @@ ATTR_WEAK void tud_hid_mouse_set_report_cb(uint8_t report_id, hid_report_type_t
 

 void hidd_init(void);

 tusb_error_t hidd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length);

-tusb_error_t hidd_control_request(uint8_t rhport, tusb_control_request_t const * p_request, uint16_t bytes_already_sent);

-void hidd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);

+bool hidd_control_request(uint8_t rhport, tusb_control_request_t const * p_request);

+bool hidd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);

 tusb_error_t hidd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes);

 void hidd_reset(uint8_t rhport);

 

@@ -390,3 +390,4 @@ void hidd_reset(uint8_t rhport);
 #endif

 

 #endif /* _TUSB_HID_DEVICE_H_ */

+

diff --git a/src/class/msc/msc_device.c b/src/class/msc/msc_device.c
index 32ad90102..92bc4c6c8 100644
--- a/src/class/msc/msc_device.c
+++ b/src/class/msc/msc_device.c
@@ -47,7 +47,6 @@
 

 #include "common/tusb_common.h"

 #include "msc_device.h"

-#include "device/control.h"

 #include "device/usbd_pvt.h"

 

 //--------------------------------------------------------------------+

@@ -60,7 +59,31 @@ enum
   MSC_STAGE_STATUS

 };

 

-CFG_TUSB_ATTR_USBRAM CFG_TUSB_MEM_ALIGN mscd_interface_t _mscd_itf;

+typedef struct {

+  CFG_TUSB_MEM_ALIGN msc_cbw_t  cbw;

+

+//#if defined (__ICCARM__) && (CFG_TUSB_MCU == OPT_MCU_LPC11UXX || CFG_TUSB_MCU == OPT_MCU_LPC13UXX)

+//  uint8_t padding1[64-sizeof(msc_cbw_t)]; // IAR cannot align struct's member

+//#endif

+

+  CFG_TUSB_MEM_ALIGN msc_csw_t csw;

+

+  uint8_t  itf_num;

+  uint8_t  ep_in;

+  uint8_t  ep_out;

+

+  // Bulk Only Transfer (BOT) Protocol

+  uint8_t  stage;

+  uint32_t total_len;

+  uint32_t xferred_len; // numbered of bytes transferred so far in the Data Stage

+

+  // Sense Response Data

+  uint8_t sense_key;

+  uint8_t add_sense_code;

+  uint8_t add_sense_qualifier;

+}mscd_interface_t;

+

+CFG_TUSB_ATTR_USBRAM CFG_TUSB_MEM_ALIGN static mscd_interface_t _mscd_itf;

 CFG_TUSB_ATTR_USBRAM CFG_TUSB_MEM_ALIGN static uint8_t _mscd_buf[CFG_TUD_MSC_BUFSIZE];

 

 //--------------------------------------------------------------------+

@@ -147,29 +170,39 @@ tusb_error_t mscd_open(uint8_t rhport, tusb_desc_interface_t const * p_desc_itf,
   return TUSB_ERROR_NONE;

 }

 

-tusb_error_t mscd_control_request(uint8_t rhport, tusb_control_request_t const * p_request, uint16_t bytes_already_sent)

+// Handle class control request

+// return false to stall control endpoint (e.g unsupported request)

+bool mscd_control_request(uint8_t rhport, tusb_control_request_t const * p_request)

 {

-  TU_ASSERT(p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS, TUSB_ERROR_DCD_CONTROL_REQUEST_NOT_SUPPORT);

+  TU_ASSERT(p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);

 

-  if(MSC_REQ_RESET == p_request->bRequest)

-  {

-    // TODO: Actually reset.

-  }

-  else if (MSC_REQ_GET_MAX_LUN == p_request->bRequest)

+  switch ( p_request->bRequest )

   {

-    // returned MAX LUN is minus 1 by specs

-    _shared_control_buffer[0] = CFG_TUD_MSC_MAXLUN-1;

-    dcd_edpt_xfer(rhport, TUSB_DIR_IN_MASK, _shared_control_buffer, 1);

-  }else

-  {

-    return TUSB_ERROR_FAILED; // stall unsupported request

+    case MSC_REQ_RESET:

+      // TODO: Actually reset interface.

+      usbd_control_status(rhport, p_request);

+    break;

+

+    case MSC_REQ_GET_MAX_LUN:

+    {

+      // returned MAX LUN is minus 1 by specs

+      uint8_t maxlun = CFG_TUD_MSC_MAXLUN-1;

+      usbd_control_xfer(rhport, p_request, &maxlun, 1);

+    }

+    break;

+

+    default: return false; // stall unsupported request

   }

-  return TUSB_ERROR_NONE;

+

+  return true;

 }

 

-void mscd_control_request_complete(uint8_t rhport, tusb_control_request_t const * p_request)

+// Invoked when class request DATA stage is finished.

+// return false to stall control endpoint (e.g Host send non-sense DATA)

+bool mscd_control_request_complete(uint8_t rhport, tusb_control_request_t const * p_request)

 {

-  return;

+  // nothing to do

+  return true;

 }

 

 // For backwards compatibility we support static block counts.

@@ -296,7 +329,7 @@ int32_t proc_builtin_scsi(msc_cbw_t const * p_cbw, uint8_t* buffer, uint32_t buf
   return ret;

 }

 

-tusb_error_t mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, uint8_t event, uint32_t xferred_bytes)

+tusb_error_t mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, tusb_event_t event, uint32_t xferred_bytes)

 {

   mscd_interface_t* p_msc = &_mscd_itf;

   msc_cbw_t const * p_cbw = &p_msc->cbw;

diff --git a/src/class/msc/msc_device.h b/src/class/msc/msc_device.h
index ac3eade22..d08d9f9cb 100644
--- a/src/class/msc/msc_device.h
+++ b/src/class/msc/msc_device.h
@@ -81,32 +81,6 @@ TU_VERIFY_STATIC(CFG_TUD_MSC_BUFSIZE < UINT16_MAX, "Size is not correct");
  extern "C" {

 #endif

 

-typedef struct {

-  CFG_TUSB_MEM_ALIGN msc_cbw_t  cbw;

-

-//#if defined (__ICCARM__) && (CFG_TUSB_MCU == OPT_MCU_LPC11UXX || CFG_TUSB_MCU == OPT_MCU_LPC13UXX)

-//  uint8_t padding1[64-sizeof(msc_cbw_t)]; // IAR cannot align struct's member

-//#endif

-

-  CFG_TUSB_MEM_ALIGN msc_csw_t csw;

-

-  uint8_t  itf_num;

-  uint8_t  ep_in;

-  uint8_t  ep_out;

-

-  // Bulk Only Transfer (BOT) Protocol

-  uint8_t  stage;

-  uint32_t total_len;

-  uint32_t xferred_len; // numbered of bytes transferred so far in the Data Stage

-

-  // Sense Response Data

-  uint8_t sense_key;

-  uint8_t add_sense_code;

-  uint8_t add_sense_qualifier;

-}mscd_interface_t;

-

-extern mscd_interface_t _mscd_itf;

-

 /** \addtogroup ClassDriver_MSC

  *  @{

  * \defgroup MSC_Device Device

@@ -198,8 +172,8 @@ ATTR_WEAK bool tud_lun_capacity_cb(uint8_t lun, uint32_t* last_valid_sector, uin
 

 void mscd_init(void);

 tusb_error_t mscd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length);

-tusb_error_t mscd_control_request(uint8_t rhport, tusb_control_request_t const * p_request, uint16_t bytes_already_sent);

-void mscd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);

+bool mscd_control_request(uint8_t rhport, tusb_control_request_t const * p_request);

+bool mscd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);

 tusb_error_t mscd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes);

 void mscd_reset(uint8_t rhport);