MSC add optional ready callback, also add setUnitReady() API

Author: hathach

examples/msc_ramdisk/msc_ramdisk.ino

@@ -41,7 +41,10 @@ void setup()
   usb_msc.setCapacity(0, DISK_BLOCK_NUM, DISK_BLOCK_SIZE);
 
   // Set callback
-  usb_msc.setCallback(0, ram_read_cb, ram_write_cb, ram_flush_cb);
+  usb_msc.setReadWriteCallback(0, ram_read_cb, ram_write_cb, ram_flush_cb);
+
+  // Set Lun ready (RAM disk is always ready)
+  usb_msc.setUnitReady(0, true);
 
   usb_msc.begin();
 

examples/msc_ramdisk_dual/msc_ramdisk_dual.ino

@@ -39,12 +39,14 @@ void setup()
   // Set disk size and callback for Logical Unit 0 (LUN 0)
   usb_msc.setID(0, "Adafruit", "Lun0", "1.0");
   usb_msc.setCapacity(0, DISK_BLOCK_NUM, DISK_BLOCK_SIZE);
-  usb_msc.setCallback(0, ram0_read_cb, ram0_write_cb, ram0_flush_cb);
+  usb_msc.setReadWriteCallback(0, ram0_read_cb, ram0_write_cb, ram0_flush_cb);
+  usb_msc.setUnitReady(0, true);
 
   // Set disk size and callback for Logical Unit 1 (LUN 1)
   usb_msc.setID(1, "Adafruit", "Lun1", "1.0");
   usb_msc.setCapacity(1, DISK_BLOCK_NUM, DISK_BLOCK_SIZE);
-  usb_msc.setCallback(1, ram1_read_cb, ram1_write_cb, ram1_flush_cb);
+  usb_msc.setReadWriteCallback(1, ram1_read_cb, ram1_write_cb, ram1_flush_cb);
+  usb_msc.setUnitReady(1, true);
 
   usb_msc.begin();
 

examples/sdcard_reader/sdcard_reader.ino

@@ -0,0 +1,111 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Ha Thach for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "Adafruit_TinyUSB.h"
+#include "SD.h"
+
+#ifdef ARDUINO_NRF52832_FEATHER
+const int chipSelect = 11;
+#else
+const int chipSelect = 10;
+#endif
+
+Adafruit_USBD_MSC usb_msc;
+
+Sd2Card card;
+SdVolume volume;
+
+// the setup function runs once when you press reset or power the board
+void setup()
+{
+  // Set disk vendor id, product id and revision with string up to 8, 16, 4 characters respectively
+  usb_msc.setID(0, "Adafruit", "SD Card", "1.0");
+
+  // Set read write callback
+  usb_msc.setReadWriteCallback(0, sd_read_cb, sd_write_cb, sd_flush_cb);
+
+  // Still initialize MSC but tell usb stack that MSC is not ready to read/write
+  // If we don't initialize, board will be enumerated as CDC only
+  usb_msc.setUnitReady(0, false);
+  usb_msc.begin();
+
+  Serial.begin(115200);
+  while ( !Serial ) delay(10);   // wait for native usb
+
+  Serial.println("Adafruit TinyUSB SD Card Reader example");
+
+  Serial.println("\nInitializing SD card...");
+
+  if ( !card.init(SPI_HALF_SPEED, chipSelect) )
+  {
+    Serial.println("initialization failed. Things to check:");
+    Serial.println("* is a card inserted?");
+    Serial.println("* is your wiring correct?");
+    Serial.println("* did you change the chipSelect pin to match your shield or module?");
+    while (1) delay(1);
+  }
+
+  // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
+  if (!volume.init(card)) {
+    Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
+    while (1) delay(1);
+  }
+  
+  uint32_t block_count = volume.blocksPerCluster()*volume.clusterCount();
+
+  Serial.print("Volume size (MB):  ");
+  Serial.println((block_count/2) / 1024);
+
+  // Set disk size, SD block size is always 512
+  usb_msc.setCapacity(0, block_count, 512);
+
+  // MSC is ready for read/write
+  usb_msc.setUnitReady(0, true);
+}
+
+void loop()
+{
+  // nothing to do
+}
+
+int32_t sd_read_cb (uint32_t lba, void* buffer, uint32_t bufsize)
+{
+  (void) bufsize;
+  return card.readBlock(lba, (uint8_t*) buffer) ? 512 : -1;
+}
+
+// Callback invoked when received WRITE10 command.
+// Process data in buffer to disk's storage and 
+// return number of written bytes (must be multiple of block size)
+int32_t sd_write_cb (uint32_t lba, uint8_t* buffer, uint32_t bufsize)
+{
+  return card.writeBlock(lba, buffer) ? 512 : -1;
+}
+
+// Callback invoked when WRITE10 command is completed (status received and accepted by host).
+// used to flush any pending cache.
+void sd_flush_cb (void)
+{
+  // nothing to do
+}

src/Adafruit_USBD_MSC.cpp

@@ -75,13 +75,23 @@ void Adafruit_USBD_MSC::getCapacity(uint8_t lun, uint32_t* block_count, uint16_t
   *block_size  = _lun[lun].block_size;
 }
 
-void Adafruit_USBD_MSC::setCallback(uint8_t lun, read_callback_t rd_cb, write_callback_t wr_cb, flush_callback_t fl_cb)
+void Adafruit_USBD_MSC::setUnitReady(uint8_t lun, bool ready)
+{
+  _lun[lun].unit_ready = ready;
+}
+
+void Adafruit_USBD_MSC::setReadWriteCallback(uint8_t lun, read_callback_t rd_cb, write_callback_t wr_cb, flush_callback_t fl_cb)
 {
   _lun[lun].rd_cb = rd_cb;
   _lun[lun].wr_cb = wr_cb;
   _lun[lun].fl_cb = fl_cb;
 }
 
+void Adafruit_USBD_MSC::setReadyCallback(uint8_t lun, ready_callback_t cb)
+{
+  _lun[lun].ready_cb = cb;
+}
+
 bool Adafruit_USBD_MSC::begin(void)
 {
   if ( !USBDevice.addInterface(*this) ) return false;
@@ -107,6 +117,7 @@ void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t product_id[16
 {
   if (!_msc_dev) return;
 
+  // If not set use default ID "Adafruit - Mass Storage - 1.0"
   const char* vid = (_msc_dev->_lun[lun]._inquiry_vid ? _msc_dev->_lun[lun]._inquiry_vid : "Adafruit");
   const char* pid = (_msc_dev->_lun[lun]._inquiry_pid ? _msc_dev->_lun[lun]._inquiry_pid : "Mass Storage");
   const char* rev = (_msc_dev->_lun[lun]._inquiry_rev ? _msc_dev->_lun[lun]._inquiry_rev : "1.0");
@@ -120,9 +131,14 @@ void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t product_id[16
 // return true allowing host to read/write this LUN e.g SD card inserted
 bool tud_msc_test_unit_ready_cb(uint8_t lun)
 {
-  (void) lun;
+  if (!_msc_dev) return false;
+
+  if (_msc_dev->_lun[lun].ready_cb)
+  {
+    _msc_dev->_lun[lun].unit_ready = _msc_dev->_lun[lun].ready_cb();
+  }
 
-  return true; // RAM disk is always ready
+  return _msc_dev->_lun[lun].unit_ready;
 }
 
 // Callback invoked to determine disk's size

src/Adafruit_USBD_MSC.h

@@ -33,6 +33,7 @@ class Adafruit_USBD_MSC : Adafruit_USBD_Interface
     typedef int32_t (*read_callback_t ) (uint32_t lba, void* buffer, uint32_t bufsize);
     typedef int32_t (*write_callback_t) (uint32_t lba, uint8_t* buffer, uint32_t bufsize);
     typedef void    (*flush_callback_t) (void);
+    typedef bool    (*ready_callback_t) (void);
 
     Adafruit_USBD_MSC(void);
 
@@ -46,7 +47,10 @@ class Adafruit_USBD_MSC : Adafruit_USBD_Interface
     void setCapacity(uint8_t lun, uint32_t block_count, uint16_t block_size);
     void getCapacity(uint8_t lun, uint32_t* block_count, uint16_t* block_size);
 
-    void setCallback(uint8_t lun, read_callback_t rd_cb, write_callback_t wr_cb, flush_callback_t fl_cb);
+    void setUnitReady(uint8_t lun, bool ready);
+
+    void setReadWriteCallback(uint8_t lun, read_callback_t rd_cb, write_callback_t wr_cb, flush_callback_t fl_cb);
+    void setReadyCallback(uint8_t lun, ready_callback_t cb);
 
     // from Adafruit_USBD_Interface
     virtual uint16_t getDescriptor(uint8_t* buf, uint16_t bufsize);
@@ -57,21 +61,26 @@ class Adafruit_USBD_MSC : Adafruit_USBD_Interface
         read_callback_t  rd_cb;
         write_callback_t wr_cb;
         flush_callback_t fl_cb;
-
-        uint32_t block_count;
-        uint16_t block_size;
+        ready_callback_t ready_cb;
 
         const char* _inquiry_vid;
         const char* _inquiry_pid;
         const char* _inquiry_rev;
+
+        uint32_t block_count;
+        uint16_t block_size;
+        bool unit_ready;
+
     } _lun[MAX_LUN];
 
     uint8_t _maxlun;
 
+    // Make all tinyusb callback friend to access private data
     friend int32_t tud_msc_read10_cb (uint8_t lun, uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize);
     friend int32_t tud_msc_write10_cb (uint8_t lun, uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize);
     friend void tud_msc_write10_complete_cb (uint8_t lun);
     friend void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t product_id[16], uint8_t product_rev[4]);
+    friend bool tud_msc_test_unit_ready_cb(uint8_t lun);
 };
 
 #endif /* ADAFRUIT_USBD_MSC_H_ */