WebSVN – canSerial – Diff – /trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_sd.c

 /**
   ******************************************************************************
   * @file    stm32f1xx_hal_sd.c
   * @author  MCD Application Team
   * @brief   SD card HAL module driver.
   *          This file provides firmware functions to manage the following
   *          functionalities of the Secure Digital (SD) peripheral:
   *           + Initialization and de-initialization functions
   *           + IO operation functions
   *           + Peripheral Control functions
   *           + Peripheral State functions
   *
-  @verbatim
+  ******************************************************************************
-  ==============================================================================
+  * @attention
-                        ##### How to use this driver #####
+  *
-  ==============================================================================
+  * Copyright (c) 2016 STMicroelectronics.
-  [..]
+  * All rights reserved.
-    This driver implements a high level communication layer for read and write from/to
+  *
-    this memory. The needed STM32 hardware resources (SDIO and GPIO) are performed by
+  * This software is licensed under terms that can be found in the LICENSE file
-    the user in HAL_SD_MspInit() function (MSP layer).
+  * in the root directory of this software component.
-    Basically, the MSP layer configuration should be the same as we provide in the
+  * If no LICENSE file comes with this software, it is provided AS-IS.
-    examples.
+  *
-    You can easily tailor this configuration according to hardware resources.
+  ******************************************************************************
+  @verbatim
-  [..]
+  ==============================================================================
-    This driver is a generic layered driver for SDIO memories which uses the HAL
+                        ##### How to use this driver #####
-    SDIO driver functions to interface with SD and uSD cards devices.
+  ==============================================================================
-    It is used as follows:
+  [..]
+    This driver implements a high level communication layer for read and write from/to
-    (#)Initialize the SDIO low level resources by implementing the HAL_SD_MspInit() API:
+    this memory. The needed STM32 hardware resources (SDIO and GPIO) are performed by
-        (##) Enable the SDIO interface clock using __HAL_RCC_SDIO_CLK_ENABLE();
+    the user in HAL_SD_MspInit() function (MSP layer).
-        (##) SDIO pins configuration for SD card
+    Basically, the MSP layer configuration should be the same as we provide in the
-            (+++) Enable the clock for the SDIO GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE();
+    examples.
-            (+++) Configure these SDIO pins as alternate function pull-up using HAL_GPIO_Init()
+    You can easily tailor this configuration according to hardware resources.
-                  and according to your pin assignment;
-        (##) DMA configuration if you need to use DMA process (HAL_SD_ReadBlocks_DMA()
+  [..]
-             and HAL_SD_WriteBlocks_DMA() APIs).
+    This driver is a generic layered driver for SDIO memories which uses the HAL
-            (+++) Enable the DMAx interface clock using __HAL_RCC_DMAx_CLK_ENABLE();
+    SDIO driver functions to interface with SD and uSD cards devices.
-            (+++) Configure the DMA using the function HAL_DMA_Init() with predeclared and filled.
+    It is used as follows:
-        (##) NVIC configuration if you need to use interrupt process when using DMA transfer.
-            (+++) Configure the SDIO and DMA interrupt priorities using functions
+    (#)Initialize the SDIO low level resources by implementing the HAL_SD_MspInit() API:
-                  HAL_NVIC_SetPriority(); DMA priority is superior to SDIO's priority
+        (##) Enable the SDIO interface clock using __HAL_RCC_SDIO_CLK_ENABLE();
-            (+++) Enable the NVIC DMA and SDIO IRQs using function HAL_NVIC_EnableIRQ()
+        (##) SDIO pins configuration for SD card
-            (+++) SDIO interrupts are managed using the macros __HAL_SD_ENABLE_IT()
+            (+++) Enable the clock for the SDIO GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE();
-                  and __HAL_SD_DISABLE_IT() inside the communication process.
+            (+++) Configure these SDIO pins as alternate function pull-up using HAL_GPIO_Init()
-            (+++) SDIO interrupts pending bits are managed using the macros __HAL_SD_GET_IT()
+                  and according to your pin assignment;
-                  and __HAL_SD_CLEAR_IT()
+        (##) DMA configuration if you need to use DMA process (HAL_SD_ReadBlocks_DMA()
-        (##) NVIC configuration if you need to use interrupt process (HAL_SD_ReadBlocks_IT()
+             and HAL_SD_WriteBlocks_DMA() APIs).
-             and HAL_SD_WriteBlocks_IT() APIs).
+            (+++) Enable the DMAx interface clock using __HAL_RCC_DMAx_CLK_ENABLE();
-            (+++) Configure the SDIO interrupt priorities using function HAL_NVIC_SetPriority();
+            (+++) Configure the DMA using the function HAL_DMA_Init() with predeclared and filled.
-            (+++) Enable the NVIC SDIO IRQs using function HAL_NVIC_EnableIRQ()
+        (##) NVIC configuration if you need to use interrupt process when using DMA transfer.
-            (+++) SDIO interrupts are managed using the macros __HAL_SD_ENABLE_IT()
+            (+++) Configure the SDIO and DMA interrupt priorities using functions
-                  and __HAL_SD_DISABLE_IT() inside the communication process.
+                  HAL_NVIC_SetPriority(); DMA priority is superior to SDIO's priority
-            (+++) SDIO interrupts pending bits are managed using the macros __HAL_SD_GET_IT()
+            (+++) Enable the NVIC DMA and SDIO IRQs using function HAL_NVIC_EnableIRQ()
-                  and __HAL_SD_CLEAR_IT()
+            (+++) SDIO interrupts are managed using the macros __HAL_SD_ENABLE_IT()
-    (#) At this stage, you can perform SD read/write/erase operations after SD card initialization
+                  and __HAL_SD_DISABLE_IT() inside the communication process.
+            (+++) SDIO interrupts pending bits are managed using the macros __HAL_SD_GET_IT()
+                  and __HAL_SD_CLEAR_IT()
-  *** SD Card Initialization and configuration ***
+        (##) NVIC configuration if you need to use interrupt process (HAL_SD_ReadBlocks_IT()
-  ================================================
+             and HAL_SD_WriteBlocks_IT() APIs).
-  [..]
+            (+++) Configure the SDIO interrupt priorities using function HAL_NVIC_SetPriority();
-    To initialize the SD Card, use the HAL_SD_Init() function. It Initializes
+            (+++) Enable the NVIC SDIO IRQs using function HAL_NVIC_EnableIRQ()
-    SDIO Peripheral(STM32 side) and the SD Card, and put it into StandBy State (Ready for data transfer).
+            (+++) SDIO interrupts are managed using the macros __HAL_SD_ENABLE_IT()
-    This function provide the following operations:
+                  and __HAL_SD_DISABLE_IT() inside the communication process.
+            (+++) SDIO interrupts pending bits are managed using the macros __HAL_SD_GET_IT()
-    (#) Apply the SD Card initialization process at 400KHz and check the SD Card
+                  and __HAL_SD_CLEAR_IT()
-        type (Standard Capacity or High Capacity). You can change or adapt this
+    (#) At this stage, you can perform SD read/write/erase operations after SD card initialization
-        frequency by adjusting the "ClockDiv" field.
-        The SD Card frequency (SDIO_CK) is computed as follows:
+  *** SD Card Initialization and configuration ***
-           SDIO_CK = SDIOCLK / (ClockDiv + 2)
+  ================================================
+  [..]
-        In initialization mode and according to the SD Card standard,
+    To initialize the SD Card, use the HAL_SD_Init() function. It Initializes
-        make sure that the SDIO_CK frequency doesn't exceed 400KHz.
+    SDIO Peripheral(STM32 side) and the SD Card, and put it into StandBy State (Ready for data transfer).
+    This function provide the following operations:
-        This phase of initialization is done through SDIO_Init() and
-        SDIO_PowerState_ON() SDIO low level APIs.
+    (#) Apply the SD Card initialization process at 400KHz and check the SD Card
+        type (Standard Capacity or High Capacity). You can change or adapt this
-    (#) Initialize the SD card. The API used is HAL_SD_InitCard().
+        frequency by adjusting the "ClockDiv" field.
-        This phase allows the card initialization and identification
+        The SD Card frequency (SDIO_CK) is computed as follows:
-        and check the SD Card type (Standard Capacity or High Capacity)
-        The initialization flow is compatible with SD standard.
+           SDIO_CK = SDIOCLK / (ClockDiv + 2)
-        This API (HAL_SD_InitCard()) could be used also to reinitialize the card in case
+        In initialization mode and according to the SD Card standard,
-        of plug-off plug-in.
+        make sure that the SDIO_CK frequency doesn't exceed 400KHz.
-    (#) Configure the SD Card Data transfer frequency. You can change or adapt this
+        This phase of initialization is done through SDIO_Init() and
-        frequency by adjusting the "ClockDiv" field.
+        SDIO_PowerState_ON() SDIO low level APIs.
-        In transfer mode and according to the SD Card standard, make sure that the
-        SDIO_CK frequency doesn't exceed 25MHz and 50MHz in High-speed mode switch.
+    (#) Initialize the SD card. The API used is HAL_SD_InitCard().
-        To be able to use a frequency higher than 24MHz, you should use the SDIO
+        This phase allows the card initialization and identification
-        peripheral in bypass mode. Refer to the corresponding reference manual
+        and check the SD Card type (Standard Capacity or High Capacity)
-        for more details.
+        The initialization flow is compatible with SD standard.
-    (#) Select the corresponding SD Card according to the address read with the step 2.
+        This API (HAL_SD_InitCard()) could be used also to reinitialize the card in case
+        of plug-off plug-in.
-    (#) Configure the SD Card in wide bus mode: 4-bits data.
+    (#) Configure the SD Card Data transfer frequency. You can change or adapt this
-  *** SD Card Read operation ***
+        frequency by adjusting the "ClockDiv" field.
-  ==============================
+        In transfer mode and according to the SD Card standard, make sure that the
-  [..]
+        SDIO_CK frequency doesn't exceed 25MHz and 50MHz in High-speed mode switch.
-    (+) You can read from SD card in polling mode by using function HAL_SD_ReadBlocks().
+        To be able to use a frequency higher than 24MHz, you should use the SDIO
-        This function support only 512-bytes block length (the block size should be
+        peripheral in bypass mode. Refer to the corresponding reference manual
-        chosen as 512 bytes).
+        for more details.
-        You can choose either one block read operation or multiple block read operation
-        by adjusting the "NumberOfBlocks" parameter.
+    (#) Select the corresponding SD Card according to the address read with the step 2.
-        After this, you have to ensure that the transfer is done correctly. The check is done
-        through HAL_SD_GetCardState() function for SD card state.
+    (#) Configure the SD Card in wide bus mode: 4-bits data.
-    (+) You can read from SD card in DMA mode by using function HAL_SD_ReadBlocks_DMA().
+  *** SD Card Read operation ***
-        This function support only 512-bytes block length (the block size should be
+  ==============================
-        chosen as 512 bytes).
+  [..]
-        You can choose either one block read operation or multiple block read operation
+    (+) You can read from SD card in polling mode by using function HAL_SD_ReadBlocks().
-        by adjusting the "NumberOfBlocks" parameter.
+        This function support only 512-bytes block length (the block size should be
-        After this, you have to ensure that the transfer is done correctly. The check is done
+        chosen as 512 bytes).
-        through HAL_SD_GetCardState() function for SD card state.
+        You can choose either one block read operation or multiple block read operation
-        You could also check the DMA transfer process through the SD Rx interrupt event.
+        by adjusting the "NumberOfBlocks" parameter.
+        After this, you have to ensure that the transfer is done correctly. The check is done
-    (+) You can read from SD card in Interrupt mode by using function HAL_SD_ReadBlocks_IT().
+        through HAL_SD_GetCardState() function for SD card state.
-        This function support only 512-bytes block length (the block size should be
-        chosen as 512 bytes).
+    (+) You can read from SD card in DMA mode by using function HAL_SD_ReadBlocks_DMA().
-        You can choose either one block read operation or multiple block read operation
+        This function support only 512-bytes block length (the block size should be
-        by adjusting the "NumberOfBlocks" parameter.
+        chosen as 512 bytes).
-        After this, you have to ensure that the transfer is done correctly. The check is done
+        You can choose either one block read operation or multiple block read operation
-        through HAL_SD_GetCardState() function for SD card state.
+        by adjusting the "NumberOfBlocks" parameter.
-        You could also check the IT transfer process through the SD Rx interrupt event.
+        After this, you have to ensure that the transfer is done correctly. The check is done
+        through HAL_SD_GetCardState() function for SD card state.
-  *** SD Card Write operation ***
+        You could also check the DMA transfer process through the SD Rx interrupt event.
-  ===============================
-  [..]
+    (+) You can read from SD card in Interrupt mode by using function HAL_SD_ReadBlocks_IT().
-    (+) You can write to SD card in polling mode by using function HAL_SD_WriteBlocks().
+        This function support only 512-bytes block length (the block size should be
-        This function support only 512-bytes block length (the block size should be
+        chosen as 512 bytes).
-        chosen as 512 bytes).
+        You can choose either one block read operation or multiple block read operation
-        You can choose either one block read operation or multiple block read operation
+        by adjusting the "NumberOfBlocks" parameter.
-        by adjusting the "NumberOfBlocks" parameter.
+        After this, you have to ensure that the transfer is done correctly. The check is done
-        After this, you have to ensure that the transfer is done correctly. The check is done
+        through HAL_SD_GetCardState() function for SD card state.
-        through HAL_SD_GetCardState() function for SD card state.
+        You could also check the IT transfer process through the SD Rx interrupt event.
-    (+) You can write to SD card in DMA mode by using function HAL_SD_WriteBlocks_DMA().
+  *** SD Card Write operation ***
-        This function support only 512-bytes block length (the block size should be
+  ===============================
-        chosen as 512 bytes).
+  [..]
-        You can choose either one block read operation or multiple block read operation
+    (+) You can write to SD card in polling mode by using function HAL_SD_WriteBlocks().
-        by adjusting the "NumberOfBlocks" parameter.
+        This function support only 512-bytes block length (the block size should be
-        After this, you have to ensure that the transfer is done correctly. The check is done
+        chosen as 512 bytes).
-        through HAL_SD_GetCardState() function for SD card state.
+        You can choose either one block read operation or multiple block read operation
-        You could also check the DMA transfer process through the SD Tx interrupt event.
+        by adjusting the "NumberOfBlocks" parameter.
+        After this, you have to ensure that the transfer is done correctly. The check is done
-    (+) You can write to SD card in Interrupt mode by using function HAL_SD_WriteBlocks_IT().
+        through HAL_SD_GetCardState() function for SD card state.
-        This function support only 512-bytes block length (the block size should be
-        chosen as 512 bytes).
+    (+) You can write to SD card in DMA mode by using function HAL_SD_WriteBlocks_DMA().
-        You can choose either one block read operation or multiple block read operation
+        This function support only 512-bytes block length (the block size should be
-        by adjusting the "NumberOfBlocks" parameter.
+        chosen as 512 bytes).
-        After this, you have to ensure that the transfer is done correctly. The check is done
+        You can choose either one block read operation or multiple block read operation
-        through HAL_SD_GetCardState() function for SD card state.
+        by adjusting the "NumberOfBlocks" parameter.
-        You could also check the IT transfer process through the SD Tx interrupt event.
+        After this, you have to ensure that the transfer is done correctly. The check is done
+        through HAL_SD_GetCardState() function for SD card state.
-  *** SD card status ***
+        You could also check the DMA transfer process through the SD Tx interrupt event.
-  ======================
-  [..]
+    (+) You can write to SD card in Interrupt mode by using function HAL_SD_WriteBlocks_IT().
-    (+) The SD Status contains status bits that are related to the SD Memory
+        This function support only 512-bytes block length (the block size should be
-        Card proprietary features. To get SD card status use the HAL_SD_GetCardStatus().
+        chosen as 512 bytes).
+        You can choose either one block read operation or multiple block read operation
-  *** SD card information ***
+        by adjusting the "NumberOfBlocks" parameter.
-  ===========================
+        After this, you have to ensure that the transfer is done correctly. The check is done
-  [..]
+        through HAL_SD_GetCardState() function for SD card state.
-    (+) To get SD card information, you can use the function HAL_SD_GetCardInfo().
+        You could also check the IT transfer process through the SD Tx interrupt event.
-        It returns useful information about the SD card such as block size, card type,
-        block number ...
+  *** SD card status ***
+  ======================
-  *** SD card CSD register ***
+  [..]
-  ============================
+    (+) The SD Status contains status bits that are related to the SD Memory
-    (+) The HAL_SD_GetCardCSD() API allows to get the parameters of the CSD register.
+        Card proprietary features. To get SD card status use the HAL_SD_GetCardStatus().
-        Some of the CSD parameters are useful for card initialization and identification.
+  *** SD card information ***
-  *** SD card CID register ***
+  ===========================
-  ============================
+  [..]
-    (+) The HAL_SD_GetCardCID() API allows to get the parameters of the CID register.
+    (+) To get SD card information, you can use the function HAL_SD_GetCardInfo().
-        Some of the CSD parameters are useful for card initialization and identification.
+        It returns useful information about the SD card such as block size, card type,
+        block number ...
-  *** SD HAL driver macros list ***
-  ==================================
+  *** SD card CSD register ***
-  [..]
+  ============================
-    Below the list of most used macros in SD HAL driver.
+    (+) The HAL_SD_GetCardCSD() API allows to get the parameters of the CSD register.
+        Some of the CSD parameters are useful for card initialization and identification.
-    (+) __HAL_SD_ENABLE : Enable the SD device
-    (+) __HAL_SD_DISABLE : Disable the SD device
+  *** SD card CID register ***
-    (+) __HAL_SD_DMA_ENABLE: Enable the SDIO DMA transfer
+  ============================
-    (+) __HAL_SD_DMA_DISABLE: Disable the SDIO DMA transfer
+    (+) The HAL_SD_GetCardCID() API allows to get the parameters of the CID register.
-    (+) __HAL_SD_ENABLE_IT: Enable the SD device interrupt
+        Some of the CSD parameters are useful for card initialization and identification.
-    (+) __HAL_SD_DISABLE_IT: Disable the SD device interrupt
-    (+) __HAL_SD_GET_FLAG:Check whether the specified SD flag is set or not
+  *** SD HAL driver macros list ***
-    (+) __HAL_SD_CLEAR_FLAG: Clear the SD's pending flags
+  ==================================
+  [..]
-    (@) You can refer to the SD HAL driver header file for more useful macros
+    Below the list of most used macros in SD HAL driver.
-  *** Callback registration ***
+    (+) __HAL_SD_ENABLE : Enable the SD device
-  =============================================
+    (+) __HAL_SD_DISABLE : Disable the SD device
-  [..]
+    (+) __HAL_SD_DMA_ENABLE: Enable the SDIO DMA transfer
-    The compilation define USE_HAL_SD_REGISTER_CALLBACKS when set to 1
+    (+) __HAL_SD_DMA_DISABLE: Disable the SDIO DMA transfer
-    allows the user to configure dynamically the driver callbacks.
+    (+) __HAL_SD_ENABLE_IT: Enable the SD device interrupt
+    (+) __HAL_SD_DISABLE_IT: Disable the SD device interrupt
-    Use Functions @ref HAL_SD_RegisterCallback() to register a user callback,
+    (+) __HAL_SD_GET_FLAG:Check whether the specified SD flag is set or not
-    it allows to register following callbacks:
+    (+) __HAL_SD_CLEAR_FLAG: Clear the SD's pending flags
-      (+) TxCpltCallback : callback when a transmission transfer is completed.
-      (+) RxCpltCallback : callback when a reception transfer is completed.
+    (@) You can refer to the SD HAL driver header file for more useful macros
-      (+) ErrorCallback : callback when error occurs.
-      (+) AbortCpltCallback : callback when abort is completed.
+  *** Callback registration ***
-      (+) MspInitCallback    : SD MspInit.
+  =============================================
-      (+) MspDeInitCallback  : SD MspDeInit.
+  [..]
-    This function takes as parameters the HAL peripheral handle, the Callback ID
+    The compilation define USE_HAL_SD_REGISTER_CALLBACKS when set to 1
-    and a pointer to the user callback function.
+    allows the user to configure dynamically the driver callbacks.
-    Use function @ref HAL_SD_UnRegisterCallback() to reset a callback to the default
+    Use Functions HAL_SD_RegisterCallback() to register a user callback,
-    weak (surcharged) function. It allows to reset following callbacks:
+    it allows to register following callbacks:
       (+) TxCpltCallback : callback when a transmission transfer is completed.
       (+) RxCpltCallback : callback when a reception transfer is completed.
       (+) ErrorCallback : callback when error occurs.
       (+) AbortCpltCallback : callback when abort is completed.
       (+) MspInitCallback    : SD MspInit.
       (+) MspDeInitCallback  : SD MspDeInit.
-    This function) takes as parameters the HAL peripheral handle and the Callback ID.
+    This function takes as parameters the HAL peripheral handle, the Callback ID
+    and a pointer to the user callback function.
-    By default, after the @ref HAL_SD_Init and if the state is HAL_SD_STATE_RESET
-    all callbacks are reset to the corresponding legacy weak (surcharged) functions.
+    Use function HAL_SD_UnRegisterCallback() to reset a callback to the default
-    Exception done for MspInit and MspDeInit callbacks that are respectively
+    weak (surcharged) function. It allows to reset following callbacks:
-    reset to the legacy weak (surcharged) functions in the @ref HAL_SD_Init
+      (+) TxCpltCallback : callback when a transmission transfer is completed.
-    and @ref  HAL_SD_DeInit only when these callbacks are null (not registered beforehand).
+      (+) RxCpltCallback : callback when a reception transfer is completed.
-    If not, MspInit or MspDeInit are not null, the @ref HAL_SD_Init and @ref HAL_SD_DeInit
+      (+) ErrorCallback : callback when error occurs.
-    keep and use the user MspInit/MspDeInit callbacks (registered beforehand)
+      (+) AbortCpltCallback : callback when abort is completed.
+      (+) MspInitCallback    : SD MspInit.
-    Callbacks can be registered/unregistered in READY state only.
+      (+) MspDeInitCallback  : SD MspDeInit.
-    Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered
+    This function) takes as parameters the HAL peripheral handle and the Callback ID.
-    in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used
-    during the Init/DeInit.
+    By default, after the HAL_SD_Init and if the state is HAL_SD_STATE_RESET
-    In that case first register the MspInit/MspDeInit user callbacks
+    all callbacks are reset to the corresponding legacy weak (surcharged) functions.
-    using @ref HAL_SD_RegisterCallback before calling @ref HAL_SD_DeInit
+    Exception done for MspInit and MspDeInit callbacks that are respectively
-    or @ref HAL_SD_Init function.
+    reset to the legacy weak (surcharged) functions in the HAL_SD_Init
+    and  HAL_SD_DeInit only when these callbacks are null (not registered beforehand).
-    When The compilation define USE_HAL_SD_REGISTER_CALLBACKS is set to 0 or
+    If not, MspInit or MspDeInit are not null, the HAL_SD_Init and HAL_SD_DeInit
-    not defined, the callback registering feature is not available
+    keep and use the user MspInit/MspDeInit callbacks (registered beforehand)
-    and weak (surcharged) callbacks are used.
+    Callbacks can be registered/unregistered in READY state only.
-  @endverbatim
+    Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered
-  ******************************************************************************
+    in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used
-  * @attention
+    during the Init/DeInit.
-  *
+    In that case first register the MspInit/MspDeInit user callbacks
-  * <h2><center>&copy; Copyright (c) 2018 STMicroelectronics.
+    using HAL_SD_RegisterCallback before calling HAL_SD_DeInit
-  * All rights reserved.</center></h2>
+    or HAL_SD_Init function.
-  *
-  * This software component is licensed by ST under BSD 3-Clause license,
+    When The compilation define USE_HAL_SD_REGISTER_CALLBACKS is set to 0 or
-  * the "License"; You may not use this file except in compliance with the
+    not defined, the callback registering feature is not available
-  * License. You may obtain a copy of the License at:
+    and weak (surcharged) callbacks are used.
-  *                       opensource.org/licenses/BSD-3-Clause
-  *
+  @endverbatim
   ******************************************************************************
   */
 /* Includes ------------------------------------------------------------------*/
 #include "stm32f1xx_hal.h"
 #if defined(SDIO)
 /** @addtogroup STM32F1xx_HAL_Driver
   * @{
   */
 /** @addtogroup SD
   * @{
   */
 #ifdef HAL_SD_MODULE_ENABLED
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /** @addtogroup SD_Private_Defines
   * @{
   */
 /**
   * @}
   */
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 /* Private function prototypes -----------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 /** @defgroup SD_Private_Functions SD Private Functions
   * @{
   */
 static uint32_t SD_InitCard(SD_HandleTypeDef *hsd);
 static uint32_t SD_PowerON(SD_HandleTypeDef *hsd);
 static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus);
 static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
 static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd);
 static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd);
 static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR);
 static void SD_PowerOFF(SD_HandleTypeDef *hsd);
 static void SD_Write_IT(SD_HandleTypeDef *hsd);
 static void SD_Read_IT(SD_HandleTypeDef *hsd);
 static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma);
 static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
 static void SD_DMAError(DMA_HandleTypeDef *hdma);
 static void SD_DMATxAbort(DMA_HandleTypeDef *hdma);
 static void SD_DMARxAbort(DMA_HandleTypeDef *hdma);
 /**
   * @}
   */
 /* Exported functions --------------------------------------------------------*/
 /** @addtogroup SD_Exported_Functions
   * @{
   */
 /** @addtogroup SD_Exported_Functions_Group1
  *  @brief   Initialization and de-initialization functions
  *
 @verbatim
   ==============================================================================
           ##### Initialization and de-initialization functions #####
   ==============================================================================
   [..]
     This section provides functions allowing to initialize/de-initialize the SD
     card device to be ready for use.
 @endverbatim
   * @{
   */
 /**
   * @brief  Initializes the SD according to the specified parameters in the
             SD_HandleTypeDef and create the associated handle.
   * @param  hsd: Pointer to the SD handle
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd)
 {
   /* Check the SD handle allocation */
   if(hsd == NULL)
   {
     return HAL_ERROR;
   }
   /* Check the parameters */
   assert_param(IS_SDIO_ALL_INSTANCE(hsd->Instance));
   assert_param(IS_SDIO_CLOCK_EDGE(hsd->Init.ClockEdge));
   assert_param(IS_SDIO_CLOCK_BYPASS(hsd->Init.ClockBypass));
   assert_param(IS_SDIO_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave));
   assert_param(IS_SDIO_BUS_WIDE(hsd->Init.BusWide));
   assert_param(IS_SDIO_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl));
   assert_param(IS_SDIO_CLKDIV(hsd->Init.ClockDiv));
   if(hsd->State == HAL_SD_STATE_RESET)
   {
     /* Allocate lock resource and initialize it */
     hsd->Lock = HAL_UNLOCKED;
 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
     /* Reset Callback pointers in HAL_SD_STATE_RESET only */
     hsd->TxCpltCallback    = HAL_SD_TxCpltCallback;
     hsd->RxCpltCallback    = HAL_SD_RxCpltCallback;
     hsd->ErrorCallback     = HAL_SD_ErrorCallback;
     hsd->AbortCpltCallback = HAL_SD_AbortCallback;
     if(hsd->MspInitCallback == NULL)
     {
       hsd->MspInitCallback = HAL_SD_MspInit;
     }
     /* Init the low level hardware */
     hsd->MspInitCallback(hsd);
 #else
     /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */
     HAL_SD_MspInit(hsd);
 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
   }
   hsd->State = HAL_SD_STATE_BUSY;
   /* Initialize the Card parameters */
   if (HAL_SD_InitCard(hsd) != HAL_OK)
   {
     return HAL_ERROR;
   }
   /* Initialize the error code */
   hsd->ErrorCode = HAL_SD_ERROR_NONE;
   /* Initialize the SD operation */
   hsd->Context = SD_CONTEXT_NONE;
   /* Initialize the SD state */
   hsd->State = HAL_SD_STATE_READY;
   return HAL_OK;
 }
 /**
   * @brief  Initializes the SD Card.
   * @param  hsd: Pointer to SD handle
   * @note   This function initializes the SD card. It could be used when a card
             re-initialization is needed.
   * @retval HAL status
   */
 HAL_StatusTypeDef HAL_SD_InitCard(SD_HandleTypeDef *hsd)
 {
   uint32_t errorstate;
   HAL_StatusTypeDef status;
   SD_InitTypeDef Init;
   /* Default SDIO peripheral configuration for SD card initialization */
   Init.ClockEdge           = SDIO_CLOCK_EDGE_RISING;
   Init.ClockBypass         = SDIO_CLOCK_BYPASS_DISABLE;
   Init.ClockPowerSave      = SDIO_CLOCK_POWER_SAVE_DISABLE;
   Init.BusWide             = SDIO_BUS_WIDE_1B;
   Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
   Init.ClockDiv            = SDIO_INIT_CLK_DIV;
   /* Initialize SDIO peripheral interface with default configuration */
   status = SDIO_Init(hsd->Instance, Init);
   if(status != HAL_OK)
   {
     return HAL_ERROR;
   }
   /* Disable SDIO Clock */
   __HAL_SD_DISABLE(hsd);
   /* Set Power State to ON */
   (void)SDIO_PowerState_ON(hsd->Instance);
   /* Enable SDIO Clock */
   __HAL_SD_ENABLE(hsd);
-  /* Identify card operating voltage */
+  /* Required power up waiting time before starting the SD initialization  sequence */
-  errorstate = SD_PowerON(hsd);
+  HAL_Delay(2);
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Identify card operating voltage */
-    hsd->State = HAL_SD_STATE_READY;
+  errorstate = SD_PowerON(hsd);
-    hsd->ErrorCode |= errorstate;
+  if(errorstate != HAL_SD_ERROR_NONE)
-    return HAL_ERROR;
+  {
-  }
+    hsd->State = HAL_SD_STATE_READY;
+    hsd->ErrorCode |= errorstate;
-  /* Card initialization */
+    return HAL_ERROR;
-  errorstate = SD_InitCard(hsd);
+  }
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Card initialization */
-    hsd->State = HAL_SD_STATE_READY;
+  errorstate = SD_InitCard(hsd);
-    hsd->ErrorCode |= errorstate;
+  if(errorstate != HAL_SD_ERROR_NONE)
-    return HAL_ERROR;
+  {
-  }
+    hsd->State = HAL_SD_STATE_READY;
+    hsd->ErrorCode |= errorstate;
-  /* Set Block Size for Card */
+    return HAL_ERROR;
-  errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
+  }
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Set Block Size for Card */
-    /* Clear all the static flags */
+  errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+  if(errorstate != HAL_SD_ERROR_NONE)
-    hsd->ErrorCode |= errorstate;
+  {
-    hsd->State = HAL_SD_STATE_READY;
+    /* Clear all the static flags */
-    return HAL_ERROR;
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-  }
+    hsd->ErrorCode |= errorstate;
+    hsd->State = HAL_SD_STATE_READY;
-  return HAL_OK;
+    return HAL_ERROR;
-}
+  }
-/**
+  return HAL_OK;
-  * @brief  De-Initializes the SD card.
+}
-  * @param  hsd: Pointer to SD handle
-  * @retval HAL status
+/**
-  */
+  * @brief  De-Initializes the SD card.
-HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
+  * @param  hsd: Pointer to SD handle
-{
+  * @retval HAL status
-  /* Check the SD handle allocation */
+  */
-  if(hsd == NULL)
+HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
-  {
+{
-    return HAL_ERROR;
+  /* Check the SD handle allocation */
-  }
+  if(hsd == NULL)
+  {
-  /* Check the parameters */
+    return HAL_ERROR;
-  assert_param(IS_SDIO_ALL_INSTANCE(hsd->Instance));
+  }
-  hsd->State = HAL_SD_STATE_BUSY;
+  /* Check the parameters */
+  assert_param(IS_SDIO_ALL_INSTANCE(hsd->Instance));
-  /* Set SD power state to off */
-  SD_PowerOFF(hsd);
+  hsd->State = HAL_SD_STATE_BUSY;
-#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
+  /* Set SD power state to off */
-  if(hsd->MspDeInitCallback == NULL)
+  SD_PowerOFF(hsd);
-  {
-    hsd->MspDeInitCallback = HAL_SD_MspDeInit;
+#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
-  }
+  if(hsd->MspDeInitCallback == NULL)
+  {
-  /* DeInit the low level hardware */
+    hsd->MspDeInitCallback = HAL_SD_MspDeInit;
-  hsd->MspDeInitCallback(hsd);
+  }
-#else
-  /* De-Initialize the MSP layer */
+  /* DeInit the low level hardware */
-  HAL_SD_MspDeInit(hsd);
+  hsd->MspDeInitCallback(hsd);
-#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
+#else
+  /* De-Initialize the MSP layer */
-  hsd->ErrorCode = HAL_SD_ERROR_NONE;
+  HAL_SD_MspDeInit(hsd);
-  hsd->State = HAL_SD_STATE_RESET;
+#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
-  return HAL_OK;
+  hsd->ErrorCode = HAL_SD_ERROR_NONE;
-}
+  hsd->State = HAL_SD_STATE_RESET;
+  return HAL_OK;
-/**
+}
-  * @brief  Initializes the SD MSP.
-  * @param  hsd: Pointer to SD handle
-  * @retval None
+/**
-  */
+  * @brief  Initializes the SD MSP.
-__weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
+  * @param  hsd: Pointer to SD handle
-{
+  * @retval None
-  /* Prevent unused argument(s) compilation warning */
+  */
-  UNUSED(hsd);
+__weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
+{
-  /* NOTE : This function should not be modified, when the callback is needed,
+  /* Prevent unused argument(s) compilation warning */
-            the HAL_SD_MspInit could be implemented in the user file
+  UNUSED(hsd);
-   */
-}
+  /* NOTE : This function should not be modified, when the callback is needed,
+            the HAL_SD_MspInit could be implemented in the user file
-/**
+   */
-  * @brief  De-Initialize SD MSP.
+}
-  * @param  hsd: Pointer to SD handle
-  * @retval None
+/**
-  */
+  * @brief  De-Initialize SD MSP.
-__weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
+  * @param  hsd: Pointer to SD handle
-{
+  * @retval None
-  /* Prevent unused argument(s) compilation warning */
+  */
-  UNUSED(hsd);
+__weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
+{
-  /* NOTE : This function should not be modified, when the callback is needed,
+  /* Prevent unused argument(s) compilation warning */
-            the HAL_SD_MspDeInit could be implemented in the user file
+  UNUSED(hsd);
-   */
-}
+  /* NOTE : This function should not be modified, when the callback is needed,
+            the HAL_SD_MspDeInit could be implemented in the user file
-/**
+   */
-  * @}
+}
-  */
+/**
-/** @addtogroup SD_Exported_Functions_Group2
+  * @}
- *  @brief   Data transfer functions
+  */
- *
-@verbatim
+/** @addtogroup SD_Exported_Functions_Group2
-  ==============================================================================
+ *  @brief   Data transfer functions
-                        ##### IO operation functions #####
+ *
-  ==============================================================================
+@verbatim
-  [..]
+  ==============================================================================
-    This subsection provides a set of functions allowing to manage the data
+                        ##### IO operation functions #####
-    transfer from/to SD card.
+  ==============================================================================
+  [..]
-@endverbatim
+    This subsection provides a set of functions allowing to manage the data
-  * @{
+    transfer from/to SD card.
-  */
+@endverbatim
-/**
+  * @{
-  * @brief  Reads block(s) from a specified address in a card. The Data transfer
+  */
-  *         is managed by polling mode.
-  * @note   This API should be followed by a check on the card state through
+/**
-  *         HAL_SD_GetCardState().
+  * @brief  Reads block(s) from a specified address in a card. The Data transfer
-  * @param  hsd: Pointer to SD handle
+  *         is managed by polling mode.
-  * @param  pData: pointer to the buffer that will contain the received data
+  * @note   This API should be followed by a check on the card state through
-  * @param  BlockAdd: Block Address from where data is to be read
+  *         HAL_SD_GetCardState().
-  * @param  NumberOfBlocks: Number of SD blocks to read
+  * @param  hsd: Pointer to SD handle
-  * @param  Timeout: Specify timeout value
+  * @param  pData: pointer to the buffer that will contain the received data
-  * @retval HAL status
+  * @param  BlockAdd: Block Address from where data is to be read
-  */
+  * @param  NumberOfBlocks: Number of SD blocks to read
-HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
+  * @param  Timeout: Specify timeout value
-{
+  * @retval HAL status
-  SDIO_DataInitTypeDef config;
+  */
-  uint32_t errorstate;
+HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
-  uint32_t tickstart = HAL_GetTick();
+{
-  uint32_t count, data, dataremaining;
+  SDIO_DataInitTypeDef config;
-  uint32_t add = BlockAdd;
+  uint32_t errorstate;
-  uint8_t *tempbuff = pData;
+  uint32_t tickstart = HAL_GetTick();
+  uint32_t count, data, dataremaining;
-  if(NULL == pData)
+  uint32_t add = BlockAdd;
-  {
+  uint8_t *tempbuff = pData;
-    hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-    return HAL_ERROR;
+  if(NULL == pData)
-  }
+  {
+    hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-  if(hsd->State == HAL_SD_STATE_READY)
+    return HAL_ERROR;
-  {
+  }
-    hsd->ErrorCode = HAL_SD_ERROR_NONE;
+  if(hsd->State == HAL_SD_STATE_READY)
-    if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
+  {
-    {
+    hsd->ErrorCode = HAL_SD_ERROR_NONE;
-      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-      return HAL_ERROR;
+    if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
-    }
+    {
+      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-    hsd->State = HAL_SD_STATE_BUSY;
+      return HAL_ERROR;
+    }
-    /* Initialize data control register */
-    hsd->Instance->DCTRL = 0U;
+    hsd->State = HAL_SD_STATE_BUSY;
-    if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
+    /* Initialize data control register */
-    {
+    hsd->Instance->DCTRL = 0U;
-      add *= 512U;
-    }
+    if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
+    {
-    /* Configure the SD DPSM (Data Path State Machine) */
+      add *= 512U;
-    config.DataTimeOut   = SDMMC_DATATIMEOUT;
+    }
-    config.DataLength    = NumberOfBlocks * BLOCKSIZE;
-    config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
+    /* Configure the SD DPSM (Data Path State Machine) */
-    config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
+    config.DataTimeOut   = SDMMC_DATATIMEOUT;
-    config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
+    config.DataLength    = NumberOfBlocks * BLOCKSIZE;
-    config.DPSM          = SDIO_DPSM_ENABLE;
+    config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
-    (void)SDIO_ConfigData(hsd->Instance, &config);
+    config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
+    config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
-    /* Read block(s) in polling mode */
+    config.DPSM          = SDIO_DPSM_ENABLE;
-    if(NumberOfBlocks > 1U)
+    (void)SDIO_ConfigData(hsd->Instance, &config);
-    {
-      hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;
+    /* Read block(s) in polling mode */
+    if(NumberOfBlocks > 1U)
-      /* Read Multi Block command */
+    {
-      errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
+      hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;
-    }
-    else
+      /* Read Multi Block command */
-    {
+      errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
-      hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;
+    }
+    else
-      /* Read Single Block command */
+    {
-      errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
+      hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;
-    }
-    if(errorstate != HAL_SD_ERROR_NONE)
+      /* Read Single Block command */
-    {
+      errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
-      /* Clear all the static flags */
+    }
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if(errorstate != HAL_SD_ERROR_NONE)
-      hsd->ErrorCode |= errorstate;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      return HAL_ERROR;
+      hsd->ErrorCode |= errorstate;
-    }
+      hsd->State = HAL_SD_STATE_READY;
+      hsd->Context = SD_CONTEXT_NONE;
-    /* Poll on SDIO flags */
+      return HAL_ERROR;
-    dataremaining = config.DataLength;
+    }
-    while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
-    {
+    /* Poll on SDIO flags */
-      if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF) && (dataremaining > 0U))
+    dataremaining = config.DataLength;
-      {
+    while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
-        /* Read data from SDIO Rx FIFO */
+    {
-        for(count = 0U; count < 8U; count++)
+      if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF) && (dataremaining > 0U))
-        {
+      {
-          data = SDIO_ReadFIFO(hsd->Instance);
+        /* Read data from SDIO Rx FIFO */
-          *tempbuff = (uint8_t)(data & 0xFFU);
+        for(count = 0U; count < 8U; count++)
-          tempbuff++;
+        {
-          dataremaining--;
+          data = SDIO_ReadFIFO(hsd->Instance);
-          *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
+          *tempbuff = (uint8_t)(data & 0xFFU);
           tempbuff++;
           dataremaining--;
-          *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
+          *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
           tempbuff++;
           dataremaining--;
-          *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
+          *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
           tempbuff++;
           dataremaining--;
-        }
+          *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
-      }
+          tempbuff++;
+          dataremaining--;
-      if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
+        }
-      {
+      }
-        /* Clear all the static flags */
-        __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+      if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
-        hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
+      {
-        hsd->State= HAL_SD_STATE_READY;
+        /* Clear all the static flags */
-        hsd->Context = SD_CONTEXT_NONE;
+        __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-        return HAL_TIMEOUT;
+        hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
-      }
+        hsd->State= HAL_SD_STATE_READY;
-    }
+        hsd->Context = SD_CONTEXT_NONE;
+        return HAL_TIMEOUT;
-    /* Send stop transmission command in case of multiblock read */
+      }
-    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))
+    }
-    {
-      if(hsd->SdCard.CardType != CARD_SECURED)
+    /* Send stop transmission command in case of multiblock read */
-      {
+    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))
-        /* Send stop transmission command */
+    {
-        errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
+      if(hsd->SdCard.CardType != CARD_SECURED)
-        if(errorstate != HAL_SD_ERROR_NONE)
+      {
-        {
+        /* Send stop transmission command */
-          /* Clear all the static flags */
+        errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
-          __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+        if(errorstate != HAL_SD_ERROR_NONE)
-          hsd->ErrorCode |= errorstate;
+        {
-          hsd->State = HAL_SD_STATE_READY;
+          /* Clear all the static flags */
-          hsd->Context = SD_CONTEXT_NONE;
+          __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-          return HAL_ERROR;
+          hsd->ErrorCode |= errorstate;
-        }
+          hsd->State = HAL_SD_STATE_READY;
-      }
+          hsd->Context = SD_CONTEXT_NONE;
-    }
+          return HAL_ERROR;
+        }
-    /* Get error state */
+      }
-    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
+    }
-    {
-      /* Clear all the static flags */
+    /* Get error state */
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
-      hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      return HAL_ERROR;
+      hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
-    }
+      hsd->State = HAL_SD_STATE_READY;
-    else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
+      hsd->Context = SD_CONTEXT_NONE;
-    {
+      return HAL_ERROR;
-      /* Clear all the static flags */
+    }
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
-      hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      return HAL_ERROR;
+      hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
-    }
+      hsd->State = HAL_SD_STATE_READY;
-    else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
+      hsd->Context = SD_CONTEXT_NONE;
-    {
+      return HAL_ERROR;
-      /* Clear all the static flags */
+    }
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
-      hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      return HAL_ERROR;
+      hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
-    }
+      hsd->State = HAL_SD_STATE_READY;
-    else
+      hsd->Context = SD_CONTEXT_NONE;
-    {
+      return HAL_ERROR;
-      /* Nothing to do */
+    }
-    }
+    else
+    {
-    /* Empty FIFO if there is still any data */
+      /* Nothing to do */
-    while ((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (dataremaining > 0U))
+    }
-    {
-      data = SDIO_ReadFIFO(hsd->Instance);
+    /* Empty FIFO if there is still any data */
-      *tempbuff = (uint8_t)(data & 0xFFU);
+    while ((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (dataremaining > 0U))
-      tempbuff++;
+    {
-      dataremaining--;
+      data = SDIO_ReadFIFO(hsd->Instance);
-      *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
+      *tempbuff = (uint8_t)(data & 0xFFU);
       tempbuff++;
       dataremaining--;
-      *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
+      *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
       tempbuff++;
       dataremaining--;
-      *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
+      *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
       tempbuff++;
       dataremaining--;
+      *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
-      if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
+      tempbuff++;
-      {
+      dataremaining--;
-        /* Clear all the static flags */
-        __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+      if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
-        hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
+      {
-        hsd->State= HAL_SD_STATE_READY;
+        /* Clear all the static flags */
-        hsd->Context = SD_CONTEXT_NONE;
+        __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-        return HAL_ERROR;
+        hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
-      }
+        hsd->State= HAL_SD_STATE_READY;
-    }
+        hsd->Context = SD_CONTEXT_NONE;
+        return HAL_ERROR;
-    /* Clear all the static flags */
+      }
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
+    }
-    hsd->State = HAL_SD_STATE_READY;
+    /* Clear all the static flags */
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
-    return HAL_OK;
-  }
+    hsd->State = HAL_SD_STATE_READY;
-  else
-  {
+    return HAL_OK;
-    hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
+  }
-    return HAL_ERROR;
+  else
-  }
+  {
-}
+    hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
+    return HAL_ERROR;
-/**
+  }
-  * @brief  Allows to write block(s) to a specified address in a card. The Data
+}
-  *         transfer is managed by polling mode.
-  * @note   This API should be followed by a check on the card state through
+/**
-  *         HAL_SD_GetCardState().
+  * @brief  Allows to write block(s) to a specified address in a card. The Data
-  * @param  hsd: Pointer to SD handle
+  *         transfer is managed by polling mode.
-  * @param  pData: pointer to the buffer that will contain the data to transmit
+  * @note   This API should be followed by a check on the card state through
-  * @param  BlockAdd: Block Address where data will be written
+  *         HAL_SD_GetCardState().
-  * @param  NumberOfBlocks: Number of SD blocks to write
+  * @param  hsd: Pointer to SD handle
-  * @param  Timeout: Specify timeout value
+  * @param  pData: pointer to the buffer that will contain the data to transmit
-  * @retval HAL status
+  * @param  BlockAdd: Block Address where data will be written
-  */
+  * @param  NumberOfBlocks: Number of SD blocks to write
-HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
+  * @param  Timeout: Specify timeout value
-{
+  * @retval HAL status
-  SDIO_DataInitTypeDef config;
+  */
-  uint32_t errorstate;
+HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
-  uint32_t tickstart = HAL_GetTick();
+{
-  uint32_t count, data, dataremaining;
+  SDIO_DataInitTypeDef config;
-  uint32_t add = BlockAdd;
+  uint32_t errorstate;
-  uint8_t *tempbuff = pData;
+  uint32_t tickstart = HAL_GetTick();
+  uint32_t count, data, dataremaining;
-  if(NULL == pData)
+  uint32_t add = BlockAdd;
-  {
+  uint8_t *tempbuff = pData;
-    hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-    return HAL_ERROR;
+  if(NULL == pData)
-  }
+  {
+    hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-  if(hsd->State == HAL_SD_STATE_READY)
+    return HAL_ERROR;
-  {
+  }
-    hsd->ErrorCode = HAL_SD_ERROR_NONE;
+  if(hsd->State == HAL_SD_STATE_READY)
-    if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
+  {
-    {
+    hsd->ErrorCode = HAL_SD_ERROR_NONE;
-      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-      return HAL_ERROR;
+    if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
-    }
+    {
+      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-    hsd->State = HAL_SD_STATE_BUSY;
+      return HAL_ERROR;
+    }
-    /* Initialize data control register */
-    hsd->Instance->DCTRL = 0U;
+    hsd->State = HAL_SD_STATE_BUSY;
-    if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
+    /* Initialize data control register */
-    {
+    hsd->Instance->DCTRL = 0U;
-      add *= 512U;
-    }
+    if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
+    {
-    /* Configure the SD DPSM (Data Path State Machine) */
+      add *= 512U;
-    config.DataTimeOut   = SDMMC_DATATIMEOUT;
+    }
-    config.DataLength    = NumberOfBlocks * BLOCKSIZE;
-    config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
+    /* Configure the SD DPSM (Data Path State Machine) */
-    config.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
+    config.DataTimeOut   = SDMMC_DATATIMEOUT;
-    config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
+    config.DataLength    = NumberOfBlocks * BLOCKSIZE;
-    config.DPSM          = SDIO_DPSM_ENABLE;
+    config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
-    (void)SDIO_ConfigData(hsd->Instance, &config);
+    config.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
+    config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
-    /* Write Blocks in Polling mode */
+    config.DPSM          = SDIO_DPSM_ENABLE;
-    if(NumberOfBlocks > 1U)
+    (void)SDIO_ConfigData(hsd->Instance, &config);
-    {
-      hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;
+    /* Write Blocks in Polling mode */
+    if(NumberOfBlocks > 1U)
-      /* Write Multi Block command */
+    {
-      errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
+      hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;
-    }
-    else
+      /* Write Multi Block command */
-    {
+      errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
-      hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;
+    }
+    else
-      /* Write Single Block command */
+    {
-      errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
+      hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;
-    }
-    if(errorstate != HAL_SD_ERROR_NONE)
+      /* Write Single Block command */
-    {
+      errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
-      /* Clear all the static flags */
+    }
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if(errorstate != HAL_SD_ERROR_NONE)
-      hsd->ErrorCode |= errorstate;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      return HAL_ERROR;
+      hsd->ErrorCode |= errorstate;
-    }
+      hsd->State = HAL_SD_STATE_READY;
+      hsd->Context = SD_CONTEXT_NONE;
-    /* Write block(s) in polling mode */
+      return HAL_ERROR;
-    dataremaining = config.DataLength;
+    }
-    while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
-    {
+    /* Write block(s) in polling mode */
-      if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE) && (dataremaining > 0U))
+    dataremaining = config.DataLength;
-      {
+    while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
-        /* Write data to SDIO Tx FIFO */
+    {
-        for(count = 0U; count < 8U; count++)
+      if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE) && (dataremaining > 0U))
-        {
+      {
-          data = (uint32_t)(*tempbuff);
+        /* Write data to SDIO Tx FIFO */
-          tempbuff++;
+        for(count = 0U; count < 8U; count++)
-          dataremaining--;
+        {
-          data |= ((uint32_t)(*tempbuff) << 8U);
+          data = (uint32_t)(*tempbuff);
           tempbuff++;
           dataremaining--;
-          data |= ((uint32_t)(*tempbuff) << 16U);
+          data |= ((uint32_t)(*tempbuff) << 8U);
           tempbuff++;
           dataremaining--;
-          data |= ((uint32_t)(*tempbuff) << 24U);
+          data |= ((uint32_t)(*tempbuff) << 16U);
           tempbuff++;
           dataremaining--;
-          (void)SDIO_WriteFIFO(hsd->Instance, &data);
+          data |= ((uint32_t)(*tempbuff) << 24U);
-        }
+          tempbuff++;
-      }
+          dataremaining--;
+          (void)SDIO_WriteFIFO(hsd->Instance, &data);
-      if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
+        }
-      {
+      }
-        /* Clear all the static flags */
-        __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+      if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
-        hsd->ErrorCode |= errorstate;
+      {
-        hsd->State = HAL_SD_STATE_READY;
+        /* Clear all the static flags */
-        hsd->Context = SD_CONTEXT_NONE;
+        __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-        return HAL_TIMEOUT;
+        hsd->ErrorCode |= errorstate;
-      }
+        hsd->State = HAL_SD_STATE_READY;
-    }
+        hsd->Context = SD_CONTEXT_NONE;
+        return HAL_TIMEOUT;
-    /* Send stop transmission command in case of multiblock write */
+      }
-    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))
+    }
-    {
-      if(hsd->SdCard.CardType != CARD_SECURED)
+    /* Send stop transmission command in case of multiblock write */
-      {
+    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))
-        /* Send stop transmission command */
+    {
-        errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
+      if(hsd->SdCard.CardType != CARD_SECURED)
-        if(errorstate != HAL_SD_ERROR_NONE)
+      {
-        {
+        /* Send stop transmission command */
-          /* Clear all the static flags */
+        errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
-          __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+        if(errorstate != HAL_SD_ERROR_NONE)
-          hsd->ErrorCode |= errorstate;
+        {
-          hsd->State = HAL_SD_STATE_READY;
+          /* Clear all the static flags */
-          hsd->Context = SD_CONTEXT_NONE;
+          __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-          return HAL_ERROR;
+          hsd->ErrorCode |= errorstate;
-        }
+          hsd->State = HAL_SD_STATE_READY;
-      }
+          hsd->Context = SD_CONTEXT_NONE;
-    }
+          return HAL_ERROR;
+        }
-    /* Get error state */
+      }
-    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
+    }
-    {
-      /* Clear all the static flags */
+    /* Get error state */
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
-      hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      return HAL_ERROR;
+      hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
-    }
+      hsd->State = HAL_SD_STATE_READY;
-    else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
+      hsd->Context = SD_CONTEXT_NONE;
-    {
+      return HAL_ERROR;
-      /* Clear all the static flags */
+    }
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
-      hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      return HAL_ERROR;
+      hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
-    }
+      hsd->State = HAL_SD_STATE_READY;
-    else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))
+      hsd->Context = SD_CONTEXT_NONE;
-    {
+      return HAL_ERROR;
-      /* Clear all the static flags */
+    }
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))
-      hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      return HAL_ERROR;
+      hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
-    }
+      hsd->State = HAL_SD_STATE_READY;
-    else
+      hsd->Context = SD_CONTEXT_NONE;
-    {
+      return HAL_ERROR;
-      /* Nothing to do */
+    }
-    }
+    else
+    {
-    /* Clear all the static flags */
+      /* Nothing to do */
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
+    }
-    hsd->State = HAL_SD_STATE_READY;
+    /* Clear all the static flags */
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
-    return HAL_OK;
-  }
+    hsd->State = HAL_SD_STATE_READY;
-  else
-  {
+    return HAL_OK;
-    hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
+  }
-    return HAL_ERROR;
+  else
-  }
+  {
-}
+    hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
+    return HAL_ERROR;
-/**
+  }
-  * @brief  Reads block(s) from a specified address in a card. The Data transfer
+}
-  *         is managed in interrupt mode.
-  * @note   This API should be followed by a check on the card state through
+/**
-  *         HAL_SD_GetCardState().
+  * @brief  Reads block(s) from a specified address in a card. The Data transfer
-  * @note   You could also check the IT transfer process through the SD Rx
+  *         is managed in interrupt mode.
-  *         interrupt event.
+  * @note   This API should be followed by a check on the card state through
-  * @param  hsd: Pointer to SD handle
+  *         HAL_SD_GetCardState().
-  * @param  pData: Pointer to the buffer that will contain the received data
+  * @note   You could also check the IT transfer process through the SD Rx
-  * @param  BlockAdd: Block Address from where data is to be read
+  *         interrupt event.
-  * @param  NumberOfBlocks: Number of blocks to read.
+  * @param  hsd: Pointer to SD handle
-  * @retval HAL status
+  * @param  pData: Pointer to the buffer that will contain the received data
-  */
+  * @param  BlockAdd: Block Address from where data is to be read
-HAL_StatusTypeDef HAL_SD_ReadBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
+  * @param  NumberOfBlocks: Number of blocks to read.
-{
+  * @retval HAL status
-  SDIO_DataInitTypeDef config;
+  */
-  uint32_t errorstate;
+HAL_StatusTypeDef HAL_SD_ReadBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
-  uint32_t add = BlockAdd;
+{
+  SDIO_DataInitTypeDef config;
-  if(NULL == pData)
+  uint32_t errorstate;
-  {
+  uint32_t add = BlockAdd;
-    hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-    return HAL_ERROR;
+  if(NULL == pData)
-  }
+  {
+    hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-  if(hsd->State == HAL_SD_STATE_READY)
+    return HAL_ERROR;
-  {
+  }
-    hsd->ErrorCode = HAL_SD_ERROR_NONE;
+  if(hsd->State == HAL_SD_STATE_READY)
-    if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
+  {
-    {
+    hsd->ErrorCode = HAL_SD_ERROR_NONE;
-      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-      return HAL_ERROR;
+    if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
-    }
+    {
+      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-    hsd->State = HAL_SD_STATE_BUSY;
+      return HAL_ERROR;
+    }
-    /* Initialize data control register */
-    hsd->Instance->DCTRL = 0U;
+    hsd->State = HAL_SD_STATE_BUSY;
-    hsd->pRxBuffPtr = pData;
+    /* Initialize data control register */
-    hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
+    hsd->Instance->DCTRL = 0U;
-    __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_FLAG_RXFIFOHF));
+    hsd->pRxBuffPtr = pData;
+    hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
-    if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
-    {
+    __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_FLAG_RXFIFOHF));
-      add *= 512U;
-    }
+    if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
+    {
-    /* Configure the SD DPSM (Data Path State Machine) */
+      add *= 512U;
-    config.DataTimeOut   = SDMMC_DATATIMEOUT;
+    }
-    config.DataLength    = BLOCKSIZE * NumberOfBlocks;
-    config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
+    /* Configure the SD DPSM (Data Path State Machine) */
-    config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
+    config.DataTimeOut   = SDMMC_DATATIMEOUT;
-    config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
+    config.DataLength    = BLOCKSIZE * NumberOfBlocks;
-    config.DPSM          = SDIO_DPSM_ENABLE;
+    config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
-    (void)SDIO_ConfigData(hsd->Instance, &config);
+    config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
+    config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
-    /* Read Blocks in IT mode */
+    config.DPSM          = SDIO_DPSM_ENABLE;
-    if(NumberOfBlocks > 1U)
+    (void)SDIO_ConfigData(hsd->Instance, &config);
-    {
-      hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_IT);
+    /* Read Blocks in IT mode */
+    if(NumberOfBlocks > 1U)
-      /* Read Multi Block command */
+    {
-      errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
+      hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_IT);
-    }
-    else
+      /* Read Multi Block command */
-    {
+      errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
-      hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_IT);
+    }
+    else
-      /* Read Single Block command */
+    {
-      errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
+      hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_IT);
-    }
-    if(errorstate != HAL_SD_ERROR_NONE)
+      /* Read Single Block command */
-    {
+      errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
-      /* Clear all the static flags */
+    }
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if(errorstate != HAL_SD_ERROR_NONE)
-      hsd->ErrorCode |= errorstate;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      return HAL_ERROR;
+      hsd->ErrorCode |= errorstate;
-    }
+      hsd->State = HAL_SD_STATE_READY;
+      hsd->Context = SD_CONTEXT_NONE;
-    return HAL_OK;
+      return HAL_ERROR;
-  }
+    }
-  else
-  {
+    return HAL_OK;
-    return HAL_BUSY;
+  }
-  }
+  else
-}
+  {
+    return HAL_BUSY;
-/**
+  }
-  * @brief  Writes block(s) to a specified address in a card. The Data transfer
+}
-  *         is managed in interrupt mode.
-  * @note   This API should be followed by a check on the card state through
+/**
-  *         HAL_SD_GetCardState().
+  * @brief  Writes block(s) to a specified address in a card. The Data transfer
-  * @note   You could also check the IT transfer process through the SD Tx
+  *         is managed in interrupt mode.
-  *         interrupt event.
+  * @note   This API should be followed by a check on the card state through
-  * @param  hsd: Pointer to SD handle
+  *         HAL_SD_GetCardState().
-  * @param  pData: Pointer to the buffer that will contain the data to transmit
+  * @note   You could also check the IT transfer process through the SD Tx
-  * @param  BlockAdd: Block Address where data will be written
+  *         interrupt event.
-  * @param  NumberOfBlocks: Number of blocks to write
+  * @param  hsd: Pointer to SD handle
-  * @retval HAL status
+  * @param  pData: Pointer to the buffer that will contain the data to transmit
-  */
+  * @param  BlockAdd: Block Address where data will be written
-HAL_StatusTypeDef HAL_SD_WriteBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
+  * @param  NumberOfBlocks: Number of blocks to write
-{
+  * @retval HAL status
-  SDIO_DataInitTypeDef config;
+  */
-  uint32_t errorstate;
+HAL_StatusTypeDef HAL_SD_WriteBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
-  uint32_t add = BlockAdd;
+{
+  SDIO_DataInitTypeDef config;
-  if(NULL == pData)
+  uint32_t errorstate;
-  {
+  uint32_t add = BlockAdd;
-    hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-    return HAL_ERROR;
+  if(NULL == pData)
-  }
+  {
+    hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-  if(hsd->State == HAL_SD_STATE_READY)
+    return HAL_ERROR;
-  {
+  }
-    hsd->ErrorCode = HAL_SD_ERROR_NONE;
+  if(hsd->State == HAL_SD_STATE_READY)
-    if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
+  {
-    {
+    hsd->ErrorCode = HAL_SD_ERROR_NONE;
-      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-      return HAL_ERROR;
+    if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
-    }
+    {
+      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-    hsd->State = HAL_SD_STATE_BUSY;
+      return HAL_ERROR;
+    }
-    /* Initialize data control register */
-    hsd->Instance->DCTRL = 0U;
+    hsd->State = HAL_SD_STATE_BUSY;
-    hsd->pTxBuffPtr = pData;
+    /* Initialize data control register */
-    hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;
+    hsd->Instance->DCTRL = 0U;
-    /* Enable transfer interrupts */
+    hsd->pTxBuffPtr = pData;
-    __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND | SDIO_FLAG_TXFIFOHE));
+    hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;
-    if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
+    /* Enable transfer interrupts */
-    {
+    __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND | SDIO_FLAG_TXFIFOHE));
-      add *= 512U;
-    }
+    if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
+    {
-    /* Write Blocks in Polling mode */
+      add *= 512U;
-    if(NumberOfBlocks > 1U)
+    }
-    {
-      hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK| SD_CONTEXT_IT);
+    /* Write Blocks in Polling mode */
+    if(NumberOfBlocks > 1U)
-      /* Write Multi Block command */
+    {
-      errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
+      hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK| SD_CONTEXT_IT);
-    }
-    else
+      /* Write Multi Block command */
-    {
+      errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
-      hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_IT);
+    }
+    else
-      /* Write Single Block command */
+    {
-      errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
+      hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_IT);
-    }
-    if(errorstate != HAL_SD_ERROR_NONE)
+      /* Write Single Block command */
-    {
+      errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
-      /* Clear all the static flags */
+    }
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if(errorstate != HAL_SD_ERROR_NONE)
-      hsd->ErrorCode |= errorstate;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      return HAL_ERROR;
+      hsd->ErrorCode |= errorstate;
-    }
+      hsd->State = HAL_SD_STATE_READY;
+      hsd->Context = SD_CONTEXT_NONE;
-    /* Configure the SD DPSM (Data Path State Machine) */
+      return HAL_ERROR;
-    config.DataTimeOut   = SDMMC_DATATIMEOUT;
+    }
-    config.DataLength    = BLOCKSIZE * NumberOfBlocks;
-    config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
+    /* Configure the SD DPSM (Data Path State Machine) */
-    config.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
+    config.DataTimeOut   = SDMMC_DATATIMEOUT;
-    config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
+    config.DataLength    = BLOCKSIZE * NumberOfBlocks;
-    config.DPSM          = SDIO_DPSM_ENABLE;
+    config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
-    (void)SDIO_ConfigData(hsd->Instance, &config);
+    config.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
+    config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
-    return HAL_OK;
+    config.DPSM          = SDIO_DPSM_ENABLE;
-  }
+    (void)SDIO_ConfigData(hsd->Instance, &config);
-  else
-  {
+    return HAL_OK;
-    return HAL_BUSY;
+  }
-  }
+  else
-}
+  {
+    return HAL_BUSY;
-/**
+  }
-  * @brief  Reads block(s) from a specified address in a card. The Data transfer
+}
-  *         is managed by DMA mode.
-  * @note   This API should be followed by a check on the card state through
+/**
-  *         HAL_SD_GetCardState().
+  * @brief  Reads block(s) from a specified address in a card. The Data transfer
-  * @note   You could also check the DMA transfer process through the SD Rx
+  *         is managed by DMA mode.
-  *         interrupt event.
+  * @note   This API should be followed by a check on the card state through
-  * @param  hsd: Pointer SD handle
+  *         HAL_SD_GetCardState().
-  * @param  pData: Pointer to the buffer that will contain the received data
+  * @note   You could also check the DMA transfer process through the SD Rx
-  * @param  BlockAdd: Block Address from where data is to be read
+  *         interrupt event.
-  * @param  NumberOfBlocks: Number of blocks to read.
+  * @param  hsd: Pointer SD handle
-  * @retval HAL status
+  * @param  pData: Pointer to the buffer that will contain the received data
-  */
+  * @param  BlockAdd: Block Address from where data is to be read
-HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
+  * @param  NumberOfBlocks: Number of blocks to read.
-{
+  * @retval HAL status
-  SDIO_DataInitTypeDef config;
+  */
-  uint32_t errorstate;
+HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
-  uint32_t add = BlockAdd;
+{
+  SDIO_DataInitTypeDef config;
-  if(NULL == pData)
+  uint32_t errorstate;
-  {
+  uint32_t add = BlockAdd;
-    hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-    return HAL_ERROR;
+  if(NULL == pData)
-  }
+  {
+    hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-  if(hsd->State == HAL_SD_STATE_READY)
+    return HAL_ERROR;
-  {
+  }
-    hsd->ErrorCode = HAL_SD_ERROR_NONE;
+  if(hsd->State == HAL_SD_STATE_READY)
-    if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
+  {
-    {
+    hsd->ErrorCode = HAL_SD_ERROR_NONE;
-      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-      return HAL_ERROR;
+    if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
-    }
+    {
+      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-    hsd->State = HAL_SD_STATE_BUSY;
+      return HAL_ERROR;
+    }
-    /* Initialize data control register */
-    hsd->Instance->DCTRL = 0U;
+    hsd->State = HAL_SD_STATE_BUSY;
-    __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
+    /* Initialize data control register */
+    hsd->Instance->DCTRL = 0U;
-    /* Set the DMA transfer complete callback */
-    hsd->hdmarx->XferCpltCallback = SD_DMAReceiveCplt;
+    __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
-    /* Set the DMA error callback */
+    /* Set the DMA transfer complete callback */
-    hsd->hdmarx->XferErrorCallback = SD_DMAError;
+    hsd->hdmarx->XferCpltCallback = SD_DMAReceiveCplt;
-    /* Set the DMA Abort callback */
+    /* Set the DMA error callback */
-    hsd->hdmarx->XferAbortCallback = NULL;
+    hsd->hdmarx->XferErrorCallback = SD_DMAError;
-    /* Force DMA Direction */
+    /* Set the DMA Abort callback */
-    hsd->hdmarx->Init.Direction = DMA_PERIPH_TO_MEMORY;
+    hsd->hdmarx->XferAbortCallback = NULL;
-    MODIFY_REG(hsd->hdmarx->Instance->CCR, DMA_CCR_DIR, hsd->hdmarx->Init.Direction);
+    /* Force DMA Direction */
-    /* Enable the DMA Channel */
+    hsd->hdmarx->Init.Direction = DMA_PERIPH_TO_MEMORY;
-    if(HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pData, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4U) != HAL_OK)
+    MODIFY_REG(hsd->hdmarx->Instance->CCR, DMA_CCR_DIR, hsd->hdmarx->Init.Direction);
-    {
-      __HAL_SD_DISABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
+    /* Enable the DMA Channel */
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if(HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pData, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4U) != HAL_OK)
-      hsd->ErrorCode |= HAL_SD_ERROR_DMA;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      __HAL_SD_DISABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
-      return HAL_ERROR;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-    }
+      hsd->ErrorCode |= HAL_SD_ERROR_DMA;
-    else
+      hsd->State = HAL_SD_STATE_READY;
-    {
+      return HAL_ERROR;
-      /* Enable SD DMA transfer */
+    }
-      __HAL_SD_DMA_ENABLE(hsd);
+    else
+    {
-      if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
+      /* Enable SD DMA transfer */
-      {
+      __HAL_SD_DMA_ENABLE(hsd);
-        add *= 512U;
-      }
+      if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
+      {
-      /* Configure the SD DPSM (Data Path State Machine) */
+        add *= 512U;
-      config.DataTimeOut   = SDMMC_DATATIMEOUT;
+      }
-      config.DataLength    = BLOCKSIZE * NumberOfBlocks;
-      config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
+      /* Configure the SD DPSM (Data Path State Machine) */
-      config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
+      config.DataTimeOut   = SDMMC_DATATIMEOUT;
-      config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
+      config.DataLength    = BLOCKSIZE * NumberOfBlocks;
-      config.DPSM          = SDIO_DPSM_ENABLE;
+      config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
-      (void)SDIO_ConfigData(hsd->Instance, &config);
+      config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
+      config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
-      /* Read Blocks in DMA mode */
+      config.DPSM          = SDIO_DPSM_ENABLE;
-      if(NumberOfBlocks > 1U)
+      (void)SDIO_ConfigData(hsd->Instance, &config);
-      {
-        hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
+      /* Read Blocks in DMA mode */
+      if(NumberOfBlocks > 1U)
-        /* Read Multi Block command */
+      {
-        errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
+        hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
-      }
-      else
+        /* Read Multi Block command */
-      {
+        errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
-        hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);
+      }
+      else
-        /* Read Single Block command */
+      {
-        errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
+        hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);
-      }
-      if(errorstate != HAL_SD_ERROR_NONE)
+        /* Read Single Block command */
-      {
+        errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
-        /* Clear all the static flags */
+      }
-        __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+      if(errorstate != HAL_SD_ERROR_NONE)
-        hsd->ErrorCode |= errorstate;
+      {
-        hsd->State = HAL_SD_STATE_READY;
+        /* Clear all the static flags */
-        hsd->Context = SD_CONTEXT_NONE;
+        __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-        return HAL_ERROR;
+        hsd->ErrorCode |= errorstate;
-      }
+        hsd->State = HAL_SD_STATE_READY;
+        hsd->Context = SD_CONTEXT_NONE;
-      return HAL_OK;
+        return HAL_ERROR;
-    }
+      }
-  }
-  else
+      return HAL_OK;
-  {
+    }
-    return HAL_BUSY;
+  }
-  }
+  else
-}
+  {
+    return HAL_BUSY;
-/**
+  }
-  * @brief  Writes block(s) to a specified address in a card. The Data transfer
+}
-  *         is managed by DMA mode.
-  * @note   This API should be followed by a check on the card state through
+/**
-  *         HAL_SD_GetCardState().
+  * @brief  Writes block(s) to a specified address in a card. The Data transfer
-  * @note   You could also check the DMA transfer process through the SD Tx
+  *         is managed by DMA mode.
-  *         interrupt event.
+  * @note   This API should be followed by a check on the card state through
-  * @param  hsd: Pointer to SD handle
+  *         HAL_SD_GetCardState().
-  * @param  pData: Pointer to the buffer that will contain the data to transmit
+  * @note   You could also check the DMA transfer process through the SD Tx
-  * @param  BlockAdd: Block Address where data will be written
+  *         interrupt event.
-  * @param  NumberOfBlocks: Number of blocks to write
+  * @param  hsd: Pointer to SD handle
-  * @retval HAL status
+  * @param  pData: Pointer to the buffer that will contain the data to transmit
-  */
+  * @param  BlockAdd: Block Address where data will be written
-HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
+  * @param  NumberOfBlocks: Number of blocks to write
-{
+  * @retval HAL status
-  SDIO_DataInitTypeDef config;
+  */
-  uint32_t errorstate;
+HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
-  uint32_t add = BlockAdd;
+{
+  SDIO_DataInitTypeDef config;
-  if(NULL == pData)
+  uint32_t errorstate;
-  {
+  uint32_t add = BlockAdd;
-    hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-    return HAL_ERROR;
+  if(NULL == pData)
-  }
+  {
+    hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-  if(hsd->State == HAL_SD_STATE_READY)
+    return HAL_ERROR;
-  {
+  }
-    hsd->ErrorCode = HAL_SD_ERROR_NONE;
+  if(hsd->State == HAL_SD_STATE_READY)
-    if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
+  {
-    {
+    hsd->ErrorCode = HAL_SD_ERROR_NONE;
-      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-      return HAL_ERROR;
+    if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
-    }
+    {
+      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-    hsd->State = HAL_SD_STATE_BUSY;
+      return HAL_ERROR;
+    }
-    /* Initialize data control register */
-    hsd->Instance->DCTRL = 0U;
+    hsd->State = HAL_SD_STATE_BUSY;
-    /* Enable SD Error interrupts */
+    /* Initialize data control register */
-    __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR));
+    hsd->Instance->DCTRL = 0U;
-    /* Set the DMA transfer complete callback */
+    /* Enable SD Error interrupts */
-    hsd->hdmatx->XferCpltCallback = SD_DMATransmitCplt;
+    __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR));
-    /* Set the DMA error callback */
+    /* Set the DMA transfer complete callback */
-    hsd->hdmatx->XferErrorCallback = SD_DMAError;
+    hsd->hdmatx->XferCpltCallback = SD_DMATransmitCplt;
-    /* Set the DMA Abort callback */
+    /* Set the DMA error callback */
-    hsd->hdmatx->XferAbortCallback = NULL;
+    hsd->hdmatx->XferErrorCallback = SD_DMAError;
-    if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
+    /* Set the DMA Abort callback */
-    {
+    hsd->hdmatx->XferAbortCallback = NULL;
-      add *= 512U;
-    }
+    if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
+    {
-    /* Write Blocks in Polling mode */
+      add *= 512U;
-    if(NumberOfBlocks > 1U)
+    }
-    {
-      hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
+    /* Write Blocks in Polling mode */
+    if(NumberOfBlocks > 1U)
-      /* Write Multi Block command */
+    {
-      errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
+      hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
-    }
-    else
+      /* Write Multi Block command */
-    {
+      errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
-      hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);
+    }
+    else
-      /* Write Single Block command */
+    {
-      errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
+      hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);
-    }
-    if(errorstate != HAL_SD_ERROR_NONE)
+      /* Write Single Block command */
-    {
+      errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
-      /* Clear all the static flags */
+    }
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if(errorstate != HAL_SD_ERROR_NONE)
-      hsd->ErrorCode |= errorstate;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      return HAL_ERROR;
+      hsd->ErrorCode |= errorstate;
-    }
+      hsd->State = HAL_SD_STATE_READY;
+      hsd->Context = SD_CONTEXT_NONE;
-    /* Enable SDIO DMA transfer */
+      return HAL_ERROR;
-    __HAL_SD_DMA_ENABLE(hsd);
+    }
-    /* Force DMA Direction */
+    /* Enable SDIO DMA transfer */
-    hsd->hdmatx->Init.Direction = DMA_MEMORY_TO_PERIPH;
+    __HAL_SD_DMA_ENABLE(hsd);
-    MODIFY_REG(hsd->hdmatx->Instance->CCR, DMA_CCR_DIR, hsd->hdmatx->Init.Direction);
+    /* Force DMA Direction */
-    /* Enable the DMA Channel */
+    hsd->hdmatx->Init.Direction = DMA_MEMORY_TO_PERIPH;
-    if(HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pData, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4U) != HAL_OK)
+    MODIFY_REG(hsd->hdmatx->Instance->CCR, DMA_CCR_DIR, hsd->hdmatx->Init.Direction);
-    {
-      __HAL_SD_DISABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR));
+    /* Enable the DMA Channel */
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if(HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pData, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4U) != HAL_OK)
-      hsd->ErrorCode |= HAL_SD_ERROR_DMA;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      __HAL_SD_DISABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR));
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      return HAL_ERROR;
+      hsd->ErrorCode |= HAL_SD_ERROR_DMA;
-    }
+      hsd->State = HAL_SD_STATE_READY;
-    else
+      hsd->Context = SD_CONTEXT_NONE;
-    {
+      return HAL_ERROR;
-      /* Configure the SD DPSM (Data Path State Machine) */
+    }
-      config.DataTimeOut   = SDMMC_DATATIMEOUT;
+    else
-      config.DataLength    = BLOCKSIZE * NumberOfBlocks;
+    {
-      config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
+      /* Configure the SD DPSM (Data Path State Machine) */
-      config.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
+      config.DataTimeOut   = SDMMC_DATATIMEOUT;
-      config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
+      config.DataLength    = BLOCKSIZE * NumberOfBlocks;
-      config.DPSM          = SDIO_DPSM_ENABLE;
+      config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
-      (void)SDIO_ConfigData(hsd->Instance, &config);
+      config.TransferDir   = SDIO_TRANSFER_DIR_TO_CARD;
+      config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
-      return HAL_OK;
+      config.DPSM          = SDIO_DPSM_ENABLE;
-    }
+      (void)SDIO_ConfigData(hsd->Instance, &config);
-  }
-  else
+      return HAL_OK;
-  {
+    }
-    return HAL_BUSY;
+  }
-  }
+  else
-}
+  {
+    return HAL_BUSY;
-/**
+  }
-  * @brief  Erases the specified memory area of the given SD card.
+}
-  * @note   This API should be followed by a check on the card state through
-  *         HAL_SD_GetCardState().
+/**
-  * @param  hsd: Pointer to SD handle
+  * @brief  Erases the specified memory area of the given SD card.
-  * @param  BlockStartAdd: Start Block address
+  * @note   This API should be followed by a check on the card state through
-  * @param  BlockEndAdd: End Block address
+  *         HAL_SD_GetCardState().
-  * @retval HAL status
+  * @param  hsd: Pointer to SD handle
-  */
+  * @param  BlockStartAdd: Start Block address
-HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
+  * @param  BlockEndAdd: End Block address
-{
+  * @retval HAL status
-  uint32_t errorstate;
+  */
-  uint32_t start_add = BlockStartAdd;
+HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
-  uint32_t end_add = BlockEndAdd;
+{
+  uint32_t errorstate;
-  if(hsd->State == HAL_SD_STATE_READY)
+  uint32_t start_add = BlockStartAdd;
-  {
+  uint32_t end_add = BlockEndAdd;
-    hsd->ErrorCode = HAL_SD_ERROR_NONE;
+  if(hsd->State == HAL_SD_STATE_READY)
-    if(end_add < start_add)
+  {
-    {
+    hsd->ErrorCode = HAL_SD_ERROR_NONE;
-      hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-      return HAL_ERROR;
+    if(end_add < start_add)
-    }
+    {
+      hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-    if(end_add > (hsd->SdCard.LogBlockNbr))
+      return HAL_ERROR;
-    {
+    }
-      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-      return HAL_ERROR;
+    if(end_add > (hsd->SdCard.LogBlockNbr))
-    }
+    {
+      hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
-    hsd->State = HAL_SD_STATE_BUSY;
+      return HAL_ERROR;
+    }
-    /* Check if the card command class supports erase command */
-    if(((hsd->SdCard.Class) & SDIO_CCCC_ERASE) == 0U)
+    hsd->State = HAL_SD_STATE_BUSY;
-    {
-      /* Clear all the static flags */
+    /* Check if the card command class supports erase command */
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if(((hsd->SdCard.Class) & SDIO_CCCC_ERASE) == 0U)
-      hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      return HAL_ERROR;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-    }
+      hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
+      hsd->State = HAL_SD_STATE_READY;
-    if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
+      return HAL_ERROR;
-    {
+    }
-      /* Clear all the static flags */
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
-      hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      return HAL_ERROR;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-    }
+      hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
+      hsd->State = HAL_SD_STATE_READY;
-    /* Get start and end block for high capacity cards */
+      return HAL_ERROR;
-    if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
+    }
-    {
-      start_add *= 512U;
+    /* Get start and end block for high capacity cards */
-      end_add   *= 512U;
+    if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
-    }
+    {
+      start_add *= 512U;
-    /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
+      end_add   *= 512U;
-    if(hsd->SdCard.CardType != CARD_SECURED)
+    }
-    {
-      /* Send CMD32 SD_ERASE_GRP_START with argument as addr  */
+    /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
-      errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);
+    if(hsd->SdCard.CardType != CARD_SECURED)
-      if(errorstate != HAL_SD_ERROR_NONE)
+    {
-      {
+      /* Send CMD32 SD_ERASE_GRP_START with argument as addr  */
-        /* Clear all the static flags */
+      errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);
-        __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+      if(errorstate != HAL_SD_ERROR_NONE)
-        hsd->ErrorCode |= errorstate;
+      {
-        hsd->State = HAL_SD_STATE_READY;
+        /* Clear all the static flags */
-        return HAL_ERROR;
+        __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      }
+        hsd->ErrorCode |= errorstate;
+        hsd->State = HAL_SD_STATE_READY;
-      /* Send CMD33 SD_ERASE_GRP_END with argument as addr  */
+        return HAL_ERROR;
-      errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);
+      }
-      if(errorstate != HAL_SD_ERROR_NONE)
-      {
+      /* Send CMD33 SD_ERASE_GRP_END with argument as addr  */
-        /* Clear all the static flags */
+      errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);
-        __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+      if(errorstate != HAL_SD_ERROR_NONE)
-        hsd->ErrorCode |= errorstate;
+      {
-        hsd->State = HAL_SD_STATE_READY;
+        /* Clear all the static flags */
-        return HAL_ERROR;
+        __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-      }
+        hsd->ErrorCode |= errorstate;
-    }
+        hsd->State = HAL_SD_STATE_READY;
+        return HAL_ERROR;
-    /* Send CMD38 ERASE */
+      }
-    errorstate = SDMMC_CmdErase(hsd->Instance);
+    }
-    if(errorstate != HAL_SD_ERROR_NONE)
-    {
+    /* Send CMD38 ERASE */
-      /* Clear all the static flags */
+    errorstate = SDMMC_CmdErase(hsd->Instance);
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if(errorstate != HAL_SD_ERROR_NONE)
-      hsd->ErrorCode |= errorstate;
+    {
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      return HAL_ERROR;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-    }
+      hsd->ErrorCode |= errorstate;
+      hsd->State = HAL_SD_STATE_READY;
-    hsd->State = HAL_SD_STATE_READY;
+      return HAL_ERROR;
+    }
-    return HAL_OK;
-  }
+    hsd->State = HAL_SD_STATE_READY;
-  else
-  {
+    return HAL_OK;
-    return HAL_BUSY;
+  }
-  }
+  else
-}
+  {
+    return HAL_BUSY;
-/**
+  }
-  * @brief  This function handles SD card interrupt request.
+}
-  * @param  hsd: Pointer to SD handle
-  * @retval None
+/**
-  */
+  * @brief  This function handles SD card interrupt request.
-void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
+  * @param  hsd: Pointer to SD handle
-{
+  * @retval None
-  uint32_t errorstate;
+  */
-  uint32_t context = hsd->Context;
+void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
+{
-  /* Check for SDIO interrupt flags */
+  uint32_t errorstate;
-  if((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
+  uint32_t context = hsd->Context;
-  {
-    SD_Read_IT(hsd);
+  /* Check for SDIO interrupt flags */
-  }
+  if((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
+  {
-  else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) != RESET)
+    SD_Read_IT(hsd);
-  {
+  }
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DATAEND);
+  else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) != RESET)
-    __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND  | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
+  {
-                             SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR  | SDIO_IT_TXFIFOHE |\
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DATAEND);
-                             SDIO_IT_RXFIFOHF);
+    __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND  | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
-    hsd->Instance->DCTRL &= ~(SDIO_DCTRL_DTEN);
+                             SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR  | SDIO_IT_TXFIFOHE |\
+                             SDIO_IT_RXFIFOHF);
-    if((context & SD_CONTEXT_IT) != 0U)
-    {
+    hsd->Instance->DCTRL &= ~(SDIO_DCTRL_DTEN);
-      if(((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
-      {
+    if((context & SD_CONTEXT_IT) != 0U)
-        errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
+    {
-        if(errorstate != HAL_SD_ERROR_NONE)
+      if(((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
-        {
+      {
-          hsd->ErrorCode |= errorstate;
+        errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
-#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
+        if(errorstate != HAL_SD_ERROR_NONE)
-          hsd->ErrorCallback(hsd);
+        {
-#else
+          hsd->ErrorCode |= errorstate;
-          HAL_SD_ErrorCallback(hsd);
+#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
-#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
+          hsd->ErrorCallback(hsd);
-        }
+#else
-      }
+          HAL_SD_ErrorCallback(hsd);
+#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
-      /* Clear all the static flags */
+        }
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
+      }
-      hsd->State = HAL_SD_STATE_READY;
+      /* Clear all the static flags */
-      hsd->Context = SD_CONTEXT_NONE;
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
-      if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
-      {
+      hsd->State = HAL_SD_STATE_READY;
-#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
+      hsd->Context = SD_CONTEXT_NONE;
-        hsd->RxCpltCallback(hsd);
+      if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
-#else
+      {
-        HAL_SD_RxCpltCallback(hsd);
+#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
-#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
+        hsd->RxCpltCallback(hsd);
-      }
+#else
-      else
+        HAL_SD_RxCpltCallback(hsd);
-      {
+#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
-#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
+      }
-        hsd->TxCpltCallback(hsd);
+      else
-#else
+      {
-        HAL_SD_TxCpltCallback(hsd);
+#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
-#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
+        hsd->TxCpltCallback(hsd);
-      }
+#else
-    }
+        HAL_SD_TxCpltCallback(hsd);
-    else if((context & SD_CONTEXT_DMA) != 0U)
+#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
-    {
+      }
-      if((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)
+    }
-      {
+    else if((context & SD_CONTEXT_DMA) != 0U)
-        errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
+    {
-        if(errorstate != HAL_SD_ERROR_NONE)
+      if((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)
-        {
+      {
-          hsd->ErrorCode |= errorstate;
+        errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
-#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
+        if(errorstate != HAL_SD_ERROR_NONE)
-          hsd->ErrorCallback(hsd);
+        {
-#else
+          hsd->ErrorCode |= errorstate;
-          HAL_SD_ErrorCallback(hsd);
+#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
-#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
+          hsd->ErrorCallback(hsd);
-        }
+#else
-      }
+          HAL_SD_ErrorCallback(hsd);
-      if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) == 0U) && ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) == 0U))
+#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
-      {
+        }
-        /* Disable the DMA transfer for transmit request by setting the DMAEN bit
+      }
-        in the SD DCTRL register */
+      if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) == 0U) && ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) == 0U))
-        hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
+      {
+        /* Disable the DMA transfer for transmit request by setting the DMAEN bit
-        hsd->State = HAL_SD_STATE_READY;
+        in the SD DCTRL register */
+        hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
-#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
-        hsd->TxCpltCallback(hsd);
+        hsd->State = HAL_SD_STATE_READY;
-#else
-        HAL_SD_TxCpltCallback(hsd);
+#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
-#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
+        hsd->TxCpltCallback(hsd);
-      }
+#else
-    }
+        HAL_SD_TxCpltCallback(hsd);
-    else
+#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
-    {
+      }
-      /* Nothing to do */
+    }
-    }
+    else
-  }
+    {
+      /* Nothing to do */
-  else if((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
+    }
-  {
+  }
-    SD_Write_IT(hsd);
-  }
+  else if((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
+  {
-  else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_RXOVERR | SDIO_FLAG_TXUNDERR) != RESET)
+    SD_Write_IT(hsd);
-  {
+  }
-    /* Set Error code */
-    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL) != RESET)
+  else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_RXOVERR | SDIO_FLAG_TXUNDERR) != RESET)
-    {
+  {
-      hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
+    /* Set Error code */
-    }
+    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL) != RESET)
-    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) != RESET)
+    {
-    {
+      hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
-      hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
+    }
-    }
+    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) != RESET)
-    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR) != RESET)
+    {
-    {
+      hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
-      hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
+    }
-    }
+    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR) != RESET)
-    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR) != RESET)
+    {
-    {
+      hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
-      hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
+    }
-    }
+    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR) != RESET)
+    {
-    /* Clear All flags */
+      hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS | SDIO_FLAG_STBITERR);
+    }
-    /* Disable all interrupts */
+    /* Clear All flags */
-    __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS | SDIO_FLAG_STBITERR);
-                             SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR | SDIO_IT_STBITERR);
+    /* Disable all interrupts */
-    hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
+    __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
+                             SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR | SDIO_IT_STBITERR);
-    if((context & SD_CONTEXT_IT) != 0U)
-    {
+    hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
-      /* Set the SD state to ready to be able to start again the process */
-      hsd->State = HAL_SD_STATE_READY;
+    if((context & SD_CONTEXT_IT) != 0U)
-      hsd->Context = SD_CONTEXT_NONE;
+    {
-#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
+      /* Set the SD state to ready to be able to start again the process */
-      hsd->ErrorCallback(hsd);
+      hsd->State = HAL_SD_STATE_READY;
-#else
+      hsd->Context = SD_CONTEXT_NONE;
-      HAL_SD_ErrorCallback(hsd);
+#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
-#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
+      hsd->ErrorCallback(hsd);
-    }
+#else
-    else if((context & SD_CONTEXT_DMA) != 0U)
+      HAL_SD_ErrorCallback(hsd);
-    {
+#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
-      /* Abort the SD DMA channel */
+    }
-      if(((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
+    else if((context & SD_CONTEXT_DMA) != 0U)
-      {
+    {
-        /* Set the DMA Tx abort callback */
+      /* Abort the SD DMA channel */
-        hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;
+      if(((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
-        /* Abort DMA in IT mode */
+      {
-        if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)
+        /* Set the DMA Tx abort callback */
-        {
+        hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;
-          SD_DMATxAbort(hsd->hdmatx);
+        /* Abort DMA in IT mode */
-        }
+        if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)
-      }
+        {
-      else if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
+          SD_DMATxAbort(hsd->hdmatx);
-      {
+        }
-        /* Set the DMA Rx abort callback */
+      }
-        hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;
+      else if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
-        /* Abort DMA in IT mode */
+      {
-        if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)
+        /* Set the DMA Rx abort callback */
-        {
+        hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;
-          SD_DMARxAbort(hsd->hdmarx);
+        /* Abort DMA in IT mode */
-        }
+        if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)
-      }
+        {
-      else
+          SD_DMARxAbort(hsd->hdmarx);
-      {
+        }
-        hsd->ErrorCode = HAL_SD_ERROR_NONE;
+      }
-        hsd->State = HAL_SD_STATE_READY;
+      else
-        hsd->Context = SD_CONTEXT_NONE;
+      {
-#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
+        hsd->ErrorCode = HAL_SD_ERROR_NONE;
-        hsd->AbortCpltCallback(hsd);
+        hsd->State = HAL_SD_STATE_READY;
-#else
+        hsd->Context = SD_CONTEXT_NONE;
-        HAL_SD_AbortCallback(hsd);
+#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
-#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
+        hsd->AbortCpltCallback(hsd);
-      }
+#else
-    }
+        HAL_SD_AbortCallback(hsd);
-    else
+#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
-    {
+      }
-      /* Nothing to do */
+    }
-    }
+    else
-  }
+    {
-  else
+      /* Nothing to do */
-  {
+    }
-    /* Nothing to do */
+  }
-  }
+  else
-}
+  {
+    /* Nothing to do */
-/**
+  }
-  * @brief return the SD state
+}
-  * @param hsd: Pointer to sd handle
-  * @retval HAL state
+/**
-  */
+  * @brief return the SD state
-HAL_SD_StateTypeDef HAL_SD_GetState(SD_HandleTypeDef *hsd)
+  * @param hsd: Pointer to sd handle
-{
+  * @retval HAL state
-  return hsd->State;
+  */
-}
+HAL_SD_StateTypeDef HAL_SD_GetState(SD_HandleTypeDef *hsd)
+{
-/**
+  return hsd->State;
-* @brief  Return the SD error code
+}
-* @param  hsd : Pointer to a SD_HandleTypeDef structure that contains
-  *              the configuration information.
+/**
-* @retval SD Error Code
+* @brief  Return the SD error code
-*/
+* @param  hsd : Pointer to a SD_HandleTypeDef structure that contains
-uint32_t HAL_SD_GetError(SD_HandleTypeDef *hsd)
+  *              the configuration information.
-{
+* @retval SD Error Code
-  return hsd->ErrorCode;
+*/
-}
+uint32_t HAL_SD_GetError(SD_HandleTypeDef *hsd)
+{
-/**
+  return hsd->ErrorCode;
-  * @brief Tx Transfer completed callbacks
+}
-  * @param hsd: Pointer to SD handle
-  * @retval None
+/**
-  */
+  * @brief Tx Transfer completed callbacks
-__weak void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
+  * @param hsd: Pointer to SD handle
-{
+  * @retval None
-  /* Prevent unused argument(s) compilation warning */
+  */
-  UNUSED(hsd);
+__weak void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
+{
-  /* NOTE : This function should not be modified, when the callback is needed,
+  /* Prevent unused argument(s) compilation warning */
-            the HAL_SD_TxCpltCallback can be implemented in the user file
+  UNUSED(hsd);
-   */
-}
+  /* NOTE : This function should not be modified, when the callback is needed,
+            the HAL_SD_TxCpltCallback can be implemented in the user file
-/**
+   */
-  * @brief Rx Transfer completed callbacks
+}
-  * @param hsd: Pointer SD handle
-  * @retval None
+/**
-  */
+  * @brief Rx Transfer completed callbacks
-__weak void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
+  * @param hsd: Pointer SD handle
-{
+  * @retval None
-  /* Prevent unused argument(s) compilation warning */
+  */
-  UNUSED(hsd);
+__weak void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
+{
-  /* NOTE : This function should not be modified, when the callback is needed,
+  /* Prevent unused argument(s) compilation warning */
-            the HAL_SD_RxCpltCallback can be implemented in the user file
+  UNUSED(hsd);
-   */
-}
+  /* NOTE : This function should not be modified, when the callback is needed,
+            the HAL_SD_RxCpltCallback can be implemented in the user file
-/**
+   */
-  * @brief SD error callbacks
+}
-  * @param hsd: Pointer SD handle
-  * @retval None
+/**
-  */
+  * @brief SD error callbacks
-__weak void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd)
+  * @param hsd: Pointer SD handle
-{
+  * @retval None
-  /* Prevent unused argument(s) compilation warning */
+  */
-  UNUSED(hsd);
+__weak void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd)
+{
-  /* NOTE : This function should not be modified, when the callback is needed,
+  /* Prevent unused argument(s) compilation warning */
-            the HAL_SD_ErrorCallback can be implemented in the user file
+  UNUSED(hsd);
-   */
-}
+  /* NOTE : This function should not be modified, when the callback is needed,
+            the HAL_SD_ErrorCallback can be implemented in the user file
-/**
+   */
-  * @brief SD Abort callbacks
+}
-  * @param hsd: Pointer SD handle
-  * @retval None
+/**
-  */
+  * @brief SD Abort callbacks
-__weak void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)
+  * @param hsd: Pointer SD handle
-{
+  * @retval None
-  /* Prevent unused argument(s) compilation warning */
+  */
-  UNUSED(hsd);
+__weak void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)
+{
-  /* NOTE : This function should not be modified, when the callback is needed,
+  /* Prevent unused argument(s) compilation warning */
-            the HAL_SD_AbortCallback can be implemented in the user file
+  UNUSED(hsd);
-   */
-}
+  /* NOTE : This function should not be modified, when the callback is needed,
+            the HAL_SD_AbortCallback can be implemented in the user file
-#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
+   */
-/**
+}
-  * @brief  Register a User SD Callback
-  *         To be used instead of the weak (surcharged) predefined callback
+#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
-  * @param hsd : SD handle
+/**
-  * @param CallbackID : ID of the callback to be registered
+  * @brief  Register a User SD Callback
-  *        This parameter can be one of the following values:
+  *         To be used instead of the weak (surcharged) predefined callback
-  *          @arg @ref HAL_SD_TX_CPLT_CB_ID    SD Tx Complete Callback ID
+  * @param hsd : SD handle
-  *          @arg @ref HAL_SD_RX_CPLT_CB_ID    SD Rx Complete Callback ID
+  * @param CallbackID : ID of the callback to be registered
-  *          @arg @ref HAL_SD_ERROR_CB_ID      SD Error Callback ID
+  *        This parameter can be one of the following values:
-  *          @arg @ref HAL_SD_ABORT_CB_ID      SD Abort Callback ID
+  *          @arg @ref HAL_SD_TX_CPLT_CB_ID    SD Tx Complete Callback ID
-  *          @arg @ref HAL_SD_MSP_INIT_CB_ID   SD MspInit Callback ID
+  *          @arg @ref HAL_SD_RX_CPLT_CB_ID    SD Rx Complete Callback ID
-  *          @arg @ref HAL_SD_MSP_DEINIT_CB_ID SD MspDeInit Callback ID
+  *          @arg @ref HAL_SD_ERROR_CB_ID      SD Error Callback ID
-  * @param pCallback : pointer to the Callback function
+  *          @arg @ref HAL_SD_ABORT_CB_ID      SD Abort Callback ID
-  * @retval status
+  *          @arg @ref HAL_SD_MSP_INIT_CB_ID   SD MspInit Callback ID
-  */
+  *          @arg @ref HAL_SD_MSP_DEINIT_CB_ID SD MspDeInit Callback ID
-HAL_StatusTypeDef HAL_SD_RegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID, pSD_CallbackTypeDef pCallback)
+  * @param pCallback : pointer to the Callback function
-{
+  * @retval status
-  HAL_StatusTypeDef status = HAL_OK;
+  */
+HAL_StatusTypeDef HAL_SD_RegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID, pSD_CallbackTypeDef pCallback)
-  if(pCallback == NULL)
+{
-  {
+  HAL_StatusTypeDef status = HAL_OK;
-    /* Update the error code */
-    hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
+  if(pCallback == NULL)
-    return HAL_ERROR;
+  {
-  }
+    /* Update the error code */
+    hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
-  /* Process locked */
+    return HAL_ERROR;
-  __HAL_LOCK(hsd);
+  }
-  if(hsd->State == HAL_SD_STATE_READY)
+  /* Process locked */
-  {
+  __HAL_LOCK(hsd);
-    switch (CallbackID)
-    {
+  if(hsd->State == HAL_SD_STATE_READY)
-    case HAL_SD_TX_CPLT_CB_ID :
+  {
-      hsd->TxCpltCallback = pCallback;
+    switch (CallbackID)
-      break;
+    {
-    case HAL_SD_RX_CPLT_CB_ID :
+    case HAL_SD_TX_CPLT_CB_ID :
-      hsd->RxCpltCallback = pCallback;
+      hsd->TxCpltCallback = pCallback;
       break;
-    case HAL_SD_ERROR_CB_ID :
+    case HAL_SD_RX_CPLT_CB_ID :
-      hsd->ErrorCallback = pCallback;
+      hsd->RxCpltCallback = pCallback;
       break;
-    case HAL_SD_ABORT_CB_ID :
+    case HAL_SD_ERROR_CB_ID :
-      hsd->AbortCpltCallback = pCallback;
+      hsd->ErrorCallback = pCallback;
       break;
-    case HAL_SD_MSP_INIT_CB_ID :
+    case HAL_SD_ABORT_CB_ID :
-      hsd->MspInitCallback = pCallback;
+      hsd->AbortCpltCallback = pCallback;
       break;
-    case HAL_SD_MSP_DEINIT_CB_ID :
+    case HAL_SD_MSP_INIT_CB_ID :
-      hsd->MspDeInitCallback = pCallback;
+      hsd->MspInitCallback = pCallback;
       break;
-    default :
+    case HAL_SD_MSP_DEINIT_CB_ID :
-      /* Update the error code */
+      hsd->MspDeInitCallback = pCallback;
-      hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
+      break;
-      /* update return status */
+    default :
-      status =  HAL_ERROR;
+      /* Update the error code */
-      break;
+      hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
-    }
+      /* update return status */
-  }
+      status =  HAL_ERROR;
-  else if (hsd->State == HAL_SD_STATE_RESET)
+      break;
-  {
+    }
-    switch (CallbackID)
+  }
-    {
+  else if (hsd->State == HAL_SD_STATE_RESET)
-    case HAL_SD_MSP_INIT_CB_ID :
+  {
-      hsd->MspInitCallback = pCallback;
+    switch (CallbackID)
-      break;
+    {
-    case HAL_SD_MSP_DEINIT_CB_ID :
+    case HAL_SD_MSP_INIT_CB_ID :
-      hsd->MspDeInitCallback = pCallback;
+      hsd->MspInitCallback = pCallback;
       break;
-    default :
+    case HAL_SD_MSP_DEINIT_CB_ID :
-      /* Update the error code */
+      hsd->MspDeInitCallback = pCallback;
-      hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
+      break;
-      /* update return status */
+    default :
-      status =  HAL_ERROR;
+      /* Update the error code */
-      break;
+      hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
-    }
+      /* update return status */
-  }
+      status =  HAL_ERROR;
-  else
+      break;
-  {
+    }
-    /* Update the error code */
+  }
-    hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
+  else
-    /* update return status */
+  {
-    status =  HAL_ERROR;
+    /* Update the error code */
-  }
+    hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
+    /* update return status */
-  /* Release Lock */
+    status =  HAL_ERROR;
-  __HAL_UNLOCK(hsd);
+  }
-  return status;
-}
+  /* Release Lock */
+  __HAL_UNLOCK(hsd);
-/**
+  return status;
-  * @brief  Unregister a User SD Callback
+}
-  *         SD Callback is redirected to the weak (surcharged) predefined callback
-  * @param hsd : SD handle
+/**
-  * @param CallbackID : ID of the callback to be unregistered
+  * @brief  Unregister a User SD Callback
-  *        This parameter can be one of the following values:
+  *         SD Callback is redirected to the weak (surcharged) predefined callback
-  *          @arg @ref HAL_SD_TX_CPLT_CB_ID    SD Tx Complete Callback ID
+  * @param hsd : SD handle
-  *          @arg @ref HAL_SD_RX_CPLT_CB_ID    SD Rx Complete Callback ID
+  * @param CallbackID : ID of the callback to be unregistered
-  *          @arg @ref HAL_SD_ERROR_CB_ID      SD Error Callback ID
+  *        This parameter can be one of the following values:
-  *          @arg @ref HAL_SD_ABORT_CB_ID      SD Abort Callback ID
+  *          @arg @ref HAL_SD_TX_CPLT_CB_ID    SD Tx Complete Callback ID
-  *          @arg @ref HAL_SD_MSP_INIT_CB_ID   SD MspInit Callback ID
+  *          @arg @ref HAL_SD_RX_CPLT_CB_ID    SD Rx Complete Callback ID
-  *          @arg @ref HAL_SD_MSP_DEINIT_CB_ID SD MspDeInit Callback ID
+  *          @arg @ref HAL_SD_ERROR_CB_ID      SD Error Callback ID
-  * @retval status
+  *          @arg @ref HAL_SD_ABORT_CB_ID      SD Abort Callback ID
-  */
+  *          @arg @ref HAL_SD_MSP_INIT_CB_ID   SD MspInit Callback ID
-HAL_StatusTypeDef HAL_SD_UnRegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID)
+  *          @arg @ref HAL_SD_MSP_DEINIT_CB_ID SD MspDeInit Callback ID
-{
+  * @retval status
-  HAL_StatusTypeDef status = HAL_OK;
+  */
+HAL_StatusTypeDef HAL_SD_UnRegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID)
-  /* Process locked */
+{
-  __HAL_LOCK(hsd);
+  HAL_StatusTypeDef status = HAL_OK;
-  if(hsd->State == HAL_SD_STATE_READY)
+  /* Process locked */
-  {
+  __HAL_LOCK(hsd);
-    switch (CallbackID)
-    {
+  if(hsd->State == HAL_SD_STATE_READY)
-    case HAL_SD_TX_CPLT_CB_ID :
+  {
-      hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
+    switch (CallbackID)
-      break;
+    {
-    case HAL_SD_RX_CPLT_CB_ID :
+    case HAL_SD_TX_CPLT_CB_ID :
-      hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
+      hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
       break;
-    case HAL_SD_ERROR_CB_ID :
+    case HAL_SD_RX_CPLT_CB_ID :
-      hsd->ErrorCallback = HAL_SD_ErrorCallback;
+      hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
       break;
-    case HAL_SD_ABORT_CB_ID :
+    case HAL_SD_ERROR_CB_ID :
-      hsd->AbortCpltCallback = HAL_SD_AbortCallback;
+      hsd->ErrorCallback = HAL_SD_ErrorCallback;
       break;
-    case HAL_SD_MSP_INIT_CB_ID :
+    case HAL_SD_ABORT_CB_ID :
-      hsd->MspInitCallback = HAL_SD_MspInit;
+      hsd->AbortCpltCallback = HAL_SD_AbortCallback;
       break;
-    case HAL_SD_MSP_DEINIT_CB_ID :
+    case HAL_SD_MSP_INIT_CB_ID :
-      hsd->MspDeInitCallback = HAL_SD_MspDeInit;
+      hsd->MspInitCallback = HAL_SD_MspInit;
       break;
-    default :
+    case HAL_SD_MSP_DEINIT_CB_ID :
-      /* Update the error code */
+      hsd->MspDeInitCallback = HAL_SD_MspDeInit;
-      hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
+      break;
-      /* update return status */
+    default :
-      status =  HAL_ERROR;
+      /* Update the error code */
-      break;
+      hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
-    }
+      /* update return status */
-  }
+      status =  HAL_ERROR;
-  else if (hsd->State == HAL_SD_STATE_RESET)
+      break;
-  {
+    }
-    switch (CallbackID)
+  }
-    {
+  else if (hsd->State == HAL_SD_STATE_RESET)
-    case HAL_SD_MSP_INIT_CB_ID :
+  {
-      hsd->MspInitCallback = HAL_SD_MspInit;
+    switch (CallbackID)
-      break;
+    {
-    case HAL_SD_MSP_DEINIT_CB_ID :
+    case HAL_SD_MSP_INIT_CB_ID :
-      hsd->MspDeInitCallback = HAL_SD_MspDeInit;
+      hsd->MspInitCallback = HAL_SD_MspInit;
       break;
-    default :
+    case HAL_SD_MSP_DEINIT_CB_ID :
-      /* Update the error code */
+      hsd->MspDeInitCallback = HAL_SD_MspDeInit;
-      hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
+      break;
-      /* update return status */
+    default :
-      status =  HAL_ERROR;
+      /* Update the error code */
-      break;
+      hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
-    }
+      /* update return status */
-  }
+      status =  HAL_ERROR;
-  else
+      break;
-  {
+    }
-    /* Update the error code */
+  }
-    hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
+  else
-    /* update return status */
+  {
-    status =  HAL_ERROR;
+    /* Update the error code */
-  }
+    hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
+    /* update return status */
-  /* Release Lock */
+    status =  HAL_ERROR;
-  __HAL_UNLOCK(hsd);
+  }
-  return status;
-}
+  /* Release Lock */
-#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
+  __HAL_UNLOCK(hsd);
+  return status;
-/**
+}
-  * @}
+#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
-  */
+/**
-/** @addtogroup SD_Exported_Functions_Group3
+  * @}
- *  @brief   management functions
+  */
- *
-@verbatim
+/** @addtogroup SD_Exported_Functions_Group3
-  ==============================================================================
+ *  @brief   management functions
-                      ##### Peripheral Control functions #####
+ *
-  ==============================================================================
+@verbatim
-  [..]
+  ==============================================================================
-    This subsection provides a set of functions allowing to control the SD card
+                      ##### Peripheral Control functions #####
-    operations and get the related information
+  ==============================================================================
+  [..]
-@endverbatim
+    This subsection provides a set of functions allowing to control the SD card
-  * @{
+    operations and get the related information
-  */
+@endverbatim
-/**
+  * @{
-  * @brief  Returns information the information of the card which are stored on
+  */
-  *         the CID register.
-  * @param  hsd: Pointer to SD handle
+/**
-  * @param  pCID: Pointer to a HAL_SD_CardCIDTypeDef structure that
+  * @brief  Returns information the information of the card which are stored on
-  *         contains all CID register parameters
+  *         the CID register.
-  * @retval HAL status
+  * @param  hsd: Pointer to SD handle
-  */
+  * @param  pCID: Pointer to a HAL_SD_CardCIDTypeDef structure that
-HAL_StatusTypeDef HAL_SD_GetCardCID(SD_HandleTypeDef *hsd, HAL_SD_CardCIDTypeDef *pCID)
+  *         contains all CID register parameters
-{
+  * @retval HAL status
-  pCID->ManufacturerID = (uint8_t)((hsd->CID[0] & 0xFF000000U) >> 24U);
+  */
+HAL_StatusTypeDef HAL_SD_GetCardCID(SD_HandleTypeDef *hsd, HAL_SD_CardCIDTypeDef *pCID)
-  pCID->OEM_AppliID = (uint16_t)((hsd->CID[0] & 0x00FFFF00U) >> 8U);
+{
+  pCID->ManufacturerID = (uint8_t)((hsd->CID[0] & 0xFF000000U) >> 24U);
-  pCID->ProdName1 = (((hsd->CID[0] & 0x000000FFU) << 24U) | ((hsd->CID[1] & 0xFFFFFF00U) >> 8U));
+  pCID->OEM_AppliID = (uint16_t)((hsd->CID[0] & 0x00FFFF00U) >> 8U);
-  pCID->ProdName2 = (uint8_t)(hsd->CID[1] & 0x000000FFU);
+  pCID->ProdName1 = (((hsd->CID[0] & 0x000000FFU) << 24U) | ((hsd->CID[1] & 0xFFFFFF00U) >> 8U));
-  pCID->ProdRev = (uint8_t)((hsd->CID[2] & 0xFF000000U) >> 24U);
+  pCID->ProdName2 = (uint8_t)(hsd->CID[1] & 0x000000FFU);
-  pCID->ProdSN = (((hsd->CID[2] & 0x00FFFFFFU) << 8U) | ((hsd->CID[3] & 0xFF000000U) >> 24U));
+  pCID->ProdRev = (uint8_t)((hsd->CID[2] & 0xFF000000U) >> 24U);
-  pCID->Reserved1 = (uint8_t)((hsd->CID[3] & 0x00F00000U) >> 20U);
+  pCID->ProdSN = (((hsd->CID[2] & 0x00FFFFFFU) << 8U) | ((hsd->CID[3] & 0xFF000000U) >> 24U));
-  pCID->ManufactDate = (uint16_t)((hsd->CID[3] & 0x000FFF00U) >> 8U);
+  pCID->Reserved1 = (uint8_t)((hsd->CID[3] & 0x00F00000U) >> 20U);
-  pCID->CID_CRC = (uint8_t)((hsd->CID[3] & 0x000000FEU) >> 1U);
+  pCID->ManufactDate = (uint16_t)((hsd->CID[3] & 0x000FFF00U) >> 8U);
-  pCID->Reserved2 = 1U;
+  pCID->CID_CRC = (uint8_t)((hsd->CID[3] & 0x000000FEU) >> 1U);
-  return HAL_OK;
-}
+  pCID->Reserved2 = 1U;
-/**
+  return HAL_OK;
-  * @brief  Returns information the information of the card which are stored on
+}
-  *         the CSD register.
-  * @param  hsd: Pointer to SD handle
+/**
-  * @param  pCSD: Pointer to a HAL_SD_CardCSDTypeDef structure that
+  * @brief  Returns information the information of the card which are stored on
-  *         contains all CSD register parameters
+  *         the CSD register.
-  * @retval HAL status
+  * @param  hsd: Pointer to SD handle
-  */
+  * @param  pCSD: Pointer to a HAL_SD_CardCSDTypeDef structure that
-HAL_StatusTypeDef HAL_SD_GetCardCSD(SD_HandleTypeDef *hsd, HAL_SD_CardCSDTypeDef *pCSD)
+  *         contains all CSD register parameters
-{
+  * @retval HAL status
-  pCSD->CSDStruct = (uint8_t)((hsd->CSD[0] & 0xC0000000U) >> 30U);
+  */
+HAL_StatusTypeDef HAL_SD_GetCardCSD(SD_HandleTypeDef *hsd, HAL_SD_CardCSDTypeDef *pCSD)
-  pCSD->SysSpecVersion = (uint8_t)((hsd->CSD[0] & 0x3C000000U) >> 26U);
+{
+  pCSD->CSDStruct = (uint8_t)((hsd->CSD[0] & 0xC0000000U) >> 30U);
-  pCSD->Reserved1 = (uint8_t)((hsd->CSD[0] & 0x03000000U) >> 24U);
+  pCSD->SysSpecVersion = (uint8_t)((hsd->CSD[0] & 0x3C000000U) >> 26U);
-  pCSD->TAAC = (uint8_t)((hsd->CSD[0] & 0x00FF0000U) >> 16U);
+  pCSD->Reserved1 = (uint8_t)((hsd->CSD[0] & 0x03000000U) >> 24U);
-  pCSD->NSAC = (uint8_t)((hsd->CSD[0] & 0x0000FF00U) >> 8U);
+  pCSD->TAAC = (uint8_t)((hsd->CSD[0] & 0x00FF0000U) >> 16U);
-  pCSD->MaxBusClkFrec = (uint8_t)(hsd->CSD[0] & 0x000000FFU);
+  pCSD->NSAC = (uint8_t)((hsd->CSD[0] & 0x0000FF00U) >> 8U);
-  pCSD->CardComdClasses = (uint16_t)((hsd->CSD[1] & 0xFFF00000U) >> 20U);
+  pCSD->MaxBusClkFrec = (uint8_t)(hsd->CSD[0] & 0x000000FFU);
-  pCSD->RdBlockLen = (uint8_t)((hsd->CSD[1] & 0x000F0000U) >> 16U);
+  pCSD->CardComdClasses = (uint16_t)((hsd->CSD[1] & 0xFFF00000U) >> 20U);
-  pCSD->PartBlockRead   = (uint8_t)((hsd->CSD[1] & 0x00008000U) >> 15U);
+  pCSD->RdBlockLen = (uint8_t)((hsd->CSD[1] & 0x000F0000U) >> 16U);
-  pCSD->WrBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00004000U) >> 14U);
+  pCSD->PartBlockRead   = (uint8_t)((hsd->CSD[1] & 0x00008000U) >> 15U);
-  pCSD->RdBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00002000U) >> 13U);
+  pCSD->WrBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00004000U) >> 14U);
-  pCSD->DSRImpl = (uint8_t)((hsd->CSD[1] & 0x00001000U) >> 12U);
+  pCSD->RdBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00002000U) >> 13U);
-  pCSD->Reserved2 = 0U; /*!< Reserved */
+  pCSD->DSRImpl = (uint8_t)((hsd->CSD[1] & 0x00001000U) >> 12U);
-  if(hsd->SdCard.CardType == CARD_SDSC)
-  {
+  pCSD->Reserved2 = 0U; /*!< Reserved */
-    pCSD->DeviceSize = (((hsd->CSD[1] & 0x000003FFU) << 2U) | ((hsd->CSD[2] & 0xC0000000U) >> 30U));
+  if(hsd->SdCard.CardType == CARD_SDSC)
-    pCSD->MaxRdCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x38000000U) >> 27U);
+  {
+    pCSD->DeviceSize = (((hsd->CSD[1] & 0x000003FFU) << 2U) | ((hsd->CSD[2] & 0xC0000000U) >> 30U));
-    pCSD->MaxRdCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x07000000U) >> 24U);
+    pCSD->MaxRdCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x38000000U) >> 27U);
-    pCSD->MaxWrCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x00E00000U) >> 21U);
+    pCSD->MaxRdCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x07000000U) >> 24U);
-    pCSD->MaxWrCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x001C0000U) >> 18U);
+    pCSD->MaxWrCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x00E00000U) >> 21U);
-    pCSD->DeviceSizeMul = (uint8_t)((hsd->CSD[2] & 0x00038000U) >> 15U);
+    pCSD->MaxWrCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x001C0000U) >> 18U);
-    hsd->SdCard.BlockNbr  = (pCSD->DeviceSize + 1U) ;
-    hsd->SdCard.BlockNbr *= (1UL << ((pCSD->DeviceSizeMul & 0x07U) + 2U));
+    pCSD->DeviceSizeMul = (uint8_t)((hsd->CSD[2] & 0x00038000U) >> 15U);
-    hsd->SdCard.BlockSize = (1UL << (pCSD->RdBlockLen & 0x0FU));
+    hsd->SdCard.BlockNbr  = (pCSD->DeviceSize + 1U) ;
-    hsd->SdCard.LogBlockNbr =  (hsd->SdCard.BlockNbr) * ((hsd->SdCard.BlockSize) / 512U);
+    hsd->SdCard.BlockNbr *= (1UL << ((pCSD->DeviceSizeMul & 0x07U) + 2U));
-    hsd->SdCard.LogBlockSize = 512U;
+    hsd->SdCard.BlockSize = (1UL << (pCSD->RdBlockLen & 0x0FU));
-  }
-  else if(hsd->SdCard.CardType == CARD_SDHC_SDXC)
+    hsd->SdCard.LogBlockNbr =  (hsd->SdCard.BlockNbr) * ((hsd->SdCard.BlockSize) / 512U);
-  {
+    hsd->SdCard.LogBlockSize = 512U;
-    /* Byte 7 */
+  }
-    pCSD->DeviceSize = (((hsd->CSD[1] & 0x0000003FU) << 16U) | ((hsd->CSD[2] & 0xFFFF0000U) >> 16U));
+  else if(hsd->SdCard.CardType == CARD_SDHC_SDXC)
+  {
-    hsd->SdCard.BlockNbr = ((pCSD->DeviceSize + 1U) * 1024U);
+    /* Byte 7 */
-    hsd->SdCard.LogBlockNbr = hsd->SdCard.BlockNbr;
+    pCSD->DeviceSize = (((hsd->CSD[1] & 0x0000003FU) << 16U) | ((hsd->CSD[2] & 0xFFFF0000U) >> 16U));
-    hsd->SdCard.BlockSize = 512U;
-    hsd->SdCard.LogBlockSize = hsd->SdCard.BlockSize;
+    hsd->SdCard.BlockNbr = ((pCSD->DeviceSize + 1U) * 1024U);
-  }
+    hsd->SdCard.LogBlockNbr = hsd->SdCard.BlockNbr;
-  else
+    hsd->SdCard.BlockSize = 512U;
-  {
+    hsd->SdCard.LogBlockSize = hsd->SdCard.BlockSize;
-    /* Clear all the static flags */
+  }
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+  else
-    hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
+  {
-    hsd->State = HAL_SD_STATE_READY;
+    /* Clear all the static flags */
-    return HAL_ERROR;
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-  }
+    hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
+    hsd->State = HAL_SD_STATE_READY;
-  pCSD->EraseGrSize = (uint8_t)((hsd->CSD[2] & 0x00004000U) >> 14U);
+    return HAL_ERROR;
+  }
-  pCSD->EraseGrMul = (uint8_t)((hsd->CSD[2] & 0x00003F80U) >> 7U);
+  pCSD->EraseGrSize = (uint8_t)((hsd->CSD[2] & 0x00004000U) >> 14U);
-  pCSD->WrProtectGrSize = (uint8_t)(hsd->CSD[2] & 0x0000007FU);
+  pCSD->EraseGrMul = (uint8_t)((hsd->CSD[2] & 0x00003F80U) >> 7U);
-  pCSD->WrProtectGrEnable = (uint8_t)((hsd->CSD[3] & 0x80000000U) >> 31U);
+  pCSD->WrProtectGrSize = (uint8_t)(hsd->CSD[2] & 0x0000007FU);
-  pCSD->ManDeflECC = (uint8_t)((hsd->CSD[3] & 0x60000000U) >> 29U);
+  pCSD->WrProtectGrEnable = (uint8_t)((hsd->CSD[3] & 0x80000000U) >> 31U);
-  pCSD->WrSpeedFact = (uint8_t)((hsd->CSD[3] & 0x1C000000U) >> 26U);
+  pCSD->ManDeflECC = (uint8_t)((hsd->CSD[3] & 0x60000000U) >> 29U);
-  pCSD->MaxWrBlockLen= (uint8_t)((hsd->CSD[3] & 0x03C00000U) >> 22U);
+  pCSD->WrSpeedFact = (uint8_t)((hsd->CSD[3] & 0x1C000000U) >> 26U);
-  pCSD->WriteBlockPaPartial = (uint8_t)((hsd->CSD[3] & 0x00200000U) >> 21U);
+  pCSD->MaxWrBlockLen= (uint8_t)((hsd->CSD[3] & 0x03C00000U) >> 22U);
-  pCSD->Reserved3 = 0;
+  pCSD->WriteBlockPaPartial = (uint8_t)((hsd->CSD[3] & 0x00200000U) >> 21U);
-  pCSD->ContentProtectAppli = (uint8_t)((hsd->CSD[3] & 0x00010000U) >> 16U);
+  pCSD->Reserved3 = 0;
-  pCSD->FileFormatGroup = (uint8_t)((hsd->CSD[3] & 0x00008000U) >> 15U);
+  pCSD->ContentProtectAppli = (uint8_t)((hsd->CSD[3] & 0x00010000U) >> 16U);
-  pCSD->CopyFlag = (uint8_t)((hsd->CSD[3] & 0x00004000U) >> 14U);
+  pCSD->FileFormatGroup = (uint8_t)((hsd->CSD[3] & 0x00008000U) >> 15U);
-  pCSD->PermWrProtect = (uint8_t)((hsd->CSD[3] & 0x00002000U) >> 13U);
+  pCSD->CopyFlag = (uint8_t)((hsd->CSD[3] & 0x00004000U) >> 14U);
-  pCSD->TempWrProtect = (uint8_t)((hsd->CSD[3] & 0x00001000U) >> 12U);
+  pCSD->PermWrProtect = (uint8_t)((hsd->CSD[3] & 0x00002000U) >> 13U);
-  pCSD->FileFormat = (uint8_t)((hsd->CSD[3] & 0x00000C00U) >> 10U);
+  pCSD->TempWrProtect = (uint8_t)((hsd->CSD[3] & 0x00001000U) >> 12U);
-  pCSD->ECC= (uint8_t)((hsd->CSD[3] & 0x00000300U) >> 8U);
+  pCSD->FileFormat = (uint8_t)((hsd->CSD[3] & 0x00000C00U) >> 10U);
-  pCSD->CSD_CRC = (uint8_t)((hsd->CSD[3] & 0x000000FEU) >> 1U);
+  pCSD->ECC= (uint8_t)((hsd->CSD[3] & 0x00000300U) >> 8U);
-  pCSD->Reserved4 = 1;
+  pCSD->CSD_CRC = (uint8_t)((hsd->CSD[3] & 0x000000FEU) >> 1U);
-  return HAL_OK;
-}
+  pCSD->Reserved4 = 1;
-/**
+  return HAL_OK;
-  * @brief  Gets the SD status info.
+}
-  * @param  hsd: Pointer to SD handle
-  * @param  pStatus: Pointer to the HAL_SD_CardStatusTypeDef structure that
+/**
-  *         will contain the SD card status information
+  * @brief  Gets the SD status info.
-  * @retval HAL status
+  * @param  hsd: Pointer to SD handle
-  */
+  * @param  pStatus: Pointer to the HAL_SD_CardStatusTypeDef structure that
-HAL_StatusTypeDef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypeDef *pStatus)
+  *         will contain the SD card status information
-{
+  * @retval HAL status
-  uint32_t sd_status[16];
+  */
-  uint32_t errorstate;
+HAL_StatusTypeDef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypeDef *pStatus)
-  HAL_StatusTypeDef status = HAL_OK;
+{
+  uint32_t sd_status[16];
-  errorstate = SD_SendSDStatus(hsd, sd_status);
+  uint32_t errorstate;
-  if(errorstate != HAL_SD_ERROR_NONE)
+  HAL_StatusTypeDef status = HAL_OK;
-  {
-    /* Clear all the static flags */
+  errorstate = SD_SendSDStatus(hsd, sd_status);
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+  if(errorstate != HAL_SD_ERROR_NONE)
-    hsd->ErrorCode |= errorstate;
+  {
-    hsd->State = HAL_SD_STATE_READY;
+    /* Clear all the static flags */
-    status = HAL_ERROR;
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-  }
+    hsd->ErrorCode |= errorstate;
-  else
+    hsd->State = HAL_SD_STATE_READY;
-  {
+    status = HAL_ERROR;
-    pStatus->DataBusWidth = (uint8_t)((sd_status[0] & 0xC0U) >> 6U);
+  }
+  else
-    pStatus->SecuredMode = (uint8_t)((sd_status[0] & 0x20U) >> 5U);
+  {
+    pStatus->DataBusWidth = (uint8_t)((sd_status[0] & 0xC0U) >> 6U);
-    pStatus->CardType = (uint16_t)(((sd_status[0] & 0x00FF0000U) >> 8U) | ((sd_status[0] & 0xFF000000U) >> 24U));
+    pStatus->SecuredMode = (uint8_t)((sd_status[0] & 0x20U) >> 5U);
-    pStatus->ProtectedAreaSize = (((sd_status[1] & 0xFFU) << 24U)    | ((sd_status[1] & 0xFF00U) << 8U) |
-                                  ((sd_status[1] & 0xFF0000U) >> 8U) | ((sd_status[1] & 0xFF000000U) >> 24U));
+    pStatus->CardType = (uint16_t)(((sd_status[0] & 0x00FF0000U) >> 8U) | ((sd_status[0] & 0xFF000000U) >> 24U));
-    pStatus->SpeedClass = (uint8_t)(sd_status[2] & 0xFFU);
+    pStatus->ProtectedAreaSize = (((sd_status[1] & 0xFFU) << 24U)    | ((sd_status[1] & 0xFF00U) << 8U) |
+                                  ((sd_status[1] & 0xFF0000U) >> 8U) | ((sd_status[1] & 0xFF000000U) >> 24U));
-    pStatus->PerformanceMove = (uint8_t)((sd_status[2] & 0xFF00U) >> 8U);
+    pStatus->SpeedClass = (uint8_t)(sd_status[2] & 0xFFU);
-    pStatus->AllocationUnitSize = (uint8_t)((sd_status[2] & 0xF00000U) >> 20U);
+    pStatus->PerformanceMove = (uint8_t)((sd_status[2] & 0xFF00U) >> 8U);
-    pStatus->EraseSize = (uint16_t)(((sd_status[2] & 0xFF000000U) >> 16U) | (sd_status[3] & 0xFFU));
+    pStatus->AllocationUnitSize = (uint8_t)((sd_status[2] & 0xF00000U) >> 20U);
-    pStatus->EraseTimeout = (uint8_t)((sd_status[3] & 0xFC00U) >> 10U);
+    pStatus->EraseSize = (uint16_t)(((sd_status[2] & 0xFF000000U) >> 16U) | (sd_status[3] & 0xFFU));
-    pStatus->EraseOffset = (uint8_t)((sd_status[3] & 0x0300U) >> 8U);
-  }
+    pStatus->EraseTimeout = (uint8_t)((sd_status[3] & 0xFC00U) >> 10U);
-  /* Set Block Size for Card */
+    pStatus->EraseOffset = (uint8_t)((sd_status[3] & 0x0300U) >> 8U);
-  errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
+  }
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Set Block Size for Card */
-    /* Clear all the static flags */
+  errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+  if(errorstate != HAL_SD_ERROR_NONE)
-    hsd->ErrorCode = errorstate;
+  {
-    hsd->State = HAL_SD_STATE_READY;
+    /* Clear all the static flags */
-    status = HAL_ERROR;
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-  }
+    hsd->ErrorCode = errorstate;
+    hsd->State = HAL_SD_STATE_READY;
-  return status;
+    status = HAL_ERROR;
-}
+  }
-/**
+  return status;
-  * @brief  Gets the SD card info.
+}
-  * @param  hsd: Pointer to SD handle
-  * @param  pCardInfo: Pointer to the HAL_SD_CardInfoTypeDef structure that
+/**
-  *         will contain the SD card status information
+  * @brief  Gets the SD card info.
-  * @retval HAL status
+  * @param  hsd: Pointer to SD handle
-  */
+  * @param  pCardInfo: Pointer to the HAL_SD_CardInfoTypeDef structure that
-HAL_StatusTypeDef HAL_SD_GetCardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypeDef *pCardInfo)
+  *         will contain the SD card status information
-{
+  * @retval HAL status
-  pCardInfo->CardType     = (uint32_t)(hsd->SdCard.CardType);
+  */
-  pCardInfo->CardVersion  = (uint32_t)(hsd->SdCard.CardVersion);
+HAL_StatusTypeDef HAL_SD_GetCardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypeDef *pCardInfo)
-  pCardInfo->Class        = (uint32_t)(hsd->SdCard.Class);
+{
-  pCardInfo->RelCardAdd   = (uint32_t)(hsd->SdCard.RelCardAdd);
+  pCardInfo->CardType     = (uint32_t)(hsd->SdCard.CardType);
-  pCardInfo->BlockNbr     = (uint32_t)(hsd->SdCard.BlockNbr);
+  pCardInfo->CardVersion  = (uint32_t)(hsd->SdCard.CardVersion);
-  pCardInfo->BlockSize    = (uint32_t)(hsd->SdCard.BlockSize);
+  pCardInfo->Class        = (uint32_t)(hsd->SdCard.Class);
-  pCardInfo->LogBlockNbr  = (uint32_t)(hsd->SdCard.LogBlockNbr);
+  pCardInfo->RelCardAdd   = (uint32_t)(hsd->SdCard.RelCardAdd);
-  pCardInfo->LogBlockSize = (uint32_t)(hsd->SdCard.LogBlockSize);
+  pCardInfo->BlockNbr     = (uint32_t)(hsd->SdCard.BlockNbr);
+  pCardInfo->BlockSize    = (uint32_t)(hsd->SdCard.BlockSize);
-  return HAL_OK;
+  pCardInfo->LogBlockNbr  = (uint32_t)(hsd->SdCard.LogBlockNbr);
-}
+  pCardInfo->LogBlockSize = (uint32_t)(hsd->SdCard.LogBlockSize);
-/**
+  return HAL_OK;
-  * @brief  Enables wide bus operation for the requested card if supported by
+}
-  *         card.
-  * @param  hsd: Pointer to SD handle
+/**
-  * @param  WideMode: Specifies the SD card wide bus mode
+  * @brief  Enables wide bus operation for the requested card if supported by
-  *          This parameter can be one of the following values:
+  *         card.
-  *            @arg SDIO_BUS_WIDE_8B: 8-bit data transfer
+  * @param  hsd: Pointer to SD handle
-  *            @arg SDIO_BUS_WIDE_4B: 4-bit data transfer
+  * @param  WideMode: Specifies the SD card wide bus mode
-  *            @arg SDIO_BUS_WIDE_1B: 1-bit data transfer
+  *          This parameter can be one of the following values:
-  * @retval HAL status
+  *            @arg SDIO_BUS_WIDE_8B: 8-bit data transfer
-  */
+  *            @arg SDIO_BUS_WIDE_4B: 4-bit data transfer
-HAL_StatusTypeDef HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef *hsd, uint32_t WideMode)
+  *            @arg SDIO_BUS_WIDE_1B: 1-bit data transfer
-{
+  * @retval HAL status
-  SDIO_InitTypeDef Init;
+  */
-  uint32_t errorstate;
+HAL_StatusTypeDef HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef *hsd, uint32_t WideMode)
-  HAL_StatusTypeDef status = HAL_OK;
+{
+  SDIO_InitTypeDef Init;
-  /* Check the parameters */
+  uint32_t errorstate;
-  assert_param(IS_SDIO_BUS_WIDE(WideMode));
+  HAL_StatusTypeDef status = HAL_OK;
-  /* Change State */
+  /* Check the parameters */
-  hsd->State = HAL_SD_STATE_BUSY;
+  assert_param(IS_SDIO_BUS_WIDE(WideMode));
-  if(hsd->SdCard.CardType != CARD_SECURED)
+  /* Change State */
-  {
+  hsd->State = HAL_SD_STATE_BUSY;
-    if(WideMode == SDIO_BUS_WIDE_8B)
-    {
+  if(hsd->SdCard.CardType != CARD_SECURED)
-      hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
+  {
-    }
+    if(WideMode == SDIO_BUS_WIDE_8B)
-    else if(WideMode == SDIO_BUS_WIDE_4B)
+    {
-    {
+      hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
-      errorstate = SD_WideBus_Enable(hsd);
+    }
+    else if(WideMode == SDIO_BUS_WIDE_4B)
-      hsd->ErrorCode |= errorstate;
+    {
-    }
+      errorstate = SD_WideBus_Enable(hsd);
-    else if(WideMode == SDIO_BUS_WIDE_1B)
-    {
+      hsd->ErrorCode |= errorstate;
-      errorstate = SD_WideBus_Disable(hsd);
+    }
+    else if(WideMode == SDIO_BUS_WIDE_1B)
-      hsd->ErrorCode |= errorstate;
+    {
-    }
+      errorstate = SD_WideBus_Disable(hsd);
-    else
-    {
+      hsd->ErrorCode |= errorstate;
-      /* WideMode is not a valid argument*/
+    }
-      hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
+    else
-    }
+    {
-  }
+      /* WideMode is not a valid argument*/
-  else
+      hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
-  {
+    }
-    /* MMC Card does not support this feature */
+  }
-    hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
+  else
-  }
+  {
+    /* MMC Card does not support this feature */
-  if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
+    hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
-  {
+  }
-    /* Clear all the static flags */
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+  if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
-    hsd->State = HAL_SD_STATE_READY;
+  {
-    status = HAL_ERROR;
+    /* Clear all the static flags */
-  }
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-  else
+    hsd->State = HAL_SD_STATE_READY;
-  {
+    status = HAL_ERROR;
-    /* Configure the SDIO peripheral */
+  }
-    Init.ClockEdge           = hsd->Init.ClockEdge;
+  else
-    Init.ClockBypass         = hsd->Init.ClockBypass;
+  {
-    Init.ClockPowerSave      = hsd->Init.ClockPowerSave;
+    /* Configure the SDIO peripheral */
-    Init.BusWide             = WideMode;
+    Init.ClockEdge           = hsd->Init.ClockEdge;
-    Init.HardwareFlowControl = hsd->Init.HardwareFlowControl;
+    Init.ClockBypass         = hsd->Init.ClockBypass;
-    Init.ClockDiv            = hsd->Init.ClockDiv;
+    Init.ClockPowerSave      = hsd->Init.ClockPowerSave;
-    (void)SDIO_Init(hsd->Instance, Init);
+    Init.BusWide             = WideMode;
-  }
+    Init.HardwareFlowControl = hsd->Init.HardwareFlowControl;
+    Init.ClockDiv            = hsd->Init.ClockDiv;
-  /* Set Block Size for Card */
+    (void)SDIO_Init(hsd->Instance, Init);
-  errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
+  }
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Set Block Size for Card */
-    /* Clear all the static flags */
+  errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+  if(errorstate != HAL_SD_ERROR_NONE)
-    hsd->ErrorCode |= errorstate;
+  {
-    status = HAL_ERROR;
+    /* Clear all the static flags */
-  }
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    hsd->ErrorCode |= errorstate;
-  /* Change State */
+    status = HAL_ERROR;
-  hsd->State = HAL_SD_STATE_READY;
+  }
-  return status;
+  /* Change State */
-}
+  hsd->State = HAL_SD_STATE_READY;
-/**
+  return status;
-  * @brief  Gets the current sd card data state.
+}
-  * @param  hsd: pointer to SD handle
-  * @retval Card state
+/**
-  */
+  * @brief  Gets the current sd card data state.
-HAL_SD_CardStateTypeDef HAL_SD_GetCardState(SD_HandleTypeDef *hsd)
+  * @param  hsd: pointer to SD handle
-{
+  * @retval Card state
-  uint32_t cardstate;
+  */
-  uint32_t errorstate;
+HAL_SD_CardStateTypeDef HAL_SD_GetCardState(SD_HandleTypeDef *hsd)
-  uint32_t resp1 = 0;
+{
+  uint32_t cardstate;
-  errorstate = SD_SendStatus(hsd, &resp1);
+  uint32_t errorstate;
-  if(errorstate != HAL_SD_ERROR_NONE)
+  uint32_t resp1 = 0;
-  {
-    hsd->ErrorCode |= errorstate;
+  errorstate = SD_SendStatus(hsd, &resp1);
-  }
+  if(errorstate != HAL_SD_ERROR_NONE)
+  {
-  cardstate = ((resp1 >> 9U) & 0x0FU);
+    hsd->ErrorCode |= errorstate;
+  }
-  return (HAL_SD_CardStateTypeDef)cardstate;
-}
+  cardstate = ((resp1 >> 9U) & 0x0FU);
-/**
+  return (HAL_SD_CardStateTypeDef)cardstate;
-  * @brief  Abort the current transfer and disable the SD.
+}
-  * @param  hsd: pointer to a SD_HandleTypeDef structure that contains
-  *                the configuration information for SD module.
+/**
-  * @retval HAL status
+  * @brief  Abort the current transfer and disable the SD.
-  */
+  * @param  hsd: pointer to a SD_HandleTypeDef structure that contains
-HAL_StatusTypeDef HAL_SD_Abort(SD_HandleTypeDef *hsd)
+  *                the configuration information for SD module.
-{
+  * @retval HAL status
-  HAL_SD_CardStateTypeDef CardState;
+  */
-  uint32_t context = hsd->Context;
+HAL_StatusTypeDef HAL_SD_Abort(SD_HandleTypeDef *hsd)
+{
-  /* DIsable All interrupts */
+  HAL_SD_CardStateTypeDef CardState;
-  __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
+  uint32_t context = hsd->Context;
-                           SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
+  /* DIsable All interrupts */
-  /* Clear All flags */
+  __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
-  __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
+                           SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
-  CLEAR_BIT(hsd->Instance->DCTRL, SDIO_DCTRL_DTEN);
+  /* Clear All flags */
+  __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
-  if ((context & SD_CONTEXT_DMA) != 0U)
-  {
+  CLEAR_BIT(hsd->Instance->DCTRL, SDIO_DCTRL_DTEN);
-    /* Disable the SD DMA request */
-    hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
+  if ((context & SD_CONTEXT_DMA) != 0U)
+  {
-    /* Abort the SD DMA Tx channel */
+    /* Disable the SD DMA request */
-    if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
+    hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
-    {
-      if(HAL_DMA_Abort(hsd->hdmatx) != HAL_OK)
+    /* Abort the SD DMA Tx channel */
-      {
+    if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
-        hsd->ErrorCode |= HAL_SD_ERROR_DMA;
+    {
-      }
+      if(HAL_DMA_Abort(hsd->hdmatx) != HAL_OK)
-    }
+      {
-    /* Abort the SD DMA Rx channel */
+        hsd->ErrorCode |= HAL_SD_ERROR_DMA;
-    else if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
+      }
-    {
+    }
-      if(HAL_DMA_Abort(hsd->hdmarx) != HAL_OK)
+    /* Abort the SD DMA Rx channel */
-      {
+    else if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
-        hsd->ErrorCode |= HAL_SD_ERROR_DMA;
+    {
-      }
+      if(HAL_DMA_Abort(hsd->hdmarx) != HAL_OK)
-    }
+      {
-    else
+        hsd->ErrorCode |= HAL_SD_ERROR_DMA;
-    {
+      }
-      /* Nothing to do */
+    }
-    }
+    else
-  }
+    {
+      /* Nothing to do */
-  hsd->State = HAL_SD_STATE_READY;
+    }
+  }
-  /* Initialize the SD operation */
-  hsd->Context = SD_CONTEXT_NONE;
+  hsd->State = HAL_SD_STATE_READY;
-  CardState = HAL_SD_GetCardState(hsd);
+  /* Initialize the SD operation */
-  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
+  hsd->Context = SD_CONTEXT_NONE;
-  {
-    hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
+  CardState = HAL_SD_GetCardState(hsd);
-  }
+  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
-  if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
+  {
-  {
+    hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
-    return HAL_ERROR;
+  }
-  }
+  if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
-  return HAL_OK;
+  {
-}
+    return HAL_ERROR;
+  }
-/**
+  return HAL_OK;
-  * @brief  Abort the current transfer and disable the SD (IT mode).
+}
-  * @param  hsd: pointer to a SD_HandleTypeDef structure that contains
-  *                the configuration information for SD module.
+/**
-  * @retval HAL status
+  * @brief  Abort the current transfer and disable the SD (IT mode).
-  */
+  * @param  hsd: pointer to a SD_HandleTypeDef structure that contains
-HAL_StatusTypeDef HAL_SD_Abort_IT(SD_HandleTypeDef *hsd)
+  *                the configuration information for SD module.
-{
+  * @retval HAL status
-  HAL_SD_CardStateTypeDef CardState;
+  */
-  uint32_t context = hsd->Context;
+HAL_StatusTypeDef HAL_SD_Abort_IT(SD_HandleTypeDef *hsd)
+{
-  /* Disable All interrupts */
+  HAL_SD_CardStateTypeDef CardState;
-  __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
+  uint32_t context = hsd->Context;
-                           SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
+  /* Disable All interrupts */
-  CLEAR_BIT(hsd->Instance->DCTRL, SDIO_DCTRL_DTEN);
+  __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
+                           SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
-  if ((context & SD_CONTEXT_DMA) != 0U)
-  {
+  CLEAR_BIT(hsd->Instance->DCTRL, SDIO_DCTRL_DTEN);
-    /* Disable the SD DMA request */
-    hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
+  if ((context & SD_CONTEXT_DMA) != 0U)
+  {
-    /* Abort the SD DMA Tx channel */
+    /* Disable the SD DMA request */
-    if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
+    hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
-    {
-      hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;
+    /* Abort the SD DMA Tx channel */
-      if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)
+    if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
-      {
+    {
-        hsd->hdmatx = NULL;
+      hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;
-      }
+      if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)
-    }
+      {
-    /* Abort the SD DMA Rx channel */
+        hsd->hdmatx = NULL;
-    else if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
+      }
-    {
+    }
-      hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;
+    /* Abort the SD DMA Rx channel */
-      if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)
+    else if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
-      {
+    {
-        hsd->hdmarx = NULL;
+      hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;
-      }
+      if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)
-    }
+      {
-    else
+        hsd->hdmarx = NULL;
-    {
+      }
-      /* Nothing to do */
+    }
-    }
+    else
-  }
+    {
-  /* No transfer ongoing on both DMA channels*/
+      /* Nothing to do */
-  else
+    }
-  {
+  }
-    /* Clear All flags */
+  /* No transfer ongoing on both DMA channels*/
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
+  else
+  {
-    CardState = HAL_SD_GetCardState(hsd);
+    /* Clear All flags */
-    hsd->State = HAL_SD_STATE_READY;
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
-    hsd->Context = SD_CONTEXT_NONE;
-    if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
+    CardState = HAL_SD_GetCardState(hsd);
-    {
+    hsd->State = HAL_SD_STATE_READY;
-      hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
+    hsd->Context = SD_CONTEXT_NONE;
-    }
+    if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
-    if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
+    {
-    {
+      hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
-      return HAL_ERROR;
+    }
-    }
+    if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
-    else
+    {
-    {
+      return HAL_ERROR;
-#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
+    }
-      hsd->AbortCpltCallback(hsd);
+    else
-#else
+    {
-      HAL_SD_AbortCallback(hsd);
+#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
-#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
+      hsd->AbortCpltCallback(hsd);
-    }
+#else
-  }
+      HAL_SD_AbortCallback(hsd);
+#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
-  return HAL_OK;
+    }
-}
+  }
-/**
+  return HAL_OK;
-  * @}
+}
-  */
+/**
-/**
+  * @}
-  * @}
+  */
-  */
+/**
-/* Private function ----------------------------------------------------------*/
+  * @}
-/** @addtogroup SD_Private_Functions
+  */
-  * @{
-  */
+/* Private function ----------------------------------------------------------*/
+/** @addtogroup SD_Private_Functions
-/**
+  * @{
-  * @brief  DMA SD transmit process complete callback
+  */
-  * @param  hdma: DMA handle
-  * @retval None
+/**
-  */
+  * @brief  DMA SD transmit process complete callback
-static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
+  * @param  hdma: DMA handle
-{
+  * @retval None
-  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
+  */
+static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
-  /* Enable DATAEND Interrupt */
+{
-  __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DATAEND));
+  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
-}
+  /* Enable DATAEND Interrupt */
-/**
+  __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DATAEND));
-  * @brief  DMA SD receive process complete callback
+}
-  * @param  hdma: DMA handle
-  * @retval None
+/**
-  */
+  * @brief  DMA SD receive process complete callback
-static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
+  * @param  hdma: DMA handle
-{
+  * @retval None
-  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
+  */
-  uint32_t errorstate;
+static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
+{
-  /* Send stop command in multiblock write */
+  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
-  if(hsd->Context == (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA))
+  uint32_t errorstate;
-  {
-    errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
+  /* Send stop command in multiblock write */
-    if(errorstate != HAL_SD_ERROR_NONE)
+  if(hsd->Context == (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA))
-    {
+  {
-      hsd->ErrorCode |= errorstate;
+    errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
-#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
+    if(errorstate != HAL_SD_ERROR_NONE)
-      hsd->ErrorCallback(hsd);
+    {
-#else
+      hsd->ErrorCode |= errorstate;
-      HAL_SD_ErrorCallback(hsd);
+#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
-#endif
+      hsd->ErrorCallback(hsd);
-    }
+#else
-  }
+      HAL_SD_ErrorCallback(hsd);
+#endif
-  /* Disable the DMA transfer for transmit request by setting the DMAEN bit
+    }
-  in the SD DCTRL register */
+  }
-  hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
+  /* Disable the DMA transfer for transmit request by setting the DMAEN bit
-  /* Clear all the static flags */
+  in the SD DCTRL register */
-  __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
+  hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
-  hsd->State = HAL_SD_STATE_READY;
+  /* Clear all the static flags */
-  hsd->Context = SD_CONTEXT_NONE;
+  __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
-#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
+  hsd->State = HAL_SD_STATE_READY;
-  hsd->RxCpltCallback(hsd);
+  hsd->Context = SD_CONTEXT_NONE;
-#else
-  HAL_SD_RxCpltCallback(hsd);
+#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
-#endif
+  hsd->RxCpltCallback(hsd);
-}
+#else
+  HAL_SD_RxCpltCallback(hsd);
-/**
+#endif
-  * @brief  DMA SD communication error callback
+}
-  * @param  hdma: DMA handle
-  * @retval None
+/**
-  */
+  * @brief  DMA SD communication error callback
-static void SD_DMAError(DMA_HandleTypeDef *hdma)
+  * @param  hdma: DMA handle
-{
+  * @retval None
-  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
+  */
-  HAL_SD_CardStateTypeDef CardState;
+static void SD_DMAError(DMA_HandleTypeDef *hdma)
-  uint32_t RxErrorCode, TxErrorCode;
+{
+  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
-    RxErrorCode = hsd->hdmarx->ErrorCode;
+  HAL_SD_CardStateTypeDef CardState;
-    TxErrorCode = hsd->hdmatx->ErrorCode;
+  uint32_t RxErrorCode, TxErrorCode;
-    if((RxErrorCode == HAL_DMA_ERROR_TE) || (TxErrorCode == HAL_DMA_ERROR_TE))
-    {
+    RxErrorCode = hsd->hdmarx->ErrorCode;
-      /* Clear All flags */
+    TxErrorCode = hsd->hdmatx->ErrorCode;
-      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
+    if((RxErrorCode == HAL_DMA_ERROR_TE) || (TxErrorCode == HAL_DMA_ERROR_TE))
+    {
-      /* Disable All interrupts */
+      /* Clear All flags */
-      __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
+      __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
-        SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
+      /* Disable All interrupts */
-      hsd->ErrorCode |= HAL_SD_ERROR_DMA;
+      __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
-      CardState = HAL_SD_GetCardState(hsd);
+        SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
-      if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
-      {
+      hsd->ErrorCode |= HAL_SD_ERROR_DMA;
-        hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
+      CardState = HAL_SD_GetCardState(hsd);
-      }
+      if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
+      {
-      hsd->State= HAL_SD_STATE_READY;
+        hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
-      hsd->Context = SD_CONTEXT_NONE;
+      }
-    }
+      hsd->State= HAL_SD_STATE_READY;
-#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
+      hsd->Context = SD_CONTEXT_NONE;
-    hsd->ErrorCallback(hsd);
+    }
-#else
-    HAL_SD_ErrorCallback(hsd);
+#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
-#endif
+    hsd->ErrorCallback(hsd);
-}
+#else
+    HAL_SD_ErrorCallback(hsd);
-/**
+#endif
-  * @brief  DMA SD Tx Abort callback
+}
-  * @param  hdma: DMA handle
-  * @retval None
+/**
-  */
+  * @brief  DMA SD Tx Abort callback
-static void SD_DMATxAbort(DMA_HandleTypeDef *hdma)
+  * @param  hdma: DMA handle
-{
+  * @retval None
-  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
+  */
-  HAL_SD_CardStateTypeDef CardState;
+static void SD_DMATxAbort(DMA_HandleTypeDef *hdma)
+{
-  /* Clear All flags */
+  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
-  __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
+  HAL_SD_CardStateTypeDef CardState;
-  CardState = HAL_SD_GetCardState(hsd);
+  /* Clear All flags */
-  hsd->State = HAL_SD_STATE_READY;
+  __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
-  hsd->Context = SD_CONTEXT_NONE;
-  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
+  CardState = HAL_SD_GetCardState(hsd);
-  {
+  hsd->State = HAL_SD_STATE_READY;
-    hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
+  hsd->Context = SD_CONTEXT_NONE;
-  }
+  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
+  {
-  if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
+    hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
-  {
+  }
-#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
-    hsd->AbortCpltCallback(hsd);
+  if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
-#else
+  {
-    HAL_SD_AbortCallback(hsd);
+#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
-#endif
+    hsd->AbortCpltCallback(hsd);
-  }
+#else
-  else
+    HAL_SD_AbortCallback(hsd);
-  {
+#endif
-#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
+  }
-    hsd->ErrorCallback(hsd);
+  else
-#else
+  {
-    HAL_SD_ErrorCallback(hsd);
+#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
-#endif
+    hsd->ErrorCallback(hsd);
-  }
+#else
-}
+    HAL_SD_ErrorCallback(hsd);
+#endif
-/**
+  }
-  * @brief  DMA SD Rx Abort callback
+}
-  * @param  hdma: DMA handle
-  * @retval None
+/**
-  */
+  * @brief  DMA SD Rx Abort callback
-static void SD_DMARxAbort(DMA_HandleTypeDef *hdma)
+  * @param  hdma: DMA handle
-{
+  * @retval None
-  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
+  */
-  HAL_SD_CardStateTypeDef CardState;
+static void SD_DMARxAbort(DMA_HandleTypeDef *hdma)
+{
-  /* Clear All flags */
+  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
-  __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
+  HAL_SD_CardStateTypeDef CardState;
-  CardState = HAL_SD_GetCardState(hsd);
+  /* Clear All flags */
-  hsd->State = HAL_SD_STATE_READY;
+  __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
-  hsd->Context = SD_CONTEXT_NONE;
-  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
+  CardState = HAL_SD_GetCardState(hsd);
-  {
+  hsd->State = HAL_SD_STATE_READY;
-    hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
+  hsd->Context = SD_CONTEXT_NONE;
-  }
+  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
+  {
-  if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
+    hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
-  {
+  }
-#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
-    hsd->AbortCpltCallback(hsd);
+  if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
-#else
+  {
-    HAL_SD_AbortCallback(hsd);
+#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
-#endif
+    hsd->AbortCpltCallback(hsd);
-  }
+#else
-  else
+    HAL_SD_AbortCallback(hsd);
-  {
+#endif
-#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
+  }
-    hsd->ErrorCallback(hsd);
+  else
-#else
+  {
-    HAL_SD_ErrorCallback(hsd);
+#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
-#endif
+    hsd->ErrorCallback(hsd);
-  }
+#else
-}
+    HAL_SD_ErrorCallback(hsd);
+#endif
-/**
+  }
-  * @brief  Initializes the sd card.
+}
-  * @param  hsd: Pointer to SD handle
-  * @retval SD Card error state
+/**
-  */
+  * @brief  Initializes the sd card.
-static uint32_t SD_InitCard(SD_HandleTypeDef *hsd)
+  * @param  hsd: Pointer to SD handle
-{
+  * @retval SD Card error state
-  HAL_SD_CardCSDTypeDef CSD;
+  */
-  uint32_t errorstate;
+static uint32_t SD_InitCard(SD_HandleTypeDef *hsd)
-  uint16_t sd_rca = 1U;
+{
+  HAL_SD_CardCSDTypeDef CSD;
-  /* Check the power State */
+  uint32_t errorstate;
-  if(SDIO_GetPowerState(hsd->Instance) == 0U)
+  uint16_t sd_rca = 1U;
-  {
-    /* Power off */
+  /* Check the power State */
-    return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
+  if(SDIO_GetPowerState(hsd->Instance) == 0U)
-  }
+  {
+    /* Power off */
-  if(hsd->SdCard.CardType != CARD_SECURED)
+    return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
-  {
+  }
-    /* Send CMD2 ALL_SEND_CID */
-    errorstate = SDMMC_CmdSendCID(hsd->Instance);
+  if(hsd->SdCard.CardType != CARD_SECURED)
-    if(errorstate != HAL_SD_ERROR_NONE)
+  {
-    {
+    /* Send CMD2 ALL_SEND_CID */
-      return errorstate;
+    errorstate = SDMMC_CmdSendCID(hsd->Instance);
-    }
+    if(errorstate != HAL_SD_ERROR_NONE)
-    else
+    {
-    {
+      return errorstate;
-      /* Get Card identification number data */
+    }
-      hsd->CID[0U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
+    else
-      hsd->CID[1U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);
+    {
-      hsd->CID[2U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);
+      /* Get Card identification number data */
-      hsd->CID[3U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);
+      hsd->CID[0U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
-    }
+      hsd->CID[1U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);
-  }
+      hsd->CID[2U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);
+      hsd->CID[3U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);
-  if(hsd->SdCard.CardType != CARD_SECURED)
+    }
-  {
+  }
-    /* Send CMD3 SET_REL_ADDR with argument 0 */
-    /* SD Card publishes its RCA. */
+  if(hsd->SdCard.CardType != CARD_SECURED)
-    errorstate = SDMMC_CmdSetRelAdd(hsd->Instance, &sd_rca);
+  {
-    if(errorstate != HAL_SD_ERROR_NONE)
+    /* Send CMD3 SET_REL_ADDR with argument 0 */
-    {
+    /* SD Card publishes its RCA. */
-      return errorstate;
+    errorstate = SDMMC_CmdSetRelAdd(hsd->Instance, &sd_rca);
-    }
+    if(errorstate != HAL_SD_ERROR_NONE)
-  }
+    {
-  if(hsd->SdCard.CardType != CARD_SECURED)
+      return errorstate;
-  {
+    }
-    /* Get the SD card RCA */
+  }
-    hsd->SdCard.RelCardAdd = sd_rca;
+  if(hsd->SdCard.CardType != CARD_SECURED)
+  {
-    /* Send CMD9 SEND_CSD with argument as card's RCA */
+    /* Get the SD card RCA */
-    errorstate = SDMMC_CmdSendCSD(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
+    hsd->SdCard.RelCardAdd = sd_rca;
-    if(errorstate != HAL_SD_ERROR_NONE)
-    {
+    /* Send CMD9 SEND_CSD with argument as card's RCA */
-      return errorstate;
+    errorstate = SDMMC_CmdSendCSD(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
-    }
+    if(errorstate != HAL_SD_ERROR_NONE)
-    else
+    {
-    {
+      return errorstate;
-      /* Get Card Specific Data */
+    }
-      hsd->CSD[0U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
+    else
-      hsd->CSD[1U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);
+    {
-      hsd->CSD[2U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);
+      /* Get Card Specific Data */
-      hsd->CSD[3U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);
+      hsd->CSD[0U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
-    }
+      hsd->CSD[1U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);
-  }
+      hsd->CSD[2U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);
+      hsd->CSD[3U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);
-  /* Get the Card Class */
+    }
-  hsd->SdCard.Class = (SDIO_GetResponse(hsd->Instance, SDIO_RESP2) >> 20U);
+  }
-  /* Get CSD parameters */
+  /* Get the Card Class */
-  if (HAL_SD_GetCardCSD(hsd, &CSD) != HAL_OK)
+  hsd->SdCard.Class = (SDIO_GetResponse(hsd->Instance, SDIO_RESP2) >> 20U);
-  {
-    return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
+  /* Get CSD parameters */
-  }
+  if (HAL_SD_GetCardCSD(hsd, &CSD) != HAL_OK)
+  {
-  /* Select the Card */
+    return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
-  errorstate = SDMMC_CmdSelDesel(hsd->Instance, (uint32_t)(((uint32_t)hsd->SdCard.RelCardAdd) << 16U));
+  }
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Select the Card */
-    return errorstate;
+  errorstate = SDMMC_CmdSelDesel(hsd->Instance, (uint32_t)(((uint32_t)hsd->SdCard.RelCardAdd) << 16U));
-  }
+  if(errorstate != HAL_SD_ERROR_NONE)
+  {
-  /* Configure SDIO peripheral interface */
+    return errorstate;
-  (void)SDIO_Init(hsd->Instance, hsd->Init);
+  }
-  /* All cards are initialized */
+  /* Configure SDIO peripheral interface */
-  return HAL_SD_ERROR_NONE;
+  (void)SDIO_Init(hsd->Instance, hsd->Init);
-}
+  /* All cards are initialized */
-/**
+  return HAL_SD_ERROR_NONE;
-  * @brief  Enquires cards about their operating voltage and configures clock
+}
-  *         controls and stores SD information that will be needed in future
-  *         in the SD handle.
+/**
-  * @param  hsd: Pointer to SD handle
+  * @brief  Enquires cards about their operating voltage and configures clock
-  * @retval error state
+  *         controls and stores SD information that will be needed in future
-  */
+  *         in the SD handle.
-static uint32_t SD_PowerON(SD_HandleTypeDef *hsd)
+  * @param  hsd: Pointer to SD handle
-{
+  * @retval error state
-  __IO uint32_t count = 0U;
+  */
-  uint32_t response = 0U, validvoltage = 0U;
+static uint32_t SD_PowerON(SD_HandleTypeDef *hsd)
-  uint32_t errorstate;
+{
+  __IO uint32_t count = 0U;
-  /* CMD0: GO_IDLE_STATE */
+  uint32_t response = 0U, validvoltage = 0U;
-  errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
+  uint32_t errorstate;
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* CMD0: GO_IDLE_STATE */
-    return errorstate;
+  errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
-  }
+  if(errorstate != HAL_SD_ERROR_NONE)
+  {
-  /* CMD8: SEND_IF_COND: Command available only on V2.0 cards */
+    return errorstate;
-  errorstate = SDMMC_CmdOperCond(hsd->Instance);
+  }
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* CMD8: SEND_IF_COND: Command available only on V2.0 cards */
-    hsd->SdCard.CardVersion = CARD_V1_X;
+  errorstate = SDMMC_CmdOperCond(hsd->Instance);
-    /* CMD0: GO_IDLE_STATE */
+  if(errorstate != HAL_SD_ERROR_NONE)
-    errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
+  {
-    if(errorstate != HAL_SD_ERROR_NONE)
+    hsd->SdCard.CardVersion = CARD_V1_X;
-    {
+    /* CMD0: GO_IDLE_STATE */
-      return errorstate;
+    errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
-    }
+    if(errorstate != HAL_SD_ERROR_NONE)
+    {
-  }
+      return errorstate;
-  else
+    }
-  {
-    hsd->SdCard.CardVersion = CARD_V2_X;
+  }
-  }
+  else
+  {
-  if( hsd->SdCard.CardVersion == CARD_V2_X)
+    hsd->SdCard.CardVersion = CARD_V2_X;
-  {
+  }
-    /* SEND CMD55 APP_CMD with RCA as 0 */
-    errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
+  if( hsd->SdCard.CardVersion == CARD_V2_X)
-    if(errorstate != HAL_SD_ERROR_NONE)
+  {
-    {
+    /* SEND CMD55 APP_CMD with RCA as 0 */
-      return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
+    errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
-    }
+    if(errorstate != HAL_SD_ERROR_NONE)
-  }
+    {
-  /* SD CARD */
+      return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
-  /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
+    }
-  while((count < SDMMC_MAX_VOLT_TRIAL) && (validvoltage == 0U))
+  }
-  {
+  /* SD CARD */
-    /* SEND CMD55 APP_CMD with RCA as 0 */
+  /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
-    errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
+  while((count < SDMMC_MAX_VOLT_TRIAL) && (validvoltage == 0U))
-    if(errorstate != HAL_SD_ERROR_NONE)
+  {
-    {
+    /* SEND CMD55 APP_CMD with RCA as 0 */
-      return errorstate;
+    errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
-    }
+    if(errorstate != HAL_SD_ERROR_NONE)
+    {
-    /* Send CMD41 */
+      return errorstate;
-    errorstate = SDMMC_CmdAppOperCommand(hsd->Instance, SDMMC_VOLTAGE_WINDOW_SD | SDMMC_HIGH_CAPACITY | SD_SWITCH_1_8V_CAPACITY);
+    }
-    if(errorstate != HAL_SD_ERROR_NONE)
-    {
+    /* Send CMD41 */
-      return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
+    errorstate = SDMMC_CmdAppOperCommand(hsd->Instance, SDMMC_VOLTAGE_WINDOW_SD | SDMMC_HIGH_CAPACITY | SD_SWITCH_1_8V_CAPACITY);
-    }
+    if(errorstate != HAL_SD_ERROR_NONE)
+    {
-    /* Get command response */
+      return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
-    response = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
+    }
-    /* Get operating voltage*/
+    /* Get command response */
-    validvoltage = (((response >> 31U) == 1U) ? 1U : 0U);
+    response = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
-    count++;
+    /* Get operating voltage*/
-  }
+    validvoltage = (((response >> 31U) == 1U) ? 1U : 0U);
-  if(count >= SDMMC_MAX_VOLT_TRIAL)
+    count++;
-  {
+  }
-    return HAL_SD_ERROR_INVALID_VOLTRANGE;
-  }
+  if(count >= SDMMC_MAX_VOLT_TRIAL)
+  {
-  if((response & SDMMC_HIGH_CAPACITY) == SDMMC_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
+    return HAL_SD_ERROR_INVALID_VOLTRANGE;
-  {
+  }
-    hsd->SdCard.CardType = CARD_SDHC_SDXC;
-  }
+  if((response & SDMMC_HIGH_CAPACITY) == SDMMC_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
-  else
+  {
-  {
+    hsd->SdCard.CardType = CARD_SDHC_SDXC;
-    hsd->SdCard.CardType = CARD_SDSC;
+  }
-  }
+  else
+  {
+    hsd->SdCard.CardType = CARD_SDSC;
-  return HAL_SD_ERROR_NONE;
+  }
-}
-/**
+  return HAL_SD_ERROR_NONE;
-  * @brief  Turns the SDIO output signals off.
+}
-  * @param  hsd: Pointer to SD handle
-  * @retval None
+/**
-  */
+  * @brief  Turns the SDIO output signals off.
-static void SD_PowerOFF(SD_HandleTypeDef *hsd)
+  * @param  hsd: Pointer to SD handle
-{
+  * @retval None
-  /* Set Power State to OFF */
+  */
-  (void)SDIO_PowerState_OFF(hsd->Instance);
+static void SD_PowerOFF(SD_HandleTypeDef *hsd)
-}
+{
+  /* Set Power State to OFF */
-/**
+  (void)SDIO_PowerState_OFF(hsd->Instance);
-  * @brief  Send Status info command.
+}
-  * @param  hsd: pointer to SD handle
-  * @param  pSDstatus: Pointer to the buffer that will contain the SD card status
+/**
-  *         SD Status register)
+  * @brief  Send Status info command.
-  * @retval error state
+  * @param  hsd: pointer to SD handle
-  */
+  * @param  pSDstatus: Pointer to the buffer that will contain the SD card status
-static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
+  *         SD Status register)
-{
+  * @retval error state
-  SDIO_DataInitTypeDef config;
+  */
-  uint32_t errorstate;
+static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
-  uint32_t tickstart = HAL_GetTick();
+{
-  uint32_t count;
+  SDIO_DataInitTypeDef config;
-  uint32_t *pData = pSDstatus;
+  uint32_t errorstate;
+  uint32_t tickstart = HAL_GetTick();
-  /* Check SD response */
+  uint32_t count;
-  if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
+  uint32_t *pData = pSDstatus;
-  {
-    return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
+  /* Check SD response */
-  }
+  if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
+  {
-  /* Set block size for card if it is not equal to current block size for card */
+    return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
-  errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U);
+  }
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Set block size for card if it is not equal to current block size for card */
-    hsd->ErrorCode |= HAL_SD_ERROR_NONE;
+  errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U);
-    return errorstate;
+  if(errorstate != HAL_SD_ERROR_NONE)
-  }
+  {
+    hsd->ErrorCode |= HAL_SD_ERROR_NONE;
-  /* Send CMD55 */
+    return errorstate;
-  errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
+  }
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Send CMD55 */
-    hsd->ErrorCode |= HAL_SD_ERROR_NONE;
+  errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
-    return errorstate;
+  if(errorstate != HAL_SD_ERROR_NONE)
-  }
+  {
+    hsd->ErrorCode |= HAL_SD_ERROR_NONE;
-  /* Configure the SD DPSM (Data Path State Machine) */
+    return errorstate;
-  config.DataTimeOut   = SDMMC_DATATIMEOUT;
+  }
-  config.DataLength    = 64U;
-  config.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
+  /* Configure the SD DPSM (Data Path State Machine) */
-  config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
+  config.DataTimeOut   = SDMMC_DATATIMEOUT;
-  config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
+  config.DataLength    = 64U;
-  config.DPSM          = SDIO_DPSM_ENABLE;
+  config.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
-  (void)SDIO_ConfigData(hsd->Instance, &config);
+  config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
+  config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
-  /* Send ACMD13 (SD_APP_STAUS)  with argument as card's RCA */
+  config.DPSM          = SDIO_DPSM_ENABLE;
-  errorstate = SDMMC_CmdStatusRegister(hsd->Instance);
+  (void)SDIO_ConfigData(hsd->Instance, &config);
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Send ACMD13 (SD_APP_STAUS)  with argument as card's RCA */
-    hsd->ErrorCode |= HAL_SD_ERROR_NONE;
+  errorstate = SDMMC_CmdStatusRegister(hsd->Instance);
-    return errorstate;
+  if(errorstate != HAL_SD_ERROR_NONE)
-  }
+  {
+    hsd->ErrorCode |= HAL_SD_ERROR_NONE;
-  /* Get status data */
+    return errorstate;
-  while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND))
+  }
-  {
-    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
+  /* Get status data */
-    {
+  while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND))
-      for(count = 0U; count < 8U; count++)
+  {
-      {
+    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
-        *pData = SDIO_ReadFIFO(hsd->Instance);
+    {
-        pData++;
+      for(count = 0U; count < 8U; count++)
-      }
+      {
-    }
+        *pData = SDIO_ReadFIFO(hsd->Instance);
+        pData++;
-    if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
+      }
-    {
+    }
-      return HAL_SD_ERROR_TIMEOUT;
-    }
+    if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
-  }
+    {
+      return HAL_SD_ERROR_TIMEOUT;
-  if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
+    }
-  {
+  }
-    return HAL_SD_ERROR_DATA_TIMEOUT;
-  }
+  if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
-  else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
+  {
-  {
+    return HAL_SD_ERROR_DATA_TIMEOUT;
-    return HAL_SD_ERROR_DATA_CRC_FAIL;
+  }
-  }
+  else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
-  else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
+  {
-  {
+    return HAL_SD_ERROR_DATA_CRC_FAIL;
-    return HAL_SD_ERROR_RX_OVERRUN;
+  }
-  }
+  else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
-  else
+  {
-  {
+    return HAL_SD_ERROR_RX_OVERRUN;
-    /* Nothing to do */
+  }
-  }
+  else
+  {
-  while ((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)))
+    /* Nothing to do */
-  {
+  }
-    *pData = SDIO_ReadFIFO(hsd->Instance);
-    pData++;
+  while ((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)))
+  {
-    if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
+    *pData = SDIO_ReadFIFO(hsd->Instance);
-    {
+    pData++;
-      return HAL_SD_ERROR_TIMEOUT;
-    }
+    if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
-  }
+    {
+      return HAL_SD_ERROR_TIMEOUT;
-  /* Clear all the static status flags*/
+    }
-  __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
+  }
-  return HAL_SD_ERROR_NONE;
+  /* Clear all the static status flags*/
-}
+  __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
-/**
+  return HAL_SD_ERROR_NONE;
-  * @brief  Returns the current card's status.
+}
-  * @param  hsd: Pointer to SD handle
-  * @param  pCardStatus: pointer to the buffer that will contain the SD card
+/**
-  *         status (Card Status register)
+  * @brief  Returns the current card's status.
-  * @retval error state
+  * @param  hsd: Pointer to SD handle
-  */
+  * @param  pCardStatus: pointer to the buffer that will contain the SD card
-static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
+  *         status (Card Status register)
-{
+  * @retval error state
-  uint32_t errorstate;
+  */
+static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
-  if(pCardStatus == NULL)
+{
-  {
+  uint32_t errorstate;
-    return HAL_SD_ERROR_PARAM;
-  }
+  if(pCardStatus == NULL)
+  {
-  /* Send Status command */
+    return HAL_SD_ERROR_PARAM;
-  errorstate = SDMMC_CmdSendStatus(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
+  }
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Send Status command */
-    return errorstate;
+  errorstate = SDMMC_CmdSendStatus(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
-  }
+  if(errorstate != HAL_SD_ERROR_NONE)
+  {
-  /* Get SD card status */
+    return errorstate;
-  *pCardStatus = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
+  }
-  return HAL_SD_ERROR_NONE;
+  /* Get SD card status */
-}
+  *pCardStatus = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
-/**
+  return HAL_SD_ERROR_NONE;
-  * @brief  Enables the SDIO wide bus mode.
+}
-  * @param  hsd: pointer to SD handle
-  * @retval error state
+/**
-  */
+  * @brief  Enables the SDIO wide bus mode.
-static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd)
+  * @param  hsd: pointer to SD handle
-{
+  * @retval error state
-  uint32_t scr[2U] = {0U, 0U};
+  */
-  uint32_t errorstate;
+static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd)
+{
-  if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
+  uint32_t scr[2U] = {0U, 0U};
-  {
+  uint32_t errorstate;
-    return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
-  }
+  if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
+  {
-  /* Get SCR Register */
+    return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
-  errorstate = SD_FindSCR(hsd, scr);
+  }
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Get SCR Register */
-    return errorstate;
+  errorstate = SD_FindSCR(hsd, scr);
-  }
+  if(errorstate != HAL_SD_ERROR_NONE)
+  {
-  /* If requested card supports wide bus operation */
+    return errorstate;
-  if((scr[1U] & SDMMC_WIDE_BUS_SUPPORT) != SDMMC_ALLZERO)
+  }
-  {
-    /* Send CMD55 APP_CMD with argument as card's RCA.*/
+  /* If requested card supports wide bus operation */
-    errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
+  if((scr[1U] & SDMMC_WIDE_BUS_SUPPORT) != SDMMC_ALLZERO)
-    if(errorstate != HAL_SD_ERROR_NONE)
+  {
-    {
+    /* Send CMD55 APP_CMD with argument as card's RCA.*/
-      return errorstate;
+    errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
-    }
+    if(errorstate != HAL_SD_ERROR_NONE)
+    {
-    /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
+      return errorstate;
-    errorstate = SDMMC_CmdBusWidth(hsd->Instance, 2U);
+    }
-    if(errorstate != HAL_SD_ERROR_NONE)
-    {
+    /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
-      return errorstate;
+    errorstate = SDMMC_CmdBusWidth(hsd->Instance, 2U);
-    }
+    if(errorstate != HAL_SD_ERROR_NONE)
+    {
-    return HAL_SD_ERROR_NONE;
+      return errorstate;
-  }
+    }
-  else
-  {
+    return HAL_SD_ERROR_NONE;
-    return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
+  }
-  }
+  else
-}
+  {
+    return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
-/**
+  }
-  * @brief  Disables the SDIO wide bus mode.
+}
-  * @param  hsd: Pointer to SD handle
-  * @retval error state
+/**
-  */
+  * @brief  Disables the SDIO wide bus mode.
-static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd)
+  * @param  hsd: Pointer to SD handle
-{
+  * @retval error state
-  uint32_t scr[2U] = {0U, 0U};
+  */
-  uint32_t errorstate;
+static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd)
+{
-  if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
+  uint32_t scr[2U] = {0U, 0U};
-  {
+  uint32_t errorstate;
-    return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
-  }
+  if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
+  {
-  /* Get SCR Register */
+    return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
-  errorstate = SD_FindSCR(hsd, scr);
+  }
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Get SCR Register */
-    return errorstate;
+  errorstate = SD_FindSCR(hsd, scr);
-  }
+  if(errorstate != HAL_SD_ERROR_NONE)
+  {
-  /* If requested card supports 1 bit mode operation */
+    return errorstate;
-  if((scr[1U] & SDMMC_SINGLE_BUS_SUPPORT) != SDMMC_ALLZERO)
+  }
-  {
-    /* Send CMD55 APP_CMD with argument as card's RCA */
+  /* If requested card supports 1 bit mode operation */
-    errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
+  if((scr[1U] & SDMMC_SINGLE_BUS_SUPPORT) != SDMMC_ALLZERO)
-    if(errorstate != HAL_SD_ERROR_NONE)
+  {
-    {
+    /* Send CMD55 APP_CMD with argument as card's RCA */
-      return errorstate;
+    errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
-    }
+    if(errorstate != HAL_SD_ERROR_NONE)
+    {
-    /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
+      return errorstate;
-    errorstate = SDMMC_CmdBusWidth(hsd->Instance, 0U);
+    }
-    if(errorstate != HAL_SD_ERROR_NONE)
-    {
+    /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
-      return errorstate;
+    errorstate = SDMMC_CmdBusWidth(hsd->Instance, 0U);
-    }
+    if(errorstate != HAL_SD_ERROR_NONE)
+    {
-    return HAL_SD_ERROR_NONE;
+      return errorstate;
-  }
+    }
-  else
-  {
+    return HAL_SD_ERROR_NONE;
-    return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
+  }
-  }
+  else
-}
+  {
+    return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
+  }
-/**
+}
-  * @brief  Finds the SD card SCR register value.
-  * @param  hsd: Pointer to SD handle
-  * @param  pSCR: pointer to the buffer that will contain the SCR value
+/**
-  * @retval error state
+  * @brief  Finds the SD card SCR register value.
-  */
+  * @param  hsd: Pointer to SD handle
-static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
+  * @param  pSCR: pointer to the buffer that will contain the SCR value
-{
+  * @retval error state
-  SDIO_DataInitTypeDef config;
+  */
-  uint32_t errorstate;
+static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
-  uint32_t tickstart = HAL_GetTick();
+{
-  uint32_t index = 0U;
+  SDIO_DataInitTypeDef config;
-  uint32_t tempscr[2U] = {0U, 0U};
+  uint32_t errorstate;
-  uint32_t *scr = pSCR;
+  uint32_t tickstart = HAL_GetTick();
+  uint32_t index = 0U;
-  /* Set Block Size To 8 Bytes */
+  uint32_t tempscr[2U] = {0U, 0U};
-  errorstate = SDMMC_CmdBlockLength(hsd->Instance, 8U);
+  uint32_t *scr = pSCR;
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Set Block Size To 8 Bytes */
-    return errorstate;
+  errorstate = SDMMC_CmdBlockLength(hsd->Instance, 8U);
-  }
+  if(errorstate != HAL_SD_ERROR_NONE)
+  {
-  /* Send CMD55 APP_CMD with argument as card's RCA */
+    return errorstate;
-  errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)((hsd->SdCard.RelCardAdd) << 16U));
+  }
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Send CMD55 APP_CMD with argument as card's RCA */
-    return errorstate;
+  errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)((hsd->SdCard.RelCardAdd) << 16U));
-  }
+  if(errorstate != HAL_SD_ERROR_NONE)
+  {
-  config.DataTimeOut   = SDMMC_DATATIMEOUT;
+    return errorstate;
-  config.DataLength    = 8U;
+  }
-  config.DataBlockSize = SDIO_DATABLOCK_SIZE_8B;
-  config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
+  config.DataTimeOut   = SDMMC_DATATIMEOUT;
-  config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
+  config.DataLength    = 8U;
-  config.DPSM          = SDIO_DPSM_ENABLE;
+  config.DataBlockSize = SDIO_DATABLOCK_SIZE_8B;
-  (void)SDIO_ConfigData(hsd->Instance, &config);
+  config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;
+  config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;
-  /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
+  config.DPSM          = SDIO_DPSM_ENABLE;
-  errorstate = SDMMC_CmdSendSCR(hsd->Instance);
+  (void)SDIO_ConfigData(hsd->Instance, &config);
-  if(errorstate != HAL_SD_ERROR_NONE)
-  {
+  /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
-    return errorstate;
+  errorstate = SDMMC_CmdSendSCR(hsd->Instance);
-  }
+  if(errorstate != HAL_SD_ERROR_NONE)
+  {
-  while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT))
+    return errorstate;
-  {
+  }
-    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL))
-    {
+  while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT))
-      *(tempscr + index) = SDIO_ReadFIFO(hsd->Instance);
+  {
-      index++;
+    if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL))
-    }
+    {
-    else if(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXACT))
+      *(tempscr + index) = SDIO_ReadFIFO(hsd->Instance);
-    {
+      index++;
-      break;
+    }
-    }
+    else if(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXACT))
+    {
-    if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
+      break;
-    {
+    }
-      return HAL_SD_ERROR_TIMEOUT;
-    }
+    if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
-  }
+    {
+      return HAL_SD_ERROR_TIMEOUT;
-  if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
+    }
-  {
+  }
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
+  if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
-    return HAL_SD_ERROR_DATA_TIMEOUT;
+  {
-  }
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
-  else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
-  {
+    return HAL_SD_ERROR_DATA_TIMEOUT;
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
+  }
+  else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
-    return HAL_SD_ERROR_DATA_CRC_FAIL;
+  {
-  }
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
-  else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
-  {
+    return HAL_SD_ERROR_DATA_CRC_FAIL;
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
+  }
+  else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
-    return HAL_SD_ERROR_RX_OVERRUN;
+  {
-  }
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
-  else
-  {
+    return HAL_SD_ERROR_RX_OVERRUN;
-    /* No error flag set */
+  }
-    /* Clear all the static flags */
+  else
-    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
+  {
+    /* No error flag set */
-    *scr = (((tempscr[1] & SDMMC_0TO7BITS) << 24)  | ((tempscr[1] & SDMMC_8TO15BITS) << 8) |\
+    /* Clear all the static flags */
-            ((tempscr[1] & SDMMC_16TO23BITS) >> 8) | ((tempscr[1] & SDMMC_24TO31BITS) >> 24));
+    __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
-    scr++;
-    *scr = (((tempscr[0] & SDMMC_0TO7BITS) << 24)  | ((tempscr[0] & SDMMC_8TO15BITS) << 8) |\
+    *scr = (((tempscr[1] & SDMMC_0TO7BITS) << 24)  | ((tempscr[1] & SDMMC_8TO15BITS) << 8) |\
-            ((tempscr[0] & SDMMC_16TO23BITS) >> 8) | ((tempscr[0] & SDMMC_24TO31BITS) >> 24));
+            ((tempscr[1] & SDMMC_16TO23BITS) >> 8) | ((tempscr[1] & SDMMC_24TO31BITS) >> 24));
+    scr++;
-  }
+    *scr = (((tempscr[0] & SDMMC_0TO7BITS) << 24)  | ((tempscr[0] & SDMMC_8TO15BITS) << 8) |\
+            ((tempscr[0] & SDMMC_16TO23BITS) >> 8) | ((tempscr[0] & SDMMC_24TO31BITS) >> 24));
-  return HAL_SD_ERROR_NONE;
-}
+  }
-/**
+  return HAL_SD_ERROR_NONE;
-  * @brief  Wrap up reading in non-blocking mode.
+}
-  * @param  hsd: pointer to a SD_HandleTypeDef structure that contains
-  *              the configuration information.
+/**
-  * @retval None
+  * @brief  Wrap up reading in non-blocking mode.
-  */
+  * @param  hsd: pointer to a SD_HandleTypeDef structure that contains
-static void SD_Read_IT(SD_HandleTypeDef *hsd)
+  *              the configuration information.
-{
+  * @retval None
-  uint32_t count, data, dataremaining;
+  */
-  uint8_t* tmp;
+static void SD_Read_IT(SD_HandleTypeDef *hsd)
+{
-  tmp = hsd->pRxBuffPtr;
+  uint32_t count, data, dataremaining;
-  dataremaining = hsd->RxXferSize;
+  uint8_t* tmp;
-  if (dataremaining > 0U)
+  tmp = hsd->pRxBuffPtr;
-  {
+  dataremaining = hsd->RxXferSize;
-    /* Read data from SDIO Rx FIFO */
-    for(count = 0U; count < 8U; count++)
+  if (dataremaining > 0U)
-    {
+  {
-      data = SDIO_ReadFIFO(hsd->Instance);
+    /* Read data from SDIO Rx FIFO */
-      *tmp = (uint8_t)(data & 0xFFU);
+    for(count = 0U; count < 8U; count++)
-      tmp++;
+    {
-      dataremaining--;
+      data = SDIO_ReadFIFO(hsd->Instance);
-      *tmp = (uint8_t)((data >> 8U) & 0xFFU);
+      *tmp = (uint8_t)(data & 0xFFU);
       tmp++;
       dataremaining--;
-      *tmp = (uint8_t)((data >> 16U) & 0xFFU);
+      *tmp = (uint8_t)((data >> 8U) & 0xFFU);
       tmp++;
       dataremaining--;
-      *tmp = (uint8_t)((data >> 24U) & 0xFFU);
+      *tmp = (uint8_t)((data >> 16U) & 0xFFU);
       tmp++;
       dataremaining--;
-    }
+      *tmp = (uint8_t)((data >> 24U) & 0xFFU);
+      tmp++;
-    hsd->pRxBuffPtr = tmp;
+      dataremaining--;
-    hsd->RxXferSize = dataremaining;
+    }
-  }
-}
+    hsd->pRxBuffPtr = tmp;
+    hsd->RxXferSize = dataremaining;
-/**
+  }
-  * @brief  Wrap up writing in non-blocking mode.
+}
-  * @param  hsd: pointer to a SD_HandleTypeDef structure that contains
-  *              the configuration information.
+/**
-  * @retval None
+  * @brief  Wrap up writing in non-blocking mode.
-  */
+  * @param  hsd: pointer to a SD_HandleTypeDef structure that contains
-static void SD_Write_IT(SD_HandleTypeDef *hsd)
+  *              the configuration information.
-{
+  * @retval None
-  uint32_t count, data, dataremaining;
+  */
-  uint8_t* tmp;
+static void SD_Write_IT(SD_HandleTypeDef *hsd)
+{
-  tmp = hsd->pTxBuffPtr;
+  uint32_t count, data, dataremaining;
-  dataremaining = hsd->TxXferSize;
+  uint8_t* tmp;
-  if (dataremaining > 0U)
+  tmp = hsd->pTxBuffPtr;
-  {
+  dataremaining = hsd->TxXferSize;
-    /* Write data to SDIO Tx FIFO */
-    for(count = 0U; count < 8U; count++)
+  if (dataremaining > 0U)
-    {
+  {
-      data = (uint32_t)(*tmp);
+    /* Write data to SDIO Tx FIFO */
-      tmp++;
+    for(count = 0U; count < 8U; count++)
-      dataremaining--;
+    {
-      data |= ((uint32_t)(*tmp) << 8U);
+      data = (uint32_t)(*tmp);
       tmp++;
       dataremaining--;
-      data |= ((uint32_t)(*tmp) << 16U);
+      data |= ((uint32_t)(*tmp) << 8U);
       tmp++;
       dataremaining--;
-      data |= ((uint32_t)(*tmp) << 24U);
+      data |= ((uint32_t)(*tmp) << 16U);
       tmp++;
       dataremaining--;
-      (void)SDIO_WriteFIFO(hsd->Instance, &data);
+      data |= ((uint32_t)(*tmp) << 24U);
-    }
+      tmp++;
+      dataremaining--;
-    hsd->pTxBuffPtr = tmp;
+      (void)SDIO_WriteFIFO(hsd->Instance, &data);
-    hsd->TxXferSize = dataremaining;
+    }
-  }
-}
+    hsd->pTxBuffPtr = tmp;
+    hsd->TxXferSize = dataremaining;
-/**
+  }
-  * @}
+}
-  */
+/**
-#endif /* HAL_SD_MODULE_ENABLED */
+  * @}
+  */
-/**
-  * @}
+#endif /* HAL_SD_MODULE_ENABLED */
-  */
+/**
-/**
+  * @}
-  * @}
+  */
-  */
+/**
-#endif /* SDIO */
+  * @}
+  */
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+#endif /* SDIO */

Subversion Repositories canSerial

(root)/trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_sd.c – Rev 2 → 3