Old / new BT module communication:
The old / new BT module do have a sligthly different command set. To keep them compatible a function has been added which returns, based on the HW identification, the command string which matches to the module. In case a command is not supported the value 0 is returned and the calling function may react. E.g. with skipping of configuration steps like it is done now for the new module.
line source
/**+ − ******************************************************************************+ − * @file stm32f4xx_hal_sd.c+ − * @author MCD Application Team+ − * @brief SD card HAL module driver.+ − * This file provides firmware functions to manage the following + − * functionalities of the Secure Digital (SD) peripheral:+ − * + Initialization and de-initialization functions+ − * + IO operation functions+ − * + Peripheral Control functions + − * + SD card Control functions+ − * + − @verbatim+ − ==============================================================================+ − ##### How to use this driver #####+ − ==============================================================================+ − [..]+ − This driver implements a high level communication layer for read and write from/to + − this memory. The needed STM32 hardware resources (SDIO and GPIO) are performed by + − the user in HAL_SD_MspInit() function (MSP layer). + − Basically, the MSP layer configuration should be the same as we provide in the + − examples.+ − You can easily tailor this configuration according to hardware resources.+ − + − [..]+ − This driver is a generic layered driver for SDIO memories which uses the HAL + − SDIO driver functions to interface with SD and uSD cards devices. + − It is used as follows:+ − + − (#)Initialize the SDIO low level resources by implement the HAL_SD_MspInit() API:+ − (##) Enable the SDIO interface clock using __HAL_RCC_SDIO_CLK_ENABLE(); + − (##) SDIO pins configuration for SD card+ − (+++) Enable the clock for the SDIO GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE(); + − (+++) Configure these SDIO pins as alternate function pull-up using HAL_GPIO_Init()+ − and according to your pin assignment;+ − (##) DMA Configuration if you need to use DMA process (HAL_SD_ReadBlocks_DMA()+ − and HAL_SD_WriteBlocks_DMA() APIs).+ − (+++) Enable the DMAx interface clock using __HAL_RCC_DMAx_CLK_ENABLE(); + − (+++) Configure the DMA using the function HAL_DMA_Init() with predeclared and filled. + − (##) NVIC configuration if you need to use interrupt process when using DMA transfer.+ − (+++) Configure the SDIO and DMA interrupt priorities using functions+ − HAL_NVIC_SetPriority(); DMA priority is superior to SDIO's priority+ − (+++) Enable the NVIC DMA and SDIO IRQs using function HAL_NVIC_EnableIRQ()+ − (+++) SDIO interrupts are managed using the macros __HAL_SD_ENABLE_IT() + − and __HAL_SD_DISABLE_IT() inside the communication process.+ − (+++) SDIO interrupts pending bits are managed using the macros __HAL_SD_GET_IT()+ − and __HAL_SD_CLEAR_IT()+ − (##) NVIC configuration if you need to use interrupt process (HAL_SD_ReadBlocks_IT()+ − and HAL_SD_WriteBlocks_IT() APIs).+ − (+++) Configure the SDIO interrupt priorities using function+ − HAL_NVIC_SetPriority();+ − (+++) Enable the NVIC SDIO IRQs using function HAL_NVIC_EnableIRQ()+ − (+++) SDIO interrupts are managed using the macros __HAL_SD_ENABLE_IT() + − and __HAL_SD_DISABLE_IT() inside the communication process.+ − (+++) SDIO interrupts pending bits are managed using the macros __HAL_SD_GET_IT()+ − and __HAL_SD_CLEAR_IT()+ − (#) At this stage, you can perform SD read/write/erase operations after SD card initialization + − + − + − *** SD Card Initialization and configuration ***+ − ================================================ + − [..]+ − To initialize the SD Card, use the HAL_SD_Init() function. It Initializes + − SDIO IP(STM32 side) and the SD Card, and put it into StandBy State (Ready for data transfer). + − This function provide the following operations:+ − + − (#) Initialize the SDIO peripheral interface with defaullt configuration.+ − The initialization process is done at 400KHz. You can change or adapt + − this frequency by adjusting the "ClockDiv" field. + − The SD Card frequency (SDIO_CK) is computed as follows:+ − + − SDIO_CK = SDIOCLK / (ClockDiv + 2)+ − + − In initialization mode and according to the SD Card standard, + − make sure that the SDIO_CK frequency doesn't exceed 400KHz.+ − + − This phase of initialization is done through SDIO_Init() and + − SDIO_PowerState_ON() SDIO low level APIs.+ − + − (#) Initialize the SD card. The API used is HAL_SD_InitCard().+ − This phase allows the card initialization and identification + − and check the SD Card type (Standard Capacity or High Capacity)+ − The initialization flow is compatible with SD standard.+ − + − This API (HAL_SD_InitCard()) could be used also to reinitialize the card in case + − of plug-off plug-in.+ − + − (#) Configure the SD Card Data transfer frequency. By Default, the card transfer + − frequency is set to 24MHz. You can change or adapt this frequency by adjusting + − the "ClockDiv" field.+ − In transfer mode and according to the SD Card standard, make sure that the + − SDIO_CK frequency doesn't exceed 25MHz and 50MHz in High-speed mode switch.+ − To be able to use a frequency higher than 24MHz, you should use the SDIO + − peripheral in bypass mode. Refer to the corresponding reference manual + − for more details.+ − + − (#) Select the corresponding SD Card according to the address read with the step 2.+ − + − (#) Configure the SD Card in wide bus mode: 4-bits data.+ − + − *** SD Card Read operation ***+ − ==============================+ − [..] + − (+) You can read from SD card in polling mode by using function HAL_SD_ReadBlocks(). + − This function allows the read of 512 bytes blocks.+ − You can choose either one block read operation or multiple block read operation + − by adjusting the "NumberOfBlocks" parameter.+ − After this, you have to ensure that the transfer is done correctly. The check is done+ − through HAL_SD_GetCardState() function for SD card state.+ − + − (+) You can read from SD card in DMA mode by using function HAL_SD_ReadBlocks_DMA().+ − This function allows the read of 512 bytes blocks.+ − You can choose either one block read operation or multiple block read operation + − by adjusting the "NumberOfBlocks" parameter.+ − After this, you have to ensure that the transfer is done correctly. The check is done+ − through HAL_SD_GetCardState() function for SD card state.+ − You could also check the DMA transfer process through the SD Rx interrupt event.+ − + − (+) You can read from SD card in Interrupt mode by using function HAL_SD_ReadBlocks_IT().+ − This function allows the read of 512 bytes blocks.+ − You can choose either one block read operation or multiple block read operation + − by adjusting the "NumberOfBlocks" parameter.+ − After this, you have to ensure that the transfer is done correctly. The check is done+ − through HAL_SD_GetCardState() function for SD card state.+ − You could also check the IT transfer process through the SD Rx interrupt event.+ − + − *** SD Card Write operation ***+ − =============================== + − [..] + − (+) You can write to SD card in polling mode by using function HAL_SD_WriteBlocks(). + − This function allows the read of 512 bytes blocks.+ − You can choose either one block read operation or multiple block read operation + − by adjusting the "NumberOfBlocks" parameter.+ − After this, you have to ensure that the transfer is done correctly. The check is done+ − through HAL_SD_GetCardState() function for SD card state.+ − + − (+) You can write to SD card in DMA mode by using function HAL_SD_WriteBlocks_DMA().+ − This function allows the read of 512 bytes blocks.+ − You can choose either one block read operation or multiple block read operation + − by adjusting the "NumberOfBlocks" parameter.+ − After this, you have to ensure that the transfer is done correctly. The check is done+ − through HAL_SD_GetCardState() function for SD card state.+ − You could also check the DMA transfer process through the SD Tx interrupt event. + − + − (+) You can write to SD card in Interrupt mode by using function HAL_SD_WriteBlocks_IT().+ − This function allows the read of 512 bytes blocks.+ − You can choose either one block read operation or multiple block read operation + − by adjusting the "NumberOfBlocks" parameter.+ − After this, you have to ensure that the transfer is done correctly. The check is done+ − through HAL_SD_GetCardState() function for SD card state.+ − You could also check the IT transfer process through the SD Tx interrupt event.+ − + − *** SD card status ***+ − ====================== + − [..]+ − (+) The SD Status contains status bits that are related to the SD Memory + − Card proprietary features. To get SD card status use the HAL_SD_GetCardStatus().+ − + − *** SD card information ***+ − =========================== + − [..]+ − (+) To get SD card information, you can use the function HAL_SD_GetCardInfo().+ − It returns useful information about the SD card such as block size, card type,+ − block number ...+ − + − *** SD card CSD register ***+ − ============================+ − [..]+ − (+) The HAL_SD_GetCardCSD() API allows to get the parameters of the CSD register.+ − Some of the CSD parameters are useful for card initialization and identification.+ − + − *** SD card CID register ***+ − ============================+ − [..]+ − (+) The HAL_SD_GetCardCID() API allows to get the parameters of the CID register.+ − Some of the CSD parameters are useful for card initialization and identification.+ − + − *** SD HAL driver macros list ***+ − ==================================+ − [..]+ − Below the list of most used macros in SD HAL driver.+ − + − (+) __HAL_SD_ENABLE : Enable the SD device+ − (+) __HAL_SD_DISABLE : Disable the SD device+ − (+) __HAL_SD_DMA_ENABLE: Enable the SDIO DMA transfer+ − (+) __HAL_SD_DMA_DISABLE: Disable the SDIO DMA transfer+ − (+) __HAL_SD_ENABLE_IT: Enable the SD device interrupt+ − (+) __HAL_SD_DISABLE_IT: Disable the SD device interrupt+ − (+) __HAL_SD_GET_FLAG:Check whether the specified SD flag is set or not+ − (+) __HAL_SD_CLEAR_FLAG: Clear the SD's pending flags+ − + − [..]+ − (@) You can refer to the SD HAL driver header file for more useful macros + − + − @endverbatim+ − ******************************************************************************+ − * @attention+ − *+ − * <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2>+ − *+ − * Redistribution and use in source and binary forms, with or without modification,+ − * are permitted provided that the following conditions are met:+ − * 1. Redistributions of source code must retain the above copyright notice,+ − * this list of conditions and the following disclaimer.+ − * 2. Redistributions in binary form must reproduce the above copyright notice,+ − * this list of conditions and the following disclaimer in the documentation+ − * and/or other materials provided with the distribution.+ − * 3. Neither the name of STMicroelectronics nor the names of its contributors+ − * may be used to endorse or promote products derived from this software+ − * without specific prior written permission.+ − *+ − * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"+ − * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+ − * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE+ − * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE+ − * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+ − * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR+ − * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER+ − * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,+ − * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+ − * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.+ − *+ − ******************************************************************************+ âËââ‚Ãââ‚Ã‚¬Ã…¡Ãƒâ€šÃ‚¬ÃƒÆ’‚ ÃƒÂ¢Ã¢â€šÂ¬Ã¢â€žÂ¢ */ + − + − /* Includes ------------------------------------------------------------------*/+ − #include "stm32f4xx_hal.h"+ − + − /** @addtogroup STM32F4xx_HAL_Driver+ − * @{+ − */+ − + − /** @addtogroup SD + − * @{+ − */+ − + − #ifdef HAL_SD_MODULE_ENABLED+ − + − #if defined(STM32F405xx) || defined(STM32F415xx) || defined(STM32F407xx) || defined(STM32F417xx) || \+ − defined(STM32F427xx) || defined(STM32F437xx) || defined(STM32F429xx) || defined(STM32F439xx) || \+ − defined(STM32F401xC) || defined(STM32F401xE) || defined(STM32F411xE) || defined(STM32F446xx) || \+ − defined(STM32F469xx) || defined(STM32F479xx) || defined(STM32F412Zx) || defined(STM32F412Vx) || \+ − defined(STM32F412Rx) || defined(STM32F412Cx) || defined(STM32F413xx) || defined(STM32F423xx)+ − + − /* Private typedef -----------------------------------------------------------*/+ − /* Private define ------------------------------------------------------------*/+ − /** @addtogroup SD_Private_Defines+ − * @{+ − */+ − + − /**+ − * @}+ − */+ − + − /* Private macro -------------------------------------------------------------*/+ − /* Private variables ---------------------------------------------------------*/+ − /* Private function prototypes -----------------------------------------------*/+ − /* Private functions ---------------------------------------------------------*/+ − /** @defgroup SD_Private_Functions SD Private Functions+ − * @{+ − */+ − static uint32_t SD_InitCard(SD_HandleTypeDef *hsd);+ − static uint32_t SD_PowerON(SD_HandleTypeDef *hsd); + − static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus);+ − static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus);+ − static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd);+ − static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd);+ − static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR);+ − static HAL_StatusTypeDef SD_PowerOFF(SD_HandleTypeDef *hsd);+ − static HAL_StatusTypeDef SD_Write_IT(SD_HandleTypeDef *hsd);+ − static HAL_StatusTypeDef SD_Read_IT(SD_HandleTypeDef *hsd);+ − static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma);+ − static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma);+ − static void SD_DMAError(DMA_HandleTypeDef *hdma);+ − static void SD_DMATxAbort(DMA_HandleTypeDef *hdma);+ − static void SD_DMARxAbort(DMA_HandleTypeDef *hdma);+ − /**+ − * @}+ − */+ − + − /* Exported functions --------------------------------------------------------*/+ − /** @addtogroup SD_Exported_Functions+ − * @{+ − */+ − + − /** @addtogroup SD_Exported_Functions_Group1+ − * @brief Initialization and de-initialization functions + − *+ − @verbatim + − ==============================================================================+ − ##### Initialization and de-initialization functions #####+ − ==============================================================================+ − [..] + − This section provides functions allowing to initialize/de-initialize the SD+ − card device to be ready for use.+ − + − @endverbatim+ − * @{+ − */+ − + − /**+ − * @brief Initializes the SD according to the specified parameters in the + − SD_HandleTypeDef and create the associated handle.+ − * @param hsd Pointer to the SD handle + − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd)+ − {+ − /* Check the SD handle allocation */+ − if(hsd == NULL)+ − {+ − return HAL_ERROR;+ − }+ − + − /* Check the parameters */+ − assert_param(IS_SDIO_ALL_INSTANCE(hsd->Instance));+ − assert_param(IS_SDIO_CLOCK_EDGE(hsd->Init.ClockEdge));+ − assert_param(IS_SDIO_CLOCK_BYPASS(hsd->Init.ClockBypass));+ − assert_param(IS_SDIO_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave));+ − assert_param(IS_SDIO_BUS_WIDE(hsd->Init.BusWide));+ − assert_param(IS_SDIO_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl));+ − assert_param(IS_SDIO_CLKDIV(hsd->Init.ClockDiv));+ − + − if(hsd->State == HAL_SD_STATE_RESET)+ − {+ − /* Allocate lock resource and initialize it */+ − hsd->Lock = HAL_UNLOCKED;+ − /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */+ − HAL_SD_MspInit(hsd);+ − }+ − + − hsd->State = HAL_SD_STATE_BUSY;+ − + − /* Initialize the Card parameters */+ − HAL_SD_InitCard(hsd);+ − + − /* Initialize the error code */+ − hsd->ErrorCode = HAL_DMA_ERROR_NONE;+ − + − /* Initialize the SD operation */+ − hsd->Context = SD_CONTEXT_NONE;+ − + − /* Initialize the SD state */+ − hsd->State = HAL_SD_STATE_READY;+ − + − return HAL_OK;+ − }+ − + − /**+ − * @brief Initializes the SD Card.+ − * @param hsd Pointer to SD handle+ − * @note This function initializes the SD card. It could be used when a card + − re-initialization is needed.+ − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_InitCard(SD_HandleTypeDef *hsd)+ − {+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − SD_InitTypeDef Init;+ − + − /* Default SDIO peripheral configuration for SD card initialization */+ − Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;+ − Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;+ − Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;+ − Init.BusWide = SDIO_BUS_WIDE_1B;+ − Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;+ − Init.ClockDiv = SDIO_INIT_CLK_DIV;+ − + − /* Initialize SDIO peripheral interface with default configuration */+ − SDIO_Init(hsd->Instance, Init);+ − + − /* Disable SDIO Clock */+ − __HAL_SD_DISABLE(hsd); + − + − /* Set Power State to ON */+ − SDIO_PowerState_ON(hsd->Instance);+ − + − /* Enable SDIO Clock */+ − __HAL_SD_ENABLE(hsd);+ − + − /* Required power up waiting time before starting the SD initialization + − sequence */+ − HAL_Delay(2U);+ − + − /* Identify card operating voltage */+ − errorstate = SD_PowerON(hsd);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − hsd->State = HAL_SD_STATE_READY;+ − hsd->ErrorCode |= errorstate;+ − return HAL_ERROR;+ − }+ − + − /* Card initialization */+ − errorstate = SD_InitCard(hsd);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − hsd->State = HAL_SD_STATE_READY;+ − hsd->ErrorCode |= errorstate;+ − return HAL_ERROR;+ − }+ − + − return HAL_OK;+ − }+ − + − /**+ − * @brief De-Initializes the SD card.+ − * @param hsd Pointer to SD handle+ − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)+ − {+ − /* Check the SD handle allocation */+ − if(hsd == NULL)+ − {+ − return HAL_ERROR;+ − }+ − + − /* Check the parameters */+ − assert_param(IS_SDIO_ALL_INSTANCE(hsd->Instance));+ − + − hsd->State = HAL_SD_STATE_BUSY;+ − + − /* Set SD power state to off */ + − SD_PowerOFF(hsd);+ − + − /* De-Initialize the MSP layer */+ − HAL_SD_MspDeInit(hsd);+ − + − hsd->ErrorCode = HAL_SD_ERROR_NONE;+ − hsd->State = HAL_SD_STATE_RESET;+ − + − return HAL_OK;+ − }+ − + − + − /**+ − * @brief Initializes the SD MSP.+ − * @param hsd Pointer to SD handle+ − * @retval None+ − */+ − __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)+ − {+ − /* Prevent unused argument(s) compilation warning */+ − UNUSED(hsd);+ − + − /* NOTE : This function Should not be modified, when the callback is needed,+ ÃÃÆÃ¢â‚¬â„¢ÃƒÆ’¢â‚¬Â ÃƒÂ¢Ã¢â€šÂ¬Ã¢â€žÂ¢ÃƒÆ’ƒâ€ Ã¢â‚¬â„¢ÃƒÆ’‚¢Ã‹â€ Ã¢â‚¬â„¢ the HAL_SD_MspInit could be implemented in the user file+ − */+ − }+ − + − /**+ − * @brief De-Initialize SD MSP.+ − * @param hsd Pointer to SD handle+ − * @retval None+ − */+ − __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)+ − {+ − /* Prevent unused argument(s) compilation warning */+ − UNUSED(hsd);+ − + − /* NOTE : This function Should not be modified, when the callback is needed,+ − the HAL_SD_MspDeInit could be implemented in the user file+ − */+ − }+ − + − /**+ − * @}+ − */+ − + − /** @addtogroup SD_Exported_Functions_Group2+ − * @brief Data transfer functions + − *+ − @verbatim + − ==============================================================================+ − ##### IO operation functions #####+ − ============================================================================== + − [..]+ − This subsection provides a set of functions allowing to manage the data + − transfer from/to SD card.+ − + − @endverbatim+ − * @{+ − */+ − + − /**+ − * @brief Reads block(s) from a specified address in a card. The Data transfer + − * is managed by polling mode.+ − * @note This API should be followed by a check on the card state through+ − * HAL_SD_GetCardState().+ − * @param hsd Pointer to SD handle+ − * @param pData pointer to the buffer that will contain the received data+ − * @param BlockAdd Block Address from where data is to be read + − * @param NumberOfBlocks Number of SD blocks to read+ − * @param Timeout Specify timeout value+ − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)+ − {+ − SDIO_DataInitTypeDef config;+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − uint32_t tickstart = HAL_GetTick();+ − uint32_t count = 0U, *tempbuff = (uint32_t *)pData;+ − + − if(NULL == pData)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_PARAM;+ − return HAL_ERROR;+ − }+ − + − if(hsd->State == HAL_SD_STATE_READY)+ − {+ − hsd->ErrorCode = HAL_DMA_ERROR_NONE;+ − + − if((BlockAdd + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;+ − return HAL_ERROR;+ − }+ − + − hsd->State = HAL_SD_STATE_BUSY;+ − + − /* Initialize data control register */+ − hsd->Instance->DCTRL = 0U;+ − + − if(hsd->SdCard.CardType != CARD_SDHC_SDXC)+ − {+ − BlockAdd *= 512U;+ − }+ − + − /* Set Block Size for Card */+ − errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Configure the SD DPSM (Data Path State Machine) */+ − config.DataTimeOut = SDMMC_DATATIMEOUT;+ − config.DataLength = NumberOfBlocks * BLOCKSIZE;+ − config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;+ − config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;+ − config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;+ − config.DPSM = SDIO_DPSM_ENABLE;+ − SDIO_ConfigData(hsd->Instance, &config);+ − + − /* Read block(s) in polling mode */+ − if(NumberOfBlocks > 1U)+ − {+ − hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;+ − + − /* Read Multi Block command */ + − errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, BlockAdd);+ − }+ − else+ − {+ − hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;+ − + − /* Read Single Block command */+ − errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, BlockAdd);+ − }+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Poll on SDIO flags */+ − #ifdef SDIO_STA_STBITERR+ − while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_STA_STBITERR))+ − #else /* SDIO_STA_STBITERR not defined */+ − while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND))+ − #endif /* SDIO_STA_STBITERR */+ − {+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))+ − {+ − /* Read data from SDIO Rx FIFO */+ − for(count = 0U; count < 8U; count++)+ − {+ − *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);+ − }+ − tempbuff += 8U;+ − }+ − + − if((Timeout == 0U)||((HAL_GetTick()-tickstart) >= Timeout))+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;+ − hsd->State= HAL_SD_STATE_READY;+ − return HAL_TIMEOUT;+ − }+ − }+ − + − /* Send stop transmission command in case of multiblock read */+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))+ − { + − if(hsd->SdCard.CardType != CARD_SECURED)+ − {+ − /* Send stop transmission command */+ − errorstate = SDMMC_CmdStopTransfer(hsd->Instance);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − }+ − }+ − + − /* Get error state */+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Empty FIFO if there is still any data */+ − while ((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)))+ − {+ − *tempbuff = SDIO_ReadFIFO(hsd->Instance);+ − tempbuff++;+ − + − if((Timeout == 0U)||((HAL_GetTick()-tickstart) >= Timeout))+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;+ − hsd->State= HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − }+ − + − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − + − hsd->State = HAL_SD_STATE_READY;+ − + − return HAL_OK;+ − }+ − else+ − {+ ̢蠉ÃÂÂÂÃ‚¢ÃƒÆ’ƒÂ¢Ã¢â€šÂ¬Ã…¡Ã‚¬Ã¢â€žÂ¢ hsd->ErrorCode |= HAL_SD_ERROR_BUSY;+ − return HAL_ERROR;+ − }+ − }+ − + − /**+ − * @brief Allows to write block(s) to a specified address in a card. The Data+ − * transfer is managed by polling mode.+ − * @note This API should be followed by a check on the card state through+ − * HAL_SD_GetCardState().+ − * @param hsd Pointer to SD handle+ − * @param pData pointer to the buffer that will contain the data to transmit+ − * @param BlockAdd Block Address where data will be written + − * @param NumberOfBlocks Number of SD blocks to write+ − * @param Timeout Specify timeout value+ − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)+ − {+ − SDIO_DataInitTypeDef config;+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − uint32_t tickstart = HAL_GetTick();+ − uint32_t count = 0U;+ − uint32_t *tempbuff = (uint32_t *)pData;+ − + − if(NULL == pData)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_PARAM;+ − return HAL_ERROR;+ − }+ − + − if(hsd->State == HAL_SD_STATE_READY)+ − {+ − hsd->ErrorCode = HAL_DMA_ERROR_NONE;+ − + − if((BlockAdd + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;+ − return HAL_ERROR;+ − }+ − + − hsd->State = HAL_SD_STATE_BUSY;+ − + − /* Initialize data control register */+ − hsd->Instance->DCTRL = 0U;+ − + − if(hsd->SdCard.CardType != CARD_SDHC_SDXC)+ − {+ − BlockAdd *= 512U;+ − }+ − + − /* Set Block Size for Card */ + − errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Write Blocks in Polling mode */+ − if(NumberOfBlocks > 1U)+ − {+ − hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;+ − + − /* Write Multi Block command */ + − errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, BlockAdd);+ − }+ − else+ − {+ − hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;+ − + − /* Write Single Block command */+ − errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, BlockAdd);+ − }+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Configure the SD DPSM (Data Path State Machine) */ + − config.DataTimeOut = SDMMC_DATATIMEOUT;+ − config.DataLength = NumberOfBlocks * BLOCKSIZE;+ − config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;+ − config.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;+ − config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;+ − config.DPSM = SDIO_DPSM_ENABLE;+ − SDIO_ConfigData(hsd->Instance, &config);+ − + − /* Write block(s) in polling mode */+ − #ifdef SDIO_STA_STBITERR+ − while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))+ − #else /* SDIO_STA_STBITERR not defined */+ − while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND))+ − #endif /* SDIO_STA_STBITERR */+ − {+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE))+ − {+ − /* Write data to SDIO Tx FIFO */+ − for(count = 0U; count < 8U; count++)+ − {+ − SDIO_WriteFIFO(hsd->Instance, (tempbuff + count));+ − }+ − tempbuff += 8U;+ − }+ − + − if((Timeout == 0U)||((HAL_GetTick()-tickstart) >= Timeout))+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_TIMEOUT;+ − }+ − }+ − + − /* Send stop transmission command in case of multiblock write */+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))+ − { + − if(hsd->SdCard.CardType != CARD_SECURED)+ − {+ − /* Send stop transmission command */+ − errorstate = SDMMC_CmdStopTransfer(hsd->Instance);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − }+ − }+ − + − /* Get error state */+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL; + − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − + − hsd->State = HAL_SD_STATE_READY;+ − + − return HAL_OK;+ − }+ − else+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_BUSY;+ − return HAL_ERROR;+ − }+ − }+ − + − /**+ − * @brief Reads block(s) from a specified address in a card. The Data transfer + − * is managed in interrupt mode. + − * @note This API should be followed by a check on the card state through+ − * HAL_SD_GetCardState().+ − * @note You could also check the IT transfer process through the SD Rx + − * interrupt event.+ − * @param hsd Pointer to SD handle + − * @param pData Pointer to the buffer that will contain the received data+ − * @param BlockAdd Block Address from where data is to be read + − * @param NumberOfBlocks Number of blocks to read.+ − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_ReadBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)+ − {+ − SDIO_DataInitTypeDef config;+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − if(NULL == pData)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_PARAM;+ − return HAL_ERROR;+ − }+ − + − if(hsd->State == HAL_SD_STATE_READY)+ − {+ − hsd->ErrorCode = HAL_DMA_ERROR_NONE;+ − + − if((BlockAdd + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;+ − return HAL_ERROR;+ − }+ − + − hsd->State = HAL_SD_STATE_BUSY;+ − + − /* Initialize data control register */+ − hsd->Instance->DCTRL = 0U;+ − + − hsd->pRxBuffPtr = (uint32_t *)pData;+ − hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;+ − + − #ifdef SDIO_STA_STBITER+ − __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_FLAG_RXFIFOHF | SDIO_IT_STBITERR));+ âÃÃÃ†â€™Ãƒâ€ ’ƒÂ¢Ã¢â€šÂ¬Ã‚¹ÃƒÂ¢Ã¢â€šÂ¬Ã‚ ÃƒÂ¢Ã¢â€šÂ¬Ã¢â€žÂ¢ #else /* SDIO_STA_STBITERR not defined */+ − __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_FLAG_RXFIFOHF));+ − #endif /* SDIO_STA_STBITERR */+ − + − if(hsd->SdCard.CardType != CARD_SDHC_SDXC)+ − {+ − BlockAdd *= 512U;+ − }+ − + − /* Configure the SD DPSM (Data Path State Machine) */ + − config.DataTimeOut = SDMMC_DATATIMEOUT;+ − config.DataLength = BLOCKSIZE * NumberOfBlocks;+ − config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;+ − config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;+ − config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;+ − config.DPSM = SDIO_DPSM_ENABLE;+ − SDIO_ConfigData(hsd->Instance, &config);+ − + − /* Set Block Size for Card */ + − errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Read Blocks in IT mode */+ − if(NumberOfBlocks > 1U)+ − {+ − hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_IT);+ − + − /* Read Multi Block command */+ − errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, BlockAdd);+ − }+ − else+ − {+ − hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_IT);+ − + − /* Read Single Block command */+ − errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, BlockAdd);+ − }+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − return HAL_OK;+ − }+ − else+ − {+ − return HAL_BUSY;+ − }+ − }+ − + − /**+ − * @brief Writes block(s) to a specified address in a card. The Data transfer + − * is managed in interrupt mode. + − * @note This API should be followed by a check on the card state through+ − * HAL_SD_GetCardState().+ − * @note You could also check the IT transfer process through the SD Tx + − * interrupt event. + − * @param hsd Pointer to SD handle+ − * @param pData Pointer to the buffer that will contain the data to transmit+ − * @param BlockAdd Block Address where data will be written + − * @param NumberOfBlocks Number of blocks to write+ − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_WriteBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)+ − {+ − SDIO_DataInitTypeDef config;+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − if(NULL == pData)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_PARAM;+ − return HAL_ERROR;+ − }+ − + − if(hsd->State == HAL_SD_STATE_READY)+ − {+ − hsd->ErrorCode = HAL_DMA_ERROR_NONE;+ − + − if((BlockAdd + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;+ − return HAL_ERROR;+ − }+ − + − hsd->State = HAL_SD_STATE_BUSY;+ − + − /* Initialize data control register */+ − hsd->Instance->DCTRL = 0U;+ − + − hsd->pTxBuffPtr = (uint32_t *)pData;+ − hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;+ − + − /* Enable transfer interrupts */+ − #ifdef SDIO_STA_STBITER+ − __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND | SDIO_FLAG_TXFIFOHE | SDIO_IT_STBITERR)); + − #else /* SDIO_STA_STBITERR not defined */+ − __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND | SDIO_FLAG_TXFIFOHE)); + − #endif /* SDIO_STA_STBITERR */+ − + − if(hsd->SdCard.CardType != CARD_SDHC_SDXC)+ − {+ − BlockAdd *= 512U;+ − }+ − + − /* Set Block Size for Card */ + − errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Write Blocks in Polling mode */+ − if(NumberOfBlocks > 1U)+ − {+ − hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK| SD_CONTEXT_IT);+ − + − /* Write Multi Block command */ + − errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, BlockAdd);+ − }+ − else+ − {+ − hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_IT);+ − + − /* Write Single Block command */ + − errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, BlockAdd);+ − }+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Configure the SD DPSM (Data Path State Machine) */ + − config.DataTimeOut = SDMMC_DATATIMEOUT;+ − config.DataLength = BLOCKSIZE * NumberOfBlocks;+ − config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;+ − config.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;+ − config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;+ − config.DPSM = SDIO_DPSM_ENABLE;+ − SDIO_ConfigData(hsd->Instance, &config);+ − + − return HAL_OK;+ − }+ − else+ − {+ − return HAL_BUSY;+ − }+ − }+ − + − /**+ − * @brief Reads block(s) from a specified address in a card. The Data transfer + − * is managed by DMA mode. + − * @note This API should be followed by a check on the card state through+ − * HAL_SD_GetCardState().+ − * @note You could also check the DMA transfer process through the SD Rx + − * interrupt event.+ − * @param hsd Pointer SD handle + − * @param pData Pointer to the buffer that will contain the received data+ − * @param BlockAdd Block Address from where data is to be read + − * @param NumberOfBlocks Number of blocks to read.+ − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)+ − {+ − SDIO_DataInitTypeDef config;+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − if(NULL == pData)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_PARAM;+ − return HAL_ERROR;+ − }+ − + − if(hsd->State == HAL_SD_STATE_READY)+ − {+ − hsd->ErrorCode = HAL_DMA_ERROR_NONE;+ − + − if((BlockAdd + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;+ − return HAL_ERROR;+ − }+ − + − hsd->State = HAL_SD_STATE_BUSY;+ − + − /* Initialize data control register */+ − hsd->Instance->DCTRL = 0U;+ − + − #ifdef SDIO_STA_STBITER+ − __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_IT_STBITERR));+ − #else /* SDIO_STA_STBITERR not defined */+ − __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));+ − #endif /* SDIO_STA_STBITERR */+ − + − /* Set the DMA transfer complete callback */+ − hsd->hdmarx->XferCpltCallback = SD_DMAReceiveCplt;+ − + − /* Set the DMA error callback */+ − hsd->hdmarx->XferErrorCallback = SD_DMAError;+ − + − /* Set the DMA Abort callback */+ − hsd->hdmarx->XferAbortCallback = NULL;+ − + − /* Enable the DMA Channel */+ − HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pData, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4);+ âˆâ€ÃÆâ€â„¢ÃƒÆ’†â€™Ãƒâ€ Ã¢â‚¬â„¢ÃƒÆ’‚¢Ã¢â‚¬Å¾Ã‚¢ + − /* Enable SD DMA transfer */+ − __HAL_SD_DMA_ENABLE(hsd);+ − + − if(hsd->SdCard.CardType != CARD_SDHC_SDXC)+ − {+ − BlockAdd *= 512U;+ − }+ − + − /* Configure the SD DPSM (Data Path State Machine) */ + − config.DataTimeOut = SDMMC_DATATIMEOUT;+ − config.DataLength = BLOCKSIZE * NumberOfBlocks;+ − config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;+ − config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;+ − config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;+ − config.DPSM = SDIO_DPSM_ENABLE;+ − SDIO_ConfigData(hsd->Instance, &config);+ − + − /* Set Block Size for Card */ + − errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Read Blocks in DMA mode */+ − if(NumberOfBlocks > 1U)+ − {+ − hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);+ − + − /* Read Multi Block command */ + − errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, BlockAdd);+ − }+ − else+ − {+ − hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);+ − + − /* Read Single Block command */ + − errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, BlockAdd);+ − }+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − return HAL_OK;+ − }+ − else+ − {+ − return HAL_BUSY;+ − }+ − }+ − + − /**+ − * @brief Writes block(s) to a specified address in a card. The Data transfer + − * is managed by DMA mode. + − * @note This API should be followed by a check on the card state through+ − * HAL_SD_GetCardState().+ − * @note You could also check the DMA transfer process through the SD Tx + − * interrupt event.+ − * @param hsd Pointer to SD handle+ − * @param pData Pointer to the buffer that will contain the data to transmit+ − * @param BlockAdd Block Address where data will be written + − * @param NumberOfBlocks Number of blocks to write+ − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)+ − {+ − SDIO_DataInitTypeDef config;+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − if(NULL == pData)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_PARAM;+ − return HAL_ERROR;+ − }+ − + − if(hsd->State == HAL_SD_STATE_READY)+ − {+ − hsd->ErrorCode = HAL_DMA_ERROR_NONE;+ − + − if((BlockAdd + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;+ − return HAL_ERROR;+ − }+ − + − hsd->State = HAL_SD_STATE_BUSY;+ − + − /* Initialize data control register */+ − hsd->Instance->DCTRL = 0U;+ − + − /* Enable SD Error interrupts */ + − #ifdef SDIO_STA_STBITER+ − __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR)); + − #else /* SDIO_STA_STBITERR not defined */+ − __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR)); + − #endif /* SDIO_STA_STBITERR */+ − + − /* Set the DMA transfer complete callback */+ − hsd->hdmatx->XferCpltCallback = SD_DMATransmitCplt;+ − + − /* Set the DMA error callback */+ − hsd->hdmatx->XferErrorCallback = SD_DMAError;+ − + − /* Set the DMA Abort callback */+ − hsd->hdmatx->XferAbortCallback = NULL;+ − + − if(hsd->SdCard.CardType != CARD_SDHC_SDXC)+ − {+ − BlockAdd *= 512U;+ − }+ − + − /* Set Block Size for Card */ + − errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Write Blocks in Polling mode */+ − if(NumberOfBlocks > 1U)+ − {+ − hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);+ − + − /* Write Multi Block command */ + − errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, BlockAdd);+ − }+ − else+ − {+ − hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);+ − + − /* Write Single Block command */+ − errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, BlockAdd);+ − }+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Enable SDIO DMA transfer */+ − __HAL_SD_DMA_ENABLE(hsd);+ − + − /* Enable the DMA Channel */+ − HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pData, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4);+ − + − /* Configure the SD DPSM (Data Path State Machine) */ + − config.DataTimeOut = SDMMC_DATATIMEOUT;+ − config.DataLength = BLOCKSIZE * NumberOfBlocks;+ − config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;+ − config.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;+ − config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;+ − config.DPSM = SDIO_DPSM_ENABLE;+ − SDIO_ConfigData(hsd->Instance, &config);+ − + − return HAL_OK;+ − }+ − else+ − {+ − return HAL_BUSY;+ − }+ − }+ − + − /**+ − * @brief Erases the specified memory area of the given SD card.+ − * @note This API should be followed by a check on the card state through+ − * HAL_SD_GetCardState().+ − * @param hsd Pointer to SD handle + − * @param BlockStartAdd Start Block address+ − * @param BlockEndAdd End Block address+ − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)+ − {+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − if(hsd->State == HAL_SD_STATE_READY)+ − {+ − hsd->ErrorCode = HAL_DMA_ERROR_NONE;+ − + − if(BlockEndAdd < BlockStartAdd)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_PARAM;+ − return HAL_ERROR;+ − }+ − + − if(BlockEndAdd > (hsd->SdCard.LogBlockNbr))+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;+ − return HAL_ERROR;+ − }+ − + − hsd->State = HAL_SD_STATE_BUSY;+ − + − /* Check if the card command class supports erase command */+ − if(((hsd->SdCard.Class) & SDIO_CCCC_ERASE) == 0U)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + âËâââ€ÃÃ¢â‚¬Â¦Ãƒâ€šÃ‚¡ÃƒÆ’‚¬Ã‚ ÃƒÂ¢Ã¢â€šÂ¬Ã¢â€žÂ¢ hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Get start and end block for high capacity cards */+ − if(hsd->SdCard.CardType != CARD_SDHC_SDXC)+ − {+ − BlockStartAdd *= 512U;+ − BlockEndAdd *= 512U;+ − }+ − + − /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */+ − if(hsd->SdCard.CardType != CARD_SECURED)+ − {+ − /* Send CMD32 SD_ERASE_GRP_START with argument as addr */+ − errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, BlockStartAdd);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − /* Send CMD33 SD_ERASE_GRP_END with argument as addr */+ − errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, BlockEndAdd);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − }+ − + − /* Send CMD38 ERASE */+ − errorstate = SDMMC_CmdErase(hsd->Instance);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − hsd->State = HAL_SD_STATE_READY;+ − + − return HAL_OK;+ − }+ − else+ − {+ − return HAL_BUSY;+ − }+ − }+ − + − /**+ − * @brief This function handles SD card interrupt request.+ − * @param hsd Pointer to SD handle+ − * @retval None+ − */+ − void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)+ − {+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − /* Check for SDIO interrupt flags */+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_DATAEND) != RESET)+ − {+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DATAEND); + − + − #ifdef SDIO_STA_STBITERR+ − __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\+ − SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR | SDIO_IT_STBITERR);+ − #else /* SDIO_STA_STBITERR not defined */+ − __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\+ − SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);+ − #endif+ − + − if((hsd->Context & SD_CONTEXT_IT) != RESET)+ − {+ − if(((hsd->Context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != RESET) || ((hsd->Context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != RESET))+ − {+ − errorstate = SDMMC_CmdStopTransfer(hsd->Instance);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − hsd->ErrorCode |= errorstate;+ − HAL_SD_ErrorCallback(hsd);+ − }+ − }+ − + − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − + − hsd->State = HAL_SD_STATE_READY;+ − if(((hsd->Context & SD_CONTEXT_READ_SINGLE_BLOCK) != RESET) || ((hsd->Context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != RESET))+ − {+ − HAL_SD_RxCpltCallback(hsd);+ − }+ − else+ − {+ − HAL_SD_TxCpltCallback(hsd);+ − }+ − }+ − else if((hsd->Context & SD_CONTEXT_DMA) != RESET)+ − {+ − if((hsd->Context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != RESET)+ − {+ − errorstate = SDMMC_CmdStopTransfer(hsd->Instance);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − hsd->ErrorCode |= errorstate;+ − HAL_SD_ErrorCallback(hsd);+ − }+ − }+ − if(((hsd->Context & SD_CONTEXT_READ_SINGLE_BLOCK) == RESET) && ((hsd->Context & SD_CONTEXT_READ_MULTIPLE_BLOCK) == RESET))+ − {+ − /* Disable the DMA transfer for transmit request by setting the DMAEN bit+ − in the SD DCTRL register */+ − hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);+ − + − hsd->State = HAL_SD_STATE_READY;+ − + − HAL_SD_TxCpltCallback(hsd);+ − }+ − }+ − }+ − + − else if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_TXFIFOHE) != RESET)+ − {+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_TXFIFOHE);+ − + − SD_Write_IT(hsd);+ − }+ − + − else if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_RXFIFOHF) != RESET)+ − {+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_RXFIFOHF);+ − + − SD_Read_IT(hsd);+ − }+ − + − #ifdef SDIO_STA_STBITERR+ − else if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR) != RESET)+ − {+ − /* Set Error code */+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_DCRCFAIL) != RESET)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL; + − }+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_DTIMEOUT) != RESET)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT; + − }+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_RXOVERR) != RESET)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN; + − }+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_TXUNDERR) != RESET)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN; + − }+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_STBITERR) != RESET)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;+ − }+ − + − /* Clear All flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS | SDIO_FLAG_STBITERR);+ − + − /* Disable all interrupts */+ − __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\+ − SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR |SDIO_IT_STBITERR);+ − + − if((hsd->Context & SD_CONTEXT_DMA) != RESET)+ − {+ − /* Abort the SD DMA Streams */+ − if(hsd->hdmatx != NULL)+ − {+ − /* Set the DMA Tx abort callback */+ − hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;+ − /* Abort DMA in IT mode */+ − if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)+ − {+ − SD_DMATxAbort(hsd->hdmatx);+ − }+ − }+ − else if(hsd->hdmarx != NULL)+ − {+ − /* Set the DMA Rx abort callback */+ − hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;+ − /* Abort DMA in IT mode */+ − if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)+ − {+ − SD_DMARxAbort(hsd->hdmarx);+ − }+ − }+ − else+ − {+ − hsd->ErrorCode = HAL_SD_ERROR_NONE;+ − hsd->State = HAL_SD_STATE_READY;+ − HAL_SD_AbortCallback(hsd);+ − }+ − }+ − else if((hsd->Context & SD_CONTEXT_IT) != RESET)+ − {+ − /* Set the SD state to ready to be able to start again the process */+ − hsd->State = HAL_SD_STATE_READY;+ − HAL_SD_ErrorCallback(hsd);+ − }+ − }+ − #else /* SDIO_STA_STBITERR not defined */+ − else if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_TXUNDERR) != RESET)+ − {+ − /* Set Error code */+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_DCRCFAIL) != RESET)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL; + − }+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_DTIMEOUT) != RESET)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT; + ÃÃÃÆâ€™Ãƒâ€ ’¢â‚¬Å¡Ãƒâ€šÃ‚¢ÃƒÆ’‹â€ Ã¢â‚¬â„¢ }+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_RXOVERR) != RESET)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN; + − }+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_IT_TXUNDERR) != RESET)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN; + − }+ − + − /* Clear All flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − + − /* Disable all interrupts */+ − __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\+ − SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);+ − + − if((hsd->Context & SD_CONTEXT_DMA) != RESET)+ − {+ − /* Abort the SD DMA Streams */+ − if(hsd->hdmatx != NULL)+ − {+ − /* Set the DMA Tx abort callback */+ − hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;+ − /* Abort DMA in IT mode */+ − if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)+ − {+ − SD_DMATxAbort(hsd->hdmatx);+ − }+ − }+ − else if(hsd->hdmarx != NULL)+ − {+ − /* Set the DMA Rx abort callback */+ − hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;+ − /* Abort DMA in IT mode */+ − if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)+ − {+ − SD_DMARxAbort(hsd->hdmarx);+ − }+ − }+ − else+ − {+ − hsd->ErrorCode = HAL_SD_ERROR_NONE;+ − hsd->State = HAL_SD_STATE_READY;+ − HAL_SD_AbortCallback(hsd);+ − }+ − }+ − else if((hsd->Context & SD_CONTEXT_IT) != RESET)+ − {+ − /* Set the SD state to ready to be able to start again the process */+ − hsd->State = HAL_SD_STATE_READY;+ − HAL_SD_ErrorCallback(hsd);+ − }+ − }+ − #endif+ − }+ − + − /**+ − * @brief return the SD state+ − * @param hsd Pointer to sd handle+ − * @retval HAL state+ − */+ − HAL_SD_StateTypeDef HAL_SD_GetState(SD_HandleTypeDef *hsd)+ − {+ − return hsd->State;+ − }+ − + − /**+ − * @brief Return the SD error code+ − * @param hsd Pointer to a SD_HandleTypeDef structure that contains+ − * the configuration information.+ − * @retval SD Error Code+ − */+ − uint32_t HAL_SD_GetError(SD_HandleTypeDef *hsd)+ − {+ − return hsd->ErrorCode;+ − }+ − + − /**+ − * @brief Tx Transfer completed callbacks+ − * @param hsd Pointer to SD handle+ − * @retval None+ − */+ − __weak void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)+ − {+ − /* Prevent unused argument(s) compilation warning */+ − UNUSED(hsd);+ − + − /* NOTE : This function should not be modified, when the callback is needed,+ − the HAL_SD_TxCpltCallback can be implemented in the user file+ − */+ − }+ − + − /**+ − * @brief Rx Transfer completed callbacks+ − * @param hsd Pointer SD handle+ − * @retval None+ − */+ − __weak void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)+ − {+ − /* Prevent unused argument(s) compilation warning */+ − UNUSED(hsd);+ − + − /* NOTE : This function should not be modified, when the callback is needed,+ − the HAL_SD_RxCpltCallback can be implemented in the user file+ − */+ − }+ − + − /**+ − * @brief SD error callbacks+ − * @param hsd Pointer SD handle+ − * @retval None+ − */+ − __weak void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd)+ − {+ − /* Prevent unused argument(s) compilation warning */+ − UNUSED(hsd);+ − + − /* NOTE : This function should not be modified, when the callback is needed,+ − the HAL_SD_ErrorCallback can be implemented in the user file+ − */ + − }+ − + − /**+ − * @brief SD Abort callbacks+ − * @param hsd Pointer SD handle+ − * @retval None+ − */+ − __weak void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)+ − {+ − /* Prevent unused argument(s) compilation warning */+ − UNUSED(hsd);+ − + − /* NOTE : This function should not be modified, when the callback is needed,+ − the HAL_SD_ErrorCallback can be implemented in the user file+ − */ + − }+ − + − + − /**+ − * @}+ − */+ − + − /** @addtogroup SD_Exported_Functions_Group3+ − * @brief management functions + − *+ − @verbatim + − ==============================================================================+ − ##### Peripheral Control functions #####+ − ============================================================================== + − [..]+ − This subsection provides a set of functions allowing to control the SD card + − operations and get the related information+ − + − @endverbatim+ − * @{+ − */+ − + − /**+ − * @brief Returns information the information of the card which are stored on+ − * the CID register.+ − * @param hsd Pointer to SD handle+ − * @param pCID Pointer to a HAL_SD_CIDTypeDef structure that + − * contains all CID register parameters + − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_GetCardCID(SD_HandleTypeDef *hsd, HAL_SD_CardCIDTypeDef *pCID)+ − {+ − uint32_t tmp = 0U;+ − + − /* Byte 0 */+ − tmp = (uint8_t)((hsd->CID[0U] & 0xFF000000U) >> 24U);+ − pCID->ManufacturerID = tmp;+ − + − /* Byte 1 */+ − tmp = (uint8_t)((hsd->CID[0U] & 0x00FF0000U) >> 16U);+ − pCID->OEM_AppliID = tmp << 8U;+ − + − /* Byte 2 */+ − tmp = (uint8_t)((hsd->CID[0U] & 0x000000FF00U) >> 8U);+ − pCID->OEM_AppliID |= tmp;+ − + − /* Byte 3 */+ − tmp = (uint8_t)(hsd->CID[0U] & 0x000000FFU);+ − pCID->ProdName1 = tmp << 24U;+ − + − /* Byte 4 */+ − tmp = (uint8_t)((hsd->CID[1U] & 0xFF000000U) >> 24U);+ − pCID->ProdName1 |= tmp << 16;+ − + − /* Byte 5 */+ − tmp = (uint8_t)((hsd->CID[1U] & 0x00FF0000U) >> 16U);+ − pCID->ProdName1 |= tmp << 8U;+ − + − /* Byte 6 */+ − tmp = (uint8_t)((hsd->CID[1U] & 0x0000FF00U) >> 8U);+ − pCID->ProdName1 |= tmp;+ − + − /* Byte 7 */+ − tmp = (uint8_t)(hsd->CID[1U] & 0x000000FFU);+ − pCID->ProdName2 = tmp;+ − + − /* Byte 8 */+ − tmp = (uint8_t)((hsd->CID[2U] & 0xFF000000U) >> 24U);+ − pCID->ProdRev = tmp;+ − + − /* Byte 9 */+ − tmp = (uint8_t)((hsd->CID[2U] & 0x00FF0000U) >> 16U);+ − pCID->ProdSN = tmp << 24U;+ − + − /* Byte 10 */+ − tmp = (uint8_t)((hsd->CID[2U] & 0x0000FF00U) >> 8U);+ − pCID->ProdSN |= tmp << 16U;+ − + − /* Byte 11 */+ − tmp = (uint8_t)(hsd->CID[2U] & 0x000000FFU);+ − pCID->ProdSN |= tmp << 8U;+ − + − /* Byte 12 */+ − tmp = (uint8_t)((hsd->CID[3U] & 0xFF000000U) >> 24U);+ − pCID->ProdSN |= tmp;+ − + − /* Byte 13 */+ âˆâ€â„Ãââââ‚Â¬Ã…¡Ã‚¬Ã…¡Ãƒâ€šÃ‚¢ tmp = (uint8_t)((hsd->CID[3U] & 0x00FF0000U) >> 16U);+ − pCID->Reserved1 |= (tmp & 0xF0U) >> 4U;+ − pCID->ManufactDate = (tmp & 0x0FU) << 8U;+ − + − /* Byte 14 */+ − tmp = (uint8_t)((hsd->CID[3U] & 0x0000FF00U) >> 8U);+ − pCID->ManufactDate |= tmp;+ − + − /* Byte 15 */+ − tmp = (uint8_t)(hsd->CID[3U] & 0x000000FFU);+ − pCID->CID_CRC = (tmp & 0xFEU) >> 1U;+ − pCID->Reserved2 = 1U;+ − + − return HAL_OK;+ − }+ − + − /**+ − * @brief Returns information the information of the card which are stored on+ − * the CSD register.+ − * @param hsd Pointer to SD handle+ − * @param pCSD Pointer to a HAL_SD_CardCSDTypeDef structure that + − * contains all CSD register parameters + − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_GetCardCSD(SD_HandleTypeDef *hsd, HAL_SD_CardCSDTypeDef *pCSD)+ − {+ − uint32_t tmp = 0U;+ − + − /* Byte 0 */+ − tmp = (hsd->CSD[0U] & 0xFF000000U) >> 24U;+ − pCSD->CSDStruct = (uint8_t)((tmp & 0xC0U) >> 6U);+ − pCSD->SysSpecVersion = (uint8_t)((tmp & 0x3CU) >> 2U);+ − pCSD->Reserved1 = tmp & 0x03U;+ − + − /* Byte 1 */+ − tmp = (hsd->CSD[0U] & 0x00FF0000U) >> 16U;+ − pCSD->TAAC = (uint8_t)tmp;+ − + − /* Byte 2 */+ − tmp = (hsd->CSD[0U] & 0x0000FF00U) >> 8U;+ − pCSD->NSAC = (uint8_t)tmp;+ − + − /* Byte 3 */+ − tmp = hsd->CSD[0U] & 0x000000FFU;+ − pCSD->MaxBusClkFrec = (uint8_t)tmp;+ − + − /* Byte 4 */+ − tmp = (hsd->CSD[1U] & 0xFF000000U) >> 24U;+ − pCSD->CardComdClasses = (uint16_t)(tmp << 4U);+ − + − /* Byte 5 */+ − tmp = (hsd->CSD[1U] & 0x00FF0000U) >> 16U;+ − pCSD->CardComdClasses |= (uint16_t)((tmp & 0xF0U) >> 4U);+ − pCSD->RdBlockLen = (uint8_t)(tmp & 0x0FU);+ − + − /* Byte 6 */+ − tmp = (hsd->CSD[1U] & 0x0000FF00U) >> 8U;+ − pCSD->PartBlockRead = (uint8_t)((tmp & 0x80U) >> 7U);+ − pCSD->WrBlockMisalign = (uint8_t)((tmp & 0x40U) >> 6U);+ − pCSD->RdBlockMisalign = (uint8_t)((tmp & 0x20U) >> 5U);+ − pCSD->DSRImpl = (uint8_t)((tmp & 0x10U) >> 4U);+ − pCSD->Reserved2 = 0U; /*!< Reserved */+ − + − if(hsd->SdCard.CardType == CARD_SDSC)+ − {+ − pCSD->DeviceSize = (tmp & 0x03U) << 10U;+ − + − /* Byte 7 */+ − tmp = (uint8_t)(hsd->CSD[1U] & 0x000000FFU);+ − pCSD->DeviceSize |= (tmp) << 2U;+ − + − /* Byte 8 */+ − tmp = (uint8_t)((hsd->CSD[2U] & 0xFF000000U) >> 24U);+ − pCSD->DeviceSize |= (tmp & 0xC0U) >> 6U;+ − + − pCSD->MaxRdCurrentVDDMin = (tmp & 0x38U) >> 3U;+ − pCSD->MaxRdCurrentVDDMax = (tmp & 0x07U);+ − + − /* Byte 9 */+ − tmp = (uint8_t)((hsd->CSD[2U] & 0x00FF0000U) >> 16U);+ − pCSD->MaxWrCurrentVDDMin = (tmp & 0xE0U) >> 5U;+ − pCSD->MaxWrCurrentVDDMax = (tmp & 0x1CU) >> 2U;+ − pCSD->DeviceSizeMul = (tmp & 0x03U) << 1U;+ − /* Byte 10 */+ − tmp = (uint8_t)((hsd->CSD[2U] & 0x0000FF00U) >> 8U);+ − pCSD->DeviceSizeMul |= (tmp & 0x80U) >> 7U;+ − + − hsd->SdCard.BlockNbr = (pCSD->DeviceSize + 1U) ;+ − hsd->SdCard.BlockNbr *= (1U << (pCSD->DeviceSizeMul + 2U));+ − hsd->SdCard.BlockSize = 1U << (pCSD->RdBlockLen);+ − + − hsd->SdCard.LogBlockNbr = (hsd->SdCard.BlockNbr) * ((hsd->SdCard.BlockSize) / 512U); + − hsd->SdCard.LogBlockSize = 512U;+ − }+ − else if(hsd->SdCard.CardType == CARD_SDHC_SDXC)+ − {+ − /* Byte 7 */+ − tmp = (uint8_t)(hsd->CSD[1U] & 0x000000FFU);+ − pCSD->DeviceSize = (tmp & 0x3FU) << 16U;+ − + − /* Byte 8 */+ − tmp = (uint8_t)((hsd->CSD[2U] & 0xFF000000U) >> 24U);+ − + − pCSD->DeviceSize |= (tmp << 8U);+ − + − /* Byte 9 */+ − tmp = (uint8_t)((hsd->CSD[2U] & 0x00FF0000U) >> 16U);+ − + − pCSD->DeviceSize |= (tmp);+ − + − /* Byte 10 */+ − tmp = (uint8_t)((hsd->CSD[2U] & 0x0000FF00U) >> 8U);+ − + − hsd->SdCard.LogBlockNbr = hsd->SdCard.BlockNbr = (((uint64_t)pCSD->DeviceSize + 1U) * 1024U);+ − hsd->SdCard.LogBlockSize = hsd->SdCard.BlockSize = 512U;+ − }+ − else+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − + − pCSD->EraseGrSize = (tmp & 0x40U) >> 6U;+ − pCSD->EraseGrMul = (tmp & 0x3FU) << 1U;+ − + − /* Byte 11 */+ − tmp = (uint8_t)(hsd->CSD[2U] & 0x000000FFU);+ − pCSD->EraseGrMul |= (tmp & 0x80U) >> 7U;+ − pCSD->WrProtectGrSize = (tmp & 0x7FU);+ − + − /* Byte 12 */+ − tmp = (uint8_t)((hsd->CSD[3U] & 0xFF000000U) >> 24U);+ − pCSD->WrProtectGrEnable = (tmp & 0x80U) >> 7U;+ − pCSD->ManDeflECC = (tmp & 0x60U) >> 5U;+ − pCSD->WrSpeedFact = (tmp & 0x1CU) >> 2U;+ − pCSD->MaxWrBlockLen = (tmp & 0x03U) << 2U;+ − + − /* Byte 13 */+ − tmp = (uint8_t)((hsd->CSD[3U] & 0x00FF0000U) >> 16U);+ − pCSD->MaxWrBlockLen |= (tmp & 0xC0U) >> 6U;+ − pCSD->WriteBlockPaPartial = (tmp & 0x20U) >> 5U;+ − pCSD->Reserved3 = 0U;+ − pCSD->ContentProtectAppli = (tmp & 0x01U);+ − + − /* Byte 14 */+ − tmp = (uint8_t)((hsd->CSD[3U] & 0x0000FF00U) >> 8U);+ − pCSD->FileFormatGrouop = (tmp & 0x80U) >> 7U;+ − pCSD->CopyFlag = (tmp & 0x40U) >> 6U;+ − pCSD->PermWrProtect = (tmp & 0x20U) >> 5U;+ − pCSD->TempWrProtect = (tmp & 0x10U) >> 4U;+ − pCSD->FileFormat = (tmp & 0x0CU) >> 2U;+ − pCSD->ECC = (tmp & 0x03U);+ − + − /* Byte 15 */+ − tmp = (uint8_t)(hsd->CSD[3U] & 0x000000FFU);+ − pCSD->CSD_CRC = (tmp & 0xFEU) >> 1U;+ − pCSD->Reserved4 = 1U;+ − + − return HAL_OK;+ − }+ − + − /**+ − * @brief Gets the SD status info.+ − * @param hsd Pointer to SD handle + − * @param pStatus Pointer to the HAL_SD_CardStatusTypeDef structure that + − * will contain the SD card status information + − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypeDef *pStatus)+ − {+ − uint32_t tmp = 0U;+ − uint32_t sd_status[16U];+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − errorstate = SD_SendSDStatus(hsd, sd_status);+ − if(errorstate != HAL_OK)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS); + − hsd->ErrorCode |= errorstate;+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − else+ − {+ − /* Byte 0 */+ − tmp = (sd_status[0U] & 0xC0U) >> 6U;+ − pStatus->DataBusWidth = (uint8_t)tmp;+ − + − /* Byte 0 */+ − tmp = (sd_status[0U] & 0x20U) >> 5U;+ − pStatus->SecuredMode = (uint8_t)tmp;+ − + − /* Byte 2 */+ − tmp = (sd_status[0U] & 0x00FF0000U) >> 16U;+ − pStatus->CardType = (uint16_t)(tmp << 8U);+ − + − /* Byte 3 */+ − tmp = (sd_status[0U] & 0xFF000000U) >> 24U;+ − pStatus->CardType |= (uint16_t)tmp;+ − + − /* Byte 4 */+ − tmp = (sd_status[1U] & 0xFFU);+ − pStatus->ProtectedAreaSize = (uint32_t)(tmp << 24U);+ − + − /* Byte 5 */+ − tmp = (sd_status[1U] & 0xFF00U) >> 8U;+ − pStatus->ProtectedAreaSize |= (uint32_t)(tmp << 16U);+ − + − /* Byte 6 */+ − tmp = (sd_status[1U] & 0xFF0000U) >> 16U;+ − pStatus->ProtectedAreaSize |= (uint32_t)(tmp << 8U);+ − + − /* Byte 7 */+ − tmp = (sd_status[1U] & 0xFF000000U) >> 24U;+ − pStatus->ProtectedAreaSize |= (uint32_t)tmp;+ − + − /* Byte 8 */+ − tmp = (sd_status[2U] & 0xFFU);+ − pStatus->SpeedClass = (uint8_t)tmp;+ − + âˆÃÆÃƒÂ¢Ã¢â€šÂ¬Ã¢â€žÂ¢ÃƒÆ’ƒâ€ Ã¢â‚¬â„¢ÃƒÆ’‚¢Ã¢â€šÂ¬Ã¢â€žÂ¢ /* Byte 9 */+ − tmp = (sd_status[2U] & 0xFF00U) >> 8U;+ − pStatus->PerformanceMove = (uint8_t)tmp;+ − + − /* Byte 10 */+ − tmp = (sd_status[2U] & 0xF00000U) >> 20U;+ − pStatus->AllocationUnitSize = (uint8_t)tmp;+ − + − /* Byte 11 */+ − tmp = (sd_status[2U] & 0xFF000000U) >> 24U;+ − pStatus->EraseSize = (uint16_t)(tmp << 8U);+ − + − /* Byte 12 */+ − tmp = (sd_status[3U] & 0xFFU);+ − pStatus->EraseSize |= (uint16_t)tmp;+ − + − /* Byte 13 */+ − tmp = (sd_status[3U] & 0xFC00U) >> 10U;+ − pStatus->EraseTimeout = (uint8_t)tmp;+ − + − /* Byte 13 */+ − tmp = (sd_status[3U] & 0x0300U) >> 8U;+ − pStatus->EraseOffset = (uint8_t)tmp;+ − }+ − + − return HAL_OK;+ − }+ − + − /**+ − * @brief Gets the SD card info.+ − * @param hsd Pointer to SD handle + − * @param pCardInfo Pointer to the HAL_SD_CardInfoTypeDef structure that + − * will contain the SD card status information + − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_GetCardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypeDef *pCardInfo)+ − {+ − pCardInfo->CardType = (uint32_t)(hsd->SdCard.CardType);+ − pCardInfo->CardVersion = (uint32_t)(hsd->SdCard.CardVersion);+ − pCardInfo->Class = (uint32_t)(hsd->SdCard.Class);+ − pCardInfo->RelCardAdd = (uint32_t)(hsd->SdCard.RelCardAdd);+ − pCardInfo->BlockNbr = (uint32_t)(hsd->SdCard.BlockNbr);+ − pCardInfo->BlockSize = (uint32_t)(hsd->SdCard.BlockSize);+ − pCardInfo->LogBlockNbr = (uint32_t)(hsd->SdCard.LogBlockNbr);+ − pCardInfo->LogBlockSize = (uint32_t)(hsd->SdCard.LogBlockSize);+ − + − return HAL_OK;+ − }+ − + − /**+ − * @brief Enables wide bus operation for the requested card if supported by + − * card.+ − * @param hsd Pointer to SD handle + − * @param WideMode Specifies the SD card wide bus mode + − * This parameter can be one of the following values:+ − * @arg SDIO_BUS_WIDE_8B: 8-bit data transfer+ − * @arg SDIO_BUS_WIDE_4B: 4-bit data transfer+ − * @arg SDIO_BUS_WIDE_1B: 1-bit data transfer+ − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef *hsd, uint32_t WideMode)+ − {+ − SDIO_InitTypeDef Init;+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − /* Check the parameters */+ − assert_param(IS_SDIO_BUS_WIDE(WideMode));+ − + − /* Chnage Satte */+ − hsd->State = HAL_SD_STATE_BUSY;+ − + − if(hsd->SdCard.CardType != CARD_SECURED) + − {+ − if(WideMode == SDIO_BUS_WIDE_8B)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;+ − }+ − else if(WideMode == SDIO_BUS_WIDE_4B)+ − {+ − errorstate = SD_WideBus_Enable(hsd);+ − + − hsd->ErrorCode |= errorstate;+ − }+ − else if(WideMode == SDIO_BUS_WIDE_1B)+ − {+ − errorstate = SD_WideBus_Disable(hsd);+ − + − hsd->ErrorCode |= errorstate;+ − }+ − else+ − {+ − /* WideMode is not a valid argument*/+ − hsd->ErrorCode |= HAL_SD_ERROR_PARAM;+ − }+ − } + − else+ − {+ − /* MMC Card does not support this feature */+ − hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;+ − }+ − + − if(hsd->ErrorCode != HAL_SD_ERROR_NONE)+ − {+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − hsd->State = HAL_SD_STATE_READY;+ − return HAL_ERROR;+ − }+ − else+ − {+ − /* Configure the SDIO peripheral */+ − Init.ClockEdge = hsd->Init.ClockEdge;+ − Init.ClockBypass = hsd->Init.ClockBypass;+ − Init.ClockPowerSave = hsd->Init.ClockPowerSave;+ − Init.BusWide = WideMode;+ − Init.HardwareFlowControl = hsd->Init.HardwareFlowControl;+ − Init.ClockDiv = hsd->Init.ClockDiv;+ − SDIO_Init(hsd->Instance, Init);+ − }+ − + − /* Change State */+ − hsd->State = HAL_SD_STATE_READY;+ − + − return HAL_OK;+ − }+ − + − + − /**+ − * @brief Gets the current sd card data state.+ − * @param hsd pointer to SD handle+ − * @retval Card state+ − */+ − HAL_SD_CardStateTypeDef HAL_SD_GetCardState(SD_HandleTypeDef *hsd)+ − {+ − HAL_SD_CardStateTypeDef cardstate = HAL_SD_CARD_TRANSFER;+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − uint32_t resp1 = 0;+ − + − errorstate = SD_SendStatus(hsd, &resp1);+ − if(errorstate != HAL_OK)+ − {+ − hsd->ErrorCode |= errorstate;+ − }+ − + − cardstate = (HAL_SD_CardStateTypeDef)((resp1 >> 9U) & 0x0FU);+ − + − return cardstate;+ − }+ − + − /**+ − * @brief Abort the current transfer and disable the SD.+ − * @param hsd pointer to a SD_HandleTypeDef structure that contains+ − * the configuration information for SD module.+ − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_Abort(SD_HandleTypeDef *hsd)+ − {+ − HAL_SD_CardStateTypeDef CardState;+ − + − /* DIsable All interrupts */+ − __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\+ − SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);+ − + − /* Clear All flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − + − if((hsd->hdmatx != NULL) || (hsd->hdmarx != NULL))+ − {+ − /* Disable the SD DMA request */+ − hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);+ − + − /* Abort the SD DMA Tx Stream */+ − if(hsd->hdmatx != NULL)+ − {+ − HAL_DMA_Abort(hsd->hdmatx);+ − }+ − /* Abort the SD DMA Rx Stream */+ − if(hsd->hdmarx != NULL)+ − {+ − HAL_DMA_Abort(hsd->hdmarx);+ − }+ − }+ − + − hsd->State = HAL_SD_STATE_READY;+ − CardState = HAL_SD_GetCardState(hsd);+ − if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))+ − {+ − hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);+ − }+ − if(hsd->ErrorCode != HAL_SD_ERROR_NONE)+ − {+ − return HAL_ERROR;+ − }+ − return HAL_OK;+ − }+ − + − /**+ − * @brief Abort the current transfer and disable the SD (IT mode).+ − * @param hsd pointer to a SD_HandleTypeDef structure that contains+ − * the configuration information for SD module.+ − * @retval HAL status+ − */+ − HAL_StatusTypeDef HAL_SD_Abort_IT(SD_HandleTypeDef *hsd)+ − {+ − HAL_SD_CardStateTypeDef CardState;+ − + − /* DIsable All interrupts */+ − __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\+ − SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);+ − + − /* Clear All flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − + − if((hsd->hdmatx != NULL) || (hsd->hdmarx != NULL))+ − {+ − /* Disable the SD DMA request */+ − hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);+ − + − /* Abort the SD DMA Tx Stream */+ − if(hsd->hdmatx != NULL)+ − {+ − hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;+ − if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)+ − {+ âÃÆÃÆ’ƒÂ¢Ã¢â€šÂ¬Ã¢â€žÂ¢ÃƒÆ’ƒÂ¢Ã¢â€šÂ¬Ã‚¹ÃƒÂ¢Ã¢â€šÂ¬Ã‚ ÃƒÂ¢Ã¢â€šÂ¬Ã¢â€žÂ¢ hsd->hdmatx = NULL;+ − }+ − }+ − /* Abort the SD DMA Rx Stream */+ − if(hsd->hdmarx != NULL)+ − {+ − hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;+ − if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)+ − {+ − hsd->hdmarx = NULL;+ − }+ − }+ − }+ − + − /* No transfer ongoing on both DMA channels*/+ − if((hsd->hdmatx == NULL) && (hsd->hdmarx == NULL))+ − {+ − CardState = HAL_SD_GetCardState(hsd);+ − hsd->State = HAL_SD_STATE_READY;+ − if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))+ − {+ − hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);+ − }+ − if(hsd->ErrorCode != HAL_SD_ERROR_NONE)+ − {+ − return HAL_ERROR;+ − }+ − else+ − {+ − HAL_SD_AbortCallback(hsd);+ − }+ − }+ − + − return HAL_OK;+ − }+ − + − /**+ − * @}+ − */+ − + − /**+ − * @}+ − */+ − + − /* Private function ----------------------------------------------------------*/ + − /** @addtogroup SD_Private_Functions+ − * @{+ − */+ − + − /**+ − * @brief DMA SD transmit process complete callback + − * @param hdma DMA handle+ − * @retval None+ − */+ − static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma) + − {+ − SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);+ − + − /* Enable DATAEND Interrupt */+ − __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DATAEND));+ − }+ − + − /**+ − * @brief DMA SD receive process complete callback + − * @param hdma DMA handle+ − * @retval None+ − */+ − static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma) + − {+ − SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − /* Send stop command in multiblock write */+ − if(hsd->Context == (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA))+ − {+ − errorstate = SDMMC_CmdStopTransfer(hsd->Instance);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − hsd->ErrorCode |= errorstate;+ − HAL_SD_ErrorCallback(hsd);+ − }+ − }+ − + − /* Disable the DMA transfer for transmit request by setting the DMAEN bit+ − in the SD DCTRL register */+ − hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);+ − + − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − + − hsd->State = HAL_SD_STATE_READY;+ − + − HAL_SD_RxCpltCallback(hsd);+ − }+ − + − /**+ − * @brief DMA SD communication error callback + − * @param hdma DMA handle+ − * @retval None+ − */+ − static void SD_DMAError(DMA_HandleTypeDef *hdma) + − {+ − SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);+ − HAL_SD_CardStateTypeDef CardState;+ − + − if((hsd->hdmarx->ErrorCode == HAL_DMA_ERROR_TE) || (hsd->hdmatx->ErrorCode == HAL_DMA_ERROR_TE))+ − {+ − /* Clear All flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − + − /* Disable All interrupts */+ − __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\+ − SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);+ − + − hsd->ErrorCode |= HAL_SD_ERROR_DMA;+ − CardState = HAL_SD_GetCardState(hsd);+ − if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))+ − {+ − hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);+ − }+ − + − hsd->State= HAL_SD_STATE_READY;+ − }+ − + − HAL_SD_ErrorCallback(hsd);+ − }+ − + − /**+ − * @brief DMA SD Tx Abort callback + − * @param hdma DMA handle+ − * @retval None+ − */+ − static void SD_DMATxAbort(DMA_HandleTypeDef *hdma) + − {+ − SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);+ − HAL_SD_CardStateTypeDef CardState;+ − + − if(hsd->hdmatx != NULL)+ − {+ − hsd->hdmatx = NULL;+ − }+ − + − /* All DMA channels are aborted */+ − if(hsd->hdmarx == NULL)+ − {+ − CardState = HAL_SD_GetCardState(hsd);+ − hsd->ErrorCode = HAL_SD_ERROR_NONE;+ − hsd->State = HAL_SD_STATE_READY;+ − if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))+ − {+ − hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);+ − + − if(hsd->ErrorCode != HAL_SD_ERROR_NONE)+ − {+ − HAL_SD_AbortCallback(hsd);+ − }+ − else+ − {+ − HAL_SD_ErrorCallback(hsd);+ − }+ − }+ − }+ − }+ − + − /**+ − * @brief DMA SD Rx Abort callback + − * @param hdma DMA handle+ − * @retval None+ − */+ − static void SD_DMARxAbort(DMA_HandleTypeDef *hdma) + − {+ − SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);+ − HAL_SD_CardStateTypeDef CardState;+ − + − if(hsd->hdmarx != NULL)+ − {+ − hsd->hdmarx = NULL;+ − }+ − + − /* All DMA channels are aborted */+ − if(hsd->hdmatx == NULL)+ − {+ − CardState = HAL_SD_GetCardState(hsd);+ − hsd->ErrorCode = HAL_SD_ERROR_NONE;+ − hsd->State = HAL_SD_STATE_READY;+ − if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))+ − {+ − hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);+ − + − if(hsd->ErrorCode != HAL_SD_ERROR_NONE)+ − {+ − HAL_SD_AbortCallback(hsd);+ − }+ − else+ − {+ − HAL_SD_ErrorCallback(hsd);+ − }+ − }+ − }+ − }+ − + − + − /**+ − * @brief Initializes the sd card.+ − * @param hsd Pointer to SD handle+ − * @retval SD Card error state+ − */+ − static uint32_t SD_InitCard(SD_HandleTypeDef *hsd)+ − {+ − HAL_SD_CardCSDTypeDef CSD;+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − uint16_t sd_rca = 1U;+ − + − /* Check the power State */+ − if(SDIO_GetPowerState(hsd->Instance) == 0U) + − {+ − /* Power off */+ − return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;+ − }+ − + − if(hsd->SdCard.CardType != CARD_SECURED) + − {+ − /* Send CMD2 ALL_SEND_CID */+ − errorstate = SDMMC_CmdSendCID(hsd->Instance);+ ÃÂÃÆâ€ââ€žÂ¢ÃƒÆ’ƒÂ¢Ã¢â€šÂ¬Ã…¡Ãƒâ€šÃ‚¢ÃƒÆ’ƒâ€¹Ã¢â‚¬Â ÃƒÂ¢Ã¢â€šÂ¬Ã¢â€žÂ¢ if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − return errorstate;+ − }+ − else+ − {+ − /* Get Card identification number data */+ − hsd->CID[0U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);+ − hsd->CID[1U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);+ − hsd->CID[2U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);+ − hsd->CID[3U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);+ − }+ − }+ − + − if(hsd->SdCard.CardType != CARD_SECURED) + − {+ − /* Send CMD3 SET_REL_ADDR with argument 0 */+ − /* SD Card publishes its RCA. */+ − errorstate = SDMMC_CmdSetRelAdd(hsd->Instance, &sd_rca);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − return errorstate;+ − }+ − }+ − if(hsd->SdCard.CardType != CARD_SECURED) + − {+ − /* Get the SD card RCA */+ − hsd->SdCard.RelCardAdd = sd_rca;+ − + − /* Send CMD9 SEND_CSD with argument as card's RCA */+ − errorstate = SDMMC_CmdSendCSD(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − return errorstate;+ − }+ − else+ − {+ − /* Get Card Specific Data */+ − hsd->CSD[0U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);+ − hsd->CSD[1U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);+ − hsd->CSD[2U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);+ − hsd->CSD[3U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);+ − }+ − }+ − + − /* Get the Card Class */+ − hsd->SdCard.Class = (SDIO_GetResponse(hsd->Instance, SDIO_RESP2) >> 20U);+ − + − /* Get CSD parameters */+ − HAL_SD_GetCardCSD(hsd, &CSD);+ − + − /* Select the Card */+ − errorstate = SDMMC_CmdSelDesel(hsd->Instance, (uint32_t)(((uint32_t)hsd->SdCard.RelCardAdd) << 16U));+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − return errorstate;+ − }+ − + − /* Configure SDIO peripheral interface */ + − SDIO_Init(hsd->Instance, hsd->Init);+ − + − /* All cards are initialized */+ − return HAL_SD_ERROR_NONE;+ − }+ − + − /**+ − * @brief Enquires cards about their operating voltage and configures clock+ − * controls and stores SD information that will be needed in future+ − * in the SD handle.+ − * @param hsd Pointer to SD handle+ − * @retval error state+ − */+ − static uint32_t SD_PowerON(SD_HandleTypeDef *hsd)+ − {+ − __IO uint32_t count = 0U;+ − uint32_t response = 0U, validvoltage = 0U;+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − /* CMD0: GO_IDLE_STATE */+ − errorstate = SDMMC_CmdGoIdleState(hsd->Instance);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − return errorstate;+ − }+ − + − /* CMD8: SEND_IF_COND: Command available only on V2.0 cards */+ − errorstate = SDMMC_CmdOperCond(hsd->Instance);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − hsd->SdCard.CardVersion = CARD_V1_X;+ − + − /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */+ − while(validvoltage == 0U)+ − {+ − if(count++ == SDMMC_MAX_VOLT_TRIAL)+ − {+ − return HAL_SD_ERROR_INVALID_VOLTRANGE;+ − }+ − + − /* SEND CMD55 APP_CMD with RCA as 0 */+ − errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0U);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − return HAL_SD_ERROR_UNSUPPORTED_FEATURE;+ − }+ − + − /* Send CMD41 */+ − errorstate = SDMMC_CmdAppOperCommand(hsd->Instance, SDMMC_STD_CAPACITY);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − return HAL_SD_ERROR_UNSUPPORTED_FEATURE;+ − }+ − + − /* Get command response */+ − response = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);+ − + − /* Get operating voltage*/+ − validvoltage = (((response >> 31U) == 1U) ? 1U : 0U);+ − }+ − /* Card type is SDSC */+ − hsd->SdCard.CardType = CARD_SDSC;+ − }+ − else+ − {+ − hsd->SdCard.CardVersion = CARD_V2_X;+ − + − /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */+ − while(validvoltage == 0U)+ − {+ − if(count++ == SDMMC_MAX_VOLT_TRIAL)+ − {+ − return HAL_SD_ERROR_INVALID_VOLTRANGE;+ − }+ − + − /* SEND CMD55 APP_CMD with RCA as 0 */+ − errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0U);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − return errorstate;+ − }+ − + − /* Send CMD41 */+ − errorstate = SDMMC_CmdAppOperCommand(hsd->Instance, SDMMC_HIGH_CAPACITY);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − return errorstate;+ − }+ − + − /* Get command response */+ − response = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);+ − + − /* Get operating voltage*/+ − validvoltage = (((response >> 31U) == 1U) ? 1U : 0U);+ − }+ − + − if((response & SDMMC_HIGH_CAPACITY) == SDMMC_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */+ − {+ − hsd->SdCard.CardType = CARD_SDHC_SDXC;+ − }+ − else+ − {+ − hsd->SdCard.CardType = CARD_SDSC;+ − }+ − }+ − + − return HAL_SD_ERROR_NONE;+ − }+ − + − /**+ − * @brief Turns the SDIO output signals off.+ − * @param hsd Pointer to SD handle+ − * @retval HAL status+ − */+ − static HAL_StatusTypeDef SD_PowerOFF(SD_HandleTypeDef *hsd)+ − {+ − /* Set Power State to OFF */+ − SDIO_PowerState_OFF(hsd->Instance);+ − + − return HAL_OK;+ − }+ − + − /**+ − * @brief Send Status info command.+ − * @param hsd pointer to SD handle+ − * @param pSDstatus Pointer to the buffer that will contain the SD card status + − * SD Status register)+ − * @retval error state+ − */+ − static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)+ − {+ − SDIO_DataInitTypeDef config;+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − uint32_t tickstart = HAL_GetTick();+ − uint32_t count = 0U;+ − + − /* Check SD response */+ − if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)+ − {+ − return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;+ − }+ − + − /* Set block size for card if it is not equal to current block size for card */+ − errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_NONE;+ − return errorstate;+ − }+ − + − /* Send CMD55 */+ − errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_NONE;+ − return errorstate;+ − }+ − + − /* Configure the SD DPSM (Data Path State Machine) */ + − config.DataTimeOut = SDMMC_DATATIMEOUT;+ − config.DataLength = 64U;+ − config.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;+ − config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;+ − config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;+ âˆâ€âââ‚ÂÃƒÆ’‚¬Ãƒâ€¦Ã‚¾Ãƒâ€šÃ‚¢ config.DPSM = SDIO_DPSM_ENABLE;+ − SDIO_ConfigData(hsd->Instance, &config);+ − + − /* Send ACMD13 (SD_APP_STAUS) with argument as card's RCA */+ − errorstate = SDMMC_CmdStatusRegister(hsd->Instance);+ − if(errorstate != HAL_SD_ERROR_NONE)+ − {+ − hsd->ErrorCode |= HAL_SD_ERROR_NONE;+ − return errorstate;+ − }+ − + − /* Get status data */+ − while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND))+ − {+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))+ − {+ − for(count = 0U; count < 8U; count++)+ − {+ − *(pSDstatus + count) = SDIO_ReadFIFO(hsd->Instance);+ − }+ − + − pSDstatus += 8U;+ − }+ − + − if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)+ − {+ − return HAL_SD_ERROR_TIMEOUT;+ − }+ − }+ − + − if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))+ − {+ − return HAL_SD_ERROR_DATA_TIMEOUT;+ − }+ − else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))+ − {+ − return HAL_SD_ERROR_DATA_CRC_FAIL;+ − }+ − else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))+ − {+ − return HAL_SD_ERROR_RX_OVERRUN;+ − }+ − + − while ((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)))+ − {+ − *pSDstatus = SDIO_ReadFIFO(hsd->Instance);+ − pSDstatus++;+ − + − if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)+ − {+ − return HAL_SD_ERROR_TIMEOUT;+ − }+ − }+ − + − /* Clear all the static status flags*/+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − + − return HAL_SD_ERROR_NONE;+ − }+ − + − /**+ − * @brief Returns the current card's status.+ − * @param hsd Pointer to SD handle+ − * @param pCardStatus pointer to the buffer that will contain the SD card + − * status (Card Status register) + − * @retval error state+ − */+ − static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)+ − {+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − if(pCardStatus == NULL)+ − {+ − return HAL_SD_ERROR_PARAM;+ − }+ − + − /* Send Status command */+ − errorstate = SDMMC_CmdSendStatus(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));+ − if(errorstate != HAL_OK)+ − {+ − return errorstate;+ − }+ − + − /* Get SD card status */+ − *pCardStatus = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);+ − + − return HAL_SD_ERROR_NONE;+ − }+ − + − /**+ − * @brief Enables the SDIO wide bus mode.+ − * @param hsd pointer to SD handle+ − * @retval error state+ − */+ − static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd)+ − {+ − uint32_t scr[2U] = {0U, 0U};+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)+ − {+ − return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;+ − }+ − + − /* Get SCR Register */+ − errorstate = SD_FindSCR(hsd, scr);+ − if(errorstate != HAL_OK)+ − {+ − return errorstate;+ − }+ − + − /* If requested card supports wide bus operation */+ − if((scr[1U] & SDMMC_WIDE_BUS_SUPPORT) != SDMMC_ALLZERO)+ − {+ − /* Send CMD55 APP_CMD with argument as card's RCA.*/+ − errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));+ − if(errorstate != HAL_OK)+ − {+ − return errorstate;+ − }+ − + − /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */+ − errorstate = SDMMC_CmdBusWidth(hsd->Instance, 2U);+ − if(errorstate != HAL_OK)+ − {+ − return errorstate;+ − }+ − + − return HAL_SD_ERROR_NONE;+ − }+ − else+ − {+ − return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;+ − }+ − }+ − + − /**+ − * @brief Disables the SDIO wide bus mode.+ − * @param hsd Pointer to SD handle+ − * @retval error state+ − */+ − static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd)+ − {+ − uint32_t scr[2U] = {0U, 0U};+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − + − if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)+ − {+ − return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;+ − }+ − + − /* Get SCR Register */+ − errorstate = SD_FindSCR(hsd, scr);+ − if(errorstate != HAL_OK)+ − {+ − return errorstate;+ − }+ − + − /* If requested card supports 1 bit mode operation */+ − if((scr[1U] & SDMMC_SINGLE_BUS_SUPPORT) != SDMMC_ALLZERO)+ − {+ − /* Send CMD55 APP_CMD with argument as card's RCA */+ − errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));+ − if(errorstate != HAL_OK)+ − {+ − return errorstate;+ − }+ − + − /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */+ − errorstate = SDMMC_CmdBusWidth(hsd->Instance, 0U);+ − if(errorstate != HAL_OK)+ − {+ − return errorstate;+ − }+ − + − return HAL_SD_ERROR_NONE;+ − }+ − else+ − {+ − return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;+ − }+ − }+ − + − + − /**+ − * @brief Finds the SD card SCR register value.+ − * @param hsd Pointer to SD handle+ − * @param pSCR pointer to the buffer that will contain the SCR value + − * @retval error state+ − */+ − static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)+ − {+ − SDIO_DataInitTypeDef config;+ − uint32_t errorstate = HAL_SD_ERROR_NONE;+ − uint32_t tickstart = HAL_GetTick();+ − uint32_t index = 0U;+ − uint32_t tempscr[2U] = {0U, 0U};+ − + − /* Set Block Size To 8 Bytes */+ − errorstate = SDMMC_CmdBlockLength(hsd->Instance, 8U);+ − if(errorstate != HAL_OK)+ − {+ − return errorstate;+ − }+ − + − /* Send CMD55 APP_CMD with argument as card's RCA */+ − errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)((hsd->SdCard.RelCardAdd) << 16U));+ − if(errorstate != HAL_OK)+ − {+ − return errorstate;+ − }+ − + − config.DataTimeOut = SDMMC_DATATIMEOUT;+ − config.DataLength = 8U;+ − config.DataBlockSize = SDIO_DATABLOCK_SIZE_8B;+ − config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;+ − config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;+ − config.DPSM = SDIO_DPSM_ENABLE;+ − SDIO_ConfigData(hsd->Instance, &config);+ − + − /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */+ − errorstate = SDMMC_CmdSendSCR(hsd->Instance);+ − if(errorstate != HAL_OK)+ − {+ ̢蠉ââââ€ÅÃƒâ€šÃ‚¡ÃƒÆ’‚¬Ã…¡Ã‚¬Ã¢â€žÂ¢ return errorstate;+ − }+ − + − while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND))+ − {+ − if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL))+ − {+ − *(tempscr + index) = SDIO_ReadFIFO(hsd->Instance);+ − index++;+ − }+ − + − if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)+ − {+ − return HAL_SD_ERROR_TIMEOUT;+ − }+ − }+ − + − if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))+ − {+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);+ − + − return HAL_SD_ERROR_DATA_TIMEOUT;+ − }+ − else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))+ − {+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);+ − + − return HAL_SD_ERROR_DATA_CRC_FAIL;+ − }+ − else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))+ − {+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);+ − + − return HAL_SD_ERROR_RX_OVERRUN;+ − }+ − else+ − {+ − /* No error flag set */+ − /* Clear all the static flags */+ − __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);+ − + − *(pSCR + 1U) = ((tempscr[0U] & SDMMC_0TO7BITS) << 24U) | ((tempscr[0U] & SDMMC_8TO15BITS) << 8U) |\+ − ((tempscr[0U] & SDMMC_16TO23BITS) >> 8U) | ((tempscr[0U] & SDMMC_24TO31BITS) >> 24U);+ − + − *(pSCR) = ((tempscr[1U] & SDMMC_0TO7BITS) << 24U) | ((tempscr[1U] & SDMMC_8TO15BITS) << 8U) |\+ − ((tempscr[1U] & SDMMC_16TO23BITS) >> 8U) | ((tempscr[1U] & SDMMC_24TO31BITS) >> 24U);+ − }+ − + − return HAL_SD_ERROR_NONE;+ − }+ − + − /**+ − * @brief Wrap up reading in non-blocking mode.+ − * @param hsd pointer to a SD_HandleTypeDef structure that contains+ − * the configuration information.+ − * @retval HAL status+ − */+ − static HAL_StatusTypeDef SD_Read_IT(SD_HandleTypeDef *hsd)+ − {+ − uint32_t count = 0U;+ − uint32_t* tmp;+ − + − tmp = (uint32_t*)hsd->pRxBuffPtr;+ − + − /* Read data from SDIO Rx FIFO */+ − for(count = 0U; count < 8U; count++)+ − {+ − *(tmp + count) = SDIO_ReadFIFO(hsd->Instance);+ − }+ − + − hsd->pRxBuffPtr += 8U;+ − + − return HAL_OK;+ − }+ − + − /**+ − * @brief Wrap up writing in non-blocking mode.+ − * @param hsd pointer to a SD_HandleTypeDef structure that contains+ − * the configuration information.+ − * @retval HAL status+ − */+ − static HAL_StatusTypeDef SD_Write_IT(SD_HandleTypeDef *hsd)+ − {+ − uint32_t count = 0U;+ − uint32_t* tmp;+ − + − tmp = (uint32_t*)hsd->pTxBuffPtr;+ − + − /* Write data to SDIO Tx FIFO */+ − for(count = 0U; count < 8U; count++)+ − {+ − SDIO_WriteFIFO(hsd->Instance, (tmp + count));+ − }+ − + − hsd->pTxBuffPtr += 8U;+ − + − return HAL_OK;+ − }+ − + − /**+ − * @}+ − */+ − + − #endif /* STM32F405xx || STM32F415xx || STM32F407xx || STM32F417xx || STM32F427xx || STM32F437xx || STM32F429xx || STM32F439xx ||+ − STM32F401xC || STM32F401xE || STM32F411xE || STM32F446xx || STM32F469xx || STM32F479xx || STM32F412Zx || STM32F412Vx || + − STM32F412Rx || STM32F412Cx || STM32F413xx || STM32F423xx */+ − + − #endif /* HAL_SD_MODULE_ENABLED */+ − + − /**+ − * @}+ − */+ − + − /**+ − * @}+ − */+ − + − /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/+ −
