add Adafruit_USBH_MSC_BlockDevice which implement SdFat FsBlockDeviceInterface API

add Adafruit_USBH_MSC.c/h, add msc_file_explorer example

Author: hathach

examples/DualRole/msc_file_explorer/.feather_rp2040_tinyusb.test.only

@@ -0,0 +1,155 @@
+/*********************************************************************
+ Adafruit invests time and resources providing this open source code,
+ please support Adafruit and open-source hardware by purchasing
+ products from Adafruit!
+
+ MIT license, check LICENSE for more information
+ Copyright (c) 2019 Ha Thach for Adafruit Industries
+ All text above, and the splash screen below must be included in
+ any redistribution
+*********************************************************************/
+
+
+/* This example demonstrates use of both device and host, where
+ * - Device run on native usb controller (controller0)
+ * - Host run on bit-banging 2 GPIOs with the help of Pico-PIO-USB library (controller1)
+ *
+ * Requirements:
+ * - [Pico-PIO-USB](https://github.com/sekigon-gonnoc/Pico-PIO-USB) library
+ * - 2 consecutive GPIOs: D+ is defined by HOST_PIN_DP (gpio20), D- = D+ +1 (gpio21)
+ * - Provide VBus (5v) and GND for peripheral
+ * - CPU Speed must be either 120 or 240 Mhz. Selected via "Menu -> CPU Speed"
+ */
+
+// pio-usb is required for rp2040 host
+#include "pio_usb.h"
+
+// SdFat is required for using Adafruit_USBH_MSC_SdFatDevice
+#include "SdFat.h"
+
+// TinyUSB lib
+#include "Adafruit_TinyUSB.h"
+
+// Pin D+ for host, D- = D+ + 1
+#define HOST_PIN_DP       20
+
+// Pin for enabling Host VBUS. comment out if not used
+#define HOST_PIN_VBUS_EN        22
+#define HOST_PIN_VBUS_EN_STATE  1
+
+// USB Host object
+Adafruit_USBH_Host USBHost;
+
+// USB Host MSC Block Device object which implemented API for use with SdFat
+Adafruit_USBH_MSC_BlockDevice msc_block_dev;
+
+// file system object from SdFat
+FatVolume fatfs;
+
+// if file system is succesfully mounted on usb block device
+bool is_mounted = false;
+
+//--------------------------------------------------------------------+
+// Setup and Loop on Core0
+//--------------------------------------------------------------------+
+
+void setup()
+{
+  Serial1.begin(115200);
+
+  Serial.begin(115200);
+  //while ( !Serial ) delay(10);   // wait for native usb
+
+  Serial.println("TinyUSB Dual Device Info Example");
+}
+
+void loop()
+{
+}
+
+//--------------------------------------------------------------------+
+// Setup and Loop on Core1
+//--------------------------------------------------------------------+
+
+void setup1() {
+  //while ( !Serial ) delay(10);   // wait for native usb
+  Serial.println("Core1 setup to run TinyUSB host with pio-usb");
+
+  // Check for CPU frequency, must be multiple of 120Mhz for bit-banging USB
+  uint32_t cpu_hz = clock_get_hz(clk_sys);
+  if ( cpu_hz != 120000000UL && cpu_hz != 240000000UL ) {
+    while ( !Serial ) {
+      delay(10);   // wait for native usb
+    }
+    Serial.printf("Error: CPU Clock = %u, PIO USB require CPU clock must be multiple of 120 Mhz\r\n", cpu_hz);
+    Serial.printf("Change your CPU Clock to either 120 or 240 Mhz in Menu->CPU Speed \r\n", cpu_hz);
+    while(1) {
+      delay(1);
+    }
+  }
+
+#ifdef HOST_PIN_VBUS_EN
+  pinMode(HOST_PIN_VBUS_EN, OUTPUT);
+  digitalWrite(HOST_PIN_VBUS_EN, HOST_PIN_VBUS_EN_STATE);
+#endif
+
+  pio_usb_configuration_t pio_cfg = PIO_USB_DEFAULT_CONFIG;
+  pio_cfg.pin_dp = HOST_PIN_DP;
+  USBHost.configure_pio_usb(1, &pio_cfg);
+
+  // run host stack on controller (rhport) 1
+  // Note: For rp2040 pico-pio-usb, calling USBHost.begin() on core1 will have most of the
+  // host bit-banging processing works done in core1 to free up core0 for other works
+  USBHost.begin(1);
+}
+
+void loop1()
+{
+  USBHost.task();
+}
+
+//--------------------------------------------------------------------+
+// TinyUSB Host callbacks
+//--------------------------------------------------------------------+
+
+// Invoked when device is mounted (configured)
+void tuh_mount_cb (uint8_t daddr)
+{
+  (void) daddr;
+}
+
+/// Invoked when device is unmounted (bus reset/unplugged)
+void tuh_umount_cb(uint8_t daddr)
+{
+  (void) daddr;
+}
+
+// Invoked when a device with MassStorage interface is mounted
+void tuh_msc_mount_cb(uint8_t dev_addr)
+{
+  // Initialize block device with MSC device address
+  msc_block_dev.begin(dev_addr);
+
+  // For simplicity this example only support LUN 0
+  msc_block_dev.setActiveLUN(0);
+
+  is_mounted = fatfs.begin(&msc_block_dev);
+
+  if (is_mounted) {
+    fatfs.ls(&Serial, LS_SIZE);
+  }
+}
+
+// Invoked when a device with MassStorage interface is unmounted
+void tuh_msc_umount_cb(uint8_t dev_addr)
+{
+  (void) dev_addr;
+
+  // unmount file system
+  is_mounted = false;
+  fatfs.end();
+
+  // end block device
+  msc_block_dev.end();
+}
+

examples/DualRole/msc_file_explorer/msc_file_explorer.ino

@@ -64,6 +64,9 @@ void TinyUSB_Device_Init(uint8_t rhport);
 #if CFG_TUH_ENABLED
 
 #include "arduino/Adafruit_USBH_Host.h"
+#if CFG_TUH_MSC
+  #include "arduino/msc/Adafruit_USBH_MSC.h"
+#endif
 
 #endif
 

src/Adafruit_TinyUSB.h

@@ -0,0 +1,135 @@
+/* 
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 Ha Thach (tinyusb.org) 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 "tusb_option.h"
+
+#if CFG_TUH_ENABLED && CFG_TUH_MSC
+
+#include "tusb.h"
+#include "Adafruit_USBH_MSC.h"
+
+#if __has_include("SdFat.h")
+
+Adafruit_USBH_MSC_BlockDevice::Adafruit_USBH_MSC_BlockDevice() {
+  _daddr = _lun = 0;
+  _busy = false;
+}
+
+bool Adafruit_USBH_MSC_BlockDevice::begin(uint8_t dev_addr) {
+  _daddr = dev_addr;
+  return true;
+}
+
+bool Adafruit_USBH_MSC_BlockDevice::setActiveLUN(uint8_t lun) {
+  _lun = lun;
+  return true;
+}
+
+void Adafruit_USBH_MSC_BlockDevice::end(void) {
+  _daddr = _lun = 0;
+}
+
+bool Adafruit_USBH_MSC_BlockDevice::mounted(void) {
+  return _daddr > 0;
+}
+
+bool Adafruit_USBH_MSC_BlockDevice::isBusy(void) {
+  return _busy;
+}
+
+bool Adafruit_USBH_MSC_BlockDevice::wait_for_io(void) {
+  while (_busy) {
+    tuh_task();
+  }
+
+  return true;
+}
+
+bool Adafruit_USBH_MSC_BlockDevice::_io_complete_cb(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data) {
+  if (dev_addr != _daddr) {
+    // something wrong occurred, maybe device removed while transferring
+    return false;
+  }
+
+  // TODO skip csw status: assuming io is successful
+  _busy = false;
+  return true;
+}
+
+static bool _msc_io_complete_cb(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data) {
+  Adafruit_USBH_MSC_BlockDevice* sdfat_dev = (Adafruit_USBH_MSC_BlockDevice*) cb_data->user_arg;
+  sdfat_dev->_io_complete_cb(dev_addr, cb_data);
+  return true;
+}
+
+uint32_t Adafruit_USBH_MSC_BlockDevice::sectorCount(void) {
+  return tuh_msc_get_block_count(_daddr, _lun);
+}
+
+bool Adafruit_USBH_MSC_BlockDevice::syncDevice(void) {
+  // no caching
+  return true;
+}
+
+bool Adafruit_USBH_MSC_BlockDevice::readSectors(uint32_t block, uint8_t *dst, size_t ns) {
+  _busy = true;
+  if( tuh_msc_read10(_daddr, _lun, dst, block, (uint16_t) ns, _msc_io_complete_cb, (uintptr_t) this) ) {
+    wait_for_io();
+    return true;
+  }else {
+    _busy = false;
+    return false;
+  }
+}
+
+bool Adafruit_USBH_MSC_BlockDevice::writeSectors(uint32_t block, const uint8_t *src, size_t ns) {
+  _busy = true;
+  if( tuh_msc_write10(_daddr, _lun, src, block, (uint16_t) ns, _msc_io_complete_cb, (uintptr_t) this) ) {
+    wait_for_io();
+    return true;
+  }else {
+    _busy = false;
+    return false;
+  }
+}
+
+bool Adafruit_USBH_MSC_BlockDevice::readSector(uint32_t block, uint8_t *dst) {
+  return readSectors(block, dst, 1);
+}
+
+bool Adafruit_USBH_MSC_BlockDevice::writeSector(uint32_t block, const uint8_t *src) {
+  return writeSectors(block, src, 1);
+}
+
+#endif
+
+//--------------------------------------------------------------------+
+// MACRO TYPEDEF CONSTANT ENUM DECLARATION
+//--------------------------------------------------------------------+
+
+
+//------------- IMPLEMENTATION -------------//
+
+
+#endif

src/arduino/msc/Adafruit_USBH_MSC.cpp

@@ -0,0 +1,72 @@
+/* 
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022 Ha Thach (tinyusb.org) 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.
+ */
+
+#ifndef ADAFRUIT_USBH_MSC_H_
+#define ADAFRUIT_USBH_MSC_H_
+
+#include "tusb.h"
+
+// define SdFat host helper class if SdFat library is available
+#if __has_include("SdFat.h")
+
+#include "SdFat.h"
+
+class Adafruit_USBH_MSC_BlockDevice : public FsBlockDeviceInterface {
+public:
+    Adafruit_USBH_MSC_BlockDevice();
+
+    bool begin(uint8_t dev_addr);
+    void end(void);
+
+    // Set active LUN
+    bool setActiveLUN(uint8_t lun);
+
+    bool mounted(void);
+
+    //------------- SdFat v2 FsBlockDeviceInterface API -------------//
+    virtual bool isBusy();
+    virtual uint32_t sectorCount();
+    virtual bool syncDevice();
+
+    virtual bool readSector(uint32_t block, uint8_t *dst);
+    virtual bool readSectors(uint32_t block, uint8_t *dst, size_t ns);
+    virtual bool writeSector(uint32_t block, const uint8_t *src);
+    virtual bool writeSectors(uint32_t block, const uint8_t *src, size_t ns);
+
+    //------------- Internal APIs -------------//
+    bool _io_complete_cb(uint8_t dev_addr, tuh_msc_complete_data_t const* cb_data);
+
+private:
+    uint8_t _daddr;
+    uint8_t _lun;
+
+    // TODO use mutex to prevent race condition or atomic for better implementation
+    volatile bool _busy;
+
+    bool wait_for_io(void);
+};
+
+#endif
+
+#endif