Subversion Repositories canSerial

/**

/**

  ******************************************************************************

  ******************************************************************************

  * @file    stm32f1xx_hal_mmc.c

  * @file    stm32f1xx_hal_mmc.c

  * @author  MCD Application Team

  * @author  MCD Application Team

  * @brief   MMC card HAL module driver.

  * @brief   MMC card HAL module driver.

  *          This file provides firmware functions to manage the following

  *          This file provides firmware functions to manage the following

  *          functionalities of the Secure Digital (MMC) peripheral:

  *          functionalities of the Secure Digital (MMC) peripheral:

  *           + Initialization and de-initialization functions

  *           + Initialization and de-initialization functions

  *           + IO operation functions

  *           + IO operation functions

  *           + Peripheral Control functions

  *           + Peripheral Control functions

  *           + MMC card Control functions

  *           + MMC card Control functions

  *

  *

  @verbatim

  ******************************************************************************

  ==============================================================================

  * @attention

                        ##### How to use this driver #####

  *

  ==============================================================================

  * Copyright (c) 2016 STMicroelectronics.

  [..]

  * All rights reserved.

    This driver implements a high level communication layer for read and write from/to

  *

    this memory. The needed STM32 hardware resources (SDMMC and GPIO) are performed by

  * This software is licensed under terms that can be found in the LICENSE file

    the user in HAL_MMC_MspInit() function (MSP layer).

  * in the root directory of this software component.

    Basically, the MSP layer configuration should be the same as we provide in the

  * If no LICENSE file comes with this software, it is provided AS-IS.

    examples.

  *

    You can easily tailor this configuration according to hardware resources.

  ******************************************************************************

  @verbatim

  [..]

  ==============================================================================

    This driver is a generic layered driver for SDMMC memories which uses the HAL

                        ##### How to use this driver #####

    SDMMC driver functions to interface with MMC and eMMC cards devices.

  ==============================================================================

    It is used as follows:

  [..]

    This driver implements a high level communication layer for read and write from/to

    (#)Initialize the SDMMC low level resources by implement the HAL_MMC_MspInit() API:

    this memory. The needed STM32 hardware resources (SDMMC and GPIO) are performed by

        (##) Enable the SDMMC interface clock using __HAL_RCC_SDMMC_CLK_ENABLE();

    the user in HAL_MMC_MspInit() function (MSP layer).

        (##) SDMMC pins configuration for MMC card

    Basically, the MSP layer configuration should be the same as we provide in the

            (+++) Enable the clock for the SDMMC GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE();

    examples.

            (+++) Configure these SDMMC pins as alternate function pull-up using HAL_GPIO_Init()

    You can easily tailor this configuration according to hardware resources.

                  and according to your pin assignment;

        (##) DMA Configuration if you need to use DMA process (HAL_MMC_ReadBlocks_DMA()

  [..]

             and HAL_MMC_WriteBlocks_DMA() APIs).

    This driver is a generic layered driver for SDMMC memories which uses the HAL

            (+++) Enable the DMAx interface clock using __HAL_RCC_DMAx_CLK_ENABLE();

    SDMMC driver functions to interface with MMC and eMMC cards devices.

            (+++) Configure the DMA using the function HAL_DMA_Init() with predeclared and filled.

    It is used as follows:

        (##) NVIC configuration if you need to use interrupt process when using DMA transfer.

            (+++) Configure the SDMMC and DMA interrupt priorities using function HAL_NVIC_SetPriority();

    (#)Initialize the SDMMC low level resources by implement the HAL_MMC_MspInit() API:

                  DMA priority is superior to SDMMC's priority

        (##) Enable the SDMMC interface clock using __HAL_RCC_SDMMC_CLK_ENABLE();

            (+++) Enable the NVIC DMA and SDMMC IRQs using function HAL_NVIC_EnableIRQ()

        (##) SDMMC pins configuration for MMC card

            (+++) SDMMC interrupts are managed using the macros __HAL_MMC_ENABLE_IT()

            (+++) Enable the clock for the SDMMC GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE();

                  and __HAL_MMC_DISABLE_IT() inside the communication process.

            (+++) Configure these SDMMC pins as alternate function pull-up using HAL_GPIO_Init()

            (+++) SDMMC interrupts pending bits are managed using the macros __HAL_MMC_GET_IT()

                  and according to your pin assignment;

                  and __HAL_MMC_CLEAR_IT()

        (##) DMA Configuration if you need to use DMA process (HAL_MMC_ReadBlocks_DMA()

        (##) NVIC configuration if you need to use interrupt process (HAL_MMC_ReadBlocks_IT()

             and HAL_MMC_WriteBlocks_DMA() APIs).

             and HAL_MMC_WriteBlocks_IT() APIs).

            (+++) Enable the DMAx interface clock using __HAL_RCC_DMAx_CLK_ENABLE();

            (+++) Configure the SDMMC interrupt priorities using function HAL_NVIC_SetPriority();

            (+++) Configure the DMA using the function HAL_DMA_Init() with predeclared and filled.

            (+++) Enable the NVIC SDMMC IRQs using function HAL_NVIC_EnableIRQ()

        (##) NVIC configuration if you need to use interrupt process when using DMA transfer.

            (+++) SDMMC interrupts are managed using the macros __HAL_MMC_ENABLE_IT()

            (+++) Configure the SDMMC and DMA interrupt priorities using function HAL_NVIC_SetPriority();

                  and __HAL_MMC_DISABLE_IT() inside the communication process.

                  DMA priority is superior to SDMMC's priority

            (+++) SDMMC interrupts pending bits are managed using the macros __HAL_MMC_GET_IT()

            (+++) Enable the NVIC DMA and SDMMC IRQs using function HAL_NVIC_EnableIRQ()

                  and __HAL_MMC_CLEAR_IT()

            (+++) SDMMC interrupts are managed using the macros __HAL_MMC_ENABLE_IT()

    (#) At this stage, you can perform MMC read/write/erase operations after MMC card initialization

                  and __HAL_MMC_DISABLE_IT() inside the communication process.

            (+++) SDMMC interrupts pending bits are managed using the macros __HAL_MMC_GET_IT()

                  and __HAL_MMC_CLEAR_IT()

  *** MMC Card Initialization and configuration ***

        (##) NVIC configuration if you need to use interrupt process (HAL_MMC_ReadBlocks_IT()

  ================================================

             and HAL_MMC_WriteBlocks_IT() APIs).

  [..]

            (+++) Configure the SDMMC interrupt priorities using function HAL_NVIC_SetPriority();

    To initialize the MMC Card, use the HAL_MMC_Init() function. It Initializes

            (+++) Enable the NVIC SDMMC IRQs using function HAL_NVIC_EnableIRQ()

    SDMMC Peripheral (STM32 side) and the MMC Card, and put it into StandBy State (Ready for data transfer).

            (+++) SDMMC interrupts are managed using the macros __HAL_MMC_ENABLE_IT()

    This function provide the following operations:

                  and __HAL_MMC_DISABLE_IT() inside the communication process.

            (+++) SDMMC interrupts pending bits are managed using the macros __HAL_MMC_GET_IT()

    (#) Initialize the SDMMC peripheral interface with defaullt configuration.

                  and __HAL_MMC_CLEAR_IT()

        The initialization process is done at 400KHz. You can change or adapt

    (#) At this stage, you can perform MMC read/write/erase operations after MMC card initialization

        this frequency by adjusting the "ClockDiv" field.

        The MMC Card frequency (SDMMC_CK) is computed as follows:

  *** MMC Card Initialization and configuration ***

           SDMMC_CK = SDMMCCLK / (ClockDiv + 2)

  ================================================

  [..]

        In initialization mode and according to the MMC Card standard,

    To initialize the MMC Card, use the HAL_MMC_Init() function. It Initializes

        make sure that the SDMMC_CK frequency doesn't exceed 400KHz.

    SDMMC Peripheral (STM32 side) and the MMC Card, and put it into StandBy State (Ready for data transfer).

    This function provide the following operations:

        This phase of initialization is done through SDMMC_Init() and

        SDMMC_PowerState_ON() SDMMC low level APIs.

    (#) Initialize the SDMMC peripheral interface with default configuration.

        The initialization process is done at 400KHz. You can change or adapt

    (#) Initialize the MMC card. The API used is HAL_MMC_InitCard().

        this frequency by adjusting the "ClockDiv" field.

        This phase allows the card initialization and identification

        The MMC Card frequency (SDMMC_CK) is computed as follows:

        and check the MMC Card type (Standard Capacity or High Capacity)

        The initialization flow is compatible with MMC standard.

           SDMMC_CK = SDMMCCLK / (ClockDiv + 2)

        This API (HAL_MMC_InitCard()) could be used also to reinitialize the card in case

        In initialization mode and according to the MMC Card standard,

        of plug-off plug-in.

        make sure that the SDMMC_CK frequency doesn't exceed 400KHz.

    (#) Configure the MMC Card Data transfer frequency. By Default, the card transfer

        This phase of initialization is done through SDMMC_Init() and

        frequency is set to 24MHz. You can change or adapt this frequency by adjusting

        SDMMC_PowerState_ON() SDMMC low level APIs.

        the "ClockDiv" field.

        In transfer mode and according to the MMC Card standard, make sure that the

    (#) Initialize the MMC card. The API used is HAL_MMC_InitCard().

        SDMMC_CK frequency doesn't exceed 25MHz and 50MHz in High-speed mode switch.

        This phase allows the card initialization and identification

        To be able to use a frequency higher than 24MHz, you should use the SDMMC

        and check the MMC Card type (Standard Capacity or High Capacity)

        peripheral in bypass mode. Refer to the corresponding reference manual

        The initialization flow is compatible with MMC standard.

        for more details.

        This API (HAL_MMC_InitCard()) could be used also to reinitialize the card in case

    (#) Select the corresponding MMC Card according to the address read with the step 2.

        of plug-off plug-in.

    (#) Configure the MMC Card in wide bus mode: 4-bits data.

    (#) Configure the MMC Card Data transfer frequency. By Default, the card transfer

        frequency is set to 24MHz. You can change or adapt this frequency by adjusting

  *** MMC Card Read operation ***

        the "ClockDiv" field.

  ==============================

        In transfer mode and according to the MMC Card standard, make sure that the

  [..]

        SDMMC_CK frequency doesn't exceed 25MHz and 50MHz in High-speed mode switch.

    (+) You can read from MMC card in polling mode by using function HAL_MMC_ReadBlocks().

        To be able to use a frequency higher than 24MHz, you should use the SDMMC

        This function support only 512-bytes block length (the block size should be

        peripheral in bypass mode. Refer to the corresponding reference manual

        chosen as 512 bytes).

        for more details.

        You can choose either one block read operation or multiple block read operation

        by adjusting the "NumberOfBlocks" parameter.

    (#) Select the corresponding MMC Card according to the address read with the step 2.

        After this, you have to ensure that the transfer is done correctly. The check is done

        through HAL_MMC_GetCardState() function for MMC card state.

    (#) Configure the MMC Card in wide bus mode: 4-bits data.

    (+) You can read from MMC card in DMA mode by using function HAL_MMC_ReadBlocks_DMA().

  *** MMC Card Read operation ***

        This function support only 512-bytes block length (the block size should be

  ==============================

        chosen as 512 bytes).

  [..]

        You can choose either one block read operation or multiple block read operation

    (+) You can read from MMC card in polling mode by using function HAL_MMC_ReadBlocks().

        by adjusting the "NumberOfBlocks" parameter.

        This function support only 512-bytes block length (the block size should be

        After this, you have to ensure that the transfer is done correctly. The check is done

        chosen as 512 bytes).

        through HAL_MMC_GetCardState() function for MMC card state.

        You can choose either one block read operation or multiple block read operation

        You could also check the DMA transfer process through the MMC Rx interrupt event.

        by adjusting the "NumberOfBlocks" parameter.

        After this, you have to ensure that the transfer is done correctly. The check is done

    (+) You can read from MMC card in Interrupt mode by using function HAL_MMC_ReadBlocks_IT().

        through HAL_MMC_GetCardState() function for MMC card state.

        This function allows the read of 512 bytes blocks.

        You can choose either one block read operation or multiple block read operation

    (+) You can read from MMC card in DMA mode by using function HAL_MMC_ReadBlocks_DMA().

        by adjusting the "NumberOfBlocks" parameter.

        This function support only 512-bytes block length (the block size should be

        After this, you have to ensure that the transfer is done correctly. The check is done

        chosen as 512 bytes).

        through HAL_MMC_GetCardState() function for MMC card state.

        You can choose either one block read operation or multiple block read operation

        You could also check the IT transfer process through the MMC Rx interrupt event.

        by adjusting the "NumberOfBlocks" parameter.

        After this, you have to ensure that the transfer is done correctly. The check is done

  *** MMC Card Write operation ***

        through HAL_MMC_GetCardState() function for MMC card state.

  ===============================

        You could also check the DMA transfer process through the MMC Rx interrupt event.

  [..]

    (+) You can write to MMC card in polling mode by using function HAL_MMC_WriteBlocks().

    (+) You can read from MMC card in Interrupt mode by using function HAL_MMC_ReadBlocks_IT().

        This function support only 512-bytes block length (the block size should be

        This function allows the read of 512 bytes blocks.

        chosen as 512 bytes).

        You can choose either one block read operation or multiple block read operation

        You can choose either one block read operation or multiple block read operation

        by adjusting the "NumberOfBlocks" parameter.

        by adjusting the "NumberOfBlocks" parameter.

        After this, you have to ensure that the transfer is done correctly. The check is done

        After this, you have to ensure that the transfer is done correctly. The check is done

        through HAL_MMC_GetCardState() function for MMC card state.

        through HAL_MMC_GetCardState() function for MMC card state.

        You could also check the IT transfer process through the MMC Rx interrupt event.

    (+) You can write to MMC card in DMA mode by using function HAL_MMC_WriteBlocks_DMA().

  *** MMC Card Write operation ***

        This function support only 512-bytes block length (the block size should be

  ===============================

        chosen as 512 byte).

  [..]

        You can choose either one block read operation or multiple block read operation

    (+) You can write to MMC card in polling mode by using function HAL_MMC_WriteBlocks().

        by adjusting the "NumberOfBlocks" parameter.

        This function support only 512-bytes block length (the block size should be

        After this, you have to ensure that the transfer is done correctly. The check is done

        chosen as 512 bytes).

        through HAL_MMC_GetCardState() function for MMC card state.

        You can choose either one block read operation or multiple block read operation

        You could also check the DMA transfer process through the MMC Tx interrupt event.  

        by adjusting the "NumberOfBlocks" parameter.

        After this, you have to ensure that the transfer is done correctly. The check is done

    (+) You can write to MMC card in Interrupt mode by using function HAL_MMC_WriteBlocks_IT().

        through HAL_MMC_GetCardState() function for MMC card state.

        This function allows the read of 512 bytes blocks.

        You can choose either one block read operation or multiple block read operation

    (+) You can write to MMC card in DMA mode by using function HAL_MMC_WriteBlocks_DMA().

        by adjusting the "NumberOfBlocks" parameter.

        This function support only 512-bytes block length (the block size should be

        After this, you have to ensure that the transfer is done correctly. The check is done

        chosen as 512 byte).

        through HAL_MMC_GetCardState() function for MMC card state.

        You can choose either one block read operation or multiple block read operation

        You could also check the IT transfer process through the MMC Tx interrupt event.

        by adjusting the "NumberOfBlocks" parameter.

        After this, you have to ensure that the transfer is done correctly. The check is done

  *** MMC card information ***

        through HAL_MMC_GetCardState() function for MMC card state.

  ===========================

        You could also check the DMA transfer process through the MMC Tx interrupt event.  

  [..]

    (+) To get MMC card information, you can use the function HAL_MMC_GetCardInfo().

    (+) You can write to MMC card in Interrupt mode by using function HAL_MMC_WriteBlocks_IT().

        It returns useful information about the MMC card such as block size, card type,

        This function allows the read of 512 bytes blocks.

        block number ...

        You can choose either one block read operation or multiple block read operation

        by adjusting the "NumberOfBlocks" parameter.

  *** MMC card CSD register ***

        After this, you have to ensure that the transfer is done correctly. The check is done

  ============================

        through HAL_MMC_GetCardState() function for MMC card state.

  [..]

        You could also check the IT transfer process through the MMC Tx interrupt event.

    (+) The HAL_MMC_GetCardCSD() API allows to get the parameters of the CSD register.

        Some of the CSD parameters are useful for card initialization and identification.

  *** MMC card information ***

  ===========================

  *** MMC card CID register ***

  [..]

  ============================

    (+) To get MMC card information, you can use the function HAL_MMC_GetCardInfo().

  [..]

        It returns useful information about the MMC card such as block size, card type,

    (+) The HAL_MMC_GetCardCID() API allows to get the parameters of the CID register.

        block number ...

        Some of the CID parameters are useful for card initialization and identification.

  *** MMC card CSD register ***

  *** MMC HAL driver macros list ***

  ============================

  ==================================

  [..]

  [..]

    (+) The HAL_MMC_GetCardCSD() API allows to get the parameters of the CSD register.

    Below the list of most used macros in MMC HAL driver.

        Some of the CSD parameters are useful for card initialization and identification.

    (+) __HAL_MMC_ENABLE : Enable the MMC device

  *** MMC card CID register ***

    (+) __HAL_MMC_DISABLE : Disable the MMC device

  ============================

    (+) __HAL_MMC_DMA_ENABLE: Enable the SDMMC DMA transfer

  [..]

    (+) __HAL_MMC_DMA_DISABLE: Disable the SDMMC DMA transfer

    (+) The HAL_MMC_GetCardCID() API allows to get the parameters of the CID register.

    (+) __HAL_MMC_ENABLE_IT: Enable the MMC device interrupt

        Some of the CID parameters are useful for card initialization and identification.

    (+) __HAL_MMC_DISABLE_IT: Disable the MMC device interrupt

    (+) __HAL_MMC_GET_FLAG:Check whether the specified MMC flag is set or not

  *** MMC HAL driver macros list ***

    (+) __HAL_MMC_CLEAR_FLAG: Clear the MMC's pending flags

  ==================================

  [..]

  [..]

    Below the list of most used macros in MMC HAL driver.

    (@) You can refer to the MMC HAL driver header file for more useful macros

    (+) __HAL_MMC_ENABLE : Enable the MMC device

  *** Callback registration ***

    (+) __HAL_MMC_DISABLE : Disable the MMC device

  =============================================

    (+) __HAL_MMC_DMA_ENABLE: Enable the SDMMC DMA transfer

  [..]

    (+) __HAL_MMC_DMA_DISABLE: Disable the SDMMC DMA transfer

    The compilation define USE_HAL_MMC_REGISTER_CALLBACKS when set to 1

    (+) __HAL_MMC_ENABLE_IT: Enable the MMC device interrupt

    allows the user to configure dynamically the driver callbacks.

    (+) __HAL_MMC_DISABLE_IT: Disable the MMC device interrupt

    (+) __HAL_MMC_GET_FLAG:Check whether the specified MMC flag is set or not

    Use Functions @ref HAL_MMC_RegisterCallback() to register a user callback,

    (+) __HAL_MMC_CLEAR_FLAG: Clear the MMC's pending flags

    it allows to register following callbacks:

      (+) TxCpltCallback : callback when a transmission transfer is completed.

  [..]

      (+) RxCpltCallback : callback when a reception transfer is completed.

    (@) You can refer to the MMC HAL driver header file for more useful macros

      (+) ErrorCallback : callback when error occurs.

      (+) AbortCpltCallback : callback when abort is completed.

  *** Callback registration ***

      (+) MspInitCallback    : MMC MspInit.

  =============================================

      (+) MspDeInitCallback  : MMC MspDeInit.

  [..]

    This function takes as parameters the HAL peripheral handle, the Callback ID

    The compilation define USE_HAL_MMC_REGISTER_CALLBACKS when set to 1

    and a pointer to the user callback function.

    allows the user to configure dynamically the driver callbacks.

    Use function @ref HAL_MMC_UnRegisterCallback() to reset a callback to the default

    Use Functions HAL_MMC_RegisterCallback() to register a user callback,

    weak (surcharged) function. It allows to reset following callbacks:

    it allows to register following callbacks:

      (+) TxCpltCallback : callback when a transmission transfer is completed.

      (+) TxCpltCallback : callback when a transmission transfer is completed.

      (+) RxCpltCallback : callback when a reception transfer is completed.

      (+) RxCpltCallback : callback when a reception transfer is completed.

      (+) ErrorCallback : callback when error occurs.

      (+) ErrorCallback : callback when error occurs.

      (+) AbortCpltCallback : callback when abort is completed.

      (+) AbortCpltCallback : callback when abort is completed.

      (+) MspInitCallback    : MMC MspInit.

      (+) MspInitCallback    : MMC MspInit.

      (+) MspDeInitCallback  : MMC MspDeInit.

      (+) MspDeInitCallback  : MMC MspDeInit.

    This function) takes as parameters the HAL peripheral handle and the Callback ID.

    This function takes as parameters the HAL peripheral handle, the Callback ID

    and a pointer to the user callback function.

    By default, after the @ref HAL_MMC_Init and if the state is HAL_MMC_STATE_RESET

    all callbacks are reset to the corresponding legacy weak (surcharged) functions.

    Use function HAL_MMC_UnRegisterCallback() to reset a callback to the default

    Exception done for MspInit and MspDeInit callbacks that are respectively

    weak (surcharged) function. It allows to reset following callbacks:

    reset to the legacy weak (surcharged) functions in the @ref HAL_MMC_Init

      (+) TxCpltCallback : callback when a transmission transfer is completed.

    and @ref  HAL_MMC_DeInit only when these callbacks are null (not registered beforehand).

      (+) RxCpltCallback : callback when a reception transfer is completed.

    If not, MspInit or MspDeInit are not null, the @ref HAL_MMC_Init and @ref HAL_MMC_DeInit

      (+) ErrorCallback : callback when error occurs.

    keep and use the user MspInit/MspDeInit callbacks (registered beforehand)

      (+) AbortCpltCallback : callback when abort is completed.

      (+) MspInitCallback    : MMC MspInit.

    Callbacks can be registered/unregistered in READY state only.

      (+) MspDeInitCallback  : MMC MspDeInit.

    Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered

    This function) takes as parameters the HAL peripheral handle and the Callback ID.

    in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used

    during the Init/DeInit.

    By default, after the HAL_MMC_Init and if the state is HAL_MMC_STATE_RESET

    In that case first register the MspInit/MspDeInit user callbacks

    all callbacks are reset to the corresponding legacy weak (surcharged) functions.

    using @ref HAL_MMC_RegisterCallback before calling @ref HAL_MMC_DeInit

    Exception done for MspInit and MspDeInit callbacks that are respectively

    or @ref HAL_MMC_Init function.

    reset to the legacy weak (surcharged) functions in the HAL_MMC_Init

    and  HAL_MMC_DeInit only when these callbacks are null (not registered beforehand).

    When The compilation define USE_HAL_MMC_REGISTER_CALLBACKS is set to 0 or

    If not, MspInit or MspDeInit are not null, the HAL_MMC_Init and HAL_MMC_DeInit

    not defined, the callback registering feature is not available

    keep and use the user MspInit/MspDeInit callbacks (registered beforehand)

    and weak (surcharged) callbacks are used.

    Callbacks can be registered/unregistered in READY state only.

  @endverbatim

    Exception done for MspInit/MspDeInit callbacks that can be registered/unregistered

  ******************************************************************************

    in READY or RESET state, thus registered (user) MspInit/DeInit callbacks can be used

  * @attention

    during the Init/DeInit.

  *

    In that case first register the MspInit/MspDeInit user callbacks

  * <h2><center>&copy; Copyright (c) 2018 STMicroelectronics.

    using HAL_MMC_RegisterCallback before calling HAL_MMC_DeInit

  * All rights reserved.</center></h2>

    or HAL_MMC_Init function.

  *

  * This software component is licensed by ST under BSD 3-Clause license,

    When The compilation define USE_HAL_MMC_REGISTER_CALLBACKS is set to 0 or

  * the "License"; You may not use this file except in compliance with the

    not defined, the callback registering feature is not available

  * License. You may obtain a copy of the License at:

    and weak (surcharged) callbacks are used.

  *                       opensource.org/licenses/BSD-3-Clause

  *

  @endverbatim

  ******************************************************************************

  ******************************************************************************

  */

  */

/* Includes ------------------------------------------------------------------*/

/* Includes ------------------------------------------------------------------*/

#include "stm32f1xx_hal.h"

#include "stm32f1xx_hal.h"

/** @addtogroup STM32F1xx_HAL_Driver

/** @addtogroup STM32F1xx_HAL_Driver

  * @{

  * @{

  */

  */

/** @defgroup MMC MMC

/** @defgroup MMC MMC

  * @brief MMC HAL module driver

  * @brief MMC HAL module driver

  * @{

  * @{

  */

  */

#ifdef HAL_MMC_MODULE_ENABLED

#ifdef HAL_MMC_MODULE_ENABLED

#if defined(SDIO)

#if defined(SDIO)

/* Private typedef -----------------------------------------------------------*/

/* Private typedef -----------------------------------------------------------*/

/* Private define ------------------------------------------------------------*/

/* Private define ------------------------------------------------------------*/

/** @addtogroup MMC_Private_Defines

/** @addtogroup MMC_Private_Defines

  * @{

  * @{

  */

  */

#if defined (VDD_VALUE) && (VDD_VALUE <= 1950U)

/**

#define MMC_VOLTAGE_RANGE               EMMC_LOW_VOLTAGE_RANGE

  * @}

  */

#define MMC_EXT_CSD_PWR_CL_26_INDEX     201

#define MMC_EXT_CSD_PWR_CL_52_INDEX     200

/* Private macro -------------------------------------------------------------*/

#define MMC_EXT_CSD_PWR_CL_DDR_52_INDEX 238

/* Private variables ---------------------------------------------------------*/

/* Private function prototypes -----------------------------------------------*/

#define MMC_EXT_CSD_PWR_CL_26_POS       8

/* Private functions ---------------------------------------------------------*/

#define MMC_EXT_CSD_PWR_CL_52_POS       0

/** @defgroup MMC_Private_Functions MMC Private Functions

#define MMC_EXT_CSD_PWR_CL_DDR_52_POS   16

  * @{

#else

  */

#define MMC_VOLTAGE_RANGE               EMMC_HIGH_VOLTAGE_RANGE

static uint32_t MMC_InitCard(MMC_HandleTypeDef *hmmc);

static uint32_t MMC_PowerON(MMC_HandleTypeDef *hmmc);

#define MMC_EXT_CSD_PWR_CL_26_INDEX     203

static uint32_t MMC_SendStatus(MMC_HandleTypeDef *hmmc, uint32_t *pCardStatus);

#define MMC_EXT_CSD_PWR_CL_52_INDEX     202

static uint32_t MMC_ReadExtCSD(MMC_HandleTypeDef *hmmc, uint32_t *pFieldData, uint16_t FieldIndex, uint32_t Timeout);

#define MMC_EXT_CSD_PWR_CL_DDR_52_INDEX 239

static void     MMC_PowerOFF(MMC_HandleTypeDef *hmmc);

static void     MMC_Write_IT(MMC_HandleTypeDef *hmmc);

#define MMC_EXT_CSD_PWR_CL_26_POS       24

static void     MMC_Read_IT(MMC_HandleTypeDef *hmmc);

#define MMC_EXT_CSD_PWR_CL_52_POS       16

static void     MMC_DMATransmitCplt(DMA_HandleTypeDef *hdma);

#define MMC_EXT_CSD_PWR_CL_DDR_52_POS   24

static void     MMC_DMAReceiveCplt(DMA_HandleTypeDef *hdma);

#endif

static void     MMC_DMAError(DMA_HandleTypeDef *hdma);

static void     MMC_DMATxAbort(DMA_HandleTypeDef *hdma);

/* Frequencies used in the driver for clock divider calculation */

static void     MMC_DMARxAbort(DMA_HandleTypeDef *hdma);

#define MMC_INIT_FREQ                   400000U   /* Initialization phase : 400 kHz max */

/**

/**

  * @}

  * @}

  */

  */

/* Exported functions --------------------------------------------------------*/

/** @addtogroup MMC_Exported_Functions

/* Private macro -------------------------------------------------------------*/

  * @{

/* Private variables ---------------------------------------------------------*/

  */

/* Private function prototypes -----------------------------------------------*/

/* Private functions ---------------------------------------------------------*/

/** @addtogroup MMC_Exported_Functions_Group1

/** @defgroup MMC_Private_Functions MMC Private Functions

 *  @brief   Initialization and de-initialization functions

  * @{

 *

  */

@verbatim

static uint32_t MMC_InitCard(MMC_HandleTypeDef *hmmc);

  ==============================================================================

static uint32_t MMC_PowerON(MMC_HandleTypeDef *hmmc);

          ##### Initialization and de-initialization functions #####

static uint32_t MMC_SendStatus(MMC_HandleTypeDef *hmmc, uint32_t *pCardStatus);

  ==============================================================================

static uint32_t MMC_ReadExtCSD(MMC_HandleTypeDef *hmmc, uint32_t *pFieldData, uint16_t FieldIndex, uint32_t Timeout);

  [..]

static void     MMC_PowerOFF(MMC_HandleTypeDef *hmmc);

    This section provides functions allowing to initialize/de-initialize the MMC

static void     MMC_Write_IT(MMC_HandleTypeDef *hmmc);

    card device to be ready for use.

static void     MMC_Read_IT(MMC_HandleTypeDef *hmmc);

static void     MMC_DMATransmitCplt(DMA_HandleTypeDef *hdma);

@endverbatim

static void     MMC_DMAReceiveCplt(DMA_HandleTypeDef *hdma);

  * @{

static void     MMC_DMAError(DMA_HandleTypeDef *hdma);

  */

static void     MMC_DMATxAbort(DMA_HandleTypeDef *hdma);

static void     MMC_DMARxAbort(DMA_HandleTypeDef *hdma);

/**

static uint32_t MMC_PwrClassUpdate(MMC_HandleTypeDef *hmmc, uint32_t Wide);

  * @brief  Initializes the MMC according to the specified parameters in the

/**

            MMC_HandleTypeDef and create the associated handle.

  * @}

  * @param  hmmc: Pointer to the MMC handle

  */

  * @retval HAL status

/* Exported functions --------------------------------------------------------*/

  */

/** @addtogroup MMC_Exported_Functions

HAL_StatusTypeDef HAL_MMC_Init(MMC_HandleTypeDef *hmmc)

  * @{

{

  */

  /* Check the MMC handle allocation */

  if(hmmc == NULL)

/** @addtogroup MMC_Exported_Functions_Group1

  {

 *  @brief   Initialization and de-initialization functions

    return HAL_ERROR;

 *

  }

@verbatim

  ==============================================================================

  /* Check the parameters */

          ##### Initialization and de-initialization functions #####

  assert_param(IS_SDIO_ALL_INSTANCE(hmmc->Instance));

  ==============================================================================

  assert_param(IS_SDIO_CLOCK_EDGE(hmmc->Init.ClockEdge));

  [..]

  assert_param(IS_SDIO_CLOCK_BYPASS(hmmc->Init.ClockBypass));

    This section provides functions allowing to initialize/de-initialize the MMC

  assert_param(IS_SDIO_CLOCK_POWER_SAVE(hmmc->Init.ClockPowerSave));

    card device to be ready for use.

  assert_param(IS_SDIO_BUS_WIDE(hmmc->Init.BusWide));

  assert_param(IS_SDIO_HARDWARE_FLOW_CONTROL(hmmc->Init.HardwareFlowControl));

@endverbatim

  assert_param(IS_SDIO_CLKDIV(hmmc->Init.ClockDiv));

  * @{

  */

  if(hmmc->State == HAL_MMC_STATE_RESET)

  {

/**

    /* Allocate lock resource and initialize it */

  * @brief  Initializes the MMC according to the specified parameters in the

    hmmc->Lock = HAL_UNLOCKED;

            MMC_HandleTypeDef and create the associated handle.

#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)

  * @param  hmmc: Pointer to the MMC handle

    /* Reset Callback pointers in HAL_MMC_STATE_RESET only */

  * @retval HAL status

    hmmc->TxCpltCallback    = HAL_MMC_TxCpltCallback;

  */

    hmmc->RxCpltCallback    = HAL_MMC_RxCpltCallback;

HAL_StatusTypeDef HAL_MMC_Init(MMC_HandleTypeDef *hmmc)

    hmmc->ErrorCallback     = HAL_MMC_ErrorCallback;

{

    hmmc->AbortCpltCallback = HAL_MMC_AbortCallback;

  /* Check the MMC handle allocation */

  if(hmmc == NULL)

    if(hmmc->MspInitCallback == NULL)

  {

    {

    return HAL_ERROR;

      hmmc->MspInitCallback = HAL_MMC_MspInit;

  }

    }

  /* Check the parameters */

    /* Init the low level hardware */

  assert_param(IS_SDIO_ALL_INSTANCE(hmmc->Instance));

    hmmc->MspInitCallback(hmmc);

  assert_param(IS_SDIO_CLOCK_EDGE(hmmc->Init.ClockEdge));

#else

  assert_param(IS_SDIO_CLOCK_BYPASS(hmmc->Init.ClockBypass));

    /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */

  assert_param(IS_SDIO_CLOCK_POWER_SAVE(hmmc->Init.ClockPowerSave));

    HAL_MMC_MspInit(hmmc);

  assert_param(IS_SDIO_BUS_WIDE(hmmc->Init.BusWide));

#endif

  assert_param(IS_SDIO_HARDWARE_FLOW_CONTROL(hmmc->Init.HardwareFlowControl));

  }

  assert_param(IS_SDIO_CLKDIV(hmmc->Init.ClockDiv));

  hmmc->State = HAL_MMC_STATE_BUSY;

  if(hmmc->State == HAL_MMC_STATE_RESET)

  {

  /* Initialize the Card parameters */

    /* Allocate lock resource and initialize it */

  if(HAL_MMC_InitCard(hmmc) == HAL_ERROR)

    hmmc->Lock = HAL_UNLOCKED;

  {

#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)

    return HAL_ERROR;

    /* Reset Callback pointers in HAL_MMC_STATE_RESET only */

  }

    hmmc->TxCpltCallback    = HAL_MMC_TxCpltCallback;

    hmmc->RxCpltCallback    = HAL_MMC_RxCpltCallback;

  /* Initialize the error code */

    hmmc->ErrorCallback     = HAL_MMC_ErrorCallback;

  hmmc->ErrorCode = HAL_DMA_ERROR_NONE;

    hmmc->AbortCpltCallback = HAL_MMC_AbortCallback;

  /* Initialize the MMC operation */

    if(hmmc->MspInitCallback == NULL)

  hmmc->Context = MMC_CONTEXT_NONE;

    {

      hmmc->MspInitCallback = HAL_MMC_MspInit;

  /* Initialize the MMC state */

    }

  hmmc->State = HAL_MMC_STATE_READY;

    /* Init the low level hardware */

  return HAL_OK;

    hmmc->MspInitCallback(hmmc);

}

#else

    /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */

/**

    HAL_MMC_MspInit(hmmc);

  * @brief  Initializes the MMC Card.

#endif

  * @param  hmmc: Pointer to MMC handle

  }

  * @note   This function initializes the MMC card. It could be used when a card

            re-initialization is needed.

  hmmc->State = HAL_MMC_STATE_BUSY;

  * @retval HAL status

  */

  /* Initialize the Card parameters */

HAL_StatusTypeDef HAL_MMC_InitCard(MMC_HandleTypeDef *hmmc)

  if(HAL_MMC_InitCard(hmmc) == HAL_ERROR)

{

  {

  uint32_t errorstate;

    return HAL_ERROR;

  MMC_InitTypeDef Init;

  }

  HAL_StatusTypeDef status;

  /* Initialize the error code */

  /* Default SDIO peripheral configuration for MMC card initialization */

  hmmc->ErrorCode = HAL_MMC_ERROR_NONE;

  Init.ClockEdge           = SDIO_CLOCK_EDGE_RISING;

  Init.ClockBypass         = SDIO_CLOCK_BYPASS_DISABLE;

  /* Initialize the MMC operation */

  Init.ClockPowerSave      = SDIO_CLOCK_POWER_SAVE_DISABLE;

  hmmc->Context = MMC_CONTEXT_NONE;

  Init.BusWide             = SDIO_BUS_WIDE_1B;

  Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;

  /* Initialize the MMC state */

  Init.ClockDiv            = SDIO_INIT_CLK_DIV;

  hmmc->State = HAL_MMC_STATE_READY;

  /* Initialize SDIO peripheral interface with default configuration */

  /* Configure bus width */

  status = SDIO_Init(hmmc->Instance, Init);

  if (hmmc->Init.BusWide != SDIO_BUS_WIDE_1B)

  if(status == HAL_ERROR)

  {

  {

    if (HAL_MMC_ConfigWideBusOperation(hmmc, hmmc->Init.BusWide) != HAL_OK)

    return HAL_ERROR;

    {

  }

      return HAL_ERROR;

    }

  /* Disable SDIO Clock */

  }

  __HAL_MMC_DISABLE(hmmc);

  return HAL_OK;

  /* Set Power State to ON */

}

  status = SDIO_PowerState_ON(hmmc->Instance);

  if(status == HAL_ERROR)

/**

  {

  * @brief  Initializes the MMC Card.

    return HAL_ERROR;

  * @param  hmmc: Pointer to MMC handle

  }

  * @note   This function initializes the MMC card. It could be used when a card

            re-initialization is needed.

  /* Enable MMC Clock */

  * @retval HAL status

  __HAL_MMC_ENABLE(hmmc);

  */

HAL_StatusTypeDef HAL_MMC_InitCard(MMC_HandleTypeDef *hmmc)

  /* Identify card operating voltage */

{

  errorstate = MMC_PowerON(hmmc);

  uint32_t errorstate;

  if(errorstate != HAL_MMC_ERROR_NONE)

  MMC_InitTypeDef Init;

  {

  HAL_StatusTypeDef status;

    hmmc->State = HAL_MMC_STATE_READY;

    hmmc->ErrorCode |= errorstate;

  /* Default SDIO peripheral configuration for MMC card initialization */

    return HAL_ERROR;

  Init.ClockEdge           = SDIO_CLOCK_EDGE_RISING;

  }

  Init.ClockBypass         = SDIO_CLOCK_BYPASS_DISABLE;

  Init.ClockPowerSave      = SDIO_CLOCK_POWER_SAVE_DISABLE;

  /* Card initialization */

  Init.BusWide             = SDIO_BUS_WIDE_1B;

  errorstate = MMC_InitCard(hmmc);

  Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;

  if(errorstate != HAL_MMC_ERROR_NONE)

  Init.ClockDiv            = SDIO_INIT_CLK_DIV;

  {

    hmmc->State = HAL_MMC_STATE_READY;

  /* Initialize SDIO peripheral interface with default configuration */

    hmmc->ErrorCode |= errorstate;

  status = SDIO_Init(hmmc->Instance, Init);

    return HAL_ERROR;

  if(status == HAL_ERROR)

  }

  {

    return HAL_ERROR;

  /* Set Block Size for Card */

  }

  errorstate = SDMMC_CmdBlockLength(hmmc->Instance, MMC_BLOCKSIZE);

  if(errorstate != HAL_MMC_ERROR_NONE)

  /* Disable SDIO Clock */

  {

  __HAL_MMC_DISABLE(hmmc);

    /* Clear all the static flags */

    __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

  /* Set Power State to ON */

    hmmc->ErrorCode |= errorstate;

  status = SDIO_PowerState_ON(hmmc->Instance);

    hmmc->State = HAL_MMC_STATE_READY;

  if(status == HAL_ERROR)

    return HAL_ERROR;

  {

  }

    return HAL_ERROR;

  }

  return HAL_OK;

}

  /* Enable MMC Clock */

  __HAL_MMC_ENABLE(hmmc);

/**

  * @brief  De-Initializes the MMC card.

  /* Required power up waiting time before starting the MMC initialization  sequence */

  * @param  hmmc: Pointer to MMC handle

  HAL_Delay(2);

  * @retval HAL status

  */

  /* Identify card operating voltage */

HAL_StatusTypeDef HAL_MMC_DeInit(MMC_HandleTypeDef *hmmc)

  errorstate = MMC_PowerON(hmmc);

{

  if(errorstate != HAL_MMC_ERROR_NONE)

  /* Check the MMC handle allocation */

  {

  if(hmmc == NULL)

    hmmc->State = HAL_MMC_STATE_READY;

  {

    hmmc->ErrorCode |= errorstate;

    return HAL_ERROR;

    return HAL_ERROR;

  }

  }

  /* Check the parameters */

  /* Card initialization */

  assert_param(IS_SDIO_ALL_INSTANCE(hmmc->Instance));

  errorstate = MMC_InitCard(hmmc);

  if(errorstate != HAL_MMC_ERROR_NONE)

  hmmc->State = HAL_MMC_STATE_BUSY;

  {

    hmmc->State = HAL_MMC_STATE_READY;

  /* Set MMC power state to off */

    hmmc->ErrorCode |= errorstate;

  MMC_PowerOFF(hmmc);

    return HAL_ERROR;

  }

#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)

  if(hmmc->MspDeInitCallback == NULL)

  /* Set Block Size for Card */

  {

  errorstate = SDMMC_CmdBlockLength(hmmc->Instance, MMC_BLOCKSIZE);

    hmmc->MspDeInitCallback = HAL_MMC_MspDeInit;

  if(errorstate != HAL_MMC_ERROR_NONE)

  }

  {

    /* Clear all the static flags */

  /* DeInit the low level hardware */

    __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

  hmmc->MspDeInitCallback(hmmc);

    hmmc->ErrorCode |= errorstate;

#else

    hmmc->State = HAL_MMC_STATE_READY;

  /* De-Initialize the MSP layer */

    return HAL_ERROR;

  HAL_MMC_MspDeInit(hmmc);

  }

#endif

  return HAL_OK;

  hmmc->ErrorCode = HAL_MMC_ERROR_NONE;

}

  hmmc->State = HAL_MMC_STATE_RESET;

/**

  return HAL_OK;

  * @brief  De-Initializes the MMC card.

}

  * @param  hmmc: Pointer to MMC handle

  * @retval HAL status

  */

/**

HAL_StatusTypeDef HAL_MMC_DeInit(MMC_HandleTypeDef *hmmc)

  * @brief  Initializes the MMC MSP.

{

  * @param  hmmc: Pointer to MMC handle

  /* Check the MMC handle allocation */

  * @retval None

  if(hmmc == NULL)

  */

  {

__weak void HAL_MMC_MspInit(MMC_HandleTypeDef *hmmc)

    return HAL_ERROR;

{

  }

  /* Prevent unused argument(s) compilation warning */

  UNUSED(hmmc);

  /* Check the parameters */

  assert_param(IS_SDIO_ALL_INSTANCE(hmmc->Instance));

  /* NOTE : This function Should not be modified, when the callback is needed,

            the HAL_MMC_MspInit could be implemented in the user file

  hmmc->State = HAL_MMC_STATE_BUSY;

   */

}

  /* Set MMC power state to off */

  MMC_PowerOFF(hmmc);

/**

  * @brief  De-Initialize MMC MSP.

#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)

  * @param  hmmc: Pointer to MMC handle

  if(hmmc->MspDeInitCallback == NULL)

  * @retval None

  {

  */

    hmmc->MspDeInitCallback = HAL_MMC_MspDeInit;

__weak void HAL_MMC_MspDeInit(MMC_HandleTypeDef *hmmc)

  }

{

  /* Prevent unused argument(s) compilation warning */

  /* DeInit the low level hardware */

  UNUSED(hmmc);

  hmmc->MspDeInitCallback(hmmc);

#else

  /* NOTE : This function Should not be modified, when the callback is needed,

  /* De-Initialize the MSP layer */

            the HAL_MMC_MspDeInit could be implemented in the user file

  HAL_MMC_MspDeInit(hmmc);

   */

#endif

}

  hmmc->ErrorCode = HAL_MMC_ERROR_NONE;

/**

  hmmc->State = HAL_MMC_STATE_RESET;

  * @}

  */

  return HAL_OK;

}

/** @addtogroup MMC_Exported_Functions_Group2

 *  @brief   Data transfer functions

 *

/**

@verbatim

  * @brief  Initializes the MMC MSP.

  ==============================================================================

  * @param  hmmc: Pointer to MMC handle

                        ##### IO operation functions #####

  * @retval None

  ==============================================================================

  */

  [..]

__weak void HAL_MMC_MspInit(MMC_HandleTypeDef *hmmc)

    This subsection provides a set of functions allowing to manage the data

{

    transfer from/to MMC card.

  /* Prevent unused argument(s) compilation warning */

  UNUSED(hmmc);

@endverbatim

  * @{

  /* NOTE : This function Should not be modified, when the callback is needed,

  */

            the HAL_MMC_MspInit could be implemented in the user file

   */

/**

}

  * @brief  Reads block(s) from a specified address in a card. The Data transfer

  *         is managed by polling mode.

/**

  * @note   This API should be followed by a check on the card state through

  * @brief  De-Initialize MMC MSP.

  *         HAL_MMC_GetCardState().

  * @param  hmmc: Pointer to MMC handle

  * @param  hmmc: Pointer to MMC handle

  * @retval None

  * @param  pData: pointer to the buffer that will contain the received data

  */

  * @param  BlockAdd: Block Address from where data is to be read

__weak void HAL_MMC_MspDeInit(MMC_HandleTypeDef *hmmc)

  * @param  NumberOfBlocks: Number of MMC blocks to read

{

  * @param  Timeout: Specify timeout value

  /* Prevent unused argument(s) compilation warning */

  * @retval HAL status

  UNUSED(hmmc);

  */

HAL_StatusTypeDef HAL_MMC_ReadBlocks(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)

  /* NOTE : This function Should not be modified, when the callback is needed,

{

            the HAL_MMC_MspDeInit could be implemented in the user file

  SDIO_DataInitTypeDef config;

   */

  uint32_t errorstate;

}

  uint32_t tickstart = HAL_GetTick();

  uint32_t count, data, dataremaining;

/**

  uint32_t add = BlockAdd;

  * @}

  uint8_t *tempbuff = pData;

  */

  if(NULL == pData)

/** @addtogroup MMC_Exported_Functions_Group2

  {

 *  @brief   Data transfer functions

    hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM;

 *

    return HAL_ERROR;

@verbatim

  }

  ==============================================================================

                        ##### IO operation functions #####

  if(hmmc->State == HAL_MMC_STATE_READY)

  ==============================================================================

  {

  [..]

    hmmc->ErrorCode = HAL_MMC_ERROR_NONE;

    This subsection provides a set of functions allowing to manage the data

    transfer from/to MMC card.

    if((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr))

    {

@endverbatim

      hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE;

  * @{

      return HAL_ERROR;

  */

    }

/**

    hmmc->State = HAL_MMC_STATE_BUSY;

  * @brief  Reads block(s) from a specified address in a card. The Data transfer

  *         is managed by polling mode.

    /* Initialize data control register */

  * @note   This API should be followed by a check on the card state through

    hmmc->Instance->DCTRL = 0U;

  *         HAL_MMC_GetCardState().

  * @param  hmmc: Pointer to MMC handle

    if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD)

  * @param  pData: pointer to the buffer that will contain the received data

    {

  * @param  BlockAdd: Block Address from where data is to be read

      add *= 512U;

  * @param  NumberOfBlocks: Number of MMC blocks to read

    }

  * @param  Timeout: Specify timeout value

  * @retval HAL status

    /* Configure the MMC DPSM (Data Path State Machine) */

  */

    config.DataTimeOut   = SDMMC_DATATIMEOUT;

HAL_StatusTypeDef HAL_MMC_ReadBlocks(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)

    config.DataLength    = NumberOfBlocks * MMC_BLOCKSIZE;

{

    config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;

  SDIO_DataInitTypeDef config;

    config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;

  uint32_t errorstate;

    config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;

  uint32_t tickstart = HAL_GetTick();

    config.DPSM          = SDIO_DPSM_ENABLE;

  uint32_t count, data, dataremaining;

    (void)SDIO_ConfigData(hmmc->Instance, &config);

  uint32_t add = BlockAdd;

  uint8_t *tempbuff = pData;

    /* Read block(s) in polling mode */

    if(NumberOfBlocks > 1U)

  if(NULL == pData)

    {

  {

      hmmc->Context = MMC_CONTEXT_READ_MULTIPLE_BLOCK;

    hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM;

    return HAL_ERROR;

      /* Read Multi Block command */

  }

      errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, add);

    }

  if(hmmc->State == HAL_MMC_STATE_READY)

    else

  {

    {

    hmmc->ErrorCode = HAL_MMC_ERROR_NONE;

      hmmc->Context = MMC_CONTEXT_READ_SINGLE_BLOCK;

    if((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr))

      /* Read Single Block command */

    {

      errorstate = SDMMC_CmdReadSingleBlock(hmmc->Instance, add);

      hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE;

    }

      return HAL_ERROR;

    if(errorstate != HAL_MMC_ERROR_NONE)

    }

    {

      /* Clear all the static flags */

    hmmc->State = HAL_MMC_STATE_BUSY;

      __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

      hmmc->ErrorCode |= errorstate;

    /* Initialize data control register */

      hmmc->State = HAL_MMC_STATE_READY;

    hmmc->Instance->DCTRL = 0U;

      return HAL_ERROR;

    }

    if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD)

    {

    /* Poll on SDIO flags */

      add *= 512U;

    dataremaining = config.DataLength;

    }

    while(!__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))

    {

    /* Configure the MMC DPSM (Data Path State Machine) */

      if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXFIFOHF) && (dataremaining > 0U))

    config.DataTimeOut   = SDMMC_DATATIMEOUT;

      {

    config.DataLength    = NumberOfBlocks * MMC_BLOCKSIZE;

        /* Read data from SDIO Rx FIFO */

    config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;

        for(count = 0U; count < 8U; count++)

    config.TransferDir   = SDIO_TRANSFER_DIR_TO_SDIO;

        {

    config.TransferMode  = SDIO_TRANSFER_MODE_BLOCK;

          data = SDIO_ReadFIFO(hmmc->Instance);

    config.DPSM          = SDIO_DPSM_ENABLE;

          *tempbuff = (uint8_t)(data & 0xFFU);

    (void)SDIO_ConfigData(hmmc->Instance, &config);

          tempbuff++;

          dataremaining--;

    /* Read block(s) in polling mode */

          *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);

    if(NumberOfBlocks > 1U)

          tempbuff++;

    {

          dataremaining--;

      hmmc->Context = MMC_CONTEXT_READ_MULTIPLE_BLOCK;

          *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);

          tempbuff++;

      /* Read Multi Block command */

          dataremaining--;

      errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, add);

          *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);

    }

          tempbuff++;

    else

          dataremaining--;

    {

        }

      hmmc->Context = MMC_CONTEXT_READ_SINGLE_BLOCK;

      }

      /* Read Single Block command */

      if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))

      errorstate = SDMMC_CmdReadSingleBlock(hmmc->Instance, add);

      {

    }

        /* Clear all the static flags */

    if(errorstate != HAL_MMC_ERROR_NONE)

        __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

    {

        hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT;

      /* Clear all the static flags */

        hmmc->State= HAL_MMC_STATE_READY;

      __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

        return HAL_TIMEOUT;

      hmmc->ErrorCode |= errorstate;

      }

      hmmc->State = HAL_MMC_STATE_READY;

    }

      return HAL_ERROR;

    }

    /* Send stop transmission command in case of multiblock read */

    if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))

    /* Poll on SDIO flags */

    {

    dataremaining = config.DataLength;

      /* Send stop transmission command */

    while(!__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))

      errorstate = SDMMC_CmdStopTransfer(hmmc->Instance);

    {

      if(errorstate != HAL_MMC_ERROR_NONE)

      if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXFIFOHF) && (dataremaining > 0U))

      {

      {

        /* Clear all the static flags */

        /* Read data from SDIO Rx FIFO */

        __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

        for(count = 0U; count < 8U; count++)

        hmmc->ErrorCode |= errorstate;

        {

        hmmc->State = HAL_MMC_STATE_READY;

          data = SDIO_ReadFIFO(hmmc->Instance);

        return HAL_ERROR;

          *tempbuff = (uint8_t)(data & 0xFFU);

      }

          tempbuff++;

    }

          dataremaining--;

          *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);

    /* Get error state */

          tempbuff++;

    if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DTIMEOUT))

          dataremaining--;

    {

          *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);

      /* Clear all the static flags */

          tempbuff++;

      __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

          dataremaining--;

      hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT;

          *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);

      hmmc->State = HAL_MMC_STATE_READY;

          tempbuff++;

      return HAL_ERROR;

          dataremaining--;

    }

        }

    else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DCRCFAIL))

      }

    {

      /* Clear all the static flags */

      if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))

      __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

      {

      hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL;

        /* Clear all the static flags */

      hmmc->State = HAL_MMC_STATE_READY;

        __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

      return HAL_ERROR;

        hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT;

    }

        hmmc->State= HAL_MMC_STATE_READY;

    else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXOVERR))

        return HAL_TIMEOUT;

    {

      }

      /* Clear all the static flags */

    }

      __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

      hmmc->ErrorCode |= HAL_MMC_ERROR_RX_OVERRUN;

    /* Send stop transmission command in case of multiblock read */

      hmmc->State = HAL_MMC_STATE_READY;

    if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))

      return HAL_ERROR;

    {

    }

      /* Send stop transmission command */

    else

      errorstate = SDMMC_CmdStopTransfer(hmmc->Instance);

    {

      if(errorstate != HAL_MMC_ERROR_NONE)

      /* Nothing to do */

      {

    }

        /* Clear all the static flags */

        __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

    /* Empty FIFO if there is still any data */

        hmmc->ErrorCode |= errorstate;

    while ((__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXDAVL)) && (dataremaining > 0U))

        hmmc->State = HAL_MMC_STATE_READY;

    {

        return HAL_ERROR;

      data = SDIO_ReadFIFO(hmmc->Instance);

      }

      *tempbuff = (uint8_t)(data & 0xFFU);

    }

      tempbuff++;

      dataremaining--;

    /* Get error state */

      *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);

    if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DTIMEOUT))

      tempbuff++;

    {

      dataremaining--;

      /* Clear all the static flags */

      *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);

      __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

      tempbuff++;

      hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT;

      dataremaining--;

      hmmc->State = HAL_MMC_STATE_READY;

      *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);

      return HAL_ERROR;

      tempbuff++;

    }

      dataremaining--;

    else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DCRCFAIL))

    {

      if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))

      /* Clear all the static flags */

      {

      __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

        /* Clear all the static flags */

      hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL;

        __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);        

      hmmc->State = HAL_MMC_STATE_READY;

        hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT;

      return HAL_ERROR;

        hmmc->State= HAL_MMC_STATE_READY;

    }

        return HAL_ERROR;

    else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXOVERR))

      }

    {

    }

      /* Clear all the static flags */

      __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);

    /* Clear all the static flags */

      hmmc->ErrorCode |= HAL_MMC_ERROR_RX_OVERRUN;

    __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_DATA_FLAGS);

      hmmc->State = HAL_MMC_STATE_READY;

      return HAL_ERROR;

    hmmc->State = HAL_MMC_STATE_READY;

    }

    else

    return HAL_OK;

    {

  }

      /* Nothing to do */

  else

    }

  {

    hmmc->ErrorCode |= HAL_MMC_ERROR_BUSY;

    /* Empty FIFO if there is still any data */

    return HAL_ERROR;

    while ((__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXDAVL)) && (dataremaining > 0U))

  }

    {

}

      data = SDIO_ReadFIFO(hmmc->Instance);

      *tempbuff = (uint8_t)(data & 0xFFU);

/**

      tempbuff++;

  * @brief  Allows to write block(s) to a specified address in a card. The Data

      dataremaining--;

  *         transfer is managed by polling mode.

      *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);

  * @note   This API should be followed by a check on the card state through

      tempbuff++;

  *         HAL_MMC_GetCardState().

      dataremaining--;

  * @param  hmmc: Pointer to MMC handle

      *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);

  * @param  pData: pointer to the buffer that will contain the data to transmit

      tempbuff++;