Merge ARMmbed#1 and ARMmbed#2

- ARMmbed#1 is based on [JojoS62/sdio-driver/master](JojoS62@c03489c).
- ARMmbed#2 is based on [NXPmicro/sdio-driver/Add_SDIO_LPC55S69](nxp-archive@370c51a)

Author: mathias-arm

SDIOBlockDevice.cpp renamed to COMPONENT_SDIO/SDIOBlockDevice.cpp

@@ -1,5 +1,6 @@
 /* mbed Microcontroller Library
- * Copyright (c) 2017 ARM Limited
+ * Copyright (c) 2019 ARM Limited
+ * SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,13 +15,11 @@
  * limitations under the License.
  */
 
-#include <errno.h>
-#include "platform/mbed_debug.h"
-#include "platform/mbed_wait_api.h"
 #include "SDIOBlockDevice.h"
+#include "platform/mbed_debug.h"
+#include "sdio_device.h"
 
-namespace mbed
-{
+using namespace mbed;
 
 /*
  *  defines
@@ -63,17 +62,14 @@ SDIOBlockDevice::SDIOBlockDevice(PinName cardDetect) : _cardDetect(cardDetect),
                                                        _sectors(0),
                                                        _init_ref_count(0)
 {
-    _card_type = SDCARD_NONE;
-
     // Only HC block size is supported.
     _block_size = BLOCK_SIZE_HC;
     _erase_size = BLOCK_SIZE_HC;
 }
 
 SDIOBlockDevice::~SDIOBlockDevice()
 {
-    if (_is_initialized)
-    {
+    if (_is_initialized) {
         deinit();
     }
 }
@@ -84,48 +80,39 @@ int SDIOBlockDevice::init()
 
     lock();
 
-    if (!_is_initialized)
-    {
+    if (!_is_initialized) {
         _init_ref_count = 0;
     }
 
     _init_ref_count++;
 
-    if (_init_ref_count != 1)
-    {
+    if (_init_ref_count != 1) {
         unlock();
         return BD_ERROR_OK;
     }
 
-    if (isPresent() == false)
-    {
+    if (isPresent() == false) {
         unlock();
         return SD_BLOCK_DEVICE_ERROR_NO_DEVICE;
     }
 
-    int status = SD_Init();
-    if (BD_ERROR_OK != status)
-    {
+    int status = SDIO_Device_Init();
+    if (BD_ERROR_OK != status) {
         unlock();
         return BD_ERROR_DEVICE_ERROR;
     }
 
-    SD_GetCardInfo(&_cardInfo);
     _is_initialized = true;
-    debug_if(SD_DBG, "SD initialized: type: %d  version: %d  class: %d\n",
-             _cardInfo.CardType, _cardInfo.CardVersion, _cardInfo.Class);
-    debug_if(SD_DBG, "SD size: %d MB\n",
-             _cardInfo.LogBlockNbr / 2 / 1024);
 
     // get sectors count from cardinfo
-    _sectors = _cardInfo.LogBlockNbr;
-    if (BLOCK_SIZE_HC != _cardInfo.BlockSize)
-    {
+    _sectors = SDIO_Device_GetBlockCount();
+    if (BLOCK_SIZE_HC != SDIO_Device_GetBlockSize()) {
         unlock();
         return SD_BLOCK_DEVICE_ERROR_UNSUPPORTED_BLOCKSIZE;
     }
 
     unlock();
+
     return status;
 }
 
@@ -134,22 +121,20 @@ int SDIOBlockDevice::deinit()
     debug_if(SD_DBG, "deinit Card...\r\n");
     lock();
 
-    if (!_is_initialized)
-    {
+    if (!_is_initialized) {
         _init_ref_count = 0;
         unlock();
         return BD_ERROR_OK;
     }
 
     _init_ref_count--;
 
-    if (_init_ref_count)
-    {
+    if (_init_ref_count) {
         unlock();
         return BD_ERROR_OK;
     }
 
-    int status = SD_DeInit();
+    int status = SDIO_Device_DeInit();
     _is_initialized = false;
 
     _sectors = 0;
@@ -161,19 +146,16 @@ int SDIOBlockDevice::deinit()
 int SDIOBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size)
 {
     lock();
-    if (isPresent() == false)
-    {
+    if (isPresent() == false) {
         unlock();
         return SD_BLOCK_DEVICE_ERROR_NO_DEVICE;
     }
-    if (!is_valid_read(addr, size))
-    {
+    if (!is_valid_read(addr, size)) {
         unlock();
         return SD_BLOCK_DEVICE_ERROR_PARAMETER;
     }
 
-    if (!_is_initialized)
-    {
+    if (!_is_initialized) {
         unlock();
         return SD_BLOCK_DEVICE_ERROR_NO_INIT;
     }
@@ -185,76 +167,33 @@ int SDIOBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size)
     bd_addr_t blockCnt = size / _block_size;
     addr = addr / _block_size;
 
-    // make sure card is ready
-    {
-        uint32_t tickstart = HAL_GetTick();
-        while (SD_GetCardState() != SD_TRANSFER_OK)
-        {
-            // wait until SD ready
-            if ((HAL_GetTick() - tickstart) >= MBED_CONF_SD_TIMEOUT)
-            {
-                unlock();
-                return SD_BLOCK_DEVICE_ERROR_READBLOCKS;
-            }
-        }
-    }
-
     // receive the data : one block/ multiple blocks is handled in ReadBlocks()
-    int status = SD_ReadBlocks_DMA(_buffer, addr, blockCnt);
+    int status = SDIO_Device_ReadBlocks(_buffer, addr, blockCnt, MBED_CONF_SD_TIMEOUT);
     debug_if(SD_DBG, "ReadBlocks dbgtest addr: %lld  blockCnt: %lld \n", addr, blockCnt);
-
-    if (status == MSD_OK)
-    {
-        // wait until DMA finished
-        uint32_t tickstart = HAL_GetTick();
-        while (SD_DMA_ReadPending() != SD_TRANSFER_OK)
-        {
-            if ((HAL_GetTick() - tickstart) >= MBED_CONF_SD_TIMEOUT)
-            {
-                unlock();
-                return SD_BLOCK_DEVICE_ERROR_READBLOCKS;
-            }
-        }
-        // make sure card is ready
-        tickstart = HAL_GetTick();
-        while (SD_GetCardState() != SD_TRANSFER_OK)
-        {
-            // wait until SD ready
-            if ((HAL_GetTick() - tickstart) >= MBED_CONF_SD_TIMEOUT)
-            {
-                unlock();
-                return SD_BLOCK_DEVICE_ERROR_READBLOCKS;
-            }
-        }
-    }
-    else
-    {
+    if (status != MSD_OK) {
         debug_if(SD_DBG, "ReadBlocks failed! addr: %lld  blockCnt: %lld \n", addr, blockCnt);
-        unlock();
-        return SD_BLOCK_DEVICE_ERROR_READBLOCKS;
+        status = SD_BLOCK_DEVICE_ERROR_READBLOCKS;
     }
 
     unlock();
+
     return status;
 }
 
 int SDIOBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t size)
 {
     lock();
 
-    if (isPresent() == false)
-    {
+    if (isPresent() == false) {
         unlock();
         return SD_BLOCK_DEVICE_ERROR_NO_DEVICE;
     }
-    if (!is_valid_program(addr, size))
-    {
+    if (!is_valid_program(addr, size)) {
         unlock();
         return SD_BLOCK_DEVICE_ERROR_PARAMETER;
     }
 
-    if (!_is_initialized)
-    {
+    if (!_is_initialized) {
         unlock();
         return SD_BLOCK_DEVICE_ERROR_NO_INIT;
     }
@@ -266,101 +205,44 @@ int SDIOBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t size)
     bd_size_t blockCnt = size / _block_size;
     addr = addr / _block_size;
 
-    // make sure card is ready
-    {
-        uint32_t tickstart = HAL_GetTick();
-        while (SD_GetCardState() != SD_TRANSFER_OK)
-        {
-            // wait until SD ready
-            if ((HAL_GetTick() - tickstart) >= MBED_CONF_SD_TIMEOUT)
-            {
-                unlock();
-                return SD_BLOCK_DEVICE_ERROR_WRITEBLOCKS;
-            }
-        }
-    }
-
-    int status = SD_WriteBlocks_DMA(_buffer, addr, blockCnt);
+    int status = SDIO_Device_WriteBlocks(_buffer, addr, blockCnt, MBED_CONF_SD_TIMEOUT);
     debug_if(SD_DBG, "WriteBlocks dbgtest addr: %lld  blockCnt: %lld \n", addr, blockCnt);
 
-    if (status == MSD_OK)
-    {
-        // wait until DMA finished
-        uint32_t tickstart = HAL_GetTick();
-        while (SD_DMA_WritePending() != SD_TRANSFER_OK)
-        {
-            if ((HAL_GetTick() - tickstart) >= MBED_CONF_SD_TIMEOUT)
-            {
-                unlock();
-                return SD_BLOCK_DEVICE_ERROR_WRITEBLOCKS;
-            }
-        }
-        // make sure card is ready
-        tickstart = HAL_GetTick();
-        while (SD_GetCardState() != SD_TRANSFER_OK)
-        {
-            // wait until SD ready
-            if ((HAL_GetTick() - tickstart) >= MBED_CONF_SD_TIMEOUT)
-            {
-                unlock();
-                return SD_BLOCK_DEVICE_ERROR_WRITEBLOCKS;
-            }
-        }
-    }
-    else
-    {
+    if (status != MSD_OK) {
         debug_if(SD_DBG, "WriteBlocks failed! addr: %lld  blockCnt: %lld \n", addr, blockCnt);
-        unlock();
-        return SD_BLOCK_DEVICE_ERROR_WRITEBLOCKS;
+        status = SD_BLOCK_DEVICE_ERROR_WRITEBLOCKS;
     }
 
     unlock();
+
     return status;
 }
 
 int SDIOBlockDevice::trim(bd_addr_t addr, bd_size_t size)
 {
     debug_if(SD_DBG, "trim Card...\r\n");
     lock();
-    if (isPresent() == false)
-    {
+    if (isPresent() == false) {
         unlock();
         return SD_BLOCK_DEVICE_ERROR_NO_DEVICE;
     }
-    if (!_is_valid_trim(addr, size))
-    {
+    if (!_is_valid_trim(addr, size)) {
         unlock();
         return SD_BLOCK_DEVICE_ERROR_PARAMETER;
     }
 
-    if (!_is_initialized)
-    {
+    if (!_is_initialized) {
         unlock();
         return SD_BLOCK_DEVICE_ERROR_NO_INIT;
     }
 
     bd_size_t blockCnt = size / _block_size;
     addr = addr / _block_size;
 
-    int status = SD_Erase(addr, blockCnt);
-    if (status != 0)
-    {
+    int status = SDIO_Device_Erase(addr, blockCnt, MBED_CONF_SD_TIMEOUT);
+    if (status != 0) {
         debug_if(SD_DBG, "Erase blocks failed! addr: %lld  blockCnt: %lld \n", addr, blockCnt);
-        unlock();
-        return SD_BLOCK_DEVICE_ERROR_ERASEBLOCKS;
-    }
-    else
-    {
-        uint32_t tickstart = HAL_GetTick();
-        while (SD_GetCardState() != SD_TRANSFER_OK)
-        {
-            // wait until SD ready
-            if ((HAL_GetTick() - tickstart) >= MBED_CONF_SD_TIMEOUT)
-            {
-                unlock();
-                return SD_BLOCK_DEVICE_ERROR_ERASEBLOCKS;
-            }
-        }
+        status = SD_BLOCK_DEVICE_ERROR_ERASEBLOCKS;
     }
 
     unlock();
@@ -404,4 +286,7 @@ bool SDIOBlockDevice::isPresent(void)
     }
 }
 
-} // namespace mbed
+const char *SDIOBlockDevice::get_type() const
+{
+    return "SDIO";
+}