Merge pull request #7 from tannewt/tinyusb_samd

Add SAMD support and simplify OS_NONE

11 files changed, 185 insertions, 110 deletions

diff --git a/src/class/cdc/cdc.h b/src/class/cdc/cdc.h
index 1b127ad28..afac8379d 100644
--- a/src/class/cdc/cdc.h
+++ b/src/class/cdc/cdc.h
@@ -50,6 +50,10 @@
  extern "C" {

 #endif

 

+#pragma GCC diagnostic push

+#pragma GCC diagnostic ignored "-Wpacked"

+#pragma GCC diagnostic ignored "-Wattributes"

+

 /** \defgroup ClassDriver_CDC_Common Common Definitions

  *  @{ */

 

@@ -86,7 +90,8 @@ typedef enum
 /// Communication Interface Protocol Codes

 typedef enum

 {

-  CDC_COMM_PROTOCOL_ATCOMMAND              = 0x01 , ///< AT Commands: V.250 etc

+  CDC_COMM_PROTOCOL_NONE                   = 0x00 , ///< No specific protocol

+  CDC_COMM_PROTOCOL_ATCOMMAND                     , ///< AT Commands: V.250 etc

   CDC_COMM_PROTOCOL_ATCOMMAND_PCCA_101            , ///< AT Commands defined by PCCA-101

   CDC_COMM_PROTOCOL_ATCOMMAND_PCCA_101_AND_ANNEXO , ///< AT Commands defined by PCCA-101 & Annex O

   CDC_COMM_PROTOCOL_ATCOMMAND_GSM_707             , ///< AT Commands defined by GSM 07.07

@@ -401,6 +406,8 @@ typedef struct ATTR_PACKED
 

 TU_VERIFY_STATIC(sizeof(cdc_line_control_state_t) == 2, "size is not correct");

 

+#pragma GCC diagnostic pop

+

 /** @} */

 

 #ifdef __cplusplus

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

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

 #include "cdc_device.h"

+#include "device/control.h"

 #include "device/usbd_pvt.h"

 

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

@@ -235,8 +236,10 @@ tusb_error_t cdcd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface
 {

   if ( CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL != p_interface_desc->bInterfaceSubClass) return TUSB_ERROR_CDC_UNSUPPORTED_SUBCLASS;

 

+  // Only support AT commands, no protocol and vendor specific commands.

   if ( !(tu_within(CDC_COMM_PROTOCOL_ATCOMMAND, p_interface_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA) ||

-         0xff == p_interface_desc->bInterfaceProtocol) )

+         p_interface_desc->bInterfaceProtocol == CDC_COMM_PROTOCOL_NONE ||

+         p_interface_desc->bInterfaceProtocol == 0xff ) )

   {

     return TUSB_ERROR_CDC_UNSUPPORTED_PROTOCOL;

   }

@@ -296,10 +299,23 @@ tusb_error_t cdcd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface
   return TUSB_ERROR_NONE;

 }

 

-tusb_error_t cdcd_control_request_st(uint8_t rhport, tusb_control_request_t const * p_request)

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

 {

-  OSAL_SUBTASK_BEGIN

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

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

+

+  // 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 ( tud_cdc_line_coding_cb ) tud_cdc_line_coding_cb(itf, &p_cdc->line_coding);

+  }

+}

+

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

+{

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

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

 

@@ -307,21 +323,18 @@ tusb_error_t cdcd_control_request_st(uint8_t rhport, tusb_control_request_t cons
   uint8_t const itf = 0;

   cdcd_interface_t* p_cdc = &_cdcd_itf[itf];

 

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

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

   {

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

-    usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, &p_cdc->line_coding, len);

-

-    // Invoke callback

-    if (CDC_REQUEST_SET_LINE_CODING == p_request->bRequest)

-    {

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

-    }

+    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 )

   {

-    dcd_control_status(rhport, p_request->bmRequestType_bit.direction); // ACK control request

-

     // 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)

@@ -334,10 +347,9 @@ tusb_error_t cdcd_control_request_st(uint8_t rhport, tusb_control_request_t cons
   }

   else

   {

-    dcd_control_stall(rhport); // stall unsupported request

+    return TUSB_ERROR_FAILED; // stall unsupported request

   }

-

-  OSAL_SUBTASK_END

+  return TUSB_ERROR_NONE;

 }

 

 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 f1bd33953..9d0b93c6d 100644
--- a/src/class/cdc/cdc_device.h
+++ b/src/class/cdc/cdc_device.h
@@ -114,7 +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_st (uint8_t rhport, tusb_control_request_t const * p_request);

+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);

 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 d43a86b14..1b36f1331 100644
--- a/src/class/custom/custom_device.c
+++ b/src/class/custom/custom_device.c
@@ -89,7 +89,7 @@ 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_st(uint8_t rhport, tusb_control_request_t const * p_request)
+tusb_error_t cusd_control_request(uint8_t rhport, tusb_control_request_t const * p_request)
 {
   return TUSB_ERROR_DCD_CONTROL_REQUEST_NOT_SUPPORT;
 }
diff --git a/src/class/custom/custom_device.h b/src/class/custom/custom_device.h
index 81a074ce3..116c6897d 100644
--- a/src/class/custom/custom_device.h
+++ b/src/class/custom/custom_device.h
@@ -65,6 +65,7 @@
 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);
 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.h b/src/class/hid/hid.h
index d2803177b..0008e47fb 100644
--- a/src/class/hid/hid.h
+++ b/src/class/hid/hid.h
@@ -49,6 +49,10 @@
  extern "C" {

 #endif

 

+#pragma GCC diagnostic push

+#pragma GCC diagnostic ignored "-Wpacked"

+#pragma GCC diagnostic ignored "-Wattributes"

+

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

 // Common Definitions

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

@@ -609,6 +613,7 @@ enum
   HID_USAGE_CONSUMER_AC_PAN                            = 0x0238,

 };

 

+#pragma GCC diagnostic pop

 

 #ifdef __cplusplus

  }

diff --git a/src/class/hid/hid_device.c b/src/class/hid/hid_device.c
index d8696f137..efa602ad6 100644
--- a/src/class/hid/hid_device.c
+++ b/src/class/hid/hid_device.c
@@ -46,6 +46,7 @@
 //--------------------------------------------------------------------+

 #include "common/tusb_common.h"

 #include "hid_device.h"

+#include "device/control.h"

 #include "device/usbd_pvt.h"

 

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

@@ -402,13 +403,11 @@ 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_st(uint8_t rhport, tusb_control_request_t const * p_request)

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

 {

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

   TU_ASSERT(p_hid, TUSB_ERROR_FAILED);

 

-  OSAL_SUBTASK_BEGIN

-

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

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

   {

@@ -418,14 +417,17 @@ tusb_error_t hidd_control_request_st(uint8_t rhport, tusb_control_request_t cons
 

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

     {

-      // use device control buffer

-      STASK_ASSERT ( p_hid->desc_len <= CFG_TUD_CTRL_BUFSIZE );

-      memcpy(_usbd_ctrl_buf, p_hid->desc_report, p_hid->desc_len);

+      // 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);

 

-      usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, _usbd_ctrl_buf, p_hid->desc_len);

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

     }else

     {

-      dcd_control_stall(rhport);

+      return TUSB_ERROR_FAILED;

     }

   }

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

@@ -447,53 +449,64 @@ tusb_error_t hidd_control_request_st(uint8_t rhport, tusb_control_request_t cons
         xferlen = p_request->wLength;

       }

 

-      STASK_ASSERT( xferlen > 0 );

-      usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, p_hid->report_buf, xferlen);

+      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 )

     {

-      usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, _usbd_ctrl_buf, p_request->wLength);

-

-      // 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, _usbd_ctrl_buf, p_request->wLength);

-      }

+      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);

-      dcd_control_status(rhport, p_request->bmRequestType_bit.direction);

     }

     else if (HID_REQ_CONTROL_GET_IDLE == p_request->bRequest)

     {

       // TODO idle rate of report

-      _usbd_ctrl_buf[0] = p_hid->idle_rate;

-      usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, _usbd_ctrl_buf, 1);

+      _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 )

     {

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

-      usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, _usbd_ctrl_buf, 1);

+      _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

-      dcd_control_status(rhport, p_request->bmRequestType_bit.direction);

     }else

     {

-      dcd_control_stall(rhport);

+      return TUSB_ERROR_FAILED;

     }

   }else

   {

-    dcd_control_stall(rhport);

+    return TUSB_ERROR_FAILED;

   }

+  return TUSB_ERROR_NONE;

+}

 

-  OSAL_SUBTASK_END

+void 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;

+  }

+

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

+  {

+    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);

+

+      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);

+      }

+    }

+  }

 }

 

 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 d5b9f3831..1dc40af57 100644
--- a/src/class/hid/hid_device.h
+++ b/src/class/hid/hid_device.h
@@ -378,7 +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_st(uint8_t rhport, tusb_control_request_t const * p_request);

+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);

 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);

 

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

 

 #endif /* _TUSB_HID_DEVICE_H_ */

-

-

diff --git a/src/class/msc/msc.h b/src/class/msc/msc.h
index 59df6bed6..e7c32b303 100644
--- a/src/class/msc/msc.h
+++ b/src/class/msc/msc.h
@@ -52,6 +52,10 @@
  extern "C" {

 #endif

 

+#pragma GCC diagnostic push

+#pragma GCC diagnostic ignored "-Wpacked"

+#pragma GCC diagnostic ignored "-Wattributes"

+

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

 // Mass Storage Class Constant

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

@@ -279,11 +283,13 @@ typedef struct ATTR_PACKED
 

 TU_VERIFY_STATIC( sizeof(scsi_mode_sense6_t) == 6, "size is not correct");

 

+// This is only a Mode parameter header(6).

 typedef struct ATTR_PACKED

 {

   uint8_t data_len;

   uint8_t medium_type;

-  uint8_t device_specific_para;

+  bool write_protected : 1;

+  uint8_t reserved : 7;

   uint8_t block_descriptor_len;

 } scsi_mode_sense6_resp_t;

 

@@ -390,6 +396,8 @@ typedef struct ATTR_PACKED
 TU_VERIFY_STATIC(sizeof(scsi_read10_t) == 10, "size is not correct");

 TU_VERIFY_STATIC(sizeof(scsi_write10_t) == 10, "size is not correct");

 

+#pragma GCC diagnostic pop

+

 #ifdef __cplusplus

  }

 #endif

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

 #include "common/tusb_common.h"

 #include "msc_device.h"

+#include "device/control.h"

 #include "device/usbd_pvt.h"

 

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

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

 };

 

-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 mscd_interface_t _mscd_itf;

 CFG_TUSB_ATTR_USBRAM CFG_TUSB_MEM_ALIGN static uint8_t _mscd_buf[CFG_TUD_MSC_BUFSIZE];

 

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

@@ -170,28 +147,40 @@ 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_st(uint8_t rhport, tusb_control_request_t const * p_request)

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

 {

-  OSAL_SUBTASK_BEGIN

-

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

 

   if(MSC_REQ_RESET == p_request->bRequest)

   {

-    dcd_control_status(rhport, p_request->bmRequestType_bit.direction);

+    // TODO: Actually reset.

   }

   else if (MSC_REQ_GET_MAX_LUN == p_request->bRequest)

   {

     // returned MAX LUN is minus 1 by specs

-    _usbd_ctrl_buf[0] = CFG_TUD_MSC_MAXLUN-1;

-    usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, _usbd_ctrl_buf, 1);

+    _shared_control_buffer[0] = CFG_TUD_MSC_MAXLUN-1;

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

   }else

   {

-    dcd_control_stall(rhport); // stall unsupported request

+    return TUSB_ERROR_FAILED; // stall unsupported request

   }

+  return TUSB_ERROR_NONE;

+}

+

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

+{

+  return;

+}

 

-  OSAL_SUBTASK_END

+// For backwards compatibility we support static block counts.

+#if defined(CFG_TUD_MSC_BLOCK_NUM) && defined(CFG_TUD_MSC_BLOCK_SZ)

+ATTR_WEAK bool tud_lun_capacity_cb(uint8_t lun, uint32_t* last_valid_sector, uint16_t* block_size) {

+    (void) lun;

+    *last_valid_sector = CFG_TUD_MSC_BLOCK_NUM-1;

+    *block_size = CFG_TUD_MSC_BLOCK_SZ;

+    return true;

 }

+#endif

 

 // return length of response (copied to buffer), -1 if it is not an built-in commands

 int32_t proc_builtin_scsi(msc_cbw_t const * p_cbw, uint8_t* buffer, uint32_t bufsize)

@@ -202,11 +191,13 @@ int32_t proc_builtin_scsi(msc_cbw_t const * p_cbw, uint8_t* buffer, uint32_t buf
   {

     case SCSI_CMD_READ_CAPACITY_10:

     {

-      scsi_read_capacity10_resp_t read_capa10 =

-      {

-          .last_lba   = ENDIAN_BE(CFG_TUD_MSC_BLOCK_NUM-1), // read capacity

-          .block_size = ENDIAN_BE(CFG_TUD_MSC_BLOCK_SZ)

-      };

+      scsi_read_capacity10_resp_t read_capa10;

+

+      uint32_t last_valid_sector;

+      uint16_t block_size;

+      tud_lun_capacity_cb(p_cbw->lun, &last_valid_sector, &block_size);

+      read_capa10.last_lba = ENDIAN_BE(last_valid_sector); // read capacity

+      read_capa10.block_size = ENDIAN_BE(block_size);

 

       ret = sizeof(read_capa10);

       memcpy(buffer, &read_capa10, ret);

@@ -218,11 +209,17 @@ int32_t proc_builtin_scsi(msc_cbw_t const * p_cbw, uint8_t* buffer, uint32_t buf
       scsi_read_format_capacity_data_t read_fmt_capa =

       {

           .list_length     = 8,

-          .block_num       = ENDIAN_BE(CFG_TUD_MSC_BLOCK_NUM),  // write capacity

+          .block_num       = 0,

           .descriptor_type = 2,                                 // formatted media

-          .block_size_u16  = ENDIAN_BE16(CFG_TUD_MSC_BLOCK_SZ)

+          .block_size_u16  = 0

       };

 

+      uint32_t last_valid_sector;

+      uint16_t block_size;

+      tud_lun_capacity_cb(p_cbw->lun, &last_valid_sector, &block_size);

+      read_fmt_capa.block_num = ENDIAN_BE(last_valid_sector+1);

+      read_fmt_capa.block_size_u16 = ENDIAN_BE16(block_size);

+

       ret = sizeof(read_fmt_capa);

       memcpy(buffer, &read_fmt_capa, ret);

     }

@@ -251,13 +248,21 @@ int32_t proc_builtin_scsi(msc_cbw_t const * p_cbw, uint8_t* buffer, uint32_t buf
 

     case SCSI_CMD_MODE_SENSE_6:

     {

-      scsi_mode_sense6_resp_t const mode_resp = {

-        .data_len = 3,

-        .medium_type = 0,

-        .device_specific_para = 0,

-        .block_descriptor_len = 0    // no block descriptor are included

+      scsi_mode_sense6_resp_t mode_resp =

+      {

+          .data_len = 3,

+          .medium_type = 0,

+          .write_protected = false,

+          .reserved = 0,

+          .block_descriptor_len = 0  // no block descriptor are included

       };

 

+      bool writable = true;

+      if (tud_msc_is_writable_cb) {

+          writable = tud_msc_is_writable_cb(p_cbw->lun);

+      }

+      mode_resp.write_protected = !writable;

+

       ret = sizeof(mode_resp);

       memcpy(buffer, &mode_resp, ret);

     }

@@ -291,7 +296,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, tusb_event_t event, uint32_t xferred_bytes)

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

 {

   mscd_interface_t* p_msc = &_mscd_itf;

   msc_cbw_t const * p_cbw = &p_msc->cbw;

@@ -425,7 +430,7 @@ tusb_error_t mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, tusb_event_t event, u
           }else

           {

             // Application consume less than what we got (including zero)

-            if ( nbytes < xferred_bytes )

+            if ( nbytes < (int32_t) xferred_bytes )

             {

               if ( nbytes > 0 )

               {

diff --git a/src/class/msc/msc_device.h b/src/class/msc/msc_device.h
index 8403dfed9..ac3eade22 100644
--- a/src/class/msc/msc_device.h
+++ b/src/class/msc/msc_device.h
@@ -55,14 +55,6 @@ TU_VERIFY_STATIC(CFG_TUD_MSC_BUFSIZE < UINT16_MAX, "Size is not correct");
   #error MSC Device: Incorrect setting of MAX LUN

 #endif

 

-#ifndef CFG_TUD_MSC_BLOCK_NUM

-  #error CFG_TUD_MSC_BLOCK_NUM must be defined

-#endif

-

-#ifndef CFG_TUD_MSC_BLOCK_SZ

-  #error CFG_TUD_MSC_BLOCK_SZ must be defined

-#endif

-

 #ifndef CFG_TUD_MSC_BUFSIZE

   #error CFG_TUD_MSC_BUFSIZE must be defined, value of CFG_TUD_MSC_BLOCK_SZ should work well, the more the better

 #endif

@@ -89,6 +81,32 @@ 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

@@ -138,7 +156,7 @@ int32_t tud_msc_read10_cb (uint8_t lun, uint32_t lba, uint32_t offset, void* buf
  * \retval      negative    Indicate error writing disk I/O. Tinyusb will \b STALL the corresponding

  *                          endpoint and return failed status in command status wrapper phase.

  */

-int32_t tud_msc_write10_cb (uint8_t lun, uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize);

+int32_t tud_msc_write10_cb (uint8_t lun, uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize);

 

 /**

  * Callback invoked when received an SCSI command not in built-in list below.

@@ -164,6 +182,12 @@ ATTR_WEAK void tud_msc_read10_complete_cb(uint8_t lun);
 ATTR_WEAK void tud_msc_write10_complete_cb(uint8_t lun);

 ATTR_WEAK void tud_msc_scsi_complete_cb(uint8_t lun, uint8_t const scsi_cmd[16]);

 

+// Hook to make a mass storage device read-only.

+ATTR_WEAK bool tud_msc_is_writable_cb(uint8_t lun);

+

+// Override for dynamic LUN sizes.

+ATTR_WEAK bool tud_lun_capacity_cb(uint8_t lun, uint32_t* last_valid_sector, uint16_t* block_size);

+

 /** @} */

 /** @} */

 

@@ -174,7 +198,8 @@ ATTR_WEAK void tud_msc_scsi_complete_cb(uint8_t lun, uint8_t const scsi_cmd[16])
 

 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_st(uint8_t rhport, tusb_control_request_t const * p_request);

+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);

 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);

 

@@ -185,4 +210,3 @@ void mscd_reset(uint8_t rhport);
 #endif

 

 #endif /* _TUSB_MSC_DEVICE_H_ */

-