SDBlockDevice: revert HW CS support, add async support (ARMmbed#181)

* SDBlockDevice: revert HW CS support, add async support

* Convert one last call

* Turn off debug mode, whoops

* Run formatter

Author: Jamie Smith

storage/blockdevice/COMPONENT_SD/include/SD/SDBlockDevice.h

@@ -58,12 +58,12 @@
  */
 class SDBlockDevice : public mbed::BlockDevice {
 public:
-    /** Creates an SDBlockDevice on a SPI bus specified by pins (using dynamic pin-map).
+    /** Creates an SDBlockDevice on a SPI bus specified by pins (using dynamic pin-map)
      *
      *  @param mosi     SPI master out, slave in pin
      *  @param miso     SPI master in, slave out pin
      *  @param sclk     SPI clock pin
-     *  @param cs       SPI chip select pin.   This constructor needs a *hardware* chip select pin.
+     *  @param cs       SPI chip select pin.  Currently, GPIO chip selects are always used.
      *  @param hz       Clock speed of the SPI bus (defaults to 1MHz)
      *  @param crc_on   Enable cyclic redundancy check (defaults to disabled)
      */
@@ -74,48 +74,14 @@ class SDBlockDevice : public mbed::BlockDevice {
                   uint64_t hz = MBED_CONF_SD_TRX_FREQUENCY,
                   bool crc_on = MBED_CONF_SD_CRC_ENABLED);
 
-    /** Creates an SDBlockDevice on a SPI bus specified by pins (using dynamic pin-map).
-     * This version creates an SPI object that uses GPIO for its chip select line instead of
-     * a dedicated hardware CS pin.
-     *
-     *  @param mosi     SPI master out, slave in pin
-     *  @param miso     SPI master in, slave out pin
-     *  @param sclk     SPI clock pin
-     *  @param cs       SPI chip select pin.  May be any GPIO pin.
-     *  @param hz       Clock speed of the SPI bus (defaults to 1MHz)
-     *  @param crc_on   Enable cyclic redundancy check (defaults to disabled)
-     */
-    SDBlockDevice(mbed::use_gpio_ssel_t,
-                  PinName mosi = MBED_CONF_SD_SPI_MOSI,
-                  PinName miso = MBED_CONF_SD_SPI_MISO,
-                  PinName sclk = MBED_CONF_SD_SPI_CLK,
-                  PinName cs = MBED_CONF_SD_SPI_CS,
-                  uint64_t hz = MBED_CONF_SD_TRX_FREQUENCY,
-                  bool crc_on = MBED_CONF_SD_CRC_ENABLED);
-
-
-    /** Creates an SDBlockDevice on a SPI bus specified by pins (using static pin-map).
-     * This version needs a pinmap containing a hardware chip select pin.
-     *
-     *  @param spi_pinmap Static SPI pin-map
-     *  @param hz         Clock speed of the SPI bus (defaults to 1MHz)
-     *  @param crc_on     Enable cyclic redundancy check (defaults to disabled)
-     */
-    SDBlockDevice(const spi_pinmap_t &spi_pinmap,
-                  uint64_t hz = MBED_CONF_SD_TRX_FREQUENCY,
-                  bool crc_on = MBED_CONF_SD_CRC_ENABLED);
-
-    /** Creates an SDBlockDevice on a SPI bus specified by pins (using static pin-map).
-     * This version creates an SPI object that uses GPIO for its chip select line instead of
-     * a dedicated hardware CS pin.
+    /** Creates an SDBlockDevice on a SPI bus specified by pins (using static pin-map)
      *
      *  @param spi_pinmap Static SPI pin-map
      *  @param cs         Chip select pin (can be any GPIO)
      *  @param hz         Clock speed of the SPI bus (defaults to 1MHz)
      *  @param crc_on     Enable cyclic redundancy check (defaults to disabled)
      */
     SDBlockDevice(const spi_pinmap_t &spi_pinmap,
-                  mbed::use_gpio_ssel_t,
                   PinName cs = MBED_CONF_SD_SPI_CS,
                   uint64_t hz = MBED_CONF_SD_TRX_FREQUENCY,
                   bool crc_on = MBED_CONF_SD_CRC_ENABLED);
@@ -132,6 +98,21 @@ class SDBlockDevice : public mbed::BlockDevice {
      */
     virtual int init();
 
+#if DEVICE_SPI_ASYNCH
+    /**
+     * @brief Configure the usage of asynchronous %SPI by this class.
+     *
+     * By default, async %SPI is not enabled, so this class will simply busy-wait while
+     * communicating with the card.  When async %SPI is enabled, %SPI operations
+     * will be done in blocking asynchronous mode, so other threads may execute
+     * in the background while data is going to and from the card.
+     *
+     * @param enabled Whether usage of async %SPI is enabled.
+     * @param dma_usage_hint DMA usage hint to pass to the underlying #SPI instance.
+     */
+    void set_async_spi_mode(bool enabled, DMAUsage dma_usage_hint = DMAUsage::DMA_USAGE_NEVER);
+#endif
+
     /** Deinitialize a block device
      *
      *  @return         BD_ERROR_OK(0) - success
@@ -330,6 +311,10 @@ class SDBlockDevice : public mbed::BlockDevice {
 #if MBED_CONF_SD_CRC_ENABLED
     bool _crc_on;
 #endif
+
+#if DEVICE_SPI_ASYNCH
+    bool _async_spi_enabled = false;
+#endif
 };
 
 #endif  /* DEVICE_SPI */

storage/blockdevice/COMPONENT_SD/source/SDBlockDevice.cpp

@@ -251,43 +251,16 @@ using namespace std::chrono;
 // Only HC block size is supported. Making this a static constant reduces code size.
 const uint32_t SDBlockDevice::_block_size = BLOCK_SIZE_HC;
 
-SDBlockDevice::SDBlockDevice(PinName mosi, PinName miso, PinName sclk, PinName cs, uint64_t hz, bool crc_on)
-    : _sectors(0), _spi(mosi, miso, sclk, cs), _is_initialized(0),
 #if MBED_CONF_SD_CRC_ENABLED
-      _init_ref_count(0), _crc_on(crc_on)
-#else
-      _init_ref_count(0)
-#endif
-{
-#if !MBED_CONF_SD_CRC_ENABLED
-    // If this assert fails, this code was compiled without CRC support but you tried to use it.
-    MBED_ASSERT(!crc_on);
-#endif
-
-    _card_type = SDCARD_NONE;
-
-    // Set default to 100kHz for initialisation and 1MHz for data transfer
-    static_assert(((MBED_CONF_SD_INIT_FREQUENCY >= 100000) && (MBED_CONF_SD_INIT_FREQUENCY <= 400000)),
-                  "Initialization frequency should be between 100KHz to 400KHz");
-    _init_sck = MBED_CONF_SD_INIT_FREQUENCY;
-    _transfer_sck = hz;
-
-    _erase_size = BLOCK_SIZE_HC;
-}
-
-SDBlockDevice::SDBlockDevice(mbed::use_gpio_ssel_t, PinName mosi, PinName miso, PinName sclk, PinName cs, uint64_t hz, bool crc_on)
+SDBlockDevice::SDBlockDevice(PinName mosi, PinName miso, PinName sclk, PinName cs, uint64_t hz, bool crc_on)
     : _sectors(0), _spi(mosi, miso, sclk, cs, use_gpio_ssel), _is_initialized(0),
-#if MBED_CONF_SD_CRC_ENABLED
       _init_ref_count(0), _crc_on(crc_on)
 #else
+SDBlockDevice::SDBlockDevice(PinName mosi, PinName miso, PinName sclk, PinName cs, uint64_t hz, bool crc_on)
+    : _sectors(0), _spi(mosi, miso, sclk, cs, use_gpio_ssel), _is_initialized(0),
       _init_ref_count(0)
 #endif
 {
-#if !MBED_CONF_SD_CRC_ENABLED
-    // If this assert fails, this code was compiled without CRC support but you tried to use it.
-    MBED_ASSERT(!crc_on);
-#endif
-
     _card_type = SDCARD_NONE;
 
     // Set default to 100kHz for initialisation and 1MHz for data transfer
@@ -299,43 +272,16 @@ SDBlockDevice::SDBlockDevice(mbed::use_gpio_ssel_t, PinName mosi, PinName miso,
     _erase_size = BLOCK_SIZE_HC;
 }
 
-SDBlockDevice::SDBlockDevice(const spi_pinmap_t &spi_pinmap, uint64_t hz, bool crc_on)
-        : _sectors(0), _spi(spi_pinmap), _is_initialized(0),
 #if MBED_CONF_SD_CRC_ENABLED
-          _init_ref_count(0), _crc_on(crc_on)
-#else
-_init_ref_count(0)
-#endif
-{
-#if !MBED_CONF_SD_CRC_ENABLED
-    // If this assert fails, this code was compiled without CRC support but you tried to use it.
-    MBED_ASSERT(!crc_on);
-#endif
-
-    _card_type = SDCARD_NONE;
-
-    // Set default to 100kHz for initialisation and 1MHz for data transfer
-    static_assert(((MBED_CONF_SD_INIT_FREQUENCY >= 100000) && (MBED_CONF_SD_INIT_FREQUENCY <= 400000)),
-                  "Initialization frequency should be between 100KHz to 400KHz");
-    _init_sck = MBED_CONF_SD_INIT_FREQUENCY;
-    _transfer_sck = hz;
-
-    _erase_size = BLOCK_SIZE_HC;
-}
-
-SDBlockDevice::SDBlockDevice(const spi_pinmap_t &spi_pinmap, mbed::use_gpio_ssel_t, PinName cs, uint64_t hz, bool crc_on)
+SDBlockDevice::SDBlockDevice(const spi_pinmap_t &spi_pinmap, PinName cs, uint64_t hz, bool crc_on)
     : _sectors(0), _spi(spi_pinmap, cs), _is_initialized(0),
-#if MBED_CONF_SD_CRC_ENABLED
       _init_ref_count(0), _crc_on(crc_on)
 #else
+SDBlockDevice::SDBlockDevice(const spi_pinmap_t &spi_pinmap, PinName cs, uint64_t hz, bool crc_on)
+    : _sectors(0), _spi(spi_pinmap, cs), _is_initialized(0),
       _init_ref_count(0)
 #endif
 {
-#if !MBED_CONF_SD_CRC_ENABLED
-    // If this assert fails, this code was compiled without CRC support but you tried to use it.
-    MBED_ASSERT(!crc_on);
-#endif
-
     _card_type = SDCARD_NONE;
 
     // Set default to 100kHz for initialisation and 1MHz for data transfer
@@ -499,6 +445,12 @@ int SDBlockDevice::init()
     return BD_ERROR_OK;
 }
 
+void SDBlockDevice::set_async_spi_mode(bool enabled, DMAUsage dma_usage_hint)
+{
+    _async_spi_enabled = enabled;
+    _spi.set_dma_usage(dma_usage_hint);
+}
+
 int SDBlockDevice::deinit()
 {
     lock();
@@ -778,8 +730,13 @@ uint8_t SDBlockDevice::_cmd_spi(SDBlockDevice::cmdSupported cmd, uint32_t arg)
     }
 
     // send a command
-    for (int i = 0; i < PACKET_SIZE; i++) {
-        _spi.write(cmdPacket[i]);
+#if DEVICE_SPI_ASYNCH
+    if (_async_spi_enabled) {
+        _spi.transfer_and_wait(cmdPacket, PACKET_SIZE, nullptr, 0);
+    } else
+#endif
+    {
+        _spi.write(cmdPacket, PACKET_SIZE, nullptr, 0);
     }
 
     // The received byte immediataly following CMD12 is a stuff byte,
@@ -966,8 +923,13 @@ int SDBlockDevice::_read_bytes(uint8_t *buffer, uint32_t length)
     }
 
     // read data
-    for (uint32_t i = 0; i < length; i++) {
-        buffer[i] = _spi.write(SPI_FILL_CHAR);
+#if DEVICE_SPI_ASYNCH
+    if (_async_spi_enabled) {
+        _spi.transfer_and_wait(nullptr, 0, buffer, length);
+    } else
+#endif
+    {
+        _spi.write(nullptr, 0, buffer, length);
     }
 
     // Read the CRC16 checksum for the data block
@@ -1004,7 +966,16 @@ int SDBlockDevice::_read(uint8_t *buffer, uint32_t length)
     }
 
     // read data
-    _spi.write(NULL, 0, (char *)buffer, length);
+#if DEVICE_SPI_ASYNCH
+    if (_async_spi_enabled) {
+        if (_spi.transfer_and_wait(nullptr, 0, buffer, length) != 0) {
+            return SD_BLOCK_DEVICE_ERROR_WRITE;
+        }
+    } else
+#endif
+    {
+        _spi.write(NULL, 0, (char *) buffer, length);
+    }
 
     // Read the CRC16 checksum for the data block
     crc = (_spi.write(SPI_FILL_CHAR) << 8);
@@ -1037,7 +1008,14 @@ uint8_t SDBlockDevice::_write(const uint8_t *buffer, uint8_t token, uint32_t len
     _spi.write(token);
 
     // write the data
-    _spi.write((char *)buffer, length, NULL, 0);
+#if DEVICE_SPI_ASYNCH
+    if (_async_spi_enabled) {
+        _spi.transfer_and_wait(buffer, length, nullptr, 0);
+    } else
+#endif
+    {
+        _spi.write(buffer, length, nullptr, 0);
+    }
 
 #if MBED_CONF_SD_CRC_ENABLED
     if (_crc_on) {