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

 /**
   ******************************************************************************
   * @file    stm32f1xx_ll_sdmmc.c
   * @author  MCD Application Team
   * @brief   SDMMC Low Layer HAL module driver.
   *
   *          This file provides firmware functions to manage the following
   *          functionalities of the SDMMC peripheral:
   *           + Initialization/de-initialization functions
   *           + I/O operation functions
   *           + Peripheral Control functions
   *           + Peripheral State functions
   *
-  @verbatim
+  ******************************************************************************
-  ==============================================================================
+  * @attention
-                       ##### SDMMC peripheral features #####
+  *
-  ==============================================================================
+  * Copyright (c) 2016 STMicroelectronics.
-    [..] The SD/SDMMC MMC card host interface (SDMMC) provides an interface between the AHB
+  * All rights reserved.
-         peripheral bus and MultiMedia cards (MMCs), SD memory cards, SDMMC cards and CE-ATA
+  *
-         devices.
+  * This software is licensed under terms that can be found in the LICENSE file
+  * in the root directory of this software component.
-    [..] The SDMMC features include the following:
+  * If no LICENSE file comes with this software, it is provided AS-IS.
-         (+) Full compliance with MultiMedia Card System Specification Version 4.2. Card support
+  *
-             for three different databus modes: 1-bit (default), 4-bit and 8-bit
+  ******************************************************************************
-         (+) Full compatibility with previous versions of MultiMedia Cards (forward compatibility)
+  @verbatim
-         (+) Full compliance with SD Memory Card Specifications Version 2.0
+  ==============================================================================
-         (+) Full compliance with SD I/O Card Specification Version 2.0: card support for two
+                       ##### SDMMC peripheral features #####
-             different data bus modes: 1-bit (default) and 4-bit
+  ==============================================================================
-         (+) Full support of the CE-ATA features (full compliance with CE-ATA digital protocol
+    [..] The SD/SDMMC MMC card host interface (SDMMC) provides an interface between the AHB
-             Rev1.1)
+         peripheral bus and MultiMedia cards (MMCs), SD memory cards, SDMMC cards and CE-ATA
-         (+) Data transfer up to 48 MHz for the 8 bit mode
+         devices.
-         (+) Data and command output enable signals to control external bidirectional drivers
+    [..] The SDMMC features include the following:
-                           ##### How to use this driver #####
+         (+) Full compliance with MultiMedia Card System Specification Version 4.2. Card support
-  ==============================================================================
+             for three different databus modes: 1-bit (default), 4-bit and 8-bit
-    [..]
+         (+) Full compatibility with previous versions of MultiMedia Cards (forward compatibility)
-      This driver is a considered as a driver of service for external devices drivers
+         (+) Full compliance with SD Memory Card Specifications Version 2.0
-      that interfaces with the SDMMC peripheral.
+         (+) Full compliance with SD I/O Card Specification Version 2.0: card support for two
-      According to the device used (SD card/ MMC card / SDMMC card ...), a set of APIs
+             different data bus modes: 1-bit (default) and 4-bit
-      is used in the device's driver to perform SDMMC operations and functionalities.
+         (+) Full support of the CE-ATA features (full compliance with CE-ATA digital protocol
+             Rev1.1)
-      This driver is almost transparent for the final user, it is only used to implement other
+         (+) Data transfer up to 48 MHz for the 8 bit mode
-      functionalities of the external device.
+         (+) Data and command output enable signals to control external bidirectional drivers
-    [..]
+                           ##### How to use this driver #####
-      (+) The SDMMC clock (SDMMCCLK = 48 MHz) is coming from a specific output (MSI, PLLUSB1CLK,
+  ==============================================================================
-          PLLUSB2CLK). Before start working with SDMMC peripheral make sure that the
+    [..]
-          PLL is well configured.
+      This driver is a considered as a driver of service for external devices drivers
-          The SDMMC peripheral uses two clock signals:
+      that interfaces with the SDMMC peripheral.
-          (++) SDMMC adapter clock (SDMMCCLK = 48 MHz)
+      According to the device used (SD card/ MMC card / SDMMC card ...), a set of APIs
-          (++) APB2 bus clock (PCLK2)
+      is used in the device's driver to perform SDMMC operations and functionalities.
-          -@@- PCLK2 and SDMMC_CK clock frequencies must respect the following condition:
+      This driver is almost transparent for the final user, it is only used to implement other
-               Frequency(PCLK2) >= (3 / 8 x Frequency(SDMMC_CK))
+      functionalities of the external device.
-      (+) Enable/Disable peripheral clock using RCC peripheral macros related to SDMMC
+    [..]
-          peripheral.
+      (+) The SDMMC clock (SDMMCCLK = 48 MHz) is coming from a specific output (MSI, PLLUSB1CLK,
+          PLLUSB2CLK). Before start working with SDMMC peripheral make sure that the
-      (+) Enable the Power ON State using the SDIO_PowerState_ON()
+          PLL is well configured.
-          function and disable it using the function SDIO_PowerState_OFF().
+          The SDMMC peripheral uses two clock signals:
+          (++) SDMMC adapter clock (SDMMCCLK = 48 MHz)
-      (+) Enable/Disable the clock using the __SDIO_ENABLE()/__SDIO_DISABLE() macros.
+          (++) APB2 bus clock (PCLK2)
-      (+) Enable/Disable the peripheral interrupts using the macros __SDIO_ENABLE_IT()
+          -@@- PCLK2 and SDMMC_CK clock frequencies must respect the following condition:
-          and __SDIO_DISABLE_IT() if you need to use interrupt mode.
+               Frequency(PCLK2) >= (3 / 8 x Frequency(SDMMC_CK))
-      (+) When using the DMA mode
+      (+) Enable/Disable peripheral clock using RCC peripheral macros related to SDMMC
-          (++) Configure the DMA in the MSP layer of the external device
+          peripheral.
-          (++) Active the needed channel Request
-          (++) Enable the DMA using __SDIO_DMA_ENABLE() macro or Disable it using the macro
+      (+) Enable the Power ON State using the SDIO_PowerState_ON()
-               __SDIO_DMA_DISABLE().
+          function and disable it using the function SDIO_PowerState_OFF().
-      (+) To control the CPSM (Command Path State Machine) and send
+      (+) Enable/Disable the clock using the __SDIO_ENABLE()/__SDIO_DISABLE() macros.
-          commands to the card use the SDIO_SendCommand(),
-          SDIO_GetCommandResponse() and SDIO_GetResponse() functions. First, user has
+      (+) Enable/Disable the peripheral interrupts using the macros __SDIO_ENABLE_IT()
-          to fill the command structure (pointer to SDIO_CmdInitTypeDef) according
+          and __SDIO_DISABLE_IT() if you need to use interrupt mode.
-          to the selected command to be sent.
-          The parameters that should be filled are:
+      (+) When using the DMA mode
-           (++) Command Argument
+          (++) Configure the DMA in the MSP layer of the external device
-           (++) Command Index
+          (++) Active the needed channel Request
-           (++) Command Response type
+          (++) Enable the DMA using __SDIO_DMA_ENABLE() macro or Disable it using the macro
-           (++) Command Wait
+               __SDIO_DMA_DISABLE().
-           (++) CPSM Status (Enable or Disable).
+      (+) To control the CPSM (Command Path State Machine) and send
-          -@@- To check if the command is well received, read the SDIO_CMDRESP
+          commands to the card use the SDIO_SendCommand(),
-              register using the SDIO_GetCommandResponse().
+          SDIO_GetCommandResponse() and SDIO_GetResponse() functions. First, user has
-              The SDMMC responses registers (SDIO_RESP1 to SDIO_RESP2), use the
+          to fill the command structure (pointer to SDIO_CmdInitTypeDef) according
-              SDIO_GetResponse() function.
+          to the selected command to be sent.
+          The parameters that should be filled are:
-      (+) To control the DPSM (Data Path State Machine) and send/receive
+           (++) Command Argument
-           data to/from the card use the SDIO_DataConfig(), SDIO_GetDataCounter(),
+           (++) Command Index
-          SDIO_ReadFIFO(), SDIO_WriteFIFO() and SDIO_GetFIFOCount() functions.
+           (++) Command Response type
+           (++) Command Wait
-    *** Read Operations ***
+           (++) CPSM Status (Enable or Disable).
-    =======================
-    [..]
+          -@@- To check if the command is well received, read the SDIO_CMDRESP
-      (#) First, user has to fill the data structure (pointer to
+              register using the SDIO_GetCommandResponse().
-          SDIO_DataInitTypeDef) according to the selected data type to be received.
+              The SDMMC responses registers (SDIO_RESP1 to SDIO_RESP2), use the
-          The parameters that should be filled are:
+              SDIO_GetResponse() function.
-           (++) Data TimeOut
-           (++) Data Length
+      (+) To control the DPSM (Data Path State Machine) and send/receive
-           (++) Data Block size
+           data to/from the card use the SDIO_DataConfig(), SDIO_GetDataCounter(),
-           (++) Data Transfer direction: should be from card (To SDMMC)
+          SDIO_ReadFIFO(), SDIO_WriteFIFO() and SDIO_GetFIFOCount() functions.
-           (++) Data Transfer mode
-           (++) DPSM Status (Enable or Disable)
+    *** Read Operations ***
+    =======================
-      (#) Configure the SDMMC resources to receive the data from the card
+    [..]
-          according to selected transfer mode (Refer to Step 8, 9 and 10).
+      (#) First, user has to fill the data structure (pointer to
+          SDIO_DataInitTypeDef) according to the selected data type to be received.
-      (#) Send the selected Read command (refer to step 11).
+          The parameters that should be filled are:
+           (++) Data TimeOut
-      (#) Use the SDIO flags/interrupts to check the transfer status.
+           (++) Data Length
+           (++) Data Block size
-    *** Write Operations ***
+           (++) Data Transfer direction: should be from card (To SDMMC)
-    ========================
+           (++) Data Transfer mode
-    [..]
+           (++) DPSM Status (Enable or Disable)
-     (#) First, user has to fill the data structure (pointer to
-         SDIO_DataInitTypeDef) according to the selected data type to be received.
+      (#) Configure the SDMMC resources to receive the data from the card
-         The parameters that should be filled are:
+          according to selected transfer mode (Refer to Step 8, 9 and 10).
-          (++) Data TimeOut
-          (++) Data Length
+      (#) Send the selected Read command (refer to step 11).
-          (++) Data Block size
-          (++) Data Transfer direction:  should be to card (To CARD)
+      (#) Use the SDIO flags/interrupts to check the transfer status.
-          (++) Data Transfer mode
-          (++) DPSM Status (Enable or Disable)
+    *** Write Operations ***
+    ========================
-     (#) Configure the SDMMC resources to send the data to the card according to
+    [..]
-         selected transfer mode.
+     (#) First, user has to fill the data structure (pointer to
+         SDIO_DataInitTypeDef) according to the selected data type to be received.
-     (#) Send the selected Write command.
+         The parameters that should be filled are:
+          (++) Data TimeOut
-     (#) Use the SDIO flags/interrupts to check the transfer status.
+          (++) Data Length
+          (++) Data Block size
-    *** Command management operations ***
+          (++) Data Transfer direction:  should be to card (To CARD)
-    =====================================
+          (++) Data Transfer mode
-    [..]
+          (++) DPSM Status (Enable or Disable)
-     (#) The commands used for Read/Write/Erase operations are managed in
-         separate functions.
+     (#) Configure the SDMMC resources to send the data to the card according to
-         Each function allows to send the needed command with the related argument,
+         selected transfer mode.
-         then check the response.
-         By the same approach, you could implement a command and check the response.
+     (#) Send the selected Write command.
-  @endverbatim
+     (#) Use the SDIO flags/interrupts to check the transfer status.
-  ******************************************************************************
-  * @attention
+    *** Command management operations ***
-  *
+    =====================================
-  * <h2><center>&copy; Copyright (c) 2018 STMicroelectronics.
+    [..]
-  * All rights reserved.</center></h2>
+     (#) The commands used for Read/Write/Erase operations are managed in
-  *
+         separate functions.
-  * This software component is licensed by ST under BSD 3-Clause license,
+         Each function allows to send the needed command with the related argument,
-  * the "License"; You may not use this file except in compliance with the
+         then check the response.
-  * License. You may obtain a copy of the License at:
+         By the same approach, you could implement a command and check the response.
-  *                       opensource.org/licenses/BSD-3-Clause
-  *
+  @endverbatim
   ******************************************************************************
   */
 /* Includes ------------------------------------------------------------------*/
 #include "stm32f1xx_hal.h"
 #if defined(SDIO)
 /** @addtogroup STM32F1xx_HAL_Driver
   * @{
   */
 /** @defgroup SDMMC_LL SDMMC Low Layer
   * @brief Low layer module for SD
   * @{
   */
 #if defined(HAL_SD_MODULE_ENABLED) || defined(HAL_MMC_MODULE_ENABLED)
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 /* Private function prototypes -----------------------------------------------*/
 static uint32_t SDMMC_GetCmdError(SDIO_TypeDef *SDIOx);
-static uint32_t SDMMC_GetCmdResp1(SDIO_TypeDef *SDIOx, uint8_t SD_CMD, uint32_t Timeout);
-static uint32_t SDMMC_GetCmdResp2(SDIO_TypeDef *SDIOx);
+/* Exported functions --------------------------------------------------------*/
-static uint32_t SDMMC_GetCmdResp3(SDIO_TypeDef *SDIOx);
-static uint32_t SDMMC_GetCmdResp7(SDIO_TypeDef *SDIOx);
+/** @defgroup SDMMC_LL_Exported_Functions SDMMC Low Layer Exported Functions
-static uint32_t SDMMC_GetCmdResp6(SDIO_TypeDef *SDIOx, uint8_t SD_CMD, uint16_t *pRCA);
+  * @{
+  */
-/* Exported functions --------------------------------------------------------*/
+/** @defgroup HAL_SDMMC_LL_Group1 Initialization de-initialization functions
-/** @defgroup SDMMC_LL_Exported_Functions SDMMC Low Layer Exported Functions
+ *  @brief    Initialization and Configuration functions
-  * @{
+ *
-  */
+@verbatim
+ ===============================================================================
-/** @defgroup HAL_SDMMC_LL_Group1 Initialization de-initialization functions
+              ##### Initialization/de-initialization functions #####
- *  @brief    Initialization and Configuration functions
+ ===============================================================================
- *
+    [..]  This section provides functions allowing to:
-@verbatim
- ===============================================================================
+@endverbatim
-              ##### Initialization/de-initialization functions #####
+  * @{
- ===============================================================================
+  */
-    [..]  This section provides functions allowing to:
+/**
-@endverbatim
+  * @brief  Initializes the SDMMC according to the specified
-  * @{
+  *         parameters in the SDMMC_InitTypeDef and create the associated handle.
-  */
+  * @param  SDIOx: Pointer to SDMMC register base
+  * @param  Init: SDMMC initialization structure
-/**
+  * @retval HAL status
-  * @brief  Initializes the SDMMC according to the specified
+  */
-  *         parameters in the SDMMC_InitTypeDef and create the associated handle.
+HAL_StatusTypeDef SDIO_Init(SDIO_TypeDef *SDIOx, SDIO_InitTypeDef Init)
-  * @param  SDIOx: Pointer to SDMMC register base
+{
-  * @param  Init: SDMMC initialization structure
+  uint32_t tmpreg = 0;
-  * @retval HAL status
-  */
+  /* Check the parameters */
-HAL_StatusTypeDef SDIO_Init(SDIO_TypeDef *SDIOx, SDIO_InitTypeDef Init)
+  assert_param(IS_SDIO_ALL_INSTANCE(SDIOx));
-{
+  assert_param(IS_SDIO_CLOCK_EDGE(Init.ClockEdge));
-  uint32_t tmpreg = 0;
+  assert_param(IS_SDIO_CLOCK_BYPASS(Init.ClockBypass));
+  assert_param(IS_SDIO_CLOCK_POWER_SAVE(Init.ClockPowerSave));
-  /* Check the parameters */
+  assert_param(IS_SDIO_BUS_WIDE(Init.BusWide));
-  assert_param(IS_SDIO_ALL_INSTANCE(SDIOx));
+  assert_param(IS_SDIO_HARDWARE_FLOW_CONTROL(Init.HardwareFlowControl));
-  assert_param(IS_SDIO_CLOCK_EDGE(Init.ClockEdge));
+  assert_param(IS_SDIO_CLKDIV(Init.ClockDiv));
-  assert_param(IS_SDIO_CLOCK_BYPASS(Init.ClockBypass));
-  assert_param(IS_SDIO_CLOCK_POWER_SAVE(Init.ClockPowerSave));
+  /* Set SDMMC configuration parameters */
-  assert_param(IS_SDIO_BUS_WIDE(Init.BusWide));
+  tmpreg |= (Init.ClockEdge           |\
-  assert_param(IS_SDIO_HARDWARE_FLOW_CONTROL(Init.HardwareFlowControl));
+             Init.ClockBypass         |\
-  assert_param(IS_SDIO_CLKDIV(Init.ClockDiv));
+             Init.ClockPowerSave      |\
+             Init.BusWide             |\
-  /* Set SDMMC configuration parameters */
+             Init.HardwareFlowControl |\
-  tmpreg |= (Init.ClockEdge           |\
+             Init.ClockDiv
-             Init.ClockBypass         |\
+             );
-             Init.ClockPowerSave      |\
-             Init.BusWide             |\
+  /* Write to SDMMC CLKCR */
-             Init.HardwareFlowControl |\
+  MODIFY_REG(SDIOx->CLKCR, CLKCR_CLEAR_MASK, tmpreg);
-             Init.ClockDiv
-             );
+  return HAL_OK;
+}
-  /* Write to SDMMC CLKCR */
-  MODIFY_REG(SDIOx->CLKCR, CLKCR_CLEAR_MASK, tmpreg);
+/**
-  return HAL_OK;
+  * @}
-}
+  */
+/** @defgroup HAL_SDMMC_LL_Group2 IO operation functions
-/**
+ *  @brief   Data transfers functions
-  * @}
+ *
-  */
+@verbatim
+ ===============================================================================
-/** @defgroup HAL_SDMMC_LL_Group2 IO operation functions
+                      ##### I/O operation functions #####
- *  @brief   Data transfers functions
+ ===============================================================================
- *
+    [..]
-@verbatim
+    This subsection provides a set of functions allowing to manage the SDMMC data
- ===============================================================================
+    transfers.
-                      ##### I/O operation functions #####
- ===============================================================================
+@endverbatim
-    [..]
+  * @{
-    This subsection provides a set of functions allowing to manage the SDMMC data
+  */
-    transfers.
+/**
-@endverbatim
+  * @brief  Read data (word) from Rx FIFO in blocking mode (polling)
-  * @{
+  * @param  SDIOx: Pointer to SDMMC register base
-  */
+  * @retval HAL status
+  */
-/**
+uint32_t SDIO_ReadFIFO(SDIO_TypeDef *SDIOx)
-  * @brief  Read data (word) from Rx FIFO in blocking mode (polling)
+{
-  * @param  SDIOx: Pointer to SDMMC register base
+  /* Read data from Rx FIFO */
-  * @retval HAL status
+  return (SDIOx->FIFO);
-  */
+}
-uint32_t SDIO_ReadFIFO(SDIO_TypeDef *SDIOx)
-{
+/**
-  /* Read data from Rx FIFO */
+  * @brief  Write data (word) to Tx FIFO in blocking mode (polling)
-  return (SDIOx->FIFO);
+  * @param  SDIOx: Pointer to SDMMC register base
-}
+  * @param  pWriteData: pointer to data to write
+  * @retval HAL status
-/**
+  */
-  * @brief  Write data (word) to Tx FIFO in blocking mode (polling)
+HAL_StatusTypeDef SDIO_WriteFIFO(SDIO_TypeDef *SDIOx, uint32_t *pWriteData)
-  * @param  SDIOx: Pointer to SDMMC register base
+{
-  * @param  pWriteData: pointer to data to write
+  /* Write data to FIFO */
-  * @retval HAL status
+  SDIOx->FIFO = *pWriteData;
-  */
-HAL_StatusTypeDef SDIO_WriteFIFO(SDIO_TypeDef *SDIOx, uint32_t *pWriteData)
+  return HAL_OK;
-{
+}
-  /* Write data to FIFO */
-  SDIOx->FIFO = *pWriteData;
+/**
+  * @}
-  return HAL_OK;
+  */
-}
+/** @defgroup HAL_SDMMC_LL_Group3 Peripheral Control functions
-/**
+ *  @brief   management functions
-  * @}
+ *
-  */
+@verbatim
+ ===============================================================================
-/** @defgroup HAL_SDMMC_LL_Group3 Peripheral Control functions
+                      ##### Peripheral Control functions #####
- *  @brief   management functions
+ ===============================================================================
- *
+    [..]
-@verbatim
+    This subsection provides a set of functions allowing to control the SDMMC data
- ===============================================================================
+    transfers.
-                      ##### Peripheral Control functions #####
- ===============================================================================
+@endverbatim
-    [..]
+  * @{
-    This subsection provides a set of functions allowing to control the SDMMC data
+  */
-    transfers.
+/**
-@endverbatim
+  * @brief  Set SDMMC Power state to ON.
-  * @{
+  * @param  SDIOx: Pointer to SDMMC register base
-  */
+  * @retval HAL status
+  */
-/**
+HAL_StatusTypeDef SDIO_PowerState_ON(SDIO_TypeDef *SDIOx)
-  * @brief  Set SDMMC Power state to ON.
+{
-  * @param  SDIOx: Pointer to SDMMC register base
+  /* Set power state to ON */
-  * @retval HAL status
+  SDIOx->POWER = SDIO_POWER_PWRCTRL;
-  */
-HAL_StatusTypeDef SDIO_PowerState_ON(SDIO_TypeDef *SDIOx)
+  return HAL_OK;
-{
+}
-  /* Set power state to ON */
-  SDIOx->POWER = SDIO_POWER_PWRCTRL;
+/**
+  * @brief  Set SDMMC Power state to OFF.
-  /* 1ms: required power up waiting time before starting the SD initialization
+  * @param  SDIOx: Pointer to SDMMC register base
-  sequence */
+  * @retval HAL status
-  HAL_Delay(2);
+  */
+HAL_StatusTypeDef SDIO_PowerState_OFF(SDIO_TypeDef *SDIOx)
-  return HAL_OK;
+{
-}
+  /* Set power state to OFF */
+  SDIOx->POWER = (uint32_t)0x00000000;
-/**
-  * @brief  Set SDMMC Power state to OFF.
+  return HAL_OK;
-  * @param  SDIOx: Pointer to SDMMC register base
+}
-  * @retval HAL status
-  */
+/**
-HAL_StatusTypeDef SDIO_PowerState_OFF(SDIO_TypeDef *SDIOx)
+  * @brief  Get SDMMC Power state.
-{
+  * @param  SDIOx: Pointer to SDMMC register base
-  /* Set power state to OFF */
+  * @retval Power status of the controller. The returned value can be one of the
-  SDIOx->POWER = (uint32_t)0x00000000;
+  *         following values:
+  *            - 0x00: Power OFF
-  return HAL_OK;
+  *            - 0x02: Power UP
-}
+  *            - 0x03: Power ON
+  */
-/**
+uint32_t SDIO_GetPowerState(SDIO_TypeDef *SDIOx)
-  * @brief  Get SDMMC Power state.
+{
-  * @param  SDIOx: Pointer to SDMMC register base
+  return (SDIOx->POWER & SDIO_POWER_PWRCTRL);
-  * @retval Power status of the controller. The returned value can be one of the
+}
-  *         following values:
-  *            - 0x00: Power OFF
+/**
-  *            - 0x02: Power UP
+  * @brief  Configure the SDMMC command path according to the specified parameters in
-  *            - 0x03: Power ON
+  *         SDIO_CmdInitTypeDef structure and send the command
-  */
+  * @param  SDIOx: Pointer to SDMMC register base
-uint32_t SDIO_GetPowerState(SDIO_TypeDef *SDIOx)
+  * @param  Command: pointer to a SDIO_CmdInitTypeDef structure that contains
-{
+  *         the configuration information for the SDMMC command
-  return (SDIOx->POWER & SDIO_POWER_PWRCTRL);
+  * @retval HAL status
-}
+  */
+HAL_StatusTypeDef SDIO_SendCommand(SDIO_TypeDef *SDIOx, SDIO_CmdInitTypeDef *Command)
-/**
+{
-  * @brief  Configure the SDMMC command path according to the specified parameters in
+  uint32_t tmpreg = 0;
-  *         SDIO_CmdInitTypeDef structure and send the command
-  * @param  SDIOx: Pointer to SDMMC register base
+  /* Check the parameters */
-  * @param  Command: pointer to a SDIO_CmdInitTypeDef structure that contains
+  assert_param(IS_SDIO_CMD_INDEX(Command->CmdIndex));
-  *         the configuration information for the SDMMC command
+  assert_param(IS_SDIO_RESPONSE(Command->Response));
-  * @retval HAL status
+  assert_param(IS_SDIO_WAIT(Command->WaitForInterrupt));
-  */
+  assert_param(IS_SDIO_CPSM(Command->CPSM));
-HAL_StatusTypeDef SDIO_SendCommand(SDIO_TypeDef *SDIOx, SDIO_CmdInitTypeDef *Command)
-{
+  /* Set the SDMMC Argument value */
-  uint32_t tmpreg = 0;
+  SDIOx->ARG = Command->Argument;
-  /* Check the parameters */
+  /* Set SDMMC command parameters */
-  assert_param(IS_SDIO_CMD_INDEX(Command->CmdIndex));
+  tmpreg |= (uint32_t)(Command->CmdIndex         |\
-  assert_param(IS_SDIO_RESPONSE(Command->Response));
+                       Command->Response         |\
-  assert_param(IS_SDIO_WAIT(Command->WaitForInterrupt));
+                       Command->WaitForInterrupt |\
-  assert_param(IS_SDIO_CPSM(Command->CPSM));
+                       Command->CPSM);
-  /* Set the SDMMC Argument value */
+  /* Write to SDMMC CMD register */
-  SDIOx->ARG = Command->Argument;
+  MODIFY_REG(SDIOx->CMD, CMD_CLEAR_MASK, tmpreg);
-  /* Set SDMMC command parameters */
+  return HAL_OK;
-  tmpreg |= (uint32_t)(Command->CmdIndex         |\
+}
-                       Command->Response         |\
-                       Command->WaitForInterrupt |\
+/**
-                       Command->CPSM);
+  * @brief  Return the command index of last command for which response received
+  * @param  SDIOx: Pointer to SDMMC register base
-  /* Write to SDMMC CMD register */
+  * @retval Command index of the last command response received
-  MODIFY_REG(SDIOx->CMD, CMD_CLEAR_MASK, tmpreg);
+  */
+uint8_t SDIO_GetCommandResponse(SDIO_TypeDef *SDIOx)
-  return HAL_OK;
+{
-}
+  return (uint8_t)(SDIOx->RESPCMD);
+}
-/**
-  * @brief  Return the command index of last command for which response received
-  * @param  SDIOx: Pointer to SDMMC register base
+/**
-  * @retval Command index of the last command response received
+  * @brief  Return the response received from the card for the last command
-  */
+  * @param  SDIOx: Pointer to SDMMC register base
-uint8_t SDIO_GetCommandResponse(SDIO_TypeDef *SDIOx)
+  * @param  Response: Specifies the SDMMC response register.
-{
+  *          This parameter can be one of the following values:
-  return (uint8_t)(SDIOx->RESPCMD);
+  *            @arg SDIO_RESP1: Response Register 1
-}
+  *            @arg SDIO_RESP2: Response Register 2
+  *            @arg SDIO_RESP3: Response Register 3
+  *            @arg SDIO_RESP4: Response Register 4
-/**
+  * @retval The Corresponding response register value
-  * @brief  Return the response received from the card for the last command
+  */
-  * @param  SDIOx: Pointer to SDMMC register base
+uint32_t SDIO_GetResponse(SDIO_TypeDef *SDIOx, uint32_t Response)
-  * @param  Response: Specifies the SDMMC response register.
+{
-  *          This parameter can be one of the following values:
+  uint32_t tmp;
-  *            @arg SDIO_RESP1: Response Register 1
-  *            @arg SDIO_RESP2: Response Register 2
+  /* Check the parameters */
-  *            @arg SDIO_RESP3: Response Register 3
+  assert_param(IS_SDIO_RESP(Response));
-  *            @arg SDIO_RESP4: Response Register 4
-  * @retval The Corresponding response register value
+  /* Get the response */
-  */
+  tmp = (uint32_t)(&(SDIOx->RESP1)) + Response;
-uint32_t SDIO_GetResponse(SDIO_TypeDef *SDIOx, uint32_t Response)
-{
+  return (*(__IO uint32_t *) tmp);
-  uint32_t tmp;
+}
-  /* Check the parameters */
+/**
-  assert_param(IS_SDIO_RESP(Response));
+  * @brief  Configure the SDMMC data path according to the specified
+  *         parameters in the SDIO_DataInitTypeDef.
-  /* Get the response */
+  * @param  SDIOx: Pointer to SDIO register base
-  tmp = (uint32_t)(&(SDIOx->RESP1)) + Response;
+  * @param  Data : pointer to a SDIO_DataInitTypeDef structure
+  *         that contains the configuration information for the SDMMC data.
-  return (*(__IO uint32_t *) tmp);
+  * @retval HAL status
-}
+  */
+HAL_StatusTypeDef SDIO_ConfigData(SDIO_TypeDef *SDIOx, SDIO_DataInitTypeDef* Data)
-/**
+{
-  * @brief  Configure the SDMMC data path according to the specified
+  uint32_t tmpreg = 0;
-  *         parameters in the SDIO_DataInitTypeDef.
-  * @param  SDIOx: Pointer to SDIO register base
+  /* Check the parameters */
-  * @param  Data : pointer to a SDIO_DataInitTypeDef structure
+  assert_param(IS_SDIO_DATA_LENGTH(Data->DataLength));
-  *         that contains the configuration information for the SDMMC data.
+  assert_param(IS_SDIO_BLOCK_SIZE(Data->DataBlockSize));
-  * @retval HAL status
+  assert_param(IS_SDIO_TRANSFER_DIR(Data->TransferDir));
-  */
+  assert_param(IS_SDIO_TRANSFER_MODE(Data->TransferMode));
-HAL_StatusTypeDef SDIO_ConfigData(SDIO_TypeDef *SDIOx, SDIO_DataInitTypeDef* Data)
+  assert_param(IS_SDIO_DPSM(Data->DPSM));
-{
-  uint32_t tmpreg = 0;
+  /* Set the SDMMC Data TimeOut value */
+  SDIOx->DTIMER = Data->DataTimeOut;
-  /* Check the parameters */
-  assert_param(IS_SDIO_DATA_LENGTH(Data->DataLength));
+  /* Set the SDMMC DataLength value */
-  assert_param(IS_SDIO_BLOCK_SIZE(Data->DataBlockSize));
+  SDIOx->DLEN = Data->DataLength;
-  assert_param(IS_SDIO_TRANSFER_DIR(Data->TransferDir));
-  assert_param(IS_SDIO_TRANSFER_MODE(Data->TransferMode));
+  /* Set the SDMMC data configuration parameters */
-  assert_param(IS_SDIO_DPSM(Data->DPSM));
+  tmpreg |= (uint32_t)(Data->DataBlockSize |\
+                       Data->TransferDir   |\
-  /* Set the SDMMC Data TimeOut value */
+                       Data->TransferMode  |\
-  SDIOx->DTIMER = Data->DataTimeOut;
+                       Data->DPSM);
-  /* Set the SDMMC DataLength value */
+  /* Write to SDMMC DCTRL */
-  SDIOx->DLEN = Data->DataLength;
+  MODIFY_REG(SDIOx->DCTRL, DCTRL_CLEAR_MASK, tmpreg);
-  /* Set the SDMMC data configuration parameters */
+  return HAL_OK;
-  tmpreg |= (uint32_t)(Data->DataBlockSize |\
-                       Data->TransferDir   |\
+}
-                       Data->TransferMode  |\
-                       Data->DPSM);
+/**
+  * @brief  Returns number of remaining data bytes to be transferred.
-  /* Write to SDMMC DCTRL */
+  * @param  SDIOx: Pointer to SDIO register base
-  MODIFY_REG(SDIOx->DCTRL, DCTRL_CLEAR_MASK, tmpreg);
+  * @retval Number of remaining data bytes to be transferred
+  */
-  return HAL_OK;
+uint32_t SDIO_GetDataCounter(SDIO_TypeDef *SDIOx)
+{
-}
+  return (SDIOx->DCOUNT);
+}
-/**
-  * @brief  Returns number of remaining data bytes to be transferred.
+/**
-  * @param  SDIOx: Pointer to SDIO register base
+  * @brief  Get the FIFO data
-  * @retval Number of remaining data bytes to be transferred
+  * @param  SDIOx: Pointer to SDIO register base
-  */
+  * @retval Data received
-uint32_t SDIO_GetDataCounter(SDIO_TypeDef *SDIOx)
+  */
-{
+uint32_t SDIO_GetFIFOCount(SDIO_TypeDef *SDIOx)
-  return (SDIOx->DCOUNT);
+{
-}
+  return (SDIOx->FIFO);
+}
-/**
-  * @brief  Get the FIFO data
+/**
-  * @param  SDIOx: Pointer to SDIO register base
+  * @brief  Sets one of the two options of inserting read wait interval.
-  * @retval Data received
+  * @param  SDIOx: Pointer to SDIO register base
-  */
+  * @param  SDIO_ReadWaitMode: SDMMC Read Wait operation mode.
-uint32_t SDIO_GetFIFOCount(SDIO_TypeDef *SDIOx)
+  *          This parameter can be:
-{
+  *            @arg SDIO_READ_WAIT_MODE_CLK: Read Wait control by stopping SDMMCCLK
-  return (SDIOx->FIFO);
+  *            @arg SDIO_READ_WAIT_MODE_DATA2: Read Wait control using SDMMC_DATA2
-}
+  * @retval None
+  */
-/**
+HAL_StatusTypeDef SDIO_SetSDMMCReadWaitMode(SDIO_TypeDef *SDIOx, uint32_t SDIO_ReadWaitMode)
-  * @brief  Sets one of the two options of inserting read wait interval.
+{
-  * @param  SDIOx: Pointer to SDIO register base
+  /* Check the parameters */
-  * @param  SDIO_ReadWaitMode: SDMMC Read Wait operation mode.
+  assert_param(IS_SDIO_READWAIT_MODE(SDIO_ReadWaitMode));
-  *          This parameter can be:
-  *            @arg SDIO_READ_WAIT_MODE_CLK: Read Wait control by stopping SDMMCCLK
+  /* Set SDMMC read wait mode */
-  *            @arg SDIO_READ_WAIT_MODE_DATA2: Read Wait control using SDMMC_DATA2
+  MODIFY_REG(SDIOx->DCTRL, SDIO_DCTRL_RWMOD, SDIO_ReadWaitMode);
-  * @retval None
-  */
+  return HAL_OK;
-HAL_StatusTypeDef SDIO_SetSDMMCReadWaitMode(SDIO_TypeDef *SDIOx, uint32_t SDIO_ReadWaitMode)
+}
-{
-  /* Check the parameters */
+/**
-  assert_param(IS_SDIO_READWAIT_MODE(SDIO_ReadWaitMode));
+  * @}
+  */
-  /* Set SDMMC read wait mode */
-  MODIFY_REG(SDIOx->DCTRL, SDIO_DCTRL_RWMOD, SDIO_ReadWaitMode);
+/** @defgroup HAL_SDMMC_LL_Group4 Command management functions
-  return HAL_OK;
+ *  @brief   Data transfers functions
-}
+ *
+@verbatim
-/**
+ ===============================================================================
-  * @}
+                   ##### Commands management functions #####
-  */
+ ===============================================================================
+    [..]
+    This subsection provides a set of functions allowing to manage the needed commands.
-/** @defgroup HAL_SDMMC_LL_Group4 Command management functions
- *  @brief   Data transfers functions
+@endverbatim
- *
+  * @{
-@verbatim
+  */
- ===============================================================================
-                   ##### Commands management functions #####
+/**
- ===============================================================================
+  * @brief  Send the Data Block Length command and check the response
-    [..]
+  * @param  SDIOx: Pointer to SDIO register base
-    This subsection provides a set of functions allowing to manage the needed commands.
+  * @retval HAL status
+  */
-@endverbatim
+uint32_t SDMMC_CmdBlockLength(SDIO_TypeDef *SDIOx, uint32_t BlockSize)
-  * @{
+{
-  */
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Data Block Length command and check the response
+  /* Set Block Size for Card */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = (uint32_t)BlockSize;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SET_BLOCKLEN;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdBlockLength(SDIO_TypeDef *SDIOx, uint32_t BlockSize)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Set Block Size for Card */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SET_BLOCKLEN, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = (uint32_t)BlockSize;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SET_BLOCKLEN;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Read Single Block command and check the response
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SET_BLOCKLEN, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdReadSingleBlock(SDIO_TypeDef *SDIOx, uint32_t ReadAdd)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Read Single Block command and check the response
+  /* Set Block Size for Card */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = (uint32_t)ReadAdd;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_READ_SINGLE_BLOCK;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdReadSingleBlock(SDIO_TypeDef *SDIOx, uint32_t ReadAdd)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Set Block Size for Card */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_READ_SINGLE_BLOCK, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = (uint32_t)ReadAdd;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_READ_SINGLE_BLOCK;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Read Multi Block command and check the response
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_READ_SINGLE_BLOCK, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdReadMultiBlock(SDIO_TypeDef *SDIOx, uint32_t ReadAdd)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Read Multi Block command and check the response
+  /* Set Block Size for Card */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = (uint32_t)ReadAdd;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_READ_MULT_BLOCK;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdReadMultiBlock(SDIO_TypeDef *SDIOx, uint32_t ReadAdd)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Set Block Size for Card */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_READ_MULT_BLOCK, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = (uint32_t)ReadAdd;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_READ_MULT_BLOCK;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Write Single Block command and check the response
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_READ_MULT_BLOCK, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdWriteSingleBlock(SDIO_TypeDef *SDIOx, uint32_t WriteAdd)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Write Single Block command and check the response
+  /* Set Block Size for Card */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = (uint32_t)WriteAdd;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_WRITE_SINGLE_BLOCK;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdWriteSingleBlock(SDIO_TypeDef *SDIOx, uint32_t WriteAdd)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Set Block Size for Card */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_WRITE_SINGLE_BLOCK, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = (uint32_t)WriteAdd;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_WRITE_SINGLE_BLOCK;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Write Multi Block command and check the response
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_WRITE_SINGLE_BLOCK, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdWriteMultiBlock(SDIO_TypeDef *SDIOx, uint32_t WriteAdd)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Write Multi Block command and check the response
+  /* Set Block Size for Card */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = (uint32_t)WriteAdd;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_WRITE_MULT_BLOCK;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdWriteMultiBlock(SDIO_TypeDef *SDIOx, uint32_t WriteAdd)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Set Block Size for Card */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_WRITE_MULT_BLOCK, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = (uint32_t)WriteAdd;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_WRITE_MULT_BLOCK;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Start Address Erase command for SD and check the response
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_WRITE_MULT_BLOCK, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdSDEraseStartAdd(SDIO_TypeDef *SDIOx, uint32_t StartAdd)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Start Address Erase command for SD and check the response
+  /* Set Block Size for Card */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = (uint32_t)StartAdd;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SD_ERASE_GRP_START;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdSDEraseStartAdd(SDIO_TypeDef *SDIOx, uint32_t StartAdd)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Set Block Size for Card */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SD_ERASE_GRP_START, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = (uint32_t)StartAdd;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SD_ERASE_GRP_START;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the End Address Erase command for SD and check the response
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SD_ERASE_GRP_START, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdSDEraseEndAdd(SDIO_TypeDef *SDIOx, uint32_t EndAdd)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the End Address Erase command for SD and check the response
+  /* Set Block Size for Card */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = (uint32_t)EndAdd;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SD_ERASE_GRP_END;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdSDEraseEndAdd(SDIO_TypeDef *SDIOx, uint32_t EndAdd)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Set Block Size for Card */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SD_ERASE_GRP_END, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = (uint32_t)EndAdd;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SD_ERASE_GRP_END;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Start Address Erase command and check the response
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SD_ERASE_GRP_END, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdEraseStartAdd(SDIO_TypeDef *SDIOx, uint32_t StartAdd)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Start Address Erase command and check the response
+  /* Set Block Size for Card */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = (uint32_t)StartAdd;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_ERASE_GRP_START;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdEraseStartAdd(SDIO_TypeDef *SDIOx, uint32_t StartAdd)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Set Block Size for Card */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_ERASE_GRP_START, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = (uint32_t)StartAdd;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_ERASE_GRP_START;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the End Address Erase command and check the response
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_ERASE_GRP_START, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdEraseEndAdd(SDIO_TypeDef *SDIOx, uint32_t EndAdd)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the End Address Erase command and check the response
+  /* Set Block Size for Card */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = (uint32_t)EndAdd;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_ERASE_GRP_END;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdEraseEndAdd(SDIO_TypeDef *SDIOx, uint32_t EndAdd)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Set Block Size for Card */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_ERASE_GRP_END, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = (uint32_t)EndAdd;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_ERASE_GRP_END;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Erase command and check the response
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_ERASE_GRP_END, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdErase(SDIO_TypeDef *SDIOx)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Erase command and check the response
+  /* Set Block Size for Card */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = 0U;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_ERASE;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdErase(SDIO_TypeDef *SDIOx)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Set Block Size for Card */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_ERASE, SDIO_MAXERASETIMEOUT);
-  sdmmc_cmdinit.Argument         = 0U;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_ERASE;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Stop Transfer command and check the response.
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_ERASE, SDIO_MAXERASETIMEOUT);
+  */
+uint32_t SDMMC_CmdStopTransfer(SDIO_TypeDef *SDIOx)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Stop Transfer command and check the response.
+  /* Send CMD12 STOP_TRANSMISSION  */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = 0U;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_STOP_TRANSMISSION;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdStopTransfer(SDIO_TypeDef *SDIOx)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Send CMD12 STOP_TRANSMISSION  */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_STOP_TRANSMISSION, SDIO_STOPTRANSFERTIMEOUT);
-  sdmmc_cmdinit.Argument         = 0U;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_STOP_TRANSMISSION;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Select Deselect command and check the response.
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @param  addr: Address of the card to be selected
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_STOP_TRANSMISSION, SDIO_STOPTRANSFERTIMEOUT);
+  * @retval HAL status
+  */
-  return errorstate;
+uint32_t SDMMC_CmdSelDesel(SDIO_TypeDef *SDIOx, uint64_t Addr)
-}
+{
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-/**
+  uint32_t errorstate;
-  * @brief  Send the Select Deselect command and check the response.
-  * @param  SDIOx: Pointer to SDIO register base
+  /* Send CMD7 SDMMC_SEL_DESEL_CARD */
-  * @param  addr: Address of the card to be selected
+  sdmmc_cmdinit.Argument         = (uint32_t)Addr;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SEL_DESEL_CARD;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdSelDesel(SDIO_TypeDef *SDIOx, uint64_t Addr)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Send CMD7 SDMMC_SEL_DESEL_CARD */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SEL_DESEL_CARD, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = (uint32_t)Addr;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SEL_DESEL_CARD;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Go Idle State command and check the response.
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SEL_DESEL_CARD, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdGoIdleState(SDIO_TypeDef *SDIOx)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Go Idle State command and check the response.
+  sdmmc_cmdinit.Argument         = 0U;
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_GO_IDLE_STATE;
-  * @retval HAL status
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_NO;
-  */
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-uint32_t SDMMC_CmdGoIdleState(SDIO_TypeDef *SDIOx)
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-{
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-  uint32_t errorstate;
+  /* Check for error conditions */
+  errorstate = SDMMC_GetCmdError(SDIOx);
-  sdmmc_cmdinit.Argument         = 0U;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_GO_IDLE_STATE;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_NO;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Operating Condition command and check the response.
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdError(SDIOx);
+  */
+uint32_t SDMMC_CmdOperCond(SDIO_TypeDef *SDIOx)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Operating Condition command and check the response.
+  /* Send CMD8 to verify SD card interface operating condition */
-  * @param  SDIOx: Pointer to SDIO register base
+  /* Argument: - [31:12]: Reserved (shall be set to '0')
-  * @retval HAL status
+  - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
-  */
+  - [7:0]: Check Pattern (recommended 0xAA) */
-uint32_t SDMMC_CmdOperCond(SDIO_TypeDef *SDIOx)
+  /* CMD Response: R7 */
-{
+  sdmmc_cmdinit.Argument         = SDMMC_CHECK_PATTERN;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_HS_SEND_EXT_CSD;
-  uint32_t errorstate;
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  /* Send CMD8 to verify SD card interface operating condition */
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  /* Argument: - [31:12]: Reserved (shall be set to '0')
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
-  - [7:0]: Check Pattern (recommended 0xAA) */
+  /* Check for error conditions */
-  /* CMD Response: R7 */
+  errorstate = SDMMC_GetCmdResp7(SDIOx);
-  sdmmc_cmdinit.Argument         = SDMMC_CHECK_PATTERN;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_HS_SEND_EXT_CSD;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Application command to verify that that the next command
+  *         is an application specific com-mand rather than a standard command
-  /* Check for error conditions */
+  *         and check the response.
-  errorstate = SDMMC_GetCmdResp7(SDIOx);
+  * @param  SDIOx: Pointer to SDIO register base
+  * @param  Argument: Command Argument
-  return errorstate;
+  * @retval HAL status
-}
+  */
+uint32_t SDMMC_CmdAppCommand(SDIO_TypeDef *SDIOx, uint32_t Argument)
-/**
+{
-  * @brief  Send the Application command to verify that that the next command
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-  *         is an application specific com-mand rather than a standard command
+  uint32_t errorstate;
-  *         and check the response.
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = (uint32_t)Argument;
-  * @param  Argument: Command Argument
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_APP_CMD;
-  * @retval HAL status
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-  */
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-uint32_t SDMMC_CmdAppCommand(SDIO_TypeDef *SDIOx, uint32_t Argument)
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-{
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-  uint32_t errorstate;
+  /* Check for error conditions */
+  /* If there is a HAL_ERROR, it is a MMC card, else
-  sdmmc_cmdinit.Argument         = (uint32_t)Argument;
+  it is a SD card: SD card 2.0 (voltage range mismatch)
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_APP_CMD;
+     or SD card 1.x */
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_APP_CMD, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+  return errorstate;
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+}
-  /* Check for error conditions */
+/**
-  /* If there is a HAL_ERROR, it is a MMC card, else
+  * @brief  Send the command asking the accessed card to send its operating
-  it is a SD card: SD card 2.0 (voltage range mismatch)
+  *         condition register (OCR)
-     or SD card 1.x */
+  * @param  SDIOx: Pointer to SDIO register base
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_APP_CMD, SDIO_CMDTIMEOUT);
+  * @param  Argument: Command Argument
+  * @retval HAL status
-  return errorstate;
+  */
-}
+uint32_t SDMMC_CmdAppOperCommand(SDIO_TypeDef *SDIOx, uint32_t Argument)
+{
-/**
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-  * @brief  Send the command asking the accessed card to send its operating
+  uint32_t errorstate;
-  *         condition register (OCR)
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = SDMMC_VOLTAGE_WINDOW_SD | Argument;
-  * @param  Argument: Command Argument
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SD_APP_OP_COND;
-  * @retval HAL status
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-  */
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-uint32_t SDMMC_CmdAppOperCommand(SDIO_TypeDef *SDIOx, uint32_t Argument)
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-{
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-  uint32_t errorstate;
+  /* Check for error conditions */
+  errorstate = SDMMC_GetCmdResp3(SDIOx);
-  sdmmc_cmdinit.Argument         = SDMMC_VOLTAGE_WINDOW_SD | Argument;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SD_APP_OP_COND;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Bus Width command and check the response.
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @param  BusWidth: BusWidth
-  errorstate = SDMMC_GetCmdResp3(SDIOx);
+  * @retval HAL status
+  */
-  return errorstate;
+uint32_t SDMMC_CmdBusWidth(SDIO_TypeDef *SDIOx, uint32_t BusWidth)
-}
+{
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-/**
+  uint32_t errorstate;
-  * @brief  Send the Bus Width command and check the response.
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = (uint32_t)BusWidth;
-  * @param  BusWidth: BusWidth
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_APP_SD_SET_BUSWIDTH;
-  * @retval HAL status
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-  */
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-uint32_t SDMMC_CmdBusWidth(SDIO_TypeDef *SDIOx, uint32_t BusWidth)
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-{
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-  uint32_t errorstate;
+  /* Check for error conditions */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_APP_SD_SET_BUSWIDTH, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = (uint32_t)BusWidth;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_APP_SD_SET_BUSWIDTH;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Send SCR command and check the response.
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_APP_SD_SET_BUSWIDTH, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdSendSCR(SDIO_TypeDef *SDIOx)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Send SCR command and check the response.
+  /* Send CMD51 SD_APP_SEND_SCR */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = 0U;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SD_APP_SEND_SCR;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdSendSCR(SDIO_TypeDef *SDIOx)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Send CMD51 SD_APP_SEND_SCR */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SD_APP_SEND_SCR, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = 0U;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SD_APP_SEND_SCR;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Send CID command and check the response.
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SD_APP_SEND_SCR, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdSendCID(SDIO_TypeDef *SDIOx)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @brief  Send the Send CID command and check the response.
+  /* Send CMD2 ALL_SEND_CID */
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = 0U;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_ALL_SEND_CID;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_LONG;
-uint32_t SDMMC_CmdSendCID(SDIO_TypeDef *SDIOx)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Send CMD2 ALL_SEND_CID */
+  errorstate = SDMMC_GetCmdResp2(SDIOx);
-  sdmmc_cmdinit.Argument         = 0U;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_ALL_SEND_CID;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_LONG;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Send CSD command and check the response.
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @param  Argument: Command Argument
-  errorstate = SDMMC_GetCmdResp2(SDIOx);
+  * @retval HAL status
+  */
-  return errorstate;
+uint32_t SDMMC_CmdSendCSD(SDIO_TypeDef *SDIOx, uint32_t Argument)
-}
+{
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-/**
+  uint32_t errorstate;
-  * @brief  Send the Send CSD command and check the response.
-  * @param  SDIOx: Pointer to SDIO register base
+  /* Send CMD9 SEND_CSD */
-  * @param  Argument: Command Argument
+  sdmmc_cmdinit.Argument         = Argument;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SEND_CSD;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_LONG;
-uint32_t SDMMC_CmdSendCSD(SDIO_TypeDef *SDIOx, uint32_t Argument)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Send CMD9 SEND_CSD */
+  errorstate = SDMMC_GetCmdResp2(SDIOx);
-  sdmmc_cmdinit.Argument         = Argument;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SEND_CSD;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_LONG;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Send CSD command and check the response.
+  * @param  SDIOx: Pointer to SDIO register base
-  /* Check for error conditions */
+  * @param  pRCA: Card RCA
-  errorstate = SDMMC_GetCmdResp2(SDIOx);
+  * @retval HAL status
+  */
-  return errorstate;
+uint32_t SDMMC_CmdSetRelAdd(SDIO_TypeDef *SDIOx, uint16_t *pRCA)
-}
+{
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-/**
+  uint32_t errorstate;
-  * @brief  Send the Send CSD command and check the response.
-  * @param  SDIOx: Pointer to SDIO register base
+  /* Send CMD3 SD_CMD_SET_REL_ADDR */
-  * @param  pRCA: Card RCA
+  sdmmc_cmdinit.Argument         = 0U;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SET_REL_ADDR;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdSetRelAdd(SDIO_TypeDef *SDIOx, uint16_t *pRCA)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Send CMD3 SD_CMD_SET_REL_ADDR */
+  errorstate = SDMMC_GetCmdResp6(SDIOx, SDMMC_CMD_SET_REL_ADDR, pRCA);
-  sdmmc_cmdinit.Argument         = 0U;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SET_REL_ADDR;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Send the Set Relative Address command to MMC card (not SD card).
+  * @param  SDIOx Pointer to SDIO register base
-  /* Check for error conditions */
+  * @param  RCA Card RCA
-  errorstate = SDMMC_GetCmdResp6(SDIOx, SDMMC_CMD_SET_REL_ADDR, pRCA);
+  * @retval HAL status
+  */
-  return errorstate;
+uint32_t SDMMC_CmdSetRelAddMmc(SDIO_TypeDef *SDIOx, uint16_t RCA)
-}
+{
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-/**
+  uint32_t errorstate;
-  * @brief  Send the Status command and check the response.
-  * @param  SDIOx: Pointer to SDIO register base
+  /* Send CMD3 SD_CMD_SET_REL_ADDR */
-  * @param  Argument: Command Argument
+  sdmmc_cmdinit.Argument         = ((uint32_t)RCA << 16U);
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SET_REL_ADDR;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdSendStatus(SDIO_TypeDef *SDIOx, uint32_t Argument)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  sdmmc_cmdinit.Argument         = Argument;
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SET_REL_ADDR, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SEND_STATUS;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+  return errorstate;
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
+}
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+/**
+  * @brief  Send the Status command and check the response.
-  /* Check for error conditions */
+  * @param  SDIOx: Pointer to SDIO register base
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SEND_STATUS, SDIO_CMDTIMEOUT);
+  * @param  Argument: Command Argument
+  * @retval HAL status
-  return errorstate;
+  */
-}
+uint32_t SDMMC_CmdSendStatus(SDIO_TypeDef *SDIOx, uint32_t Argument)
+{
-/**
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-  * @brief  Send the Status register command and check the response.
+  uint32_t errorstate;
-  * @param  SDIOx: Pointer to SDIO register base
-  * @retval HAL status
+  sdmmc_cmdinit.Argument         = Argument;
-  */
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SEND_STATUS;
-uint32_t SDMMC_CmdStatusRegister(SDIO_TypeDef *SDIOx)
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-{
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  uint32_t errorstate;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  sdmmc_cmdinit.Argument         = 0U;
+  /* Check for error conditions */
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SD_APP_STATUS;
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SEND_STATUS, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
+  return errorstate;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+}
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+/**
-  /* Check for error conditions */
+  * @brief  Send the Status register command and check the response.
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SD_APP_STATUS, SDIO_CMDTIMEOUT);
+  * @param  SDIOx: Pointer to SDIO register base
+  * @retval HAL status
-  return errorstate;
+  */
-}
+uint32_t SDMMC_CmdStatusRegister(SDIO_TypeDef *SDIOx)
+{
-/**
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-  * @brief  Sends host capacity support information and activates the card's
+  uint32_t errorstate;
-  *         initialization process. Send SDMMC_CMD_SEND_OP_COND command
-  * @param  SDIOx: Pointer to SDIO register base
+  sdmmc_cmdinit.Argument         = 0U;
-  * @parame Argument: Argument used for the command
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SD_APP_STATUS;
-  * @retval HAL status
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-  */
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-uint32_t SDMMC_CmdOpCondition(SDIO_TypeDef *SDIOx, uint32_t Argument)
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-{
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-  uint32_t errorstate;
+  /* Check for error conditions */
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_SD_APP_STATUS, SDIO_CMDTIMEOUT);
-  sdmmc_cmdinit.Argument         = Argument;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SEND_OP_COND;
+  return errorstate;
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+}
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+/**
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @brief  Sends host capacity support information and activates the card's
+  *         initialization process. Send SDMMC_CMD_SEND_OP_COND command
-  /* Check for error conditions */
+  * @param  SDIOx: Pointer to SDIO register base
-  errorstate = SDMMC_GetCmdResp3(SDIOx);
+  * @parame Argument: Argument used for the command
+  * @retval HAL status
-  return errorstate;
+  */
-}
+uint32_t SDMMC_CmdOpCondition(SDIO_TypeDef *SDIOx, uint32_t Argument)
+{
-/**
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-  * @brief  Checks switchable function and switch card function. SDMMC_CMD_HS_SWITCH command
+  uint32_t errorstate;
-  * @param  SDIOx: Pointer to SDIO register base
-  * @parame Argument: Argument used for the command
+  sdmmc_cmdinit.Argument         = Argument;
-  * @retval HAL status
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_SEND_OP_COND;
-  */
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-uint32_t SDMMC_CmdSwitch(SDIO_TypeDef *SDIOx, uint32_t Argument)
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-{
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-  uint32_t errorstate;
+  /* Check for error conditions */
-  /* Send CMD6 to activate SDR50 Mode and Power Limit 1.44W */
+  errorstate = SDMMC_GetCmdResp3(SDIOx);
-  /* CMD Response: R1 */
-  sdmmc_cmdinit.Argument         = Argument; /* SDMMC_SDR25_SWITCH_PATTERN */
+  return errorstate;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_HS_SWITCH;
+}
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
+/**
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+  * @brief  Checks switchable function and switch card function. SDMMC_CMD_HS_SWITCH command
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  * @param  SDIOx: Pointer to SDIO register base
+  * @parame Argument: Argument used for the command
-  /* Check for error conditions */
+  * @retval HAL status
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_HS_SWITCH, SDIO_CMDTIMEOUT);
+  */
+uint32_t SDMMC_CmdSwitch(SDIO_TypeDef *SDIOx, uint32_t Argument)
-  return errorstate;
+{
-}
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  uint32_t errorstate;
-/**
-  * @}
+  /* Send CMD6 to activate SDR50 Mode and Power Limit 1.44W */
-  */
+  /* CMD Response: R1 */
+  sdmmc_cmdinit.Argument         = Argument; /* SDMMC_SDR25_SWITCH_PATTERN */
-/* Private function ----------------------------------------------------------*/
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_HS_SWITCH;
-/** @addtogroup SD_Private_Functions
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
-  * @{
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  */
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-/**
-  * @brief  Checks for error conditions for CMD0.
+  /* Check for error conditions */
-  * @param  hsd: SD handle
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_HS_SWITCH, SDIO_CMDTIMEOUT);
-  * @retval SD Card error state
-  */
+  return errorstate;
-static uint32_t SDMMC_GetCmdError(SDIO_TypeDef *SDIOx)
+}
-{
-  /* 8 is the number of required instructions cycles for the below loop statement.
+/**
-  The SDIO_CMDTIMEOUT is expressed in ms */
+  * @brief  Send the Send EXT_CSD command and check the response.
-  uint32_t count = SDIO_CMDTIMEOUT * (SystemCoreClock / 8U /1000U);
+  * @param  SDIOx Pointer to SDMMC register base
+  * @param  Argument Command Argument
-  do
+  * @retval HAL status
-  {
+  */
-    if (count-- == 0U)
+uint32_t SDMMC_CmdSendEXTCSD(SDIO_TypeDef *SDIOx, uint32_t Argument)
-    {
+{
-      return SDMMC_ERROR_TIMEOUT;
+  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
-    }
+  uint32_t errorstate;
-  }while(!__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CMDSENT));
+  /* Send CMD9 SEND_CSD */
+  sdmmc_cmdinit.Argument         = Argument;
-  /* Clear all the static flags */
+  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_HS_SEND_EXT_CSD;
-  __SDIO_CLEAR_FLAG(SDIOx, SDIO_STATIC_CMD_FLAGS);
+  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
-  return SDMMC_ERROR_NONE;
+  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
-}
+  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
-/**
+  /* Check for error conditions */
-  * @brief  Checks for error conditions for R1 response.
+  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_HS_SEND_EXT_CSD,SDIO_CMDTIMEOUT);
-  * @param  hsd: SD handle
-  * @param  SD_CMD: The sent command index
+  return errorstate;
-  * @retval SD Card error state
+}
-  */
-static uint32_t SDMMC_GetCmdResp1(SDIO_TypeDef *SDIOx, uint8_t SD_CMD, uint32_t Timeout)
+/**
-{
+  * @}
-  uint32_t response_r1;
+  */
-  uint32_t sta_reg;
+/** @defgroup HAL_SDMMC_LL_Group5 Responses management functions
-  /* 8 is the number of required instructions cycles for the below loop statement.
+ *  @brief   Responses functions
-  The Timeout is expressed in ms */
+ *
-  uint32_t count = Timeout * (SystemCoreClock / 8U /1000U);
+@verbatim
+ ===============================================================================
-  do
+                   ##### Responses management functions #####
-  {
+ ===============================================================================
-    if (count-- == 0U)
+    [..]
-    {
+    This subsection provides a set of functions allowing to manage the needed responses.
-      return SDMMC_ERROR_TIMEOUT;
-    }
+@endverbatim
-    sta_reg = SDIOx->STA;
+  * @{
-  }while(((sta_reg & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) == 0U) ||
+  */
-         ((sta_reg & SDIO_FLAG_CMDACT) != 0U ));
+/**
+  * @brief  Checks for error conditions for R1 response.
-  if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT))
+  * @param  SDIOx Pointer to SDMMC register base
-  {
+  * @param  SD_CMD: The sent command index
-    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT);
+  * @retval SD Card error state
+  */
-    return SDMMC_ERROR_CMD_RSP_TIMEOUT;
+uint32_t SDMMC_GetCmdResp1(SDIO_TypeDef *SDIOx, uint8_t SD_CMD, uint32_t Timeout)
-  }
+{
-  else if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL))
+  uint32_t response_r1;
-  {
+  uint32_t sta_reg;
-    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL);
+  /* 8 is the number of required instructions cycles for the below loop statement.
-    return SDMMC_ERROR_CMD_CRC_FAIL;
+  The Timeout is expressed in ms */
-  }
+  uint32_t count = Timeout * (SystemCoreClock / 8U /1000U);
-  else
-  {
+  do
-    /* Nothing to do */
+  {
-  }
+    if (count-- == 0U)
+    {
-  /* Clear all the static flags */
+      return SDMMC_ERROR_TIMEOUT;
-  __SDIO_CLEAR_FLAG(SDIOx, SDIO_STATIC_CMD_FLAGS);
+    }
+    sta_reg = SDIOx->STA;
-  /* Check response received is of desired command */
+  }while(((sta_reg & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) == 0U) ||
-  if(SDIO_GetCommandResponse(SDIOx) != SD_CMD)
+         ((sta_reg & SDIO_FLAG_CMDACT) != 0U ));
-  {
-    return SDMMC_ERROR_CMD_CRC_FAIL;
+  if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT))
-  }
+  {
+    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT);
-  /* We have received response, retrieve it for analysis  */
-  response_r1 = SDIO_GetResponse(SDIOx, SDIO_RESP1);
+    return SDMMC_ERROR_CMD_RSP_TIMEOUT;
+  }
-  if((response_r1 & SDMMC_OCR_ERRORBITS) == SDMMC_ALLZERO)
+  else if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL))
   {
-    return SDMMC_ERROR_NONE;
+    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL);
-  }
-  else if((response_r1 & SDMMC_OCR_ADDR_OUT_OF_RANGE) == SDMMC_OCR_ADDR_OUT_OF_RANGE)
+    return SDMMC_ERROR_CMD_CRC_FAIL;
-  {
+  }
-    return SDMMC_ERROR_ADDR_OUT_OF_RANGE;
+  else
-  }
+  {
-  else if((response_r1 & SDMMC_OCR_ADDR_MISALIGNED) == SDMMC_OCR_ADDR_MISALIGNED)
+    /* Nothing to do */
-  {
+  }
-    return SDMMC_ERROR_ADDR_MISALIGNED;
-  }
+  /* Clear all the static flags */
-  else if((response_r1 & SDMMC_OCR_BLOCK_LEN_ERR) == SDMMC_OCR_BLOCK_LEN_ERR)
+  __SDIO_CLEAR_FLAG(SDIOx, SDIO_STATIC_CMD_FLAGS);
-  {
-    return SDMMC_ERROR_BLOCK_LEN_ERR;
+  /* Check response received is of desired command */
-  }
+  if(SDIO_GetCommandResponse(SDIOx) != SD_CMD)
-  else if((response_r1 & SDMMC_OCR_ERASE_SEQ_ERR) == SDMMC_OCR_ERASE_SEQ_ERR)
+  {
-  {
+    return SDMMC_ERROR_CMD_CRC_FAIL;
-    return SDMMC_ERROR_ERASE_SEQ_ERR;
+  }
-  }
-  else if((response_r1 & SDMMC_OCR_BAD_ERASE_PARAM) == SDMMC_OCR_BAD_ERASE_PARAM)
+  /* We have received response, retrieve it for analysis  */
-  {
+  response_r1 = SDIO_GetResponse(SDIOx, SDIO_RESP1);
-    return SDMMC_ERROR_BAD_ERASE_PARAM;
-  }
+  if((response_r1 & SDMMC_OCR_ERRORBITS) == SDMMC_ALLZERO)
-  else if((response_r1 & SDMMC_OCR_WRITE_PROT_VIOLATION) == SDMMC_OCR_WRITE_PROT_VIOLATION)
+  {
-  {
+    return SDMMC_ERROR_NONE;
-    return SDMMC_ERROR_WRITE_PROT_VIOLATION;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_ADDR_OUT_OF_RANGE) == SDMMC_OCR_ADDR_OUT_OF_RANGE)
-  else if((response_r1 & SDMMC_OCR_LOCK_UNLOCK_FAILED) == SDMMC_OCR_LOCK_UNLOCK_FAILED)
+  {
-  {
+    return SDMMC_ERROR_ADDR_OUT_OF_RANGE;
-    return SDMMC_ERROR_LOCK_UNLOCK_FAILED;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_ADDR_MISALIGNED) == SDMMC_OCR_ADDR_MISALIGNED)
-  else if((response_r1 & SDMMC_OCR_COM_CRC_FAILED) == SDMMC_OCR_COM_CRC_FAILED)
+  {
-  {
+    return SDMMC_ERROR_ADDR_MISALIGNED;
-    return SDMMC_ERROR_COM_CRC_FAILED;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_BLOCK_LEN_ERR) == SDMMC_OCR_BLOCK_LEN_ERR)
-  else if((response_r1 & SDMMC_OCR_ILLEGAL_CMD) == SDMMC_OCR_ILLEGAL_CMD)
+  {
-  {
+    return SDMMC_ERROR_BLOCK_LEN_ERR;
-    return SDMMC_ERROR_ILLEGAL_CMD;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_ERASE_SEQ_ERR) == SDMMC_OCR_ERASE_SEQ_ERR)
-  else if((response_r1 & SDMMC_OCR_CARD_ECC_FAILED) == SDMMC_OCR_CARD_ECC_FAILED)
+  {
-  {
+    return SDMMC_ERROR_ERASE_SEQ_ERR;
-    return SDMMC_ERROR_CARD_ECC_FAILED;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_BAD_ERASE_PARAM) == SDMMC_OCR_BAD_ERASE_PARAM)
-  else if((response_r1 & SDMMC_OCR_CC_ERROR) == SDMMC_OCR_CC_ERROR)
+  {
-  {
+    return SDMMC_ERROR_BAD_ERASE_PARAM;
-    return SDMMC_ERROR_CC_ERR;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_WRITE_PROT_VIOLATION) == SDMMC_OCR_WRITE_PROT_VIOLATION)
-  else if((response_r1 & SDMMC_OCR_STREAM_READ_UNDERRUN) == SDMMC_OCR_STREAM_READ_UNDERRUN)
+  {
-  {
+    return SDMMC_ERROR_WRITE_PROT_VIOLATION;
-    return SDMMC_ERROR_STREAM_READ_UNDERRUN;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_LOCK_UNLOCK_FAILED) == SDMMC_OCR_LOCK_UNLOCK_FAILED)
-  else if((response_r1 & SDMMC_OCR_STREAM_WRITE_OVERRUN) == SDMMC_OCR_STREAM_WRITE_OVERRUN)
+  {
-  {
+    return SDMMC_ERROR_LOCK_UNLOCK_FAILED;
-    return SDMMC_ERROR_STREAM_WRITE_OVERRUN;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_COM_CRC_FAILED) == SDMMC_OCR_COM_CRC_FAILED)
-  else if((response_r1 & SDMMC_OCR_CID_CSD_OVERWRITE) == SDMMC_OCR_CID_CSD_OVERWRITE)
+  {
-  {
+    return SDMMC_ERROR_COM_CRC_FAILED;
-    return SDMMC_ERROR_CID_CSD_OVERWRITE;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_ILLEGAL_CMD) == SDMMC_OCR_ILLEGAL_CMD)
-  else if((response_r1 & SDMMC_OCR_WP_ERASE_SKIP) == SDMMC_OCR_WP_ERASE_SKIP)
+  {
-  {
+    return SDMMC_ERROR_ILLEGAL_CMD;
-    return SDMMC_ERROR_WP_ERASE_SKIP;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_CARD_ECC_FAILED) == SDMMC_OCR_CARD_ECC_FAILED)
-  else if((response_r1 & SDMMC_OCR_CARD_ECC_DISABLED) == SDMMC_OCR_CARD_ECC_DISABLED)
+  {
-  {
+    return SDMMC_ERROR_CARD_ECC_FAILED;
-    return SDMMC_ERROR_CARD_ECC_DISABLED;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_CC_ERROR) == SDMMC_OCR_CC_ERROR)
-  else if((response_r1 & SDMMC_OCR_ERASE_RESET) == SDMMC_OCR_ERASE_RESET)
+  {
-  {
+    return SDMMC_ERROR_CC_ERR;
-    return SDMMC_ERROR_ERASE_RESET;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_STREAM_READ_UNDERRUN) == SDMMC_OCR_STREAM_READ_UNDERRUN)
-  else if((response_r1 & SDMMC_OCR_AKE_SEQ_ERROR) == SDMMC_OCR_AKE_SEQ_ERROR)
+  {
-  {
+    return SDMMC_ERROR_STREAM_READ_UNDERRUN;
-    return SDMMC_ERROR_AKE_SEQ_ERR;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_STREAM_WRITE_OVERRUN) == SDMMC_OCR_STREAM_WRITE_OVERRUN)
-  else
+  {
-  {
+    return SDMMC_ERROR_STREAM_WRITE_OVERRUN;
-    return SDMMC_ERROR_GENERAL_UNKNOWN_ERR;
+  }
-  }
+  else if((response_r1 & SDMMC_OCR_CID_CSD_OVERWRITE) == SDMMC_OCR_CID_CSD_OVERWRITE)
-}
+  {
+    return SDMMC_ERROR_CID_CSD_OVERWRITE;
-/**
+  }
-  * @brief  Checks for error conditions for R2 (CID or CSD) response.
+  else if((response_r1 & SDMMC_OCR_WP_ERASE_SKIP) == SDMMC_OCR_WP_ERASE_SKIP)
-  * @param  hsd: SD handle
+  {
-  * @retval SD Card error state
+    return SDMMC_ERROR_WP_ERASE_SKIP;
-  */
+  }
-static uint32_t SDMMC_GetCmdResp2(SDIO_TypeDef *SDIOx)
+  else if((response_r1 & SDMMC_OCR_CARD_ECC_DISABLED) == SDMMC_OCR_CARD_ECC_DISABLED)
-{
+  {
-  uint32_t sta_reg;
+    return SDMMC_ERROR_CARD_ECC_DISABLED;
-  /* 8 is the number of required instructions cycles for the below loop statement.
+  }
-  The SDIO_CMDTIMEOUT is expressed in ms */
+  else if((response_r1 & SDMMC_OCR_ERASE_RESET) == SDMMC_OCR_ERASE_RESET)
-  uint32_t count = SDIO_CMDTIMEOUT * (SystemCoreClock / 8U /1000U);
+  {
+    return SDMMC_ERROR_ERASE_RESET;
-  do
+  }
-  {
+  else if((response_r1 & SDMMC_OCR_AKE_SEQ_ERROR) == SDMMC_OCR_AKE_SEQ_ERROR)
-    if (count-- == 0U)
+  {
-    {
+    return SDMMC_ERROR_AKE_SEQ_ERR;
-      return SDMMC_ERROR_TIMEOUT;
+  }
-    }
+  else
-    sta_reg = SDIOx->STA;
+  {
-  }while(((sta_reg & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) == 0U) ||
+    return SDMMC_ERROR_GENERAL_UNKNOWN_ERR;
-         ((sta_reg & SDIO_FLAG_CMDACT) != 0U ));
+  }
+}
-  if (__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT))
-  {
+/**
-    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT);
+  * @brief  Checks for error conditions for R2 (CID or CSD) response.
+  * @param  SDIOx Pointer to SDMMC register base
-    return SDMMC_ERROR_CMD_RSP_TIMEOUT;
+  * @retval SD Card error state
-  }
+  */
-  else if (__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL))
+uint32_t SDMMC_GetCmdResp2(SDIO_TypeDef *SDIOx)
-  {
+{
-    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL);
+  uint32_t sta_reg;
+  /* 8 is the number of required instructions cycles for the below loop statement.
-    return SDMMC_ERROR_CMD_CRC_FAIL;
+  The SDIO_CMDTIMEOUT is expressed in ms */
-  }
+  uint32_t count = SDIO_CMDTIMEOUT * (SystemCoreClock / 8U /1000U);
-  else
-  {
+  do
-    /* No error flag set */
+  {
-    /* Clear all the static flags */
+    if (count-- == 0U)
-    __SDIO_CLEAR_FLAG(SDIOx, SDIO_STATIC_CMD_FLAGS);
+    {
-  }
+      return SDMMC_ERROR_TIMEOUT;
+    }
-  return SDMMC_ERROR_NONE;
+    sta_reg = SDIOx->STA;
-}
+  }while(((sta_reg & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) == 0U) ||
+         ((sta_reg & SDIO_FLAG_CMDACT) != 0U ));
-/**
-  * @brief  Checks for error conditions for R3 (OCR) response.
+  if (__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT))
-  * @param  hsd: SD handle
+  {
-  * @retval SD Card error state
+    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT);
-  */
-static uint32_t SDMMC_GetCmdResp3(SDIO_TypeDef *SDIOx)
+    return SDMMC_ERROR_CMD_RSP_TIMEOUT;
-{
+  }
-  uint32_t sta_reg;
+  else if (__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL))
-  /* 8 is the number of required instructions cycles for the below loop statement.
+  {
-  The SDIO_CMDTIMEOUT is expressed in ms */
+    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL);
-  uint32_t count = SDIO_CMDTIMEOUT * (SystemCoreClock / 8U /1000U);
+    return SDMMC_ERROR_CMD_CRC_FAIL;
-  do
+  }
-  {
+  else
-    if (count-- == 0U)
+  {
-    {
+    /* No error flag set */
-      return SDMMC_ERROR_TIMEOUT;
+    /* Clear all the static flags */
-    }
+    __SDIO_CLEAR_FLAG(SDIOx, SDIO_STATIC_CMD_FLAGS);
-    sta_reg = SDIOx->STA;
+  }
-  }while(((sta_reg & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) == 0U) ||
-         ((sta_reg & SDIO_FLAG_CMDACT) != 0U ));
+  return SDMMC_ERROR_NONE;
+}
-  if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT))
-  {
+/**
-    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT);
+  * @brief  Checks for error conditions for R3 (OCR) response.
+  * @param  SDIOx Pointer to SDMMC register base
-    return SDMMC_ERROR_CMD_RSP_TIMEOUT;
+  * @retval SD Card error state
-  }
+  */
-  else
+uint32_t SDMMC_GetCmdResp3(SDIO_TypeDef *SDIOx)
-  {
+{
-    /* Clear all the static flags */
+  uint32_t sta_reg;
-    __SDIO_CLEAR_FLAG(SDIOx, SDIO_STATIC_CMD_FLAGS);
+  /* 8 is the number of required instructions cycles for the below loop statement.
-  }
+  The SDIO_CMDTIMEOUT is expressed in ms */
+  uint32_t count = SDIO_CMDTIMEOUT * (SystemCoreClock / 8U /1000U);
-  return SDMMC_ERROR_NONE;
-}
+  do
+  {
-/**
+    if (count-- == 0U)
-  * @brief  Checks for error conditions for R6 (RCA) response.
+    {
-  * @param  hsd: SD handle
+      return SDMMC_ERROR_TIMEOUT;
-  * @param  SD_CMD: The sent command index
+    }
-  * @param  pRCA: Pointer to the variable that will contain the SD card relative
+    sta_reg = SDIOx->STA;
-  *         address RCA
+  }while(((sta_reg & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) == 0U) ||
-  * @retval SD Card error state
+         ((sta_reg & SDIO_FLAG_CMDACT) != 0U ));
-  */
-static uint32_t SDMMC_GetCmdResp6(SDIO_TypeDef *SDIOx, uint8_t SD_CMD, uint16_t *pRCA)
+  if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT))
-{
+  {
-  uint32_t response_r1;
+    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT);
-  uint32_t sta_reg;
+    return SDMMC_ERROR_CMD_RSP_TIMEOUT;
-  /* 8 is the number of required instructions cycles for the below loop statement.
+  }
-  The SDIO_CMDTIMEOUT is expressed in ms */
+  else
-  uint32_t count = SDIO_CMDTIMEOUT * (SystemCoreClock / 8U /1000U);
+  {
+    /* Clear all the static flags */
-  do
+    __SDIO_CLEAR_FLAG(SDIOx, SDIO_STATIC_CMD_FLAGS);
-  {
+  }
-    if (count-- == 0U)
-    {
+  return SDMMC_ERROR_NONE;
-      return SDMMC_ERROR_TIMEOUT;
+}
-    }
-    sta_reg = SDIOx->STA;
+/**
-  }while(((sta_reg & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) == 0U) ||
+  * @brief  Checks for error conditions for R6 (RCA) response.
-         ((sta_reg & SDIO_FLAG_CMDACT) != 0U ));
+  * @param  SDIOx Pointer to SDMMC register base
+  * @param  SD_CMD: The sent command index
-  if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT))
+  * @param  pRCA: Pointer to the variable that will contain the SD card relative
-  {
+  *         address RCA
-    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT);
+  * @retval SD Card error state
+  */
-    return SDMMC_ERROR_CMD_RSP_TIMEOUT;
+uint32_t SDMMC_GetCmdResp6(SDIO_TypeDef *SDIOx, uint8_t SD_CMD, uint16_t *pRCA)
-  }
+{
-  else if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL))
+  uint32_t response_r1;
-  {
+  uint32_t sta_reg;
-    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL);
+  /* 8 is the number of required instructions cycles for the below loop statement.
-    return SDMMC_ERROR_CMD_CRC_FAIL;
+  The SDIO_CMDTIMEOUT is expressed in ms */
-  }
+  uint32_t count = SDIO_CMDTIMEOUT * (SystemCoreClock / 8U /1000U);
-  else
-  {
+  do
-    /* Nothing to do */
+  {
-  }
+    if (count-- == 0U)
+    {
-  /* Check response received is of desired command */
+      return SDMMC_ERROR_TIMEOUT;
-  if(SDIO_GetCommandResponse(SDIOx) != SD_CMD)
+    }
-  {
+    sta_reg = SDIOx->STA;
-    return SDMMC_ERROR_CMD_CRC_FAIL;
+  }while(((sta_reg & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) == 0U) ||
-  }
+         ((sta_reg & SDIO_FLAG_CMDACT) != 0U ));
-  /* Clear all the static flags */
+  if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT))
-  __SDIO_CLEAR_FLAG(SDIOx, SDIO_STATIC_CMD_FLAGS);
+  {
+    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT);
-  /* We have received response, retrieve it.  */
-  response_r1 = SDIO_GetResponse(SDIOx, SDIO_RESP1);
+    return SDMMC_ERROR_CMD_RSP_TIMEOUT;
+  }
-  if((response_r1 & (SDMMC_R6_GENERAL_UNKNOWN_ERROR | SDMMC_R6_ILLEGAL_CMD | SDMMC_R6_COM_CRC_FAILED)) == SDMMC_ALLZERO)
+  else if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL))
   {
-    *pRCA = (uint16_t) (response_r1 >> 16);
+    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL);
-    return SDMMC_ERROR_NONE;
+    return SDMMC_ERROR_CMD_CRC_FAIL;
   }
-  else if((response_r1 & SDMMC_R6_ILLEGAL_CMD) == SDMMC_R6_ILLEGAL_CMD)
+  else
   {
-    return SDMMC_ERROR_ILLEGAL_CMD;
+    /* Nothing to do */
   }
-  else if((response_r1 & SDMMC_R6_COM_CRC_FAILED) == SDMMC_R6_COM_CRC_FAILED)
-  {
+  /* Check response received is of desired command */
-    return SDMMC_ERROR_COM_CRC_FAILED;
+  if(SDIO_GetCommandResponse(SDIOx) != SD_CMD)
-  }
+  {
-  else
+    return SDMMC_ERROR_CMD_CRC_FAIL;
-  {
+  }
-    return SDMMC_ERROR_GENERAL_UNKNOWN_ERR;
-  }
+  /* Clear all the static flags */
-}
+  __SDIO_CLEAR_FLAG(SDIOx, SDIO_STATIC_CMD_FLAGS);
-/**
+  /* We have received response, retrieve it.  */
-  * @brief  Checks for error conditions for R7 response.
+  response_r1 = SDIO_GetResponse(SDIOx, SDIO_RESP1);
-  * @param  hsd: SD handle
-  * @retval SD Card error state
+  if((response_r1 & (SDMMC_R6_GENERAL_UNKNOWN_ERROR | SDMMC_R6_ILLEGAL_CMD | SDMMC_R6_COM_CRC_FAILED)) == SDMMC_ALLZERO)
-  */
+  {
-static uint32_t SDMMC_GetCmdResp7(SDIO_TypeDef *SDIOx)
+    *pRCA = (uint16_t) (response_r1 >> 16);
-{
-  uint32_t sta_reg;
+    return SDMMC_ERROR_NONE;
-  /* 8 is the number of required instructions cycles for the below loop statement.
+  }
-  The SDIO_CMDTIMEOUT is expressed in ms */
+  else if((response_r1 & SDMMC_R6_ILLEGAL_CMD) == SDMMC_R6_ILLEGAL_CMD)
-  uint32_t count = SDIO_CMDTIMEOUT * (SystemCoreClock / 8U /1000U);
+  {
+    return SDMMC_ERROR_ILLEGAL_CMD;
-  do
+  }
-  {
+  else if((response_r1 & SDMMC_R6_COM_CRC_FAILED) == SDMMC_R6_COM_CRC_FAILED)
-    if (count-- == 0U)
+  {
-    {
+    return SDMMC_ERROR_COM_CRC_FAILED;
-      return SDMMC_ERROR_TIMEOUT;
+  }
-    }
+  else
-    sta_reg = SDIOx->STA;
+  {
-  }while(((sta_reg & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) == 0U) ||
+    return SDMMC_ERROR_GENERAL_UNKNOWN_ERR;
-         ((sta_reg & SDIO_FLAG_CMDACT) != 0U ));
+  }
+}
-  if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT))
-  {
+/**
-    /* Card is SD V2.0 compliant */
+  * @brief  Checks for error conditions for R7 response.
-    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT);
+  * @param  SDIOx Pointer to SDMMC register base
+  * @retval SD Card error state
-    return SDMMC_ERROR_CMD_RSP_TIMEOUT;
+  */
-  }
+uint32_t SDMMC_GetCmdResp7(SDIO_TypeDef *SDIOx)
-  else if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL))
+{
-  {
+  uint32_t sta_reg;
-    /* Card is SD V2.0 compliant */
+  /* 8 is the number of required instructions cycles for the below loop statement.
-    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL);
+  The SDIO_CMDTIMEOUT is expressed in ms */
+  uint32_t count = SDIO_CMDTIMEOUT * (SystemCoreClock / 8U /1000U);
-    return SDMMC_ERROR_CMD_CRC_FAIL;
-  }
+  do
-  else
+  {
-  {
+    if (count-- == 0U)
-    /* Nothing to do */
+    {
-  }
+      return SDMMC_ERROR_TIMEOUT;
+    }
-  if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CMDREND))
+    sta_reg = SDIOx->STA;
-  {
+  }while(((sta_reg & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) == 0U) ||
-    /* Card is SD V2.0 compliant */
+         ((sta_reg & SDIO_FLAG_CMDACT) != 0U ));
-    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CMDREND);
-  }
+  if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT))
+  {
-  return SDMMC_ERROR_NONE;
+    /* Card is SD V2.0 compliant */
+    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CTIMEOUT);
-}
+    return SDMMC_ERROR_CMD_RSP_TIMEOUT;
-/**
+  }
-  * @brief  Send the Send EXT_CSD command and check the response.
+  else if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL))
-  * @param  SDIOx: Pointer to SDMMC register base
+  {
-  * @param  Argument: Command Argument
+    /* Card is SD V2.0 compliant */
-  * @retval HAL status
+    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CCRCFAIL);
-  */
-uint32_t SDMMC_CmdSendEXTCSD(SDIO_TypeDef *SDIOx, uint32_t Argument)
+    return SDMMC_ERROR_CMD_CRC_FAIL;
-{
+  }
-  SDIO_CmdInitTypeDef  sdmmc_cmdinit;
+  else
-  uint32_t errorstate;
+  {
+    /* Nothing to do */
-  /* Send CMD9 SEND_CSD */
+  }
-  sdmmc_cmdinit.Argument         = Argument;
-  sdmmc_cmdinit.CmdIndex         = SDMMC_CMD_HS_SEND_EXT_CSD;
+  if(__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CMDREND))
-  sdmmc_cmdinit.Response         = SDIO_RESPONSE_SHORT;
+  {
-  sdmmc_cmdinit.WaitForInterrupt = SDIO_WAIT_NO;
+    /* Card is SD V2.0 compliant */
-  sdmmc_cmdinit.CPSM             = SDIO_CPSM_ENABLE;
+    __SDIO_CLEAR_FLAG(SDIOx, SDIO_FLAG_CMDREND);
-  (void)SDIO_SendCommand(SDIOx, &sdmmc_cmdinit);
+  }
-  /* Check for error conditions */
+  return SDMMC_ERROR_NONE;
-  errorstate = SDMMC_GetCmdResp1(SDIOx, SDMMC_CMD_HS_SEND_EXT_CSD,SDIO_CMDTIMEOUT);
+}
-  return errorstate;
-}
+/**
+  * @}
+  */
-/**
-  * @}
+/* Private function ----------------------------------------------------------*/
-  */
+/** @addtogroup SD_Private_Functions
+  * @{
-#endif /* HAL_SD_MODULE_ENABLED || HAL_MMC_MODULE_ENABLED */
+  */
-/**
-  * @}
+/**
-  */
+  * @brief  Checks for error conditions for CMD0.
+  * @param  SDIOx Pointer to SDMMC register base
-/**
+  * @retval SD Card error state
-  * @}
+  */
-  */
+static uint32_t SDMMC_GetCmdError(SDIO_TypeDef *SDIOx)
+{
-#endif /* SDIO */
+  /* 8 is the number of required instructions cycles for the below loop statement.
+  The SDIO_CMDTIMEOUT is expressed in ms */
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+  uint32_t count = SDIO_CMDTIMEOUT * (SystemCoreClock / 8U /1000U);
+  do
+  {
+    if (count-- == 0U)
+    {
+      return SDMMC_ERROR_TIMEOUT;
+    }
+  }while(!__SDIO_GET_FLAG(SDIOx, SDIO_FLAG_CMDSENT));
+  /* Clear all the static flags */
+  __SDIO_CLEAR_FLAG(SDIOx, SDIO_STATIC_CMD_FLAGS);
+  return SDMMC_ERROR_NONE;
+}
+/**
+  * @}
+  */
+#endif /* HAL_SD_MODULE_ENABLED || HAL_MMC_MODULE_ENABLED */
+/**
+  * @}
+  */
+/**
+  * @}
+  */
+#endif /* SDIO */

Subversion Repositories canSerial

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