Johannes Stratmann / mbed-dev

added prescaler for 16 bit pwm in LPC1347 target

Fork of mbed-dev by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_sd.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Committer:
<>
Date:
Fri Sep 02 15:07:44 2016 +0100
Revision:
144:ef7eb2e8f9f7
Parent:
83:a036322b8637 
This updates the lib to the mbed lib v125

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32f7xx_hal_sd.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 144:ef7eb2e8f9f7 5 * @version V1.1.0
<> 144:ef7eb2e8f9f7 6 * @date 22-April-2016
<> 144:ef7eb2e8f9f7 7 * @brief SD card HAL module driver.
<> 144:ef7eb2e8f9f7 8 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 9 * functionalities of the Secure Digital (SD) peripheral:
<> 144:ef7eb2e8f9f7 10 * + Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 11 * + IO operation functions
<> 144:ef7eb2e8f9f7 12 * + Peripheral Control functions
<> 144:ef7eb2e8f9f7 13 * + Peripheral State functions
<> 144:ef7eb2e8f9f7 14 *
<> 144:ef7eb2e8f9f7 15 @verbatim
<> 144:ef7eb2e8f9f7 16 ==============================================================================
<> 144:ef7eb2e8f9f7 17 ##### How to use this driver #####
<> 144:ef7eb2e8f9f7 18 ==============================================================================
<> 144:ef7eb2e8f9f7 19 [..]
<> 144:ef7eb2e8f9f7 20 This driver implements a high level communication layer for read and write from/to
<> 144:ef7eb2e8f9f7 21 this memory. The needed STM32 hardware resources (SDMMC and GPIO) are performed by
<> 144:ef7eb2e8f9f7 22 the user in HAL_SD_MspInit() function (MSP layer).
<> 144:ef7eb2e8f9f7 23 Basically, the MSP layer configuration should be the same as we provide in the
<> 144:ef7eb2e8f9f7 24 examples.
<> 144:ef7eb2e8f9f7 25 You can easily tailor this configuration according to hardware resources.
<> 144:ef7eb2e8f9f7 26
<> 144:ef7eb2e8f9f7 27 [..]
<> 144:ef7eb2e8f9f7 28 This driver is a generic layered driver for SDMMC memories which uses the HAL
<> 144:ef7eb2e8f9f7 29 SDMMC driver functions to interface with SD and uSD cards devices.
<> 144:ef7eb2e8f9f7 30 It is used as follows:
<> 144:ef7eb2e8f9f7 31
<> 144:ef7eb2e8f9f7 32 (#)Initialize the SDMMC low level resources by implement the HAL_SD_MspInit() API:
<> 144:ef7eb2e8f9f7 33 (##) Enable the SDMMC interface clock using __HAL_RCC_SDMMC_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 34 (##) SDMMC pins configuration for SD card
<> 144:ef7eb2e8f9f7 35 (+++) Enable the clock for the SDMMC GPIOs using the functions __HAL_RCC_GPIOx_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 36 (+++) Configure these SDMMC pins as alternate function pull-up using HAL_GPIO_Init()
<> 144:ef7eb2e8f9f7 37 and according to your pin assignment;
<> 144:ef7eb2e8f9f7 38 (##) DMA Configuration if you need to use DMA process (HAL_SD_ReadBlocks_DMA()
<> 144:ef7eb2e8f9f7 39 and HAL_SD_WriteBlocks_DMA() APIs).
<> 144:ef7eb2e8f9f7 40 (+++) Enable the DMAx interface clock using __HAL_RCC_DMAx_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 41 (+++) Configure the DMA using the function HAL_DMA_Init() with predeclared and filled.
<> 144:ef7eb2e8f9f7 42 (##) NVIC configuration if you need to use interrupt process when using DMA transfer.
<> 144:ef7eb2e8f9f7 43 (+++) Configure the SDMMC and DMA interrupt priorities using functions
<> 144:ef7eb2e8f9f7 44 HAL_NVIC_SetPriority(); DMA priority is superior to SDMMC's priority
<> 144:ef7eb2e8f9f7 45 (+++) Enable the NVIC DMA and SDMMC IRQs using function HAL_NVIC_EnableIRQ()
<> 144:ef7eb2e8f9f7 46 (+++) SDMMC interrupts are managed using the macros __HAL_SD_SDMMC_ENABLE_IT()
<> 144:ef7eb2e8f9f7 47 and __HAL_SD_SDMMC_DISABLE_IT() inside the communication process.
<> 144:ef7eb2e8f9f7 48 (+++) SDMMC interrupts pending bits are managed using the macros __HAL_SD_SDMMC_GET_IT()
<> 144:ef7eb2e8f9f7 49 and __HAL_SD_SDMMC_CLEAR_IT()
<> 144:ef7eb2e8f9f7 50 (#) At this stage, you can perform SD read/write/erase operations after SD card initialization
<> 144:ef7eb2e8f9f7 51
<> 144:ef7eb2e8f9f7 52
<> 144:ef7eb2e8f9f7 53 *** SD Card Initialization and configuration ***
<> 144:ef7eb2e8f9f7 54 ================================================
<> 144:ef7eb2e8f9f7 55 [..]
<> 144:ef7eb2e8f9f7 56 To initialize the SD Card, use the HAL_SD_Init() function. It Initializes
<> 144:ef7eb2e8f9f7 57 the SD Card and put it into StandBy State (Ready for data transfer).
<> 144:ef7eb2e8f9f7 58 This function provide the following operations:
<> 144:ef7eb2e8f9f7 59
<> 144:ef7eb2e8f9f7 60 (#) Apply the SD Card initialization process at 400KHz and check the SD Card
<> 144:ef7eb2e8f9f7 61 type (Standard Capacity or High Capacity). You can change or adapt this
<> 144:ef7eb2e8f9f7 62 frequency by adjusting the "ClockDiv" field.
<> 144:ef7eb2e8f9f7 63 The SD Card frequency (SDMMC_CK) is computed as follows:
<> 144:ef7eb2e8f9f7 64
<> 144:ef7eb2e8f9f7 65 SDMMC_CK = SDMMCCLK / (ClockDiv + 2)
<> 144:ef7eb2e8f9f7 66
<> 144:ef7eb2e8f9f7 67 In initialization mode and according to the SD Card standard,
<> 144:ef7eb2e8f9f7 68 make sure that the SDMMC_CK frequency doesn't exceed 400KHz.
<> 144:ef7eb2e8f9f7 69
<> 144:ef7eb2e8f9f7 70 (#) Get the SD CID and CSD data. All these information are managed by the SDCardInfo
<> 144:ef7eb2e8f9f7 71 structure. This structure provide also ready computed SD Card capacity
<> 144:ef7eb2e8f9f7 72 and Block size.
<> 144:ef7eb2e8f9f7 73
<> 144:ef7eb2e8f9f7 74 -@- These information are stored in SD handle structure in case of future use.
<> 144:ef7eb2e8f9f7 75
<> 144:ef7eb2e8f9f7 76 (#) Configure the SD Card Data transfer frequency. By Default, the card transfer
<> 144:ef7eb2e8f9f7 77 frequency is set to 24MHz. You can change or adapt this frequency by adjusting
<> 144:ef7eb2e8f9f7 78 the "ClockDiv" field.
<> 144:ef7eb2e8f9f7 79 In transfer mode and according to the SD Card standard, make sure that the
<> 144:ef7eb2e8f9f7 80 SDMMC_CK frequency doesn't exceed 25MHz and 50MHz in High-speed mode switch.
<> 144:ef7eb2e8f9f7 81 To be able to use a frequency higher than 24MHz, you should use the SDMMC
<> 144:ef7eb2e8f9f7 82 peripheral in bypass mode. Refer to the corresponding reference manual
<> 144:ef7eb2e8f9f7 83 for more details.
<> 144:ef7eb2e8f9f7 84
<> 144:ef7eb2e8f9f7 85 (#) Select the corresponding SD Card according to the address read with the step 2.
<> 144:ef7eb2e8f9f7 86
<> 144:ef7eb2e8f9f7 87 (#) Configure the SD Card in wide bus mode: 4-bits data.
<> 144:ef7eb2e8f9f7 88
<> 144:ef7eb2e8f9f7 89 *** SD Card Read operation ***
<> 144:ef7eb2e8f9f7 90 ==============================
<> 144:ef7eb2e8f9f7 91 [..]
<> 144:ef7eb2e8f9f7 92 (+) You can read from SD card in polling mode by using function HAL_SD_ReadBlocks().
<> 144:ef7eb2e8f9f7 93 This function support only 512-bytes block length (the block size should be
<> 144:ef7eb2e8f9f7 94 chosen as 512 bytes).
<> 144:ef7eb2e8f9f7 95 You can choose either one block read operation or multiple block read operation
<> 144:ef7eb2e8f9f7 96 by adjusting the "NumberOfBlocks" parameter.
<> 144:ef7eb2e8f9f7 97
<> 144:ef7eb2e8f9f7 98 (+) You can read from SD card in DMA mode by using function HAL_SD_ReadBlocks_DMA().
<> 144:ef7eb2e8f9f7 99 This function support only 512-bytes block length (the block size should be
<> 144:ef7eb2e8f9f7 100 chosen as 512 bytes).
<> 144:ef7eb2e8f9f7 101 You can choose either one block read operation or multiple block read operation
<> 144:ef7eb2e8f9f7 102 by adjusting the "NumberOfBlocks" parameter.
<> 144:ef7eb2e8f9f7 103 After this, you have to call the function HAL_SD_CheckReadOperation(), to insure
<> 144:ef7eb2e8f9f7 104 that the read transfer is done correctly in both DMA and SD sides.
<> 144:ef7eb2e8f9f7 105
<> 144:ef7eb2e8f9f7 106 *** SD Card Write operation ***
<> 144:ef7eb2e8f9f7 107 ===============================
<> 144:ef7eb2e8f9f7 108 [..]
<> 144:ef7eb2e8f9f7 109 (+) You can write to SD card in polling mode by using function HAL_SD_WriteBlocks().
<> 144:ef7eb2e8f9f7 110 This function support only 512-bytes block length (the block size should be
<> 144:ef7eb2e8f9f7 111 chosen as 512 bytes).
<> 144:ef7eb2e8f9f7 112 You can choose either one block read operation or multiple block read operation
<> 144:ef7eb2e8f9f7 113 by adjusting the "NumberOfBlocks" parameter.
<> 144:ef7eb2e8f9f7 114
<> 144:ef7eb2e8f9f7 115 (+) You can write to SD card in DMA mode by using function HAL_SD_WriteBlocks_DMA().
<> 144:ef7eb2e8f9f7 116 This function support only 512-bytes block length (the block size should be
<> 144:ef7eb2e8f9f7 117 chosen as 512 byte).
<> 144:ef7eb2e8f9f7 118 You can choose either one block read operation or multiple block read operation
<> 144:ef7eb2e8f9f7 119 by adjusting the "NumberOfBlocks" parameter.
<> 144:ef7eb2e8f9f7 120 After this, you have to call the function HAL_SD_CheckWriteOperation(), to insure
<> 144:ef7eb2e8f9f7 121 that the write transfer is done correctly in both DMA and SD sides.
<> 144:ef7eb2e8f9f7 122
<> 144:ef7eb2e8f9f7 123 *** SD card status ***
<> 144:ef7eb2e8f9f7 124 ======================
<> 144:ef7eb2e8f9f7 125 [..]
<> 144:ef7eb2e8f9f7 126 (+) At any time, you can check the SD Card status and get the SD card state
<> 144:ef7eb2e8f9f7 127 by using the HAL_SD_GetStatus() function. This function checks first if the
<> 144:ef7eb2e8f9f7 128 SD card is still connected and then get the internal SD Card transfer state.
<> 144:ef7eb2e8f9f7 129 (+) You can also get the SD card SD Status register by using the HAL_SD_SendSDStatus()
<> 144:ef7eb2e8f9f7 130 function.
<> 144:ef7eb2e8f9f7 131
<> 144:ef7eb2e8f9f7 132 *** SD HAL driver macros list ***
<> 144:ef7eb2e8f9f7 133 ==================================
<> 144:ef7eb2e8f9f7 134 [..]
<> 144:ef7eb2e8f9f7 135 Below the list of most used macros in SD HAL driver.
<> 144:ef7eb2e8f9f7 136
<> 144:ef7eb2e8f9f7 137 (+) __HAL_SD_SDMMC_ENABLE : Enable the SD device
<> 144:ef7eb2e8f9f7 138 (+) __HAL_SD_SDMMC_DISABLE : Disable the SD device
<> 144:ef7eb2e8f9f7 139 (+) __HAL_SD_SDMMC_DMA_ENABLE: Enable the SDMMC DMA transfer
<> 144:ef7eb2e8f9f7 140 (+) __HAL_SD_SDMMC_DMA_DISABLE: Disable the SDMMC DMA transfer
<> 144:ef7eb2e8f9f7 141 (+) __HAL_SD_SDMMC_ENABLE_IT: Enable the SD device interrupt
<> 144:ef7eb2e8f9f7 142 (+) __HAL_SD_SDMMC_DISABLE_IT: Disable the SD device interrupt
<> 144:ef7eb2e8f9f7 143 (+) __HAL_SD_SDMMC_GET_FLAG:Check whether the specified SD flag is set or not
<> 144:ef7eb2e8f9f7 144 (+) __HAL_SD_SDMMC_CLEAR_FLAG: Clear the SD's pending flags
<> 144:ef7eb2e8f9f7 145
<> 144:ef7eb2e8f9f7 146 (@) You can refer to the SD HAL driver header file for more useful macros
<> 144:ef7eb2e8f9f7 147
<> 144:ef7eb2e8f9f7 148 @endverbatim
<> 144:ef7eb2e8f9f7 149 ******************************************************************************
<> 144:ef7eb2e8f9f7 150 * @attention
<> 144:ef7eb2e8f9f7 151 *
<> 144:ef7eb2e8f9f7 152 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 153 *
<> 144:ef7eb2e8f9f7 154 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 155 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 156 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 157 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 158 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 159 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 160 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 161 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 162 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 163 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 164 *
<> 144:ef7eb2e8f9f7 165 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 166 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 167 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 168 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 169 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 170 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 171 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 172 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 173 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 174 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 175 *
<> 144:ef7eb2e8f9f7 176 ******************************************************************************
<> 144:ef7eb2e8f9f7 177 */
<> 144:ef7eb2e8f9f7 178
<> 144:ef7eb2e8f9f7 179 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 180 #include "stm32f7xx_hal.h"
<> 144:ef7eb2e8f9f7 181
<> 144:ef7eb2e8f9f7 182 /** @addtogroup STM32F7xx_HAL_Driver
<> 144:ef7eb2e8f9f7 183 * @{
<> 144:ef7eb2e8f9f7 184 */
<> 144:ef7eb2e8f9f7 185
<> 144:ef7eb2e8f9f7 186 /** @addtogroup SD
<> 144:ef7eb2e8f9f7 187 * @{
<> 144:ef7eb2e8f9f7 188 */
<> 144:ef7eb2e8f9f7 189
<> 144:ef7eb2e8f9f7 190 #ifdef HAL_SD_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 191
<> 144:ef7eb2e8f9f7 192 /* Private typedef -----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 193 /* Private define ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 194 /** @addtogroup SD_Private_Defines
<> 144:ef7eb2e8f9f7 195 * @{
<> 144:ef7eb2e8f9f7 196 */
<> 144:ef7eb2e8f9f7 197 /**
<> 144:ef7eb2e8f9f7 198 * @brief SDMMC Data block size
<> 144:ef7eb2e8f9f7 199 */
<> 144:ef7eb2e8f9f7 200 #define DATA_BLOCK_SIZE ((uint32_t)(9 << 4))
<> 144:ef7eb2e8f9f7 201 /**
<> 144:ef7eb2e8f9f7 202 * @brief SDMMC Static flags, Timeout, FIFO Address
<> 144:ef7eb2e8f9f7 203 */
<> 144:ef7eb2e8f9f7 204 #define SDMMC_STATIC_FLAGS ((uint32_t)(SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_CTIMEOUT |\
<> 144:ef7eb2e8f9f7 205 SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_RXOVERR |\
<> 144:ef7eb2e8f9f7 206 SDMMC_FLAG_CMDREND | SDMMC_FLAG_CMDSENT | SDMMC_FLAG_DATAEND |\
<> 144:ef7eb2e8f9f7 207 SDMMC_FLAG_DBCKEND))
<> 144:ef7eb2e8f9f7 208
<> 144:ef7eb2e8f9f7 209 #define SDMMC_CMD0TIMEOUT ((uint32_t)0x00010000U)
<> 144:ef7eb2e8f9f7 210
<> 144:ef7eb2e8f9f7 211 /**
<> 144:ef7eb2e8f9f7 212 * @brief Mask for errors Card Status R1 (OCR Register)
<> 144:ef7eb2e8f9f7 213 */
<> 144:ef7eb2e8f9f7 214 #define SD_OCR_ADDR_OUT_OF_RANGE ((uint32_t)0x80000000U)
<> 144:ef7eb2e8f9f7 215 #define SD_OCR_ADDR_MISALIGNED ((uint32_t)0x40000000U)
<> 144:ef7eb2e8f9f7 216 #define SD_OCR_BLOCK_LEN_ERR ((uint32_t)0x20000000U)
<> 144:ef7eb2e8f9f7 217 #define SD_OCR_ERASE_SEQ_ERR ((uint32_t)0x10000000U)
<> 144:ef7eb2e8f9f7 218 #define SD_OCR_BAD_ERASE_PARAM ((uint32_t)0x08000000U)
<> 144:ef7eb2e8f9f7 219 #define SD_OCR_WRITE_PROT_VIOLATION ((uint32_t)0x04000000U)
<> 144:ef7eb2e8f9f7 220 #define SD_OCR_LOCK_UNLOCK_FAILED ((uint32_t)0x01000000U)
<> 144:ef7eb2e8f9f7 221 #define SD_OCR_COM_CRC_FAILED ((uint32_t)0x00800000U)
<> 144:ef7eb2e8f9f7 222 #define SD_OCR_ILLEGAL_CMD ((uint32_t)0x00400000U)
<> 144:ef7eb2e8f9f7 223 #define SD_OCR_CARD_ECC_FAILED ((uint32_t)0x00200000U)
<> 144:ef7eb2e8f9f7 224 #define SD_OCR_CC_ERROR ((uint32_t)0x00100000U)
<> 144:ef7eb2e8f9f7 225 #define SD_OCR_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00080000U)
<> 144:ef7eb2e8f9f7 226 #define SD_OCR_STREAM_READ_UNDERRUN ((uint32_t)0x00040000U)
<> 144:ef7eb2e8f9f7 227 #define SD_OCR_STREAM_WRITE_OVERRUN ((uint32_t)0x00020000U)
<> 144:ef7eb2e8f9f7 228 #define SD_OCR_CID_CSD_OVERWRITE ((uint32_t)0x00010000U)
<> 144:ef7eb2e8f9f7 229 #define SD_OCR_WP_ERASE_SKIP ((uint32_t)0x00008000U)
<> 144:ef7eb2e8f9f7 230 #define SD_OCR_CARD_ECC_DISABLED ((uint32_t)0x00004000U)
<> 144:ef7eb2e8f9f7 231 #define SD_OCR_ERASE_RESET ((uint32_t)0x00002000U)
<> 144:ef7eb2e8f9f7 232 #define SD_OCR_AKE_SEQ_ERROR ((uint32_t)0x00000008U)
<> 144:ef7eb2e8f9f7 233 #define SD_OCR_ERRORBITS ((uint32_t)0xFDFFE008U)
<> 144:ef7eb2e8f9f7 234
<> 144:ef7eb2e8f9f7 235 /**
<> 144:ef7eb2e8f9f7 236 * @brief Masks for R6 Response
<> 144:ef7eb2e8f9f7 237 */
<> 144:ef7eb2e8f9f7 238 #define SD_R6_GENERAL_UNKNOWN_ERROR ((uint32_t)0x00002000U)
<> 144:ef7eb2e8f9f7 239 #define SD_R6_ILLEGAL_CMD ((uint32_t)0x00004000U)
<> 144:ef7eb2e8f9f7 240 #define SD_R6_COM_CRC_FAILED ((uint32_t)0x00008000U)
<> 144:ef7eb2e8f9f7 241
<> 144:ef7eb2e8f9f7 242 #define SD_VOLTAGE_WINDOW_SD ((uint32_t)0x80100000U)
<> 144:ef7eb2e8f9f7 243 #define SD_HIGH_CAPACITY ((uint32_t)0x40000000U)
<> 144:ef7eb2e8f9f7 244 #define SD_STD_CAPACITY ((uint32_t)0x00000000U)
<> 144:ef7eb2e8f9f7 245 #define SD_CHECK_PATTERN ((uint32_t)0x000001AAU)
<> 144:ef7eb2e8f9f7 246
<> 144:ef7eb2e8f9f7 247 #define SD_MAX_VOLT_TRIAL ((uint32_t)0x0000FFFFU)
<> 144:ef7eb2e8f9f7 248 #define SD_ALLZERO ((uint32_t)0x00000000U)
<> 144:ef7eb2e8f9f7 249
<> 144:ef7eb2e8f9f7 250 #define SD_WIDE_BUS_SUPPORT ((uint32_t)0x00040000U)
<> 144:ef7eb2e8f9f7 251 #define SD_SINGLE_BUS_SUPPORT ((uint32_t)0x00010000U)
<> 144:ef7eb2e8f9f7 252 #define SD_CARD_LOCKED ((uint32_t)0x02000000U)
<> 144:ef7eb2e8f9f7 253
<> 144:ef7eb2e8f9f7 254 #define SD_DATATIMEOUT ((uint32_t)0xFFFFFFFFU)
<> 144:ef7eb2e8f9f7 255 #define SD_0TO7BITS ((uint32_t)0x000000FFU)
<> 144:ef7eb2e8f9f7 256 #define SD_8TO15BITS ((uint32_t)0x0000FF00U)
<> 144:ef7eb2e8f9f7 257 #define SD_16TO23BITS ((uint32_t)0x00FF0000U)
<> 144:ef7eb2e8f9f7 258 #define SD_24TO31BITS ((uint32_t)0xFF000000U)
<> 144:ef7eb2e8f9f7 259 #define SD_MAX_DATA_LENGTH ((uint32_t)0x01FFFFFFU)
<> 144:ef7eb2e8f9f7 260
<> 144:ef7eb2e8f9f7 261 #define SD_HALFFIFO ((uint32_t)0x00000008U)
<> 144:ef7eb2e8f9f7 262 #define SD_HALFFIFOBYTES ((uint32_t)0x00000020U)
<> 144:ef7eb2e8f9f7 263
<> 144:ef7eb2e8f9f7 264 /**
<> 144:ef7eb2e8f9f7 265 * @brief Command Class Supported
<> 144:ef7eb2e8f9f7 266 */
<> 144:ef7eb2e8f9f7 267 #define SD_CCCC_LOCK_UNLOCK ((uint32_t)0x00000080U)
<> 144:ef7eb2e8f9f7 268 #define SD_CCCC_WRITE_PROT ((uint32_t)0x00000040U)
<> 144:ef7eb2e8f9f7 269 #define SD_CCCC_ERASE ((uint32_t)0x00000020U)
<> 144:ef7eb2e8f9f7 270
<> 144:ef7eb2e8f9f7 271 /**
<> 144:ef7eb2e8f9f7 272 * @brief Following commands are SD Card Specific commands.
<> 144:ef7eb2e8f9f7 273 * SDMMC_APP_CMD should be sent before sending these commands.
<> 144:ef7eb2e8f9f7 274 */
<> 144:ef7eb2e8f9f7 275 #define SD_SDMMC_SEND_IF_COND ((uint32_t)SD_CMD_HS_SEND_EXT_CSD)
<> 144:ef7eb2e8f9f7 276 /**
<> 144:ef7eb2e8f9f7 277 * @}
<> 144:ef7eb2e8f9f7 278 */
<> 144:ef7eb2e8f9f7 279
<> 144:ef7eb2e8f9f7 280 /* Private macro -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 281 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 282 /* Private function prototypes -----------------------------------------------*/
<> 144:ef7eb2e8f9f7 283 /* Private functions ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 284 /** @defgroup SD_Private_Functions SD Private Functions
<> 144:ef7eb2e8f9f7 285 * @{
<> 144:ef7eb2e8f9f7 286 */
<> 144:ef7eb2e8f9f7 287 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd);
<> 144:ef7eb2e8f9f7 288 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr);
<> 144:ef7eb2e8f9f7 289 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd);
<> 144:ef7eb2e8f9f7 290 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd);
<> 144:ef7eb2e8f9f7 291 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
<> 144:ef7eb2e8f9f7 292 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd);
<> 144:ef7eb2e8f9f7 293 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus);
<> 144:ef7eb2e8f9f7 294 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd);
<> 144:ef7eb2e8f9f7 295 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD);
<> 144:ef7eb2e8f9f7 296 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd);
<> 144:ef7eb2e8f9f7 297 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd);
<> 144:ef7eb2e8f9f7 298 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd);
<> 144:ef7eb2e8f9f7 299 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA);
<> 144:ef7eb2e8f9f7 300 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd);
<> 144:ef7eb2e8f9f7 301 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd);
<> 144:ef7eb2e8f9f7 302 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR);
<> 144:ef7eb2e8f9f7 303 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma);
<> 144:ef7eb2e8f9f7 304 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma);
<> 144:ef7eb2e8f9f7 305 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma);
<> 144:ef7eb2e8f9f7 306 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma);
<> 144:ef7eb2e8f9f7 307 /**
<> 144:ef7eb2e8f9f7 308 * @}
<> 144:ef7eb2e8f9f7 309 */
<> 144:ef7eb2e8f9f7 310 /* Exported functions --------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 311 /** @addtogroup SD_Exported_Functions
<> 144:ef7eb2e8f9f7 312 * @{
<> 144:ef7eb2e8f9f7 313 */
<> 144:ef7eb2e8f9f7 314
<> 144:ef7eb2e8f9f7 315 /** @addtogroup SD_Exported_Functions_Group1
<> 144:ef7eb2e8f9f7 316 * @brief Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 317 *
<> 144:ef7eb2e8f9f7 318 @verbatim
<> 144:ef7eb2e8f9f7 319 ==============================================================================
<> 144:ef7eb2e8f9f7 320 ##### Initialization and de-initialization functions #####
<> 144:ef7eb2e8f9f7 321 ==============================================================================
<> 144:ef7eb2e8f9f7 322 [..]
<> 144:ef7eb2e8f9f7 323 This section provides functions allowing to initialize/de-initialize the SD
<> 144:ef7eb2e8f9f7 324 card device to be ready for use.
<> 144:ef7eb2e8f9f7 325
<> 144:ef7eb2e8f9f7 326
<> 144:ef7eb2e8f9f7 327 @endverbatim
<> 144:ef7eb2e8f9f7 328 * @{
<> 144:ef7eb2e8f9f7 329 */
<> 144:ef7eb2e8f9f7 330
<> 144:ef7eb2e8f9f7 331 /**
<> 144:ef7eb2e8f9f7 332 * @brief Initializes the SD card according to the specified parameters in the
<> 144:ef7eb2e8f9f7 333 SD_HandleTypeDef and create the associated handle.
<> 144:ef7eb2e8f9f7 334 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 335 * @param SDCardInfo: HAL_SD_CardInfoTypedef structure for SD card information
<> 144:ef7eb2e8f9f7 336 * @retval HAL SD error state
<> 144:ef7eb2e8f9f7 337 */
<> 144:ef7eb2e8f9f7 338 HAL_SD_ErrorTypedef HAL_SD_Init(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *SDCardInfo)
<> 144:ef7eb2e8f9f7 339 {
<> 144:ef7eb2e8f9f7 340 __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 341 SD_InitTypeDef tmpinit;
<> 144:ef7eb2e8f9f7 342
<> 144:ef7eb2e8f9f7 343 /* Allocate lock resource and initialize it */
<> 144:ef7eb2e8f9f7 344 hsd->Lock = HAL_UNLOCKED;
<> 144:ef7eb2e8f9f7 345
<> 144:ef7eb2e8f9f7 346 /* Initialize the low level hardware (MSP) */
<> 144:ef7eb2e8f9f7 347 HAL_SD_MspInit(hsd);
<> 144:ef7eb2e8f9f7 348
<> 144:ef7eb2e8f9f7 349 /* Default SDMMC peripheral configuration for SD card initialization */
<> 144:ef7eb2e8f9f7 350 tmpinit.ClockEdge = SDMMC_CLOCK_EDGE_RISING;
<> 144:ef7eb2e8f9f7 351 tmpinit.ClockBypass = SDMMC_CLOCK_BYPASS_DISABLE;
<> 144:ef7eb2e8f9f7 352 tmpinit.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE;
<> 144:ef7eb2e8f9f7 353 tmpinit.BusWide = SDMMC_BUS_WIDE_1B;
<> 144:ef7eb2e8f9f7 354 tmpinit.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE;
<> 144:ef7eb2e8f9f7 355 tmpinit.ClockDiv = SDMMC_INIT_CLK_DIV;
<> 144:ef7eb2e8f9f7 356
<> 144:ef7eb2e8f9f7 357 /* Initialize SDMMC peripheral interface with default configuration */
<> 144:ef7eb2e8f9f7 358 SDMMC_Init(hsd->Instance, tmpinit);
<> 144:ef7eb2e8f9f7 359
<> 144:ef7eb2e8f9f7 360 /* Identify card operating voltage */
<> 144:ef7eb2e8f9f7 361 errorstate = SD_PowerON(hsd);
<> 144:ef7eb2e8f9f7 362
<> 144:ef7eb2e8f9f7 363 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 364 {
<> 144:ef7eb2e8f9f7 365 return errorstate;
<> 144:ef7eb2e8f9f7 366 }
<> 144:ef7eb2e8f9f7 367
<> 144:ef7eb2e8f9f7 368 /* Initialize the present SDMMC card(s) and put them in idle state */
<> 144:ef7eb2e8f9f7 369 errorstate = SD_Initialize_Cards(hsd);
<> 144:ef7eb2e8f9f7 370
<> 144:ef7eb2e8f9f7 371 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 372 {
<> 144:ef7eb2e8f9f7 373 return errorstate;
<> 144:ef7eb2e8f9f7 374 }
<> 144:ef7eb2e8f9f7 375
<> 144:ef7eb2e8f9f7 376 /* Read CSD/CID MSD registers */
<> 144:ef7eb2e8f9f7 377 errorstate = HAL_SD_Get_CardInfo(hsd, SDCardInfo);
<> 144:ef7eb2e8f9f7 378
<> 144:ef7eb2e8f9f7 379 if (errorstate == SD_OK)
<> 144:ef7eb2e8f9f7 380 {
<> 144:ef7eb2e8f9f7 381 /* Select the Card */
<> 144:ef7eb2e8f9f7 382 errorstate = SD_Select_Deselect(hsd, (uint32_t)(((uint32_t)SDCardInfo->RCA) << 16));
<> 144:ef7eb2e8f9f7 383 }
<> 144:ef7eb2e8f9f7 384
<> 144:ef7eb2e8f9f7 385 /* Configure SDMMC peripheral interface */
<> 144:ef7eb2e8f9f7 386 SDMMC_Init(hsd->Instance, hsd->Init);
<> 144:ef7eb2e8f9f7 387
<> 144:ef7eb2e8f9f7 388 return errorstate;
<> 144:ef7eb2e8f9f7 389 }
<> 144:ef7eb2e8f9f7 390
<> 144:ef7eb2e8f9f7 391 /**
<> 144:ef7eb2e8f9f7 392 * @brief De-Initializes the SD card.
<> 144:ef7eb2e8f9f7 393 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 394 * @retval HAL status
<> 144:ef7eb2e8f9f7 395 */
<> 144:ef7eb2e8f9f7 396 HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 397 {
<> 144:ef7eb2e8f9f7 398
<> 144:ef7eb2e8f9f7 399 /* Set SD power state to off */
<> 144:ef7eb2e8f9f7 400 SD_PowerOFF(hsd);
<> 144:ef7eb2e8f9f7 401
<> 144:ef7eb2e8f9f7 402 /* De-Initialize the MSP layer */
<> 144:ef7eb2e8f9f7 403 HAL_SD_MspDeInit(hsd);
<> 144:ef7eb2e8f9f7 404
<> 144:ef7eb2e8f9f7 405 return HAL_OK;
<> 144:ef7eb2e8f9f7 406 }
<> 144:ef7eb2e8f9f7 407
<> 144:ef7eb2e8f9f7 408
<> 144:ef7eb2e8f9f7 409 /**
<> 144:ef7eb2e8f9f7 410 * @brief Initializes the SD MSP.
<> 144:ef7eb2e8f9f7 411 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 412 * @retval None
<> 144:ef7eb2e8f9f7 413 */
<> 144:ef7eb2e8f9f7 414 __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 415 {
<> 144:ef7eb2e8f9f7 416 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 417 UNUSED(hsd);
<> 144:ef7eb2e8f9f7 418
<> 144:ef7eb2e8f9f7 419 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 420 the HAL_SD_MspInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 421 */
<> 144:ef7eb2e8f9f7 422 }
<> 144:ef7eb2e8f9f7 423
<> 144:ef7eb2e8f9f7 424 /**
<> 144:ef7eb2e8f9f7 425 * @brief De-Initialize SD MSP.
<> 144:ef7eb2e8f9f7 426 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 427 * @retval None
<> 144:ef7eb2e8f9f7 428 */
<> 144:ef7eb2e8f9f7 429 __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 430 {
<> 144:ef7eb2e8f9f7 431 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 432 UNUSED(hsd);
<> 144:ef7eb2e8f9f7 433
<> 144:ef7eb2e8f9f7 434 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 435 the HAL_SD_MspDeInit could be implemented in the user file
<> 144:ef7eb2e8f9f7 436 */
<> 144:ef7eb2e8f9f7 437 }
<> 144:ef7eb2e8f9f7 438
<> 144:ef7eb2e8f9f7 439 /**
<> 144:ef7eb2e8f9f7 440 * @}
<> 144:ef7eb2e8f9f7 441 */
<> 144:ef7eb2e8f9f7 442
<> 144:ef7eb2e8f9f7 443 /** @addtogroup SD_Exported_Functions_Group2
<> 144:ef7eb2e8f9f7 444 * @brief Data transfer functions
<> 144:ef7eb2e8f9f7 445 *
<> 144:ef7eb2e8f9f7 446 @verbatim
<> 144:ef7eb2e8f9f7 447 ==============================================================================
<> 144:ef7eb2e8f9f7 448 ##### IO operation functions #####
<> 144:ef7eb2e8f9f7 449 ==============================================================================
<> 144:ef7eb2e8f9f7 450 [..]
<> 144:ef7eb2e8f9f7 451 This subsection provides a set of functions allowing to manage the data
<> 144:ef7eb2e8f9f7 452 transfer from/to SD card.
<> 144:ef7eb2e8f9f7 453
<> 144:ef7eb2e8f9f7 454 @endverbatim
<> 144:ef7eb2e8f9f7 455 * @{
<> 144:ef7eb2e8f9f7 456 */
<> 144:ef7eb2e8f9f7 457
<> 144:ef7eb2e8f9f7 458 /**
<> 144:ef7eb2e8f9f7 459 * @brief Reads block(s) from a specified address in a card. The Data transfer
<> 144:ef7eb2e8f9f7 460 * is managed by polling mode.
<> 144:ef7eb2e8f9f7 461 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 462 * @param pReadBuffer: pointer to the buffer that will contain the received data
<> 144:ef7eb2e8f9f7 463 * @param ReadAddr: Address from where data is to be read
<> 144:ef7eb2e8f9f7 464 * @param BlockSize: SD card Data block size
<> 144:ef7eb2e8f9f7 465 * @note BlockSize must be 512 bytes.
<> 144:ef7eb2e8f9f7 466 * @param NumberOfBlocks: Number of SD blocks to read
<> 144:ef7eb2e8f9f7 467 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 468 */
<> 144:ef7eb2e8f9f7 469 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
<> 144:ef7eb2e8f9f7 470 {
<> 144:ef7eb2e8f9f7 471 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 472 SDMMC_DataInitTypeDef sdmmc_datainitstructure;
<> 144:ef7eb2e8f9f7 473 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 474 uint32_t count = 0, *tempbuff = (uint32_t *)pReadBuffer;
<> 144:ef7eb2e8f9f7 475
<> 144:ef7eb2e8f9f7 476 /* Initialize data control register */
<> 144:ef7eb2e8f9f7 477 hsd->Instance->DCTRL = 0;
<> 144:ef7eb2e8f9f7 478
<> 144:ef7eb2e8f9f7 479 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
<> 144:ef7eb2e8f9f7 480 {
<> 144:ef7eb2e8f9f7 481 BlockSize = 512;
<> 144:ef7eb2e8f9f7 482 ReadAddr /= 512;
<> 144:ef7eb2e8f9f7 483 }
<> 144:ef7eb2e8f9f7 484
<> 144:ef7eb2e8f9f7 485 /* Set Block Size for Card */
<> 144:ef7eb2e8f9f7 486 sdmmc_cmdinitstructure.Argument = (uint32_t) BlockSize;
<> 144:ef7eb2e8f9f7 487 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
<> 144:ef7eb2e8f9f7 488 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 489 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 490 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 491 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 492
<> 144:ef7eb2e8f9f7 493 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 494 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
<> 144:ef7eb2e8f9f7 495
<> 144:ef7eb2e8f9f7 496 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 497 {
<> 144:ef7eb2e8f9f7 498 return errorstate;
<> 144:ef7eb2e8f9f7 499 }
<> 144:ef7eb2e8f9f7 500
<> 144:ef7eb2e8f9f7 501 /* Configure the SD DPSM (Data Path State Machine) */
<> 144:ef7eb2e8f9f7 502 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
<> 144:ef7eb2e8f9f7 503 sdmmc_datainitstructure.DataLength = NumberOfBlocks * BlockSize;
<> 144:ef7eb2e8f9f7 504 sdmmc_datainitstructure.DataBlockSize = DATA_BLOCK_SIZE;
<> 144:ef7eb2e8f9f7 505 sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
<> 144:ef7eb2e8f9f7 506 sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
<> 144:ef7eb2e8f9f7 507 sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
<> 144:ef7eb2e8f9f7 508 SDMMC_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
<> 144:ef7eb2e8f9f7 509
<> 144:ef7eb2e8f9f7 510 if(NumberOfBlocks > 1)
<> 144:ef7eb2e8f9f7 511 {
<> 144:ef7eb2e8f9f7 512 /* Send CMD18 READ_MULT_BLOCK with argument data address */
<> 144:ef7eb2e8f9f7 513 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
<> 144:ef7eb2e8f9f7 514 }
<> 144:ef7eb2e8f9f7 515 else
<> 144:ef7eb2e8f9f7 516 {
<> 144:ef7eb2e8f9f7 517 /* Send CMD17 READ_SINGLE_BLOCK */
<> 144:ef7eb2e8f9f7 518 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
<> 144:ef7eb2e8f9f7 519 }
<> 144:ef7eb2e8f9f7 520
<> 144:ef7eb2e8f9f7 521 sdmmc_cmdinitstructure.Argument = (uint32_t)ReadAddr;
<> 144:ef7eb2e8f9f7 522 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 523
<> 144:ef7eb2e8f9f7 524 /* Read block(s) in polling mode */
<> 144:ef7eb2e8f9f7 525 if(NumberOfBlocks > 1)
<> 144:ef7eb2e8f9f7 526 {
<> 144:ef7eb2e8f9f7 527 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 528 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
<> 144:ef7eb2e8f9f7 529
<> 144:ef7eb2e8f9f7 530 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 531 {
<> 144:ef7eb2e8f9f7 532 return errorstate;
<> 144:ef7eb2e8f9f7 533 }
<> 144:ef7eb2e8f9f7 534
<> 144:ef7eb2e8f9f7 535 /* Poll on SDMMC flags */
<> 144:ef7eb2e8f9f7 536 while(!__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
<> 144:ef7eb2e8f9f7 537 {
<> 144:ef7eb2e8f9f7 538 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
<> 144:ef7eb2e8f9f7 539 {
<> 144:ef7eb2e8f9f7 540 /* Read data from SDMMC Rx FIFO */
<> 144:ef7eb2e8f9f7 541 for (count = 0; count < 8; count++)
<> 144:ef7eb2e8f9f7 542 {
<> 144:ef7eb2e8f9f7 543 *(tempbuff + count) = SDMMC_ReadFIFO(hsd->Instance);
<> 144:ef7eb2e8f9f7 544 }
<> 144:ef7eb2e8f9f7 545
<> 144:ef7eb2e8f9f7 546 tempbuff += 8;
<> 144:ef7eb2e8f9f7 547 }
<> 144:ef7eb2e8f9f7 548 }
<> 144:ef7eb2e8f9f7 549 }
<> 144:ef7eb2e8f9f7 550 else
<> 144:ef7eb2e8f9f7 551 {
<> 144:ef7eb2e8f9f7 552 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 553 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
<> 144:ef7eb2e8f9f7 554
<> 144:ef7eb2e8f9f7 555 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 556 {
<> 144:ef7eb2e8f9f7 557 return errorstate;
<> 144:ef7eb2e8f9f7 558 }
<> 144:ef7eb2e8f9f7 559
<> 144:ef7eb2e8f9f7 560 /* In case of single block transfer, no need of stop transfer at all */
<> 144:ef7eb2e8f9f7 561 while(!__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND))
<> 144:ef7eb2e8f9f7 562 {
<> 144:ef7eb2e8f9f7 563 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
<> 144:ef7eb2e8f9f7 564 {
<> 144:ef7eb2e8f9f7 565 /* Read data from SDMMC Rx FIFO */
<> 144:ef7eb2e8f9f7 566 for (count = 0; count < 8; count++)
<> 144:ef7eb2e8f9f7 567 {
<> 144:ef7eb2e8f9f7 568 *(tempbuff + count) = SDMMC_ReadFIFO(hsd->Instance);
<> 144:ef7eb2e8f9f7 569 }
<> 144:ef7eb2e8f9f7 570
<> 144:ef7eb2e8f9f7 571 tempbuff += 8;
<> 144:ef7eb2e8f9f7 572 }
<> 144:ef7eb2e8f9f7 573 }
<> 144:ef7eb2e8f9f7 574 }
<> 144:ef7eb2e8f9f7 575
<> 144:ef7eb2e8f9f7 576 /* Send stop transmission command in case of multiblock read */
<> 144:ef7eb2e8f9f7 577 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1))
<> 144:ef7eb2e8f9f7 578 {
<> 144:ef7eb2e8f9f7 579 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) ||\
<> 144:ef7eb2e8f9f7 580 (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
<> 144:ef7eb2e8f9f7 581 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
<> 144:ef7eb2e8f9f7 582 {
<> 144:ef7eb2e8f9f7 583 /* Send stop transmission command */
<> 144:ef7eb2e8f9f7 584 errorstate = HAL_SD_StopTransfer(hsd);
<> 144:ef7eb2e8f9f7 585 }
<> 144:ef7eb2e8f9f7 586 }
<> 144:ef7eb2e8f9f7 587
<> 144:ef7eb2e8f9f7 588 /* Get error state */
<> 144:ef7eb2e8f9f7 589 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
<> 144:ef7eb2e8f9f7 590 {
<> 144:ef7eb2e8f9f7 591 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
<> 144:ef7eb2e8f9f7 592
<> 144:ef7eb2e8f9f7 593 errorstate = SD_DATA_TIMEOUT;
<> 144:ef7eb2e8f9f7 594
<> 144:ef7eb2e8f9f7 595 return errorstate;
<> 144:ef7eb2e8f9f7 596 }
<> 144:ef7eb2e8f9f7 597 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
<> 144:ef7eb2e8f9f7 598 {
<> 144:ef7eb2e8f9f7 599 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
<> 144:ef7eb2e8f9f7 600
<> 144:ef7eb2e8f9f7 601 errorstate = SD_DATA_CRC_FAIL;
<> 144:ef7eb2e8f9f7 602
<> 144:ef7eb2e8f9f7 603 return errorstate;
<> 144:ef7eb2e8f9f7 604 }
<> 144:ef7eb2e8f9f7 605 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
<> 144:ef7eb2e8f9f7 606 {
<> 144:ef7eb2e8f9f7 607 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
<> 144:ef7eb2e8f9f7 608
<> 144:ef7eb2e8f9f7 609 errorstate = SD_RX_OVERRUN;
<> 144:ef7eb2e8f9f7 610
<> 144:ef7eb2e8f9f7 611 return errorstate;
<> 144:ef7eb2e8f9f7 612 }
<> 144:ef7eb2e8f9f7 613 else
<> 144:ef7eb2e8f9f7 614 {
<> 144:ef7eb2e8f9f7 615 /* No error flag set */
<> 144:ef7eb2e8f9f7 616 }
<> 144:ef7eb2e8f9f7 617
<> 144:ef7eb2e8f9f7 618 count = SD_DATATIMEOUT;
<> 144:ef7eb2e8f9f7 619
<> 144:ef7eb2e8f9f7 620 /* Empty FIFO if there is still any data */
<> 144:ef7eb2e8f9f7 621 while ((__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXDAVL)) && (count > 0))
<> 144:ef7eb2e8f9f7 622 {
<> 144:ef7eb2e8f9f7 623 *tempbuff = SDMMC_ReadFIFO(hsd->Instance);
<> 144:ef7eb2e8f9f7 624 tempbuff++;
<> 144:ef7eb2e8f9f7 625 count--;
<> 144:ef7eb2e8f9f7 626 }
<> 144:ef7eb2e8f9f7 627
<> 144:ef7eb2e8f9f7 628 /* Clear all the static flags */
<> 144:ef7eb2e8f9f7 629 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 630
<> 144:ef7eb2e8f9f7 631 return errorstate;
<> 144:ef7eb2e8f9f7 632 }
<> 144:ef7eb2e8f9f7 633
<> 144:ef7eb2e8f9f7 634 /**
<> 144:ef7eb2e8f9f7 635 * @brief Allows to write block(s) to a specified address in a card. The Data
<> 144:ef7eb2e8f9f7 636 * transfer is managed by polling mode.
<> 144:ef7eb2e8f9f7 637 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 638 * @param pWriteBuffer: pointer to the buffer that will contain the data to transmit
<> 144:ef7eb2e8f9f7 639 * @param WriteAddr: Address from where data is to be written
<> 144:ef7eb2e8f9f7 640 * @param BlockSize: SD card Data block size
<> 144:ef7eb2e8f9f7 641 * @note BlockSize must be 512 bytes.
<> 144:ef7eb2e8f9f7 642 * @param NumberOfBlocks: Number of SD blocks to write
<> 144:ef7eb2e8f9f7 643 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 644 */
<> 144:ef7eb2e8f9f7 645 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
<> 144:ef7eb2e8f9f7 646 {
<> 144:ef7eb2e8f9f7 647 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 648 SDMMC_DataInitTypeDef sdmmc_datainitstructure;
<> 144:ef7eb2e8f9f7 649 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 650 uint32_t totalnumberofbytes = 0, bytestransferred = 0, count = 0, restwords = 0;
<> 144:ef7eb2e8f9f7 651 uint32_t *tempbuff = (uint32_t *)pWriteBuffer;
<> 144:ef7eb2e8f9f7 652 uint8_t cardstate = 0;
<> 144:ef7eb2e8f9f7 653
<> 144:ef7eb2e8f9f7 654 /* Initialize data control register */
<> 144:ef7eb2e8f9f7 655 hsd->Instance->DCTRL = 0;
<> 144:ef7eb2e8f9f7 656
<> 144:ef7eb2e8f9f7 657 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
<> 144:ef7eb2e8f9f7 658 {
<> 144:ef7eb2e8f9f7 659 BlockSize = 512;
<> 144:ef7eb2e8f9f7 660 WriteAddr /= 512;
<> 144:ef7eb2e8f9f7 661 }
<> 144:ef7eb2e8f9f7 662
<> 144:ef7eb2e8f9f7 663 /* Set Block Size for Card */
<> 144:ef7eb2e8f9f7 664 sdmmc_cmdinitstructure.Argument = (uint32_t)BlockSize;
<> 144:ef7eb2e8f9f7 665 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
<> 144:ef7eb2e8f9f7 666 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 667 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 668 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 669 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 670
<> 144:ef7eb2e8f9f7 671 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 672 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
<> 144:ef7eb2e8f9f7 673
<> 144:ef7eb2e8f9f7 674 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 675 {
<> 144:ef7eb2e8f9f7 676 return errorstate;
<> 144:ef7eb2e8f9f7 677 }
<> 144:ef7eb2e8f9f7 678
<> 144:ef7eb2e8f9f7 679 if(NumberOfBlocks > 1)
<> 144:ef7eb2e8f9f7 680 {
<> 144:ef7eb2e8f9f7 681 /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
<> 144:ef7eb2e8f9f7 682 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
<> 144:ef7eb2e8f9f7 683 }
<> 144:ef7eb2e8f9f7 684 else
<> 144:ef7eb2e8f9f7 685 {
<> 144:ef7eb2e8f9f7 686 /* Send CMD24 WRITE_SINGLE_BLOCK */
<> 144:ef7eb2e8f9f7 687 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
<> 144:ef7eb2e8f9f7 688 }
<> 144:ef7eb2e8f9f7 689
<> 144:ef7eb2e8f9f7 690 sdmmc_cmdinitstructure.Argument = (uint32_t)WriteAddr;
<> 144:ef7eb2e8f9f7 691 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 692
<> 144:ef7eb2e8f9f7 693 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 694 if(NumberOfBlocks > 1)
<> 144:ef7eb2e8f9f7 695 {
<> 144:ef7eb2e8f9f7 696 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
<> 144:ef7eb2e8f9f7 697 }
<> 144:ef7eb2e8f9f7 698 else
<> 144:ef7eb2e8f9f7 699 {
<> 144:ef7eb2e8f9f7 700 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
<> 144:ef7eb2e8f9f7 701 }
<> 144:ef7eb2e8f9f7 702
<> 144:ef7eb2e8f9f7 703 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 704 {
<> 144:ef7eb2e8f9f7 705 return errorstate;
<> 144:ef7eb2e8f9f7 706 }
<> 144:ef7eb2e8f9f7 707
<> 144:ef7eb2e8f9f7 708 /* Set total number of bytes to write */
<> 144:ef7eb2e8f9f7 709 totalnumberofbytes = NumberOfBlocks * BlockSize;
<> 144:ef7eb2e8f9f7 710
<> 144:ef7eb2e8f9f7 711 /* Configure the SD DPSM (Data Path State Machine) */
<> 144:ef7eb2e8f9f7 712 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
<> 144:ef7eb2e8f9f7 713 sdmmc_datainitstructure.DataLength = NumberOfBlocks * BlockSize;
<> 144:ef7eb2e8f9f7 714 sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
<> 144:ef7eb2e8f9f7 715 sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
<> 144:ef7eb2e8f9f7 716 sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
<> 144:ef7eb2e8f9f7 717 sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
<> 144:ef7eb2e8f9f7 718 SDMMC_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
<> 144:ef7eb2e8f9f7 719
<> 144:ef7eb2e8f9f7 720 /* Write block(s) in polling mode */
<> 144:ef7eb2e8f9f7 721 if(NumberOfBlocks > 1)
<> 144:ef7eb2e8f9f7 722 {
<> 144:ef7eb2e8f9f7 723 while(!__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
<> 144:ef7eb2e8f9f7 724 {
<> 144:ef7eb2e8f9f7 725 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE))
<> 144:ef7eb2e8f9f7 726 {
<> 144:ef7eb2e8f9f7 727 if ((totalnumberofbytes - bytestransferred) < 32)
<> 144:ef7eb2e8f9f7 728 {
<> 144:ef7eb2e8f9f7 729 restwords = ((totalnumberofbytes - bytestransferred) % 4 == 0) ? ((totalnumberofbytes - bytestransferred) / 4) : (( totalnumberofbytes - bytestransferred) / 4 + 1);
<> 144:ef7eb2e8f9f7 730
<> 144:ef7eb2e8f9f7 731 /* Write data to SDMMC Tx FIFO */
<> 144:ef7eb2e8f9f7 732 for (count = 0; count < restwords; count++)
<> 144:ef7eb2e8f9f7 733 {
<> 144:ef7eb2e8f9f7 734 SDMMC_WriteFIFO(hsd->Instance, tempbuff);
<> 144:ef7eb2e8f9f7 735 tempbuff++;
<> 144:ef7eb2e8f9f7 736 bytestransferred += 4;
<> 144:ef7eb2e8f9f7 737 }
<> 144:ef7eb2e8f9f7 738 }
<> 144:ef7eb2e8f9f7 739 else
<> 144:ef7eb2e8f9f7 740 {
<> 144:ef7eb2e8f9f7 741 /* Write data to SDMMC Tx FIFO */
<> 144:ef7eb2e8f9f7 742 for (count = 0; count < 8; count++)
<> 144:ef7eb2e8f9f7 743 {
<> 144:ef7eb2e8f9f7 744 SDMMC_WriteFIFO(hsd->Instance, (tempbuff + count));
<> 144:ef7eb2e8f9f7 745 }
<> 144:ef7eb2e8f9f7 746
<> 144:ef7eb2e8f9f7 747 tempbuff += 8;
<> 144:ef7eb2e8f9f7 748 bytestransferred += 32;
<> 144:ef7eb2e8f9f7 749 }
<> 144:ef7eb2e8f9f7 750 }
<> 144:ef7eb2e8f9f7 751 }
<> 144:ef7eb2e8f9f7 752 }
<> 144:ef7eb2e8f9f7 753 else
<> 144:ef7eb2e8f9f7 754 {
<> 144:ef7eb2e8f9f7 755 /* In case of single data block transfer no need of stop command at all */
<> 144:ef7eb2e8f9f7 756 while(!__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND))
<> 144:ef7eb2e8f9f7 757 {
<> 144:ef7eb2e8f9f7 758 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE))
<> 144:ef7eb2e8f9f7 759 {
<> 144:ef7eb2e8f9f7 760 if ((totalnumberofbytes - bytestransferred) < 32)
<> 144:ef7eb2e8f9f7 761 {
<> 144:ef7eb2e8f9f7 762 restwords = ((totalnumberofbytes - bytestransferred) % 4 == 0) ? ((totalnumberofbytes - bytestransferred) / 4) : (( totalnumberofbytes - bytestransferred) / 4 + 1);
<> 144:ef7eb2e8f9f7 763
<> 144:ef7eb2e8f9f7 764 /* Write data to SDMMC Tx FIFO */
<> 144:ef7eb2e8f9f7 765 for (count = 0; count < restwords; count++)
<> 144:ef7eb2e8f9f7 766 {
<> 144:ef7eb2e8f9f7 767 SDMMC_WriteFIFO(hsd->Instance, tempbuff);
<> 144:ef7eb2e8f9f7 768 tempbuff++;
<> 144:ef7eb2e8f9f7 769 bytestransferred += 4;
<> 144:ef7eb2e8f9f7 770 }
<> 144:ef7eb2e8f9f7 771 }
<> 144:ef7eb2e8f9f7 772 else
<> 144:ef7eb2e8f9f7 773 {
<> 144:ef7eb2e8f9f7 774 /* Write data to SDMMC Tx FIFO */
<> 144:ef7eb2e8f9f7 775 for (count = 0; count < 8; count++)
<> 144:ef7eb2e8f9f7 776 {
<> 144:ef7eb2e8f9f7 777 SDMMC_WriteFIFO(hsd->Instance, (tempbuff + count));
<> 144:ef7eb2e8f9f7 778 }
<> 144:ef7eb2e8f9f7 779
<> 144:ef7eb2e8f9f7 780 tempbuff += 8;
<> 144:ef7eb2e8f9f7 781 bytestransferred += 32;
<> 144:ef7eb2e8f9f7 782 }
<> 144:ef7eb2e8f9f7 783 }
<> 144:ef7eb2e8f9f7 784 }
<> 144:ef7eb2e8f9f7 785 }
<> 144:ef7eb2e8f9f7 786
<> 144:ef7eb2e8f9f7 787 /* Send stop transmission command in case of multiblock write */
<> 144:ef7eb2e8f9f7 788 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1))
<> 144:ef7eb2e8f9f7 789 {
<> 144:ef7eb2e8f9f7 790 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
<> 144:ef7eb2e8f9f7 791 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
<> 144:ef7eb2e8f9f7 792 {
<> 144:ef7eb2e8f9f7 793 /* Send stop transmission command */
<> 144:ef7eb2e8f9f7 794 errorstate = HAL_SD_StopTransfer(hsd);
<> 144:ef7eb2e8f9f7 795 }
<> 144:ef7eb2e8f9f7 796 }
<> 144:ef7eb2e8f9f7 797
<> 144:ef7eb2e8f9f7 798 /* Get error state */
<> 144:ef7eb2e8f9f7 799 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
<> 144:ef7eb2e8f9f7 800 {
<> 144:ef7eb2e8f9f7 801 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
<> 144:ef7eb2e8f9f7 802
<> 144:ef7eb2e8f9f7 803 errorstate = SD_DATA_TIMEOUT;
<> 144:ef7eb2e8f9f7 804
<> 144:ef7eb2e8f9f7 805 return errorstate;
<> 144:ef7eb2e8f9f7 806 }
<> 144:ef7eb2e8f9f7 807 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
<> 144:ef7eb2e8f9f7 808 {
<> 144:ef7eb2e8f9f7 809 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
<> 144:ef7eb2e8f9f7 810
<> 144:ef7eb2e8f9f7 811 errorstate = SD_DATA_CRC_FAIL;
<> 144:ef7eb2e8f9f7 812
<> 144:ef7eb2e8f9f7 813 return errorstate;
<> 144:ef7eb2e8f9f7 814 }
<> 144:ef7eb2e8f9f7 815 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR))
<> 144:ef7eb2e8f9f7 816 {
<> 144:ef7eb2e8f9f7 817 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_TXUNDERR);
<> 144:ef7eb2e8f9f7 818
<> 144:ef7eb2e8f9f7 819 errorstate = SD_TX_UNDERRUN;
<> 144:ef7eb2e8f9f7 820
<> 144:ef7eb2e8f9f7 821 return errorstate;
<> 144:ef7eb2e8f9f7 822 }
<> 144:ef7eb2e8f9f7 823 else
<> 144:ef7eb2e8f9f7 824 {
<> 144:ef7eb2e8f9f7 825 /* No error flag set */
<> 144:ef7eb2e8f9f7 826 }
<> 144:ef7eb2e8f9f7 827
<> 144:ef7eb2e8f9f7 828 /* Clear all the static flags */
<> 144:ef7eb2e8f9f7 829 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 830
<> 144:ef7eb2e8f9f7 831 /* Wait till the card is in programming state */
<> 144:ef7eb2e8f9f7 832 errorstate = SD_IsCardProgramming(hsd, &cardstate);
<> 144:ef7eb2e8f9f7 833
<> 144:ef7eb2e8f9f7 834 while ((errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
<> 144:ef7eb2e8f9f7 835 {
<> 144:ef7eb2e8f9f7 836 errorstate = SD_IsCardProgramming(hsd, &cardstate);
<> 144:ef7eb2e8f9f7 837 }
<> 144:ef7eb2e8f9f7 838
<> 144:ef7eb2e8f9f7 839 return errorstate;
<> 144:ef7eb2e8f9f7 840 }
<> 144:ef7eb2e8f9f7 841
<> 144:ef7eb2e8f9f7 842 /**
<> 144:ef7eb2e8f9f7 843 * @brief Reads block(s) from a specified address in a card. The Data transfer
<> 144:ef7eb2e8f9f7 844 * is managed by DMA mode.
<> 144:ef7eb2e8f9f7 845 * @note This API should be followed by the function HAL_SD_CheckReadOperation()
<> 144:ef7eb2e8f9f7 846 * to check the completion of the read process
<> 144:ef7eb2e8f9f7 847 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 848 * @param pReadBuffer: Pointer to the buffer that will contain the received data
<> 144:ef7eb2e8f9f7 849 * @param ReadAddr: Address from where data is to be read
<> 144:ef7eb2e8f9f7 850 * @param BlockSize: SD card Data block size
<> 144:ef7eb2e8f9f7 851 * @note BlockSize must be 512 bytes.
<> 144:ef7eb2e8f9f7 852 * @param NumberOfBlocks: Number of blocks to read.
<> 144:ef7eb2e8f9f7 853 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 854 */
<> 144:ef7eb2e8f9f7 855 HAL_SD_ErrorTypedef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
<> 144:ef7eb2e8f9f7 856 {
<> 144:ef7eb2e8f9f7 857 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 858 SDMMC_DataInitTypeDef sdmmc_datainitstructure;
<> 144:ef7eb2e8f9f7 859 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 860
<> 144:ef7eb2e8f9f7 861 /* Initialize data control register */
<> 144:ef7eb2e8f9f7 862 hsd->Instance->DCTRL = 0;
<> 144:ef7eb2e8f9f7 863
<> 144:ef7eb2e8f9f7 864 /* Initialize handle flags */
<> 144:ef7eb2e8f9f7 865 hsd->SdTransferCplt = 0;
<> 144:ef7eb2e8f9f7 866 hsd->DmaTransferCplt = 0;
<> 144:ef7eb2e8f9f7 867 hsd->SdTransferErr = SD_OK;
<> 144:ef7eb2e8f9f7 868
<> 144:ef7eb2e8f9f7 869 /* Initialize SD Read operation */
<> 144:ef7eb2e8f9f7 870 if(NumberOfBlocks > 1)
<> 144:ef7eb2e8f9f7 871 {
<> 144:ef7eb2e8f9f7 872 hsd->SdOperation = SD_READ_MULTIPLE_BLOCK;
<> 144:ef7eb2e8f9f7 873 }
<> 144:ef7eb2e8f9f7 874 else
<> 144:ef7eb2e8f9f7 875 {
<> 144:ef7eb2e8f9f7 876 hsd->SdOperation = SD_READ_SINGLE_BLOCK;
<> 144:ef7eb2e8f9f7 877 }
<> 144:ef7eb2e8f9f7 878
<> 144:ef7eb2e8f9f7 879 /* Enable transfer interrupts */
<> 144:ef7eb2e8f9f7 880 __HAL_SD_SDMMC_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL |\
<> 144:ef7eb2e8f9f7 881 SDMMC_IT_DTIMEOUT |\
<> 144:ef7eb2e8f9f7 882 SDMMC_IT_DATAEND |\
<> 144:ef7eb2e8f9f7 883 SDMMC_IT_RXOVERR));
<> 144:ef7eb2e8f9f7 884
<> 144:ef7eb2e8f9f7 885 /* Enable SDMMC DMA transfer */
<> 144:ef7eb2e8f9f7 886 __HAL_SD_SDMMC_DMA_ENABLE(hsd);
<> 144:ef7eb2e8f9f7 887
<> 144:ef7eb2e8f9f7 888 /* Configure DMA user callbacks */
<> 144:ef7eb2e8f9f7 889 hsd->hdmarx->XferCpltCallback = SD_DMA_RxCplt;
<> 144:ef7eb2e8f9f7 890 hsd->hdmarx->XferErrorCallback = SD_DMA_RxError;
<> 144:ef7eb2e8f9f7 891
<> 144:ef7eb2e8f9f7 892 /* Enable the DMA Channel */
<> 144:ef7eb2e8f9f7 893 HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pReadBuffer, (uint32_t)(BlockSize * NumberOfBlocks)/4);
<> 144:ef7eb2e8f9f7 894
<> 144:ef7eb2e8f9f7 895 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
<> 144:ef7eb2e8f9f7 896 {
<> 144:ef7eb2e8f9f7 897 BlockSize = 512;
<> 144:ef7eb2e8f9f7 898 ReadAddr /= 512;
<> 144:ef7eb2e8f9f7 899 }
<> 144:ef7eb2e8f9f7 900
<> 144:ef7eb2e8f9f7 901 /* Set Block Size for Card */
<> 144:ef7eb2e8f9f7 902 sdmmc_cmdinitstructure.Argument = (uint32_t)BlockSize;
<> 144:ef7eb2e8f9f7 903 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
<> 144:ef7eb2e8f9f7 904 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 905 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 906 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 907 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 908
<> 144:ef7eb2e8f9f7 909 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 910 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
<> 144:ef7eb2e8f9f7 911
<> 144:ef7eb2e8f9f7 912 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 913 {
<> 144:ef7eb2e8f9f7 914 return errorstate;
<> 144:ef7eb2e8f9f7 915 }
<> 144:ef7eb2e8f9f7 916
<> 144:ef7eb2e8f9f7 917 /* Configure the SD DPSM (Data Path State Machine) */
<> 144:ef7eb2e8f9f7 918 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
<> 144:ef7eb2e8f9f7 919 sdmmc_datainitstructure.DataLength = BlockSize * NumberOfBlocks;
<> 144:ef7eb2e8f9f7 920 sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
<> 144:ef7eb2e8f9f7 921 sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
<> 144:ef7eb2e8f9f7 922 sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
<> 144:ef7eb2e8f9f7 923 sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
<> 144:ef7eb2e8f9f7 924 SDMMC_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
<> 144:ef7eb2e8f9f7 925
<> 144:ef7eb2e8f9f7 926 /* Check number of blocks command */
<> 144:ef7eb2e8f9f7 927 if(NumberOfBlocks > 1)
<> 144:ef7eb2e8f9f7 928 {
<> 144:ef7eb2e8f9f7 929 /* Send CMD18 READ_MULT_BLOCK with argument data address */
<> 144:ef7eb2e8f9f7 930 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_READ_MULT_BLOCK;
<> 144:ef7eb2e8f9f7 931 }
<> 144:ef7eb2e8f9f7 932 else
<> 144:ef7eb2e8f9f7 933 {
<> 144:ef7eb2e8f9f7 934 /* Send CMD17 READ_SINGLE_BLOCK */
<> 144:ef7eb2e8f9f7 935 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
<> 144:ef7eb2e8f9f7 936 }
<> 144:ef7eb2e8f9f7 937
<> 144:ef7eb2e8f9f7 938 sdmmc_cmdinitstructure.Argument = (uint32_t)ReadAddr;
<> 144:ef7eb2e8f9f7 939 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 940
<> 144:ef7eb2e8f9f7 941 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 942 if(NumberOfBlocks > 1)
<> 144:ef7eb2e8f9f7 943 {
<> 144:ef7eb2e8f9f7 944 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_MULT_BLOCK);
<> 144:ef7eb2e8f9f7 945 }
<> 144:ef7eb2e8f9f7 946 else
<> 144:ef7eb2e8f9f7 947 {
<> 144:ef7eb2e8f9f7 948 errorstate = SD_CmdResp1Error(hsd, SD_CMD_READ_SINGLE_BLOCK);
<> 144:ef7eb2e8f9f7 949 }
<> 144:ef7eb2e8f9f7 950
<> 144:ef7eb2e8f9f7 951 /* Update the SD transfer error in SD handle */
<> 144:ef7eb2e8f9f7 952 hsd->SdTransferErr = errorstate;
<> 144:ef7eb2e8f9f7 953
<> 144:ef7eb2e8f9f7 954 return errorstate;
<> 144:ef7eb2e8f9f7 955 }
<> 144:ef7eb2e8f9f7 956
<> 144:ef7eb2e8f9f7 957
<> 144:ef7eb2e8f9f7 958 /**
<> 144:ef7eb2e8f9f7 959 * @brief Writes block(s) to a specified address in a card. The Data transfer
<> 144:ef7eb2e8f9f7 960 * is managed by DMA mode.
<> 144:ef7eb2e8f9f7 961 * @note This API should be followed by the function HAL_SD_CheckWriteOperation()
<> 144:ef7eb2e8f9f7 962 * to check the completion of the write process (by SD current status polling).
<> 144:ef7eb2e8f9f7 963 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 964 * @param pWriteBuffer: pointer to the buffer that will contain the data to transmit
<> 144:ef7eb2e8f9f7 965 * @param WriteAddr: Address from where data is to be read
<> 144:ef7eb2e8f9f7 966 * @param BlockSize: the SD card Data block size
<> 144:ef7eb2e8f9f7 967 * @note BlockSize must be 512 bytes.
<> 144:ef7eb2e8f9f7 968 * @param NumberOfBlocks: Number of blocks to write
<> 144:ef7eb2e8f9f7 969 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 970 */
<> 144:ef7eb2e8f9f7 971 HAL_SD_ErrorTypedef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks)
<> 144:ef7eb2e8f9f7 972 {
<> 144:ef7eb2e8f9f7 973 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 974 SDMMC_DataInitTypeDef sdmmc_datainitstructure;
<> 144:ef7eb2e8f9f7 975 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 976
<> 144:ef7eb2e8f9f7 977 /* Initialize data control register */
<> 144:ef7eb2e8f9f7 978 hsd->Instance->DCTRL = 0;
<> 144:ef7eb2e8f9f7 979
<> 144:ef7eb2e8f9f7 980 /* Initialize handle flags */
<> 144:ef7eb2e8f9f7 981 hsd->SdTransferCplt = 0;
<> 144:ef7eb2e8f9f7 982 hsd->DmaTransferCplt = 0;
<> 144:ef7eb2e8f9f7 983 hsd->SdTransferErr = SD_OK;
<> 144:ef7eb2e8f9f7 984
<> 144:ef7eb2e8f9f7 985 /* Initialize SD Write operation */
<> 144:ef7eb2e8f9f7 986 if(NumberOfBlocks > 1)
<> 144:ef7eb2e8f9f7 987 {
<> 144:ef7eb2e8f9f7 988 hsd->SdOperation = SD_WRITE_MULTIPLE_BLOCK;
<> 144:ef7eb2e8f9f7 989 }
<> 144:ef7eb2e8f9f7 990 else
<> 144:ef7eb2e8f9f7 991 {
<> 144:ef7eb2e8f9f7 992 hsd->SdOperation = SD_WRITE_SINGLE_BLOCK;
<> 144:ef7eb2e8f9f7 993 }
<> 144:ef7eb2e8f9f7 994
<> 144:ef7eb2e8f9f7 995 /* Enable transfer interrupts */
<> 144:ef7eb2e8f9f7 996 __HAL_SD_SDMMC_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL |\
<> 144:ef7eb2e8f9f7 997 SDMMC_IT_DTIMEOUT |\
<> 144:ef7eb2e8f9f7 998 SDMMC_IT_DATAEND |\
<> 144:ef7eb2e8f9f7 999 SDMMC_IT_TXUNDERR));
<> 144:ef7eb2e8f9f7 1000
<> 144:ef7eb2e8f9f7 1001 /* Configure DMA user callbacks */
<> 144:ef7eb2e8f9f7 1002 hsd->hdmatx->XferCpltCallback = SD_DMA_TxCplt;
<> 144:ef7eb2e8f9f7 1003 hsd->hdmatx->XferErrorCallback = SD_DMA_TxError;
<> 144:ef7eb2e8f9f7 1004
<> 144:ef7eb2e8f9f7 1005 /* Enable the DMA Channel */
<> 144:ef7eb2e8f9f7 1006 HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pWriteBuffer, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BlockSize * NumberOfBlocks)/4);
<> 144:ef7eb2e8f9f7 1007
<> 144:ef7eb2e8f9f7 1008 /* Enable SDMMC DMA transfer */
<> 144:ef7eb2e8f9f7 1009 __HAL_SD_SDMMC_DMA_ENABLE(hsd);
<> 144:ef7eb2e8f9f7 1010
<> 144:ef7eb2e8f9f7 1011 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
<> 144:ef7eb2e8f9f7 1012 {
<> 144:ef7eb2e8f9f7 1013 BlockSize = 512;
<> 144:ef7eb2e8f9f7 1014 WriteAddr /= 512;
<> 144:ef7eb2e8f9f7 1015 }
<> 144:ef7eb2e8f9f7 1016
<> 144:ef7eb2e8f9f7 1017 /* Set Block Size for Card */
<> 144:ef7eb2e8f9f7 1018 sdmmc_cmdinitstructure.Argument = (uint32_t)BlockSize;
<> 144:ef7eb2e8f9f7 1019 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
<> 144:ef7eb2e8f9f7 1020 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 1021 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 1022 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 1023 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 1024
<> 144:ef7eb2e8f9f7 1025 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 1026 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
<> 144:ef7eb2e8f9f7 1027
<> 144:ef7eb2e8f9f7 1028 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 1029 {
<> 144:ef7eb2e8f9f7 1030 return errorstate;
<> 144:ef7eb2e8f9f7 1031 }
<> 144:ef7eb2e8f9f7 1032
<> 144:ef7eb2e8f9f7 1033 /* Check number of blocks command */
<> 144:ef7eb2e8f9f7 1034 if(NumberOfBlocks <= 1)
<> 144:ef7eb2e8f9f7 1035 {
<> 144:ef7eb2e8f9f7 1036 /* Send CMD24 WRITE_SINGLE_BLOCK */
<> 144:ef7eb2e8f9f7 1037 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
<> 144:ef7eb2e8f9f7 1038 }
<> 144:ef7eb2e8f9f7 1039 else
<> 144:ef7eb2e8f9f7 1040 {
<> 144:ef7eb2e8f9f7 1041 /* Send CMD25 WRITE_MULT_BLOCK with argument data address */
<> 144:ef7eb2e8f9f7 1042 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
<> 144:ef7eb2e8f9f7 1043 }
<> 144:ef7eb2e8f9f7 1044
<> 144:ef7eb2e8f9f7 1045 sdmmc_cmdinitstructure.Argument = (uint32_t)WriteAddr;
<> 144:ef7eb2e8f9f7 1046 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 1047
<> 144:ef7eb2e8f9f7 1048 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 1049 if(NumberOfBlocks > 1)
<> 144:ef7eb2e8f9f7 1050 {
<> 144:ef7eb2e8f9f7 1051 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_MULT_BLOCK);
<> 144:ef7eb2e8f9f7 1052 }
<> 144:ef7eb2e8f9f7 1053 else
<> 144:ef7eb2e8f9f7 1054 {
<> 144:ef7eb2e8f9f7 1055 errorstate = SD_CmdResp1Error(hsd, SD_CMD_WRITE_SINGLE_BLOCK);
<> 144:ef7eb2e8f9f7 1056 }
<> 144:ef7eb2e8f9f7 1057
<> 144:ef7eb2e8f9f7 1058 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 1059 {
<> 144:ef7eb2e8f9f7 1060 return errorstate;
<> 144:ef7eb2e8f9f7 1061 }
<> 144:ef7eb2e8f9f7 1062
<> 144:ef7eb2e8f9f7 1063 /* Configure the SD DPSM (Data Path State Machine) */
<> 144:ef7eb2e8f9f7 1064 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
<> 144:ef7eb2e8f9f7 1065 sdmmc_datainitstructure.DataLength = BlockSize * NumberOfBlocks;
<> 144:ef7eb2e8f9f7 1066 sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
<> 144:ef7eb2e8f9f7 1067 sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
<> 144:ef7eb2e8f9f7 1068 sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
<> 144:ef7eb2e8f9f7 1069 sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
<> 144:ef7eb2e8f9f7 1070 SDMMC_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
<> 144:ef7eb2e8f9f7 1071
<> 144:ef7eb2e8f9f7 1072 hsd->SdTransferErr = errorstate;
<> 144:ef7eb2e8f9f7 1073
<> 144:ef7eb2e8f9f7 1074 return errorstate;
<> 144:ef7eb2e8f9f7 1075 }
<> 144:ef7eb2e8f9f7 1076
<> 144:ef7eb2e8f9f7 1077 /**
<> 144:ef7eb2e8f9f7 1078 * @brief This function waits until the SD DMA data read transfer is finished.
<> 144:ef7eb2e8f9f7 1079 * This API should be called after HAL_SD_ReadBlocks_DMA() function
<> 144:ef7eb2e8f9f7 1080 * to insure that all data sent by the card is already transferred by the
<> 144:ef7eb2e8f9f7 1081 * DMA controller.
<> 144:ef7eb2e8f9f7 1082 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 1083 * @param Timeout: Timeout duration
<> 144:ef7eb2e8f9f7 1084 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 1085 */
<> 144:ef7eb2e8f9f7 1086 HAL_SD_ErrorTypedef HAL_SD_CheckReadOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 1087 {
<> 144:ef7eb2e8f9f7 1088 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 1089 uint32_t timeout = Timeout;
<> 144:ef7eb2e8f9f7 1090 uint32_t tmp1, tmp2;
<> 144:ef7eb2e8f9f7 1091 HAL_SD_ErrorTypedef tmp3;
<> 144:ef7eb2e8f9f7 1092
<> 144:ef7eb2e8f9f7 1093 /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
<> 144:ef7eb2e8f9f7 1094 tmp1 = hsd->DmaTransferCplt;
<> 144:ef7eb2e8f9f7 1095 tmp2 = hsd->SdTransferCplt;
<> 144:ef7eb2e8f9f7 1096 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
<> 144:ef7eb2e8f9f7 1097
<> 144:ef7eb2e8f9f7 1098 while (((tmp1 & tmp2) == 0) && (tmp3 == SD_OK) && (timeout > 0))
<> 144:ef7eb2e8f9f7 1099 {
<> 144:ef7eb2e8f9f7 1100 tmp1 = hsd->DmaTransferCplt;
<> 144:ef7eb2e8f9f7 1101 tmp2 = hsd->SdTransferCplt;
<> 144:ef7eb2e8f9f7 1102 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
<> 144:ef7eb2e8f9f7 1103 timeout--;
<> 144:ef7eb2e8f9f7 1104 }
<> 144:ef7eb2e8f9f7 1105
<> 144:ef7eb2e8f9f7 1106 timeout = Timeout;
<> 144:ef7eb2e8f9f7 1107
<> 144:ef7eb2e8f9f7 1108 /* Wait until the Rx transfer is no longer active */
<> 144:ef7eb2e8f9f7 1109 while((__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXACT)) && (timeout > 0))
<> 144:ef7eb2e8f9f7 1110 {
<> 144:ef7eb2e8f9f7 1111 timeout--;
<> 144:ef7eb2e8f9f7 1112 }
<> 144:ef7eb2e8f9f7 1113
<> 144:ef7eb2e8f9f7 1114 /* Send stop command in multiblock read */
<> 144:ef7eb2e8f9f7 1115 if (hsd->SdOperation == SD_READ_MULTIPLE_BLOCK)
<> 144:ef7eb2e8f9f7 1116 {
<> 144:ef7eb2e8f9f7 1117 errorstate = HAL_SD_StopTransfer(hsd);
<> 144:ef7eb2e8f9f7 1118 }
<> 144:ef7eb2e8f9f7 1119
<> 144:ef7eb2e8f9f7 1120 if ((timeout == 0) && (errorstate == SD_OK))
<> 144:ef7eb2e8f9f7 1121 {
<> 144:ef7eb2e8f9f7 1122 errorstate = SD_DATA_TIMEOUT;
<> 144:ef7eb2e8f9f7 1123 }
<> 144:ef7eb2e8f9f7 1124
<> 144:ef7eb2e8f9f7 1125 /* Clear all the static flags */
<> 144:ef7eb2e8f9f7 1126 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 1127
<> 144:ef7eb2e8f9f7 1128 /* Return error state */
<> 144:ef7eb2e8f9f7 1129 if (hsd->SdTransferErr != SD_OK)
<> 144:ef7eb2e8f9f7 1130 {
<> 144:ef7eb2e8f9f7 1131 return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
<> 144:ef7eb2e8f9f7 1132 }
<> 144:ef7eb2e8f9f7 1133
<> 144:ef7eb2e8f9f7 1134 return errorstate;
<> 144:ef7eb2e8f9f7 1135 }
<> 144:ef7eb2e8f9f7 1136
<> 144:ef7eb2e8f9f7 1137 /**
<> 144:ef7eb2e8f9f7 1138 * @brief This function waits until the SD DMA data write transfer is finished.
<> 144:ef7eb2e8f9f7 1139 * This API should be called after HAL_SD_WriteBlocks_DMA() function
<> 144:ef7eb2e8f9f7 1140 * to insure that all data sent by the card is already transferred by the
<> 144:ef7eb2e8f9f7 1141 * DMA controller.
<> 144:ef7eb2e8f9f7 1142 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 1143 * @param Timeout: Timeout duration
<> 144:ef7eb2e8f9f7 1144 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 1145 */
<> 144:ef7eb2e8f9f7 1146 HAL_SD_ErrorTypedef HAL_SD_CheckWriteOperation(SD_HandleTypeDef *hsd, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 1147 {
<> 144:ef7eb2e8f9f7 1148 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 1149 uint32_t timeout = Timeout;
<> 144:ef7eb2e8f9f7 1150 uint32_t tmp1, tmp2;
<> 144:ef7eb2e8f9f7 1151 HAL_SD_ErrorTypedef tmp3;
<> 144:ef7eb2e8f9f7 1152
<> 144:ef7eb2e8f9f7 1153 /* Wait for DMA/SD transfer end or SD error variables to be in SD handle */
<> 144:ef7eb2e8f9f7 1154 tmp1 = hsd->DmaTransferCplt;
<> 144:ef7eb2e8f9f7 1155 tmp2 = hsd->SdTransferCplt;
<> 144:ef7eb2e8f9f7 1156 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
<> 144:ef7eb2e8f9f7 1157
<> 144:ef7eb2e8f9f7 1158 while (((tmp1 & tmp2) == 0) && (tmp3 == SD_OK) && (timeout > 0))
<> 144:ef7eb2e8f9f7 1159 {
<> 144:ef7eb2e8f9f7 1160 tmp1 = hsd->DmaTransferCplt;
<> 144:ef7eb2e8f9f7 1161 tmp2 = hsd->SdTransferCplt;
<> 144:ef7eb2e8f9f7 1162 tmp3 = (HAL_SD_ErrorTypedef)hsd->SdTransferErr;
<> 144:ef7eb2e8f9f7 1163 timeout--;
<> 144:ef7eb2e8f9f7 1164 }
<> 144:ef7eb2e8f9f7 1165
<> 144:ef7eb2e8f9f7 1166 timeout = Timeout;
<> 144:ef7eb2e8f9f7 1167
<> 144:ef7eb2e8f9f7 1168 /* Wait until the Tx transfer is no longer active */
<> 144:ef7eb2e8f9f7 1169 while((__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_TXACT)) && (timeout > 0))
<> 144:ef7eb2e8f9f7 1170 {
<> 144:ef7eb2e8f9f7 1171 timeout--;
<> 144:ef7eb2e8f9f7 1172 }
<> 144:ef7eb2e8f9f7 1173
<> 144:ef7eb2e8f9f7 1174 /* Send stop command in multiblock write */
<> 144:ef7eb2e8f9f7 1175 if (hsd->SdOperation == SD_WRITE_MULTIPLE_BLOCK)
<> 144:ef7eb2e8f9f7 1176 {
<> 144:ef7eb2e8f9f7 1177 errorstate = HAL_SD_StopTransfer(hsd);
<> 144:ef7eb2e8f9f7 1178 }
<> 144:ef7eb2e8f9f7 1179
<> 144:ef7eb2e8f9f7 1180 if ((timeout == 0) && (errorstate == SD_OK))
<> 144:ef7eb2e8f9f7 1181 {
<> 144:ef7eb2e8f9f7 1182 errorstate = SD_DATA_TIMEOUT;
<> 144:ef7eb2e8f9f7 1183 }
<> 144:ef7eb2e8f9f7 1184
<> 144:ef7eb2e8f9f7 1185 /* Clear all the static flags */
<> 144:ef7eb2e8f9f7 1186 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 1187
<> 144:ef7eb2e8f9f7 1188 /* Return error state */
<> 144:ef7eb2e8f9f7 1189 if (hsd->SdTransferErr != SD_OK)
<> 144:ef7eb2e8f9f7 1190 {
<> 144:ef7eb2e8f9f7 1191 return (HAL_SD_ErrorTypedef)(hsd->SdTransferErr);
<> 144:ef7eb2e8f9f7 1192 }
<> 144:ef7eb2e8f9f7 1193
<> 144:ef7eb2e8f9f7 1194 /* Wait until write is complete */
<> 144:ef7eb2e8f9f7 1195 while(HAL_SD_GetStatus(hsd) != SD_TRANSFER_OK)
<> 144:ef7eb2e8f9f7 1196 {
<> 144:ef7eb2e8f9f7 1197 }
<> 144:ef7eb2e8f9f7 1198
<> 144:ef7eb2e8f9f7 1199 return errorstate;
<> 144:ef7eb2e8f9f7 1200 }
<> 144:ef7eb2e8f9f7 1201
<> 144:ef7eb2e8f9f7 1202 /**
<> 144:ef7eb2e8f9f7 1203 * @brief Erases the specified memory area of the given SD card.
<> 144:ef7eb2e8f9f7 1204 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 1205 * @param startaddr: Start byte address
<> 144:ef7eb2e8f9f7 1206 * @param endaddr: End byte address
<> 144:ef7eb2e8f9f7 1207 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 1208 */
<> 144:ef7eb2e8f9f7 1209 HAL_SD_ErrorTypedef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint64_t startaddr, uint64_t endaddr)
<> 144:ef7eb2e8f9f7 1210 {
<> 144:ef7eb2e8f9f7 1211 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 1212 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 1213
<> 144:ef7eb2e8f9f7 1214 uint32_t delay = 0;
<> 144:ef7eb2e8f9f7 1215 __IO uint32_t maxdelay = 0;
<> 144:ef7eb2e8f9f7 1216 uint8_t cardstate = 0;
<> 144:ef7eb2e8f9f7 1217
<> 144:ef7eb2e8f9f7 1218 /* Check if the card command class supports erase command */
<> 144:ef7eb2e8f9f7 1219 if (((hsd->CSD[1] >> 20) & SD_CCCC_ERASE) == 0)
<> 144:ef7eb2e8f9f7 1220 {
<> 144:ef7eb2e8f9f7 1221 errorstate = SD_REQUEST_NOT_APPLICABLE;
<> 144:ef7eb2e8f9f7 1222
<> 144:ef7eb2e8f9f7 1223 return errorstate;
<> 144:ef7eb2e8f9f7 1224 }
<> 144:ef7eb2e8f9f7 1225
<> 144:ef7eb2e8f9f7 1226 /* Get max delay value */
<> 144:ef7eb2e8f9f7 1227 maxdelay = 120000 / (((hsd->Instance->CLKCR) & 0xFF) + 2);
<> 144:ef7eb2e8f9f7 1228
<> 144:ef7eb2e8f9f7 1229 if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
<> 144:ef7eb2e8f9f7 1230 {
<> 144:ef7eb2e8f9f7 1231 errorstate = SD_LOCK_UNLOCK_FAILED;
<> 144:ef7eb2e8f9f7 1232
<> 144:ef7eb2e8f9f7 1233 return errorstate;
<> 144:ef7eb2e8f9f7 1234 }
<> 144:ef7eb2e8f9f7 1235
<> 144:ef7eb2e8f9f7 1236 /* Get start and end block for high capacity cards */
<> 144:ef7eb2e8f9f7 1237 if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
<> 144:ef7eb2e8f9f7 1238 {
<> 144:ef7eb2e8f9f7 1239 startaddr /= 512;
<> 144:ef7eb2e8f9f7 1240 endaddr /= 512;
<> 144:ef7eb2e8f9f7 1241 }
<> 144:ef7eb2e8f9f7 1242
<> 144:ef7eb2e8f9f7 1243 /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
<> 144:ef7eb2e8f9f7 1244 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
<> 144:ef7eb2e8f9f7 1245 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
<> 144:ef7eb2e8f9f7 1246 {
<> 144:ef7eb2e8f9f7 1247 /* Send CMD32 SD_ERASE_GRP_START with argument as addr */
<> 144:ef7eb2e8f9f7 1248 sdmmc_cmdinitstructure.Argument =(uint32_t)startaddr;
<> 144:ef7eb2e8f9f7 1249 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SD_ERASE_GRP_START;
<> 144:ef7eb2e8f9f7 1250 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 1251 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 1252 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 1253 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 1254
<> 144:ef7eb2e8f9f7 1255 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 1256 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_START);
<> 144:ef7eb2e8f9f7 1257
<> 144:ef7eb2e8f9f7 1258 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 1259 {
<> 144:ef7eb2e8f9f7 1260 return errorstate;
<> 144:ef7eb2e8f9f7 1261 }
<> 144:ef7eb2e8f9f7 1262
<> 144:ef7eb2e8f9f7 1263 /* Send CMD33 SD_ERASE_GRP_END with argument as addr */
<> 144:ef7eb2e8f9f7 1264 sdmmc_cmdinitstructure.Argument = (uint32_t)endaddr;
<> 144:ef7eb2e8f9f7 1265 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SD_ERASE_GRP_END;
<> 144:ef7eb2e8f9f7 1266 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 1267
<> 144:ef7eb2e8f9f7 1268 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 1269 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_ERASE_GRP_END);
<> 144:ef7eb2e8f9f7 1270
<> 144:ef7eb2e8f9f7 1271 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 1272 {
<> 144:ef7eb2e8f9f7 1273 return errorstate;
<> 144:ef7eb2e8f9f7 1274 }
<> 144:ef7eb2e8f9f7 1275 }
<> 144:ef7eb2e8f9f7 1276
<> 144:ef7eb2e8f9f7 1277 /* Send CMD38 ERASE */
<> 144:ef7eb2e8f9f7 1278 sdmmc_cmdinitstructure.Argument = 0;
<> 144:ef7eb2e8f9f7 1279 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_ERASE;
<> 144:ef7eb2e8f9f7 1280 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 1281
<> 144:ef7eb2e8f9f7 1282 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 1283 errorstate = SD_CmdResp1Error(hsd, SD_CMD_ERASE);
<> 144:ef7eb2e8f9f7 1284
<> 144:ef7eb2e8f9f7 1285 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 1286 {
<> 144:ef7eb2e8f9f7 1287 return errorstate;
<> 144:ef7eb2e8f9f7 1288 }
<> 144:ef7eb2e8f9f7 1289
<> 144:ef7eb2e8f9f7 1290 for (; delay < maxdelay; delay++)
<> 144:ef7eb2e8f9f7 1291 {
<> 144:ef7eb2e8f9f7 1292 }
<> 144:ef7eb2e8f9f7 1293
<> 144:ef7eb2e8f9f7 1294 /* Wait until the card is in programming state */
<> 144:ef7eb2e8f9f7 1295 errorstate = SD_IsCardProgramming(hsd, &cardstate);
<> 144:ef7eb2e8f9f7 1296
<> 144:ef7eb2e8f9f7 1297 delay = SD_DATATIMEOUT;
<> 144:ef7eb2e8f9f7 1298
<> 144:ef7eb2e8f9f7 1299 while ((delay > 0) && (errorstate == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
<> 144:ef7eb2e8f9f7 1300 {
<> 144:ef7eb2e8f9f7 1301 errorstate = SD_IsCardProgramming(hsd, &cardstate);
<> 144:ef7eb2e8f9f7 1302 delay--;
<> 144:ef7eb2e8f9f7 1303 }
<> 144:ef7eb2e8f9f7 1304
<> 144:ef7eb2e8f9f7 1305 return errorstate;
<> 144:ef7eb2e8f9f7 1306 }
<> 144:ef7eb2e8f9f7 1307
<> 144:ef7eb2e8f9f7 1308 /**
<> 144:ef7eb2e8f9f7 1309 * @brief This function handles SD card interrupt request.
<> 144:ef7eb2e8f9f7 1310 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 1311 * @retval None
<> 144:ef7eb2e8f9f7 1312 */
<> 144:ef7eb2e8f9f7 1313 void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 1314 {
<> 144:ef7eb2e8f9f7 1315 /* Check for SDMMC interrupt flags */
<> 144:ef7eb2e8f9f7 1316 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_IT_DATAEND))
<> 144:ef7eb2e8f9f7 1317 {
<> 144:ef7eb2e8f9f7 1318 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_IT_DATAEND);
<> 144:ef7eb2e8f9f7 1319
<> 144:ef7eb2e8f9f7 1320 /* SD transfer is complete */
<> 144:ef7eb2e8f9f7 1321 hsd->SdTransferCplt = 1;
<> 144:ef7eb2e8f9f7 1322
<> 144:ef7eb2e8f9f7 1323 /* No transfer error */
<> 144:ef7eb2e8f9f7 1324 hsd->SdTransferErr = SD_OK;
<> 144:ef7eb2e8f9f7 1325
<> 144:ef7eb2e8f9f7 1326 HAL_SD_XferCpltCallback(hsd);
<> 144:ef7eb2e8f9f7 1327 }
<> 144:ef7eb2e8f9f7 1328 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_IT_DCRCFAIL))
<> 144:ef7eb2e8f9f7 1329 {
<> 144:ef7eb2e8f9f7 1330 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
<> 144:ef7eb2e8f9f7 1331
<> 144:ef7eb2e8f9f7 1332 hsd->SdTransferErr = SD_DATA_CRC_FAIL;
<> 144:ef7eb2e8f9f7 1333
<> 144:ef7eb2e8f9f7 1334 HAL_SD_XferErrorCallback(hsd);
<> 144:ef7eb2e8f9f7 1335
<> 144:ef7eb2e8f9f7 1336 }
<> 144:ef7eb2e8f9f7 1337 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_IT_DTIMEOUT))
<> 144:ef7eb2e8f9f7 1338 {
<> 144:ef7eb2e8f9f7 1339 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
<> 144:ef7eb2e8f9f7 1340
<> 144:ef7eb2e8f9f7 1341 hsd->SdTransferErr = SD_DATA_TIMEOUT;
<> 144:ef7eb2e8f9f7 1342
<> 144:ef7eb2e8f9f7 1343 HAL_SD_XferErrorCallback(hsd);
<> 144:ef7eb2e8f9f7 1344 }
<> 144:ef7eb2e8f9f7 1345 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_IT_RXOVERR))
<> 144:ef7eb2e8f9f7 1346 {
<> 144:ef7eb2e8f9f7 1347 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
<> 144:ef7eb2e8f9f7 1348
<> 144:ef7eb2e8f9f7 1349 hsd->SdTransferErr = SD_RX_OVERRUN;
<> 144:ef7eb2e8f9f7 1350
<> 144:ef7eb2e8f9f7 1351 HAL_SD_XferErrorCallback(hsd);
<> 144:ef7eb2e8f9f7 1352 }
<> 144:ef7eb2e8f9f7 1353 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_IT_TXUNDERR))
<> 144:ef7eb2e8f9f7 1354 {
<> 144:ef7eb2e8f9f7 1355 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_TXUNDERR);
<> 144:ef7eb2e8f9f7 1356
<> 144:ef7eb2e8f9f7 1357 hsd->SdTransferErr = SD_TX_UNDERRUN;
<> 144:ef7eb2e8f9f7 1358
<> 144:ef7eb2e8f9f7 1359 HAL_SD_XferErrorCallback(hsd);
<> 144:ef7eb2e8f9f7 1360 }
<> 144:ef7eb2e8f9f7 1361 else
<> 144:ef7eb2e8f9f7 1362 {
<> 144:ef7eb2e8f9f7 1363 /* No error flag set */
<> 144:ef7eb2e8f9f7 1364 }
<> 144:ef7eb2e8f9f7 1365
<> 144:ef7eb2e8f9f7 1366 /* Disable all SDMMC peripheral interrupt sources */
<> 144:ef7eb2e8f9f7 1367 __HAL_SD_SDMMC_DISABLE_IT(hsd, SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_DATAEND |\
<> 144:ef7eb2e8f9f7 1368 SDMMC_IT_TXFIFOHE | SDMMC_IT_RXFIFOHF | SDMMC_IT_TXUNDERR |\
<> 144:ef7eb2e8f9f7 1369 SDMMC_IT_RXOVERR);
<> 144:ef7eb2e8f9f7 1370 }
<> 144:ef7eb2e8f9f7 1371
<> 144:ef7eb2e8f9f7 1372
<> 144:ef7eb2e8f9f7 1373 /**
<> 144:ef7eb2e8f9f7 1374 * @brief SD end of transfer callback.
<> 144:ef7eb2e8f9f7 1375 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 1376 * @retval None
<> 144:ef7eb2e8f9f7 1377 */
<> 144:ef7eb2e8f9f7 1378 __weak void HAL_SD_XferCpltCallback(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 1379 {
<> 144:ef7eb2e8f9f7 1380 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1381 UNUSED(hsd);
<> 144:ef7eb2e8f9f7 1382
<> 144:ef7eb2e8f9f7 1383 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 1384 the HAL_SD_XferCpltCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1385 */
<> 144:ef7eb2e8f9f7 1386 }
<> 144:ef7eb2e8f9f7 1387
<> 144:ef7eb2e8f9f7 1388 /**
<> 144:ef7eb2e8f9f7 1389 * @brief SD Transfer Error callback.
<> 144:ef7eb2e8f9f7 1390 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 1391 * @retval None
<> 144:ef7eb2e8f9f7 1392 */
<> 144:ef7eb2e8f9f7 1393 __weak void HAL_SD_XferErrorCallback(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 1394 {
<> 144:ef7eb2e8f9f7 1395 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1396 UNUSED(hsd);
<> 144:ef7eb2e8f9f7 1397
<> 144:ef7eb2e8f9f7 1398 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 1399 the HAL_SD_XferErrorCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1400 */
<> 144:ef7eb2e8f9f7 1401 }
<> 144:ef7eb2e8f9f7 1402
<> 144:ef7eb2e8f9f7 1403 /**
<> 144:ef7eb2e8f9f7 1404 * @brief SD Transfer complete Rx callback in non blocking mode.
<> 144:ef7eb2e8f9f7 1405 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1406 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 1407 * @retval None
<> 144:ef7eb2e8f9f7 1408 */
<> 144:ef7eb2e8f9f7 1409 __weak void HAL_SD_DMA_RxCpltCallback(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 1410 {
<> 144:ef7eb2e8f9f7 1411 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1412 UNUSED(hdma);
<> 144:ef7eb2e8f9f7 1413
<> 144:ef7eb2e8f9f7 1414 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 1415 the HAL_SD_DMA_RxCpltCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1416 */
<> 144:ef7eb2e8f9f7 1417 }
<> 144:ef7eb2e8f9f7 1418
<> 144:ef7eb2e8f9f7 1419 /**
<> 144:ef7eb2e8f9f7 1420 * @brief SD DMA transfer complete Rx error callback.
<> 144:ef7eb2e8f9f7 1421 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1422 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 1423 * @retval None
<> 144:ef7eb2e8f9f7 1424 */
<> 144:ef7eb2e8f9f7 1425 __weak void HAL_SD_DMA_RxErrorCallback(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 1426 {
<> 144:ef7eb2e8f9f7 1427 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1428 UNUSED(hdma);
<> 144:ef7eb2e8f9f7 1429
<> 144:ef7eb2e8f9f7 1430 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 1431 the HAL_SD_DMA_RxErrorCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1432 */
<> 144:ef7eb2e8f9f7 1433 }
<> 144:ef7eb2e8f9f7 1434
<> 144:ef7eb2e8f9f7 1435 /**
<> 144:ef7eb2e8f9f7 1436 * @brief SD Transfer complete Tx callback in non blocking mode.
<> 144:ef7eb2e8f9f7 1437 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1438 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 1439 * @retval None
<> 144:ef7eb2e8f9f7 1440 */
<> 144:ef7eb2e8f9f7 1441 __weak void HAL_SD_DMA_TxCpltCallback(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 1442 {
<> 144:ef7eb2e8f9f7 1443 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1444 UNUSED(hdma);
<> 144:ef7eb2e8f9f7 1445
<> 144:ef7eb2e8f9f7 1446 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 1447 the HAL_SD_DMA_TxCpltCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1448 */
<> 144:ef7eb2e8f9f7 1449 }
<> 144:ef7eb2e8f9f7 1450
<> 144:ef7eb2e8f9f7 1451 /**
<> 144:ef7eb2e8f9f7 1452 * @brief SD DMA transfer complete error Tx callback.
<> 144:ef7eb2e8f9f7 1453 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1454 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 1455 * @retval None
<> 144:ef7eb2e8f9f7 1456 */
<> 144:ef7eb2e8f9f7 1457 __weak void HAL_SD_DMA_TxErrorCallback(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 1458 {
<> 144:ef7eb2e8f9f7 1459 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1460 UNUSED(hdma);
<> 144:ef7eb2e8f9f7 1461
<> 144:ef7eb2e8f9f7 1462 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 1463 the HAL_SD_DMA_TxErrorCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1464 */
<> 144:ef7eb2e8f9f7 1465 }
<> 144:ef7eb2e8f9f7 1466
<> 144:ef7eb2e8f9f7 1467 /**
<> 144:ef7eb2e8f9f7 1468 * @}
<> 144:ef7eb2e8f9f7 1469 */
<> 144:ef7eb2e8f9f7 1470
<> 144:ef7eb2e8f9f7 1471 /** @addtogroup SD_Exported_Functions_Group3
<> 144:ef7eb2e8f9f7 1472 * @brief management functions
<> 144:ef7eb2e8f9f7 1473 *
<> 144:ef7eb2e8f9f7 1474 @verbatim
<> 144:ef7eb2e8f9f7 1475 ==============================================================================
<> 144:ef7eb2e8f9f7 1476 ##### Peripheral Control functions #####
<> 144:ef7eb2e8f9f7 1477 ==============================================================================
<> 144:ef7eb2e8f9f7 1478 [..]
<> 144:ef7eb2e8f9f7 1479 This subsection provides a set of functions allowing to control the SD card
<> 144:ef7eb2e8f9f7 1480 operations.
<> 144:ef7eb2e8f9f7 1481
<> 144:ef7eb2e8f9f7 1482 @endverbatim
<> 144:ef7eb2e8f9f7 1483 * @{
<> 144:ef7eb2e8f9f7 1484 */
<> 144:ef7eb2e8f9f7 1485
<> 144:ef7eb2e8f9f7 1486 /**
<> 144:ef7eb2e8f9f7 1487 * @brief Returns information about specific card.
<> 144:ef7eb2e8f9f7 1488 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 1489 * @param pCardInfo: Pointer to a HAL_SD_CardInfoTypedef structure that
<> 144:ef7eb2e8f9f7 1490 * contains all SD cardinformation
<> 144:ef7eb2e8f9f7 1491 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 1492 */
<> 144:ef7eb2e8f9f7 1493 HAL_SD_ErrorTypedef HAL_SD_Get_CardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *pCardInfo)
<> 144:ef7eb2e8f9f7 1494 {
<> 144:ef7eb2e8f9f7 1495 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 1496 uint32_t tmp = 0;
<> 144:ef7eb2e8f9f7 1497
<> 144:ef7eb2e8f9f7 1498 pCardInfo->CardType = (uint8_t)(hsd->CardType);
<> 144:ef7eb2e8f9f7 1499 pCardInfo->RCA = (uint16_t)(hsd->RCA);
<> 144:ef7eb2e8f9f7 1500
<> 144:ef7eb2e8f9f7 1501 /* Byte 0 */
<> 144:ef7eb2e8f9f7 1502 tmp = (hsd->CSD[0] & 0xFF000000U) >> 24;
<> 144:ef7eb2e8f9f7 1503 pCardInfo->SD_csd.CSDStruct = (uint8_t)((tmp & 0xC0) >> 6);
<> 144:ef7eb2e8f9f7 1504 pCardInfo->SD_csd.SysSpecVersion = (uint8_t)((tmp & 0x3C) >> 2);
<> 144:ef7eb2e8f9f7 1505 pCardInfo->SD_csd.Reserved1 = tmp & 0x03;
<> 144:ef7eb2e8f9f7 1506
<> 144:ef7eb2e8f9f7 1507 /* Byte 1 */
<> 144:ef7eb2e8f9f7 1508 tmp = (hsd->CSD[0] & 0x00FF0000) >> 16;
<> 144:ef7eb2e8f9f7 1509 pCardInfo->SD_csd.TAAC = (uint8_t)tmp;
<> 144:ef7eb2e8f9f7 1510
<> 144:ef7eb2e8f9f7 1511 /* Byte 2 */
<> 144:ef7eb2e8f9f7 1512 tmp = (hsd->CSD[0] & 0x0000FF00) >> 8;
<> 144:ef7eb2e8f9f7 1513 pCardInfo->SD_csd.NSAC = (uint8_t)tmp;
<> 144:ef7eb2e8f9f7 1514
<> 144:ef7eb2e8f9f7 1515 /* Byte 3 */
<> 144:ef7eb2e8f9f7 1516 tmp = hsd->CSD[0] & 0x000000FF;
<> 144:ef7eb2e8f9f7 1517 pCardInfo->SD_csd.MaxBusClkFrec = (uint8_t)tmp;
<> 144:ef7eb2e8f9f7 1518
<> 144:ef7eb2e8f9f7 1519 /* Byte 4 */
<> 144:ef7eb2e8f9f7 1520 tmp = (hsd->CSD[1] & 0xFF000000U) >> 24;
<> 144:ef7eb2e8f9f7 1521 pCardInfo->SD_csd.CardComdClasses = (uint16_t)(tmp << 4);
<> 144:ef7eb2e8f9f7 1522
<> 144:ef7eb2e8f9f7 1523 /* Byte 5 */
<> 144:ef7eb2e8f9f7 1524 tmp = (hsd->CSD[1] & 0x00FF0000U) >> 16;
<> 144:ef7eb2e8f9f7 1525 pCardInfo->SD_csd.CardComdClasses |= (uint16_t)((tmp & 0xF0) >> 4);
<> 144:ef7eb2e8f9f7 1526 pCardInfo->SD_csd.RdBlockLen = (uint8_t)(tmp & 0x0F);
<> 144:ef7eb2e8f9f7 1527
<> 144:ef7eb2e8f9f7 1528 /* Byte 6 */
<> 144:ef7eb2e8f9f7 1529 tmp = (hsd->CSD[1] & 0x0000FF00U) >> 8;
<> 144:ef7eb2e8f9f7 1530 pCardInfo->SD_csd.PartBlockRead = (uint8_t)((tmp & 0x80) >> 7);
<> 144:ef7eb2e8f9f7 1531 pCardInfo->SD_csd.WrBlockMisalign = (uint8_t)((tmp & 0x40) >> 6);
<> 144:ef7eb2e8f9f7 1532 pCardInfo->SD_csd.RdBlockMisalign = (uint8_t)((tmp & 0x20) >> 5);
<> 144:ef7eb2e8f9f7 1533 pCardInfo->SD_csd.DSRImpl = (uint8_t)((tmp & 0x10) >> 4);
<> 144:ef7eb2e8f9f7 1534 pCardInfo->SD_csd.Reserved2 = 0; /*!< Reserved */
<> 144:ef7eb2e8f9f7 1535
<> 144:ef7eb2e8f9f7 1536 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0))
<> 144:ef7eb2e8f9f7 1537 {
<> 144:ef7eb2e8f9f7 1538 pCardInfo->SD_csd.DeviceSize = (tmp & 0x03) << 10;
<> 144:ef7eb2e8f9f7 1539
<> 144:ef7eb2e8f9f7 1540 /* Byte 7 */
<> 144:ef7eb2e8f9f7 1541 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FFU);
<> 144:ef7eb2e8f9f7 1542 pCardInfo->SD_csd.DeviceSize |= (tmp) << 2;
<> 144:ef7eb2e8f9f7 1543
<> 144:ef7eb2e8f9f7 1544 /* Byte 8 */
<> 144:ef7eb2e8f9f7 1545 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000U) >> 24);
<> 144:ef7eb2e8f9f7 1546 pCardInfo->SD_csd.DeviceSize |= (tmp & 0xC0) >> 6;
<> 144:ef7eb2e8f9f7 1547
<> 144:ef7eb2e8f9f7 1548 pCardInfo->SD_csd.MaxRdCurrentVDDMin = (tmp & 0x38) >> 3;
<> 144:ef7eb2e8f9f7 1549 pCardInfo->SD_csd.MaxRdCurrentVDDMax = (tmp & 0x07);
<> 144:ef7eb2e8f9f7 1550
<> 144:ef7eb2e8f9f7 1551 /* Byte 9 */
<> 144:ef7eb2e8f9f7 1552 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000U) >> 16);
<> 144:ef7eb2e8f9f7 1553 pCardInfo->SD_csd.MaxWrCurrentVDDMin = (tmp & 0xE0) >> 5;
<> 144:ef7eb2e8f9f7 1554 pCardInfo->SD_csd.MaxWrCurrentVDDMax = (tmp & 0x1C) >> 2;
<> 144:ef7eb2e8f9f7 1555 pCardInfo->SD_csd.DeviceSizeMul = (tmp & 0x03) << 1;
<> 144:ef7eb2e8f9f7 1556 /* Byte 10 */
<> 144:ef7eb2e8f9f7 1557 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00U) >> 8);
<> 144:ef7eb2e8f9f7 1558 pCardInfo->SD_csd.DeviceSizeMul |= (tmp & 0x80) >> 7;
<> 144:ef7eb2e8f9f7 1559
<> 144:ef7eb2e8f9f7 1560 pCardInfo->CardCapacity = (pCardInfo->SD_csd.DeviceSize + 1) ;
<> 144:ef7eb2e8f9f7 1561 pCardInfo->CardCapacity *= (1 << (pCardInfo->SD_csd.DeviceSizeMul + 2));
<> 144:ef7eb2e8f9f7 1562 pCardInfo->CardBlockSize = 1 << (pCardInfo->SD_csd.RdBlockLen);
<> 144:ef7eb2e8f9f7 1563 pCardInfo->CardCapacity *= pCardInfo->CardBlockSize;
<> 144:ef7eb2e8f9f7 1564 }
<> 144:ef7eb2e8f9f7 1565 else if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
<> 144:ef7eb2e8f9f7 1566 {
<> 144:ef7eb2e8f9f7 1567 /* Byte 7 */
<> 144:ef7eb2e8f9f7 1568 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FFU);
<> 144:ef7eb2e8f9f7 1569 pCardInfo->SD_csd.DeviceSize = (tmp & 0x3F) << 16;
<> 144:ef7eb2e8f9f7 1570
<> 144:ef7eb2e8f9f7 1571 /* Byte 8 */
<> 144:ef7eb2e8f9f7 1572 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000U) >> 24);
<> 144:ef7eb2e8f9f7 1573
<> 144:ef7eb2e8f9f7 1574 pCardInfo->SD_csd.DeviceSize |= (tmp << 8);
<> 144:ef7eb2e8f9f7 1575
<> 144:ef7eb2e8f9f7 1576 /* Byte 9 */
<> 144:ef7eb2e8f9f7 1577 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000U) >> 16);
<> 144:ef7eb2e8f9f7 1578
<> 144:ef7eb2e8f9f7 1579 pCardInfo->SD_csd.DeviceSize |= (tmp);
<> 144:ef7eb2e8f9f7 1580
<> 144:ef7eb2e8f9f7 1581 /* Byte 10 */
<> 144:ef7eb2e8f9f7 1582 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00U) >> 8);
<> 144:ef7eb2e8f9f7 1583
<> 144:ef7eb2e8f9f7 1584 pCardInfo->CardCapacity = (uint64_t)(((uint64_t)pCardInfo->SD_csd.DeviceSize + 1) * 512 * 1024);
<> 144:ef7eb2e8f9f7 1585 pCardInfo->CardBlockSize = 512;
<> 144:ef7eb2e8f9f7 1586 }
<> 144:ef7eb2e8f9f7 1587 else
<> 144:ef7eb2e8f9f7 1588 {
<> 144:ef7eb2e8f9f7 1589 /* Not supported card type */
<> 144:ef7eb2e8f9f7 1590 errorstate = SD_ERROR;
<> 144:ef7eb2e8f9f7 1591 }
<> 144:ef7eb2e8f9f7 1592
<> 144:ef7eb2e8f9f7 1593 pCardInfo->SD_csd.EraseGrSize = (tmp & 0x40) >> 6;
<> 144:ef7eb2e8f9f7 1594 pCardInfo->SD_csd.EraseGrMul = (tmp & 0x3F) << 1;
<> 144:ef7eb2e8f9f7 1595
<> 144:ef7eb2e8f9f7 1596 /* Byte 11 */
<> 144:ef7eb2e8f9f7 1597 tmp = (uint8_t)(hsd->CSD[2] & 0x000000FF);
<> 144:ef7eb2e8f9f7 1598 pCardInfo->SD_csd.EraseGrMul |= (tmp & 0x80) >> 7;
<> 144:ef7eb2e8f9f7 1599 pCardInfo->SD_csd.WrProtectGrSize = (tmp & 0x7F);
<> 144:ef7eb2e8f9f7 1600
<> 144:ef7eb2e8f9f7 1601 /* Byte 12 */
<> 144:ef7eb2e8f9f7 1602 tmp = (uint8_t)((hsd->CSD[3] & 0xFF000000U) >> 24);
<> 144:ef7eb2e8f9f7 1603 pCardInfo->SD_csd.WrProtectGrEnable = (tmp & 0x80) >> 7;
<> 144:ef7eb2e8f9f7 1604 pCardInfo->SD_csd.ManDeflECC = (tmp & 0x60) >> 5;
<> 144:ef7eb2e8f9f7 1605 pCardInfo->SD_csd.WrSpeedFact = (tmp & 0x1C) >> 2;
<> 144:ef7eb2e8f9f7 1606 pCardInfo->SD_csd.MaxWrBlockLen = (tmp & 0x03) << 2;
<> 144:ef7eb2e8f9f7 1607
<> 144:ef7eb2e8f9f7 1608 /* Byte 13 */
<> 144:ef7eb2e8f9f7 1609 tmp = (uint8_t)((hsd->CSD[3] & 0x00FF0000) >> 16);
<> 144:ef7eb2e8f9f7 1610 pCardInfo->SD_csd.MaxWrBlockLen |= (tmp & 0xC0) >> 6;
<> 144:ef7eb2e8f9f7 1611 pCardInfo->SD_csd.WriteBlockPaPartial = (tmp & 0x20) >> 5;
<> 144:ef7eb2e8f9f7 1612 pCardInfo->SD_csd.Reserved3 = 0;
<> 144:ef7eb2e8f9f7 1613 pCardInfo->SD_csd.ContentProtectAppli = (tmp & 0x01);
<> 144:ef7eb2e8f9f7 1614
<> 144:ef7eb2e8f9f7 1615 /* Byte 14 */
<> 144:ef7eb2e8f9f7 1616 tmp = (uint8_t)((hsd->CSD[3] & 0x0000FF00) >> 8);
<> 144:ef7eb2e8f9f7 1617 pCardInfo->SD_csd.FileFormatGrouop = (tmp & 0x80) >> 7;
<> 144:ef7eb2e8f9f7 1618 pCardInfo->SD_csd.CopyFlag = (tmp & 0x40) >> 6;
<> 144:ef7eb2e8f9f7 1619 pCardInfo->SD_csd.PermWrProtect = (tmp & 0x20) >> 5;
<> 144:ef7eb2e8f9f7 1620 pCardInfo->SD_csd.TempWrProtect = (tmp & 0x10) >> 4;
<> 144:ef7eb2e8f9f7 1621 pCardInfo->SD_csd.FileFormat = (tmp & 0x0C) >> 2;
<> 144:ef7eb2e8f9f7 1622 pCardInfo->SD_csd.ECC = (tmp & 0x03);
<> 144:ef7eb2e8f9f7 1623
<> 144:ef7eb2e8f9f7 1624 /* Byte 15 */
<> 144:ef7eb2e8f9f7 1625 tmp = (uint8_t)(hsd->CSD[3] & 0x000000FF);
<> 144:ef7eb2e8f9f7 1626 pCardInfo->SD_csd.CSD_CRC = (tmp & 0xFE) >> 1;
<> 144:ef7eb2e8f9f7 1627 pCardInfo->SD_csd.Reserved4 = 1;
<> 144:ef7eb2e8f9f7 1628
<> 144:ef7eb2e8f9f7 1629 /* Byte 0 */
<> 144:ef7eb2e8f9f7 1630 tmp = (uint8_t)((hsd->CID[0] & 0xFF000000U) >> 24);
<> 144:ef7eb2e8f9f7 1631 pCardInfo->SD_cid.ManufacturerID = tmp;
<> 144:ef7eb2e8f9f7 1632
<> 144:ef7eb2e8f9f7 1633 /* Byte 1 */
<> 144:ef7eb2e8f9f7 1634 tmp = (uint8_t)((hsd->CID[0] & 0x00FF0000) >> 16);
<> 144:ef7eb2e8f9f7 1635 pCardInfo->SD_cid.OEM_AppliID = tmp << 8;
<> 144:ef7eb2e8f9f7 1636
<> 144:ef7eb2e8f9f7 1637 /* Byte 2 */
<> 144:ef7eb2e8f9f7 1638 tmp = (uint8_t)((hsd->CID[0] & 0x000000FF00) >> 8);
<> 144:ef7eb2e8f9f7 1639 pCardInfo->SD_cid.OEM_AppliID |= tmp;
<> 144:ef7eb2e8f9f7 1640
<> 144:ef7eb2e8f9f7 1641 /* Byte 3 */
<> 144:ef7eb2e8f9f7 1642 tmp = (uint8_t)(hsd->CID[0] & 0x000000FF);
<> 144:ef7eb2e8f9f7 1643 pCardInfo->SD_cid.ProdName1 = tmp << 24;
<> 144:ef7eb2e8f9f7 1644
<> 144:ef7eb2e8f9f7 1645 /* Byte 4 */
<> 144:ef7eb2e8f9f7 1646 tmp = (uint8_t)((hsd->CID[1] & 0xFF000000U) >> 24);
<> 144:ef7eb2e8f9f7 1647 pCardInfo->SD_cid.ProdName1 |= tmp << 16;
<> 144:ef7eb2e8f9f7 1648
<> 144:ef7eb2e8f9f7 1649 /* Byte 5 */
<> 144:ef7eb2e8f9f7 1650 tmp = (uint8_t)((hsd->CID[1] & 0x00FF0000) >> 16);
<> 144:ef7eb2e8f9f7 1651 pCardInfo->SD_cid.ProdName1 |= tmp << 8;
<> 144:ef7eb2e8f9f7 1652
<> 144:ef7eb2e8f9f7 1653 /* Byte 6 */
<> 144:ef7eb2e8f9f7 1654 tmp = (uint8_t)((hsd->CID[1] & 0x0000FF00) >> 8);
<> 144:ef7eb2e8f9f7 1655 pCardInfo->SD_cid.ProdName1 |= tmp;
<> 144:ef7eb2e8f9f7 1656
<> 144:ef7eb2e8f9f7 1657 /* Byte 7 */
<> 144:ef7eb2e8f9f7 1658 tmp = (uint8_t)(hsd->CID[1] & 0x000000FF);
<> 144:ef7eb2e8f9f7 1659 pCardInfo->SD_cid.ProdName2 = tmp;
<> 144:ef7eb2e8f9f7 1660
<> 144:ef7eb2e8f9f7 1661 /* Byte 8 */
<> 144:ef7eb2e8f9f7 1662 tmp = (uint8_t)((hsd->CID[2] & 0xFF000000U) >> 24);
<> 144:ef7eb2e8f9f7 1663 pCardInfo->SD_cid.ProdRev = tmp;
<> 144:ef7eb2e8f9f7 1664
<> 144:ef7eb2e8f9f7 1665 /* Byte 9 */
<> 144:ef7eb2e8f9f7 1666 tmp = (uint8_t)((hsd->CID[2] & 0x00FF0000) >> 16);
<> 144:ef7eb2e8f9f7 1667 pCardInfo->SD_cid.ProdSN = tmp << 24;
<> 144:ef7eb2e8f9f7 1668
<> 144:ef7eb2e8f9f7 1669 /* Byte 10 */
<> 144:ef7eb2e8f9f7 1670 tmp = (uint8_t)((hsd->CID[2] & 0x0000FF00) >> 8);
<> 144:ef7eb2e8f9f7 1671 pCardInfo->SD_cid.ProdSN |= tmp << 16;
<> 144:ef7eb2e8f9f7 1672
<> 144:ef7eb2e8f9f7 1673 /* Byte 11 */
<> 144:ef7eb2e8f9f7 1674 tmp = (uint8_t)(hsd->CID[2] & 0x000000FF);
<> 144:ef7eb2e8f9f7 1675 pCardInfo->SD_cid.ProdSN |= tmp << 8;
<> 144:ef7eb2e8f9f7 1676
<> 144:ef7eb2e8f9f7 1677 /* Byte 12 */
<> 144:ef7eb2e8f9f7 1678 tmp = (uint8_t)((hsd->CID[3] & 0xFF000000U) >> 24);
<> 144:ef7eb2e8f9f7 1679 pCardInfo->SD_cid.ProdSN |= tmp;
<> 144:ef7eb2e8f9f7 1680
<> 144:ef7eb2e8f9f7 1681 /* Byte 13 */
<> 144:ef7eb2e8f9f7 1682 tmp = (uint8_t)((hsd->CID[3] & 0x00FF0000) >> 16);
<> 144:ef7eb2e8f9f7 1683 pCardInfo->SD_cid.Reserved1 |= (tmp & 0xF0) >> 4;
<> 144:ef7eb2e8f9f7 1684 pCardInfo->SD_cid.ManufactDate = (tmp & 0x0F) << 8;
<> 144:ef7eb2e8f9f7 1685
<> 144:ef7eb2e8f9f7 1686 /* Byte 14 */
<> 144:ef7eb2e8f9f7 1687 tmp = (uint8_t)((hsd->CID[3] & 0x0000FF00) >> 8);
<> 144:ef7eb2e8f9f7 1688 pCardInfo->SD_cid.ManufactDate |= tmp;
<> 144:ef7eb2e8f9f7 1689
<> 144:ef7eb2e8f9f7 1690 /* Byte 15 */
<> 144:ef7eb2e8f9f7 1691 tmp = (uint8_t)(hsd->CID[3] & 0x000000FF);
<> 144:ef7eb2e8f9f7 1692 pCardInfo->SD_cid.CID_CRC = (tmp & 0xFE) >> 1;
<> 144:ef7eb2e8f9f7 1693 pCardInfo->SD_cid.Reserved2 = 1;
<> 144:ef7eb2e8f9f7 1694
<> 144:ef7eb2e8f9f7 1695 return errorstate;
<> 144:ef7eb2e8f9f7 1696 }
<> 144:ef7eb2e8f9f7 1697
<> 144:ef7eb2e8f9f7 1698 /**
<> 144:ef7eb2e8f9f7 1699 * @brief Enables wide bus operation for the requested card if supported by
<> 144:ef7eb2e8f9f7 1700 * card.
<> 144:ef7eb2e8f9f7 1701 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 1702 * @param WideMode: Specifies the SD card wide bus mode
<> 144:ef7eb2e8f9f7 1703 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 1704 * @arg SDMMC_BUS_WIDE_8B: 8-bit data transfer (Only for MMC)
<> 144:ef7eb2e8f9f7 1705 * @arg SDMMC_BUS_WIDE_4B: 4-bit data transfer
<> 144:ef7eb2e8f9f7 1706 * @arg SDMMC_BUS_WIDE_1B: 1-bit data transfer
<> 144:ef7eb2e8f9f7 1707 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 1708 */
<> 144:ef7eb2e8f9f7 1709 HAL_SD_ErrorTypedef HAL_SD_WideBusOperation_Config(SD_HandleTypeDef *hsd, uint32_t WideMode)
<> 144:ef7eb2e8f9f7 1710 {
<> 144:ef7eb2e8f9f7 1711 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 1712 SDMMC_InitTypeDef tmpinit;
<> 144:ef7eb2e8f9f7 1713
<> 144:ef7eb2e8f9f7 1714 /* MMC Card does not support this feature */
<> 144:ef7eb2e8f9f7 1715 if (hsd->CardType == MULTIMEDIA_CARD)
<> 144:ef7eb2e8f9f7 1716 {
<> 144:ef7eb2e8f9f7 1717 errorstate = SD_UNSUPPORTED_FEATURE;
<> 144:ef7eb2e8f9f7 1718
<> 144:ef7eb2e8f9f7 1719 return errorstate;
<> 144:ef7eb2e8f9f7 1720 }
<> 144:ef7eb2e8f9f7 1721 else if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
<> 144:ef7eb2e8f9f7 1722 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
<> 144:ef7eb2e8f9f7 1723 {
<> 144:ef7eb2e8f9f7 1724 if (WideMode == SDMMC_BUS_WIDE_8B)
<> 144:ef7eb2e8f9f7 1725 {
<> 144:ef7eb2e8f9f7 1726 errorstate = SD_UNSUPPORTED_FEATURE;
<> 144:ef7eb2e8f9f7 1727 }
<> 144:ef7eb2e8f9f7 1728 else if (WideMode == SDMMC_BUS_WIDE_4B)
<> 144:ef7eb2e8f9f7 1729 {
<> 144:ef7eb2e8f9f7 1730 errorstate = SD_WideBus_Enable(hsd);
<> 144:ef7eb2e8f9f7 1731 }
<> 144:ef7eb2e8f9f7 1732 else if (WideMode == SDMMC_BUS_WIDE_1B)
<> 144:ef7eb2e8f9f7 1733 {
<> 144:ef7eb2e8f9f7 1734 errorstate = SD_WideBus_Disable(hsd);
<> 144:ef7eb2e8f9f7 1735 }
<> 144:ef7eb2e8f9f7 1736 else
<> 144:ef7eb2e8f9f7 1737 {
<> 144:ef7eb2e8f9f7 1738 /* WideMode is not a valid argument*/
<> 144:ef7eb2e8f9f7 1739 errorstate = SD_INVALID_PARAMETER;
<> 144:ef7eb2e8f9f7 1740 }
<> 144:ef7eb2e8f9f7 1741
<> 144:ef7eb2e8f9f7 1742 if (errorstate == SD_OK)
<> 144:ef7eb2e8f9f7 1743 {
<> 144:ef7eb2e8f9f7 1744 /* Configure the SDMMC peripheral */
<> 144:ef7eb2e8f9f7 1745 tmpinit.ClockEdge = hsd->Init.ClockEdge;
<> 144:ef7eb2e8f9f7 1746 tmpinit.ClockBypass = hsd->Init.ClockBypass;
<> 144:ef7eb2e8f9f7 1747 tmpinit.ClockPowerSave = hsd->Init.ClockPowerSave;
<> 144:ef7eb2e8f9f7 1748 tmpinit.BusWide = WideMode;
<> 144:ef7eb2e8f9f7 1749 tmpinit.HardwareFlowControl = hsd->Init.HardwareFlowControl;
<> 144:ef7eb2e8f9f7 1750 tmpinit.ClockDiv = hsd->Init.ClockDiv;
<> 144:ef7eb2e8f9f7 1751 SDMMC_Init(hsd->Instance, tmpinit);
<> 144:ef7eb2e8f9f7 1752 }
<> 144:ef7eb2e8f9f7 1753 }
<> 144:ef7eb2e8f9f7 1754
<> 144:ef7eb2e8f9f7 1755 return errorstate;
<> 144:ef7eb2e8f9f7 1756 }
<> 144:ef7eb2e8f9f7 1757
<> 144:ef7eb2e8f9f7 1758 /**
<> 144:ef7eb2e8f9f7 1759 * @brief Aborts an ongoing data transfer.
<> 144:ef7eb2e8f9f7 1760 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 1761 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 1762 */
<> 144:ef7eb2e8f9f7 1763 HAL_SD_ErrorTypedef HAL_SD_StopTransfer(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 1764 {
<> 144:ef7eb2e8f9f7 1765 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 1766 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 1767
<> 144:ef7eb2e8f9f7 1768 /* Send CMD12 STOP_TRANSMISSION */
<> 144:ef7eb2e8f9f7 1769 sdmmc_cmdinitstructure.Argument = 0;
<> 144:ef7eb2e8f9f7 1770 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_STOP_TRANSMISSION;
<> 144:ef7eb2e8f9f7 1771 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 1772 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 1773 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 1774 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 1775
<> 144:ef7eb2e8f9f7 1776 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 1777 errorstate = SD_CmdResp1Error(hsd, SD_CMD_STOP_TRANSMISSION);
<> 144:ef7eb2e8f9f7 1778
<> 144:ef7eb2e8f9f7 1779 return errorstate;
<> 144:ef7eb2e8f9f7 1780 }
<> 144:ef7eb2e8f9f7 1781
<> 144:ef7eb2e8f9f7 1782 /**
<> 144:ef7eb2e8f9f7 1783 * @brief Switches the SD card to High Speed mode.
<> 144:ef7eb2e8f9f7 1784 * This API must be used after "Transfer State"
<> 144:ef7eb2e8f9f7 1785 * @note This operation should be followed by the configuration
<> 144:ef7eb2e8f9f7 1786 * of PLL to have SDMMCCK clock between 67 and 75 MHz
<> 144:ef7eb2e8f9f7 1787 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 1788 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 1789 */
<> 144:ef7eb2e8f9f7 1790 HAL_SD_ErrorTypedef HAL_SD_HighSpeed (SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 1791 {
<> 144:ef7eb2e8f9f7 1792 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 1793 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 1794 SDMMC_DataInitTypeDef sdmmc_datainitstructure;
<> 144:ef7eb2e8f9f7 1795
<> 144:ef7eb2e8f9f7 1796 uint8_t SD_hs[64] = {0};
<> 144:ef7eb2e8f9f7 1797 uint32_t SD_scr[2] = {0, 0};
<> 144:ef7eb2e8f9f7 1798 uint32_t SD_SPEC = 0 ;
<> 144:ef7eb2e8f9f7 1799 uint32_t count = 0, *tempbuff = (uint32_t *)SD_hs;
<> 144:ef7eb2e8f9f7 1800
<> 144:ef7eb2e8f9f7 1801 /* Initialize the Data control register */
<> 144:ef7eb2e8f9f7 1802 hsd->Instance->DCTRL = 0;
<> 144:ef7eb2e8f9f7 1803
<> 144:ef7eb2e8f9f7 1804 /* Get SCR Register */
<> 144:ef7eb2e8f9f7 1805 errorstate = SD_FindSCR(hsd, SD_scr);
<> 144:ef7eb2e8f9f7 1806
<> 144:ef7eb2e8f9f7 1807 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 1808 {
<> 144:ef7eb2e8f9f7 1809 return errorstate;
<> 144:ef7eb2e8f9f7 1810 }
<> 144:ef7eb2e8f9f7 1811
<> 144:ef7eb2e8f9f7 1812 /* Test the Version supported by the card*/
<> 144:ef7eb2e8f9f7 1813 SD_SPEC = (SD_scr[1] & 0x01000000) | (SD_scr[1] & 0x02000000);
<> 144:ef7eb2e8f9f7 1814
<> 144:ef7eb2e8f9f7 1815 if (SD_SPEC != SD_ALLZERO)
<> 144:ef7eb2e8f9f7 1816 {
<> 144:ef7eb2e8f9f7 1817 /* Set Block Size for Card */
<> 144:ef7eb2e8f9f7 1818 sdmmc_cmdinitstructure.Argument = (uint32_t)64;
<> 144:ef7eb2e8f9f7 1819 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
<> 144:ef7eb2e8f9f7 1820 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 1821 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 1822 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 1823 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 1824
<> 144:ef7eb2e8f9f7 1825 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 1826 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
<> 144:ef7eb2e8f9f7 1827
<> 144:ef7eb2e8f9f7 1828 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 1829 {
<> 144:ef7eb2e8f9f7 1830 return errorstate;
<> 144:ef7eb2e8f9f7 1831 }
<> 144:ef7eb2e8f9f7 1832
<> 144:ef7eb2e8f9f7 1833 /* Configure the SD DPSM (Data Path State Machine) */
<> 144:ef7eb2e8f9f7 1834 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
<> 144:ef7eb2e8f9f7 1835 sdmmc_datainitstructure.DataLength = 64;
<> 144:ef7eb2e8f9f7 1836 sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ;
<> 144:ef7eb2e8f9f7 1837 sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
<> 144:ef7eb2e8f9f7 1838 sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
<> 144:ef7eb2e8f9f7 1839 sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
<> 144:ef7eb2e8f9f7 1840 SDMMC_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
<> 144:ef7eb2e8f9f7 1841
<> 144:ef7eb2e8f9f7 1842 /* Send CMD6 switch mode */
<> 144:ef7eb2e8f9f7 1843 sdmmc_cmdinitstructure.Argument = 0x80FFFF01U;
<> 144:ef7eb2e8f9f7 1844 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_HS_SWITCH;
<> 144:ef7eb2e8f9f7 1845 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 1846
<> 144:ef7eb2e8f9f7 1847 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 1848 errorstate = SD_CmdResp1Error(hsd, SD_CMD_HS_SWITCH);
<> 144:ef7eb2e8f9f7 1849
<> 144:ef7eb2e8f9f7 1850 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 1851 {
<> 144:ef7eb2e8f9f7 1852 return errorstate;
<> 144:ef7eb2e8f9f7 1853 }
<> 144:ef7eb2e8f9f7 1854
<> 144:ef7eb2e8f9f7 1855 while(!__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND))
<> 144:ef7eb2e8f9f7 1856 {
<> 144:ef7eb2e8f9f7 1857 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
<> 144:ef7eb2e8f9f7 1858 {
<> 144:ef7eb2e8f9f7 1859 for (count = 0; count < 8; count++)
<> 144:ef7eb2e8f9f7 1860 {
<> 144:ef7eb2e8f9f7 1861 *(tempbuff + count) = SDMMC_ReadFIFO(hsd->Instance);
<> 144:ef7eb2e8f9f7 1862 }
<> 144:ef7eb2e8f9f7 1863
<> 144:ef7eb2e8f9f7 1864 tempbuff += 8;
<> 144:ef7eb2e8f9f7 1865 }
<> 144:ef7eb2e8f9f7 1866 }
<> 144:ef7eb2e8f9f7 1867
<> 144:ef7eb2e8f9f7 1868 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
<> 144:ef7eb2e8f9f7 1869 {
<> 144:ef7eb2e8f9f7 1870 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
<> 144:ef7eb2e8f9f7 1871
<> 144:ef7eb2e8f9f7 1872 errorstate = SD_DATA_TIMEOUT;
<> 144:ef7eb2e8f9f7 1873
<> 144:ef7eb2e8f9f7 1874 return errorstate;
<> 144:ef7eb2e8f9f7 1875 }
<> 144:ef7eb2e8f9f7 1876 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
<> 144:ef7eb2e8f9f7 1877 {
<> 144:ef7eb2e8f9f7 1878 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
<> 144:ef7eb2e8f9f7 1879
<> 144:ef7eb2e8f9f7 1880 errorstate = SD_DATA_CRC_FAIL;
<> 144:ef7eb2e8f9f7 1881
<> 144:ef7eb2e8f9f7 1882 return errorstate;
<> 144:ef7eb2e8f9f7 1883 }
<> 144:ef7eb2e8f9f7 1884 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
<> 144:ef7eb2e8f9f7 1885 {
<> 144:ef7eb2e8f9f7 1886 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
<> 144:ef7eb2e8f9f7 1887
<> 144:ef7eb2e8f9f7 1888 errorstate = SD_RX_OVERRUN;
<> 144:ef7eb2e8f9f7 1889
<> 144:ef7eb2e8f9f7 1890 return errorstate;
<> 144:ef7eb2e8f9f7 1891 }
<> 144:ef7eb2e8f9f7 1892 else
<> 144:ef7eb2e8f9f7 1893 {
<> 144:ef7eb2e8f9f7 1894 /* No error flag set */
<> 144:ef7eb2e8f9f7 1895 }
<> 144:ef7eb2e8f9f7 1896
<> 144:ef7eb2e8f9f7 1897 count = SD_DATATIMEOUT;
<> 144:ef7eb2e8f9f7 1898
<> 144:ef7eb2e8f9f7 1899 while ((__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXDAVL)) && (count > 0))
<> 144:ef7eb2e8f9f7 1900 {
<> 144:ef7eb2e8f9f7 1901 *tempbuff = SDMMC_ReadFIFO(hsd->Instance);
<> 144:ef7eb2e8f9f7 1902 tempbuff++;
<> 144:ef7eb2e8f9f7 1903 count--;
<> 144:ef7eb2e8f9f7 1904 }
<> 144:ef7eb2e8f9f7 1905
<> 144:ef7eb2e8f9f7 1906 /* Clear all the static flags */
<> 144:ef7eb2e8f9f7 1907 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 1908
<> 144:ef7eb2e8f9f7 1909 /* Test if the switch mode HS is ok */
<> 144:ef7eb2e8f9f7 1910 if ((SD_hs[13]& 2) != 2)
<> 144:ef7eb2e8f9f7 1911 {
<> 144:ef7eb2e8f9f7 1912 errorstate = SD_UNSUPPORTED_FEATURE;
<> 144:ef7eb2e8f9f7 1913 }
<> 144:ef7eb2e8f9f7 1914 }
<> 144:ef7eb2e8f9f7 1915
<> 144:ef7eb2e8f9f7 1916 return errorstate;
<> 144:ef7eb2e8f9f7 1917 }
<> 144:ef7eb2e8f9f7 1918
<> 144:ef7eb2e8f9f7 1919 /**
<> 144:ef7eb2e8f9f7 1920 * @}
<> 144:ef7eb2e8f9f7 1921 */
<> 144:ef7eb2e8f9f7 1922
<> 144:ef7eb2e8f9f7 1923 /** @addtogroup SD_Exported_Functions_Group4
<> 144:ef7eb2e8f9f7 1924 * @brief Peripheral State functions
<> 144:ef7eb2e8f9f7 1925 *
<> 144:ef7eb2e8f9f7 1926 @verbatim
<> 144:ef7eb2e8f9f7 1927 ==============================================================================
<> 144:ef7eb2e8f9f7 1928 ##### Peripheral State functions #####
<> 144:ef7eb2e8f9f7 1929 ==============================================================================
<> 144:ef7eb2e8f9f7 1930 [..]
<> 144:ef7eb2e8f9f7 1931 This subsection permits to get in runtime the status of the peripheral
<> 144:ef7eb2e8f9f7 1932 and the data flow.
<> 144:ef7eb2e8f9f7 1933
<> 144:ef7eb2e8f9f7 1934 @endverbatim
<> 144:ef7eb2e8f9f7 1935 * @{
<> 144:ef7eb2e8f9f7 1936 */
<> 144:ef7eb2e8f9f7 1937
<> 144:ef7eb2e8f9f7 1938 /**
<> 144:ef7eb2e8f9f7 1939 * @brief Returns the current SD card's status.
<> 144:ef7eb2e8f9f7 1940 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 1941 * @param pSDstatus: Pointer to the buffer that will contain the SD card status
<> 144:ef7eb2e8f9f7 1942 * SD Status register)
<> 144:ef7eb2e8f9f7 1943 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 1944 */
<> 144:ef7eb2e8f9f7 1945 HAL_SD_ErrorTypedef HAL_SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
<> 144:ef7eb2e8f9f7 1946 {
<> 144:ef7eb2e8f9f7 1947 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 1948 SDMMC_DataInitTypeDef sdmmc_datainitstructure;
<> 144:ef7eb2e8f9f7 1949 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 1950 uint32_t count = 0;
<> 144:ef7eb2e8f9f7 1951
<> 144:ef7eb2e8f9f7 1952 /* Check SD response */
<> 144:ef7eb2e8f9f7 1953 if ((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
<> 144:ef7eb2e8f9f7 1954 {
<> 144:ef7eb2e8f9f7 1955 errorstate = SD_LOCK_UNLOCK_FAILED;
<> 144:ef7eb2e8f9f7 1956
<> 144:ef7eb2e8f9f7 1957 return errorstate;
<> 144:ef7eb2e8f9f7 1958 }
<> 144:ef7eb2e8f9f7 1959
<> 144:ef7eb2e8f9f7 1960 /* Set block size for card if it is not equal to current block size for card */
<> 144:ef7eb2e8f9f7 1961 sdmmc_cmdinitstructure.Argument = 64;
<> 144:ef7eb2e8f9f7 1962 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
<> 144:ef7eb2e8f9f7 1963 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 1964 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 1965 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 1966 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 1967
<> 144:ef7eb2e8f9f7 1968 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 1969 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
<> 144:ef7eb2e8f9f7 1970
<> 144:ef7eb2e8f9f7 1971 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 1972 {
<> 144:ef7eb2e8f9f7 1973 return errorstate;
<> 144:ef7eb2e8f9f7 1974 }
<> 144:ef7eb2e8f9f7 1975
<> 144:ef7eb2e8f9f7 1976 /* Send CMD55 */
<> 144:ef7eb2e8f9f7 1977 sdmmc_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
<> 144:ef7eb2e8f9f7 1978 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
<> 144:ef7eb2e8f9f7 1979 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 1980
<> 144:ef7eb2e8f9f7 1981 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 1982 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
<> 144:ef7eb2e8f9f7 1983
<> 144:ef7eb2e8f9f7 1984 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 1985 {
<> 144:ef7eb2e8f9f7 1986 return errorstate;
<> 144:ef7eb2e8f9f7 1987 }
<> 144:ef7eb2e8f9f7 1988
<> 144:ef7eb2e8f9f7 1989 /* Configure the SD DPSM (Data Path State Machine) */
<> 144:ef7eb2e8f9f7 1990 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
<> 144:ef7eb2e8f9f7 1991 sdmmc_datainitstructure.DataLength = 64;
<> 144:ef7eb2e8f9f7 1992 sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B;
<> 144:ef7eb2e8f9f7 1993 sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
<> 144:ef7eb2e8f9f7 1994 sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
<> 144:ef7eb2e8f9f7 1995 sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
<> 144:ef7eb2e8f9f7 1996 SDMMC_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
<> 144:ef7eb2e8f9f7 1997
<> 144:ef7eb2e8f9f7 1998 /* Send ACMD13 (SD_APP_STAUS) with argument as card's RCA */
<> 144:ef7eb2e8f9f7 1999 sdmmc_cmdinitstructure.Argument = 0;
<> 144:ef7eb2e8f9f7 2000 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_STATUS;
<> 144:ef7eb2e8f9f7 2001 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 2002
<> 144:ef7eb2e8f9f7 2003 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 2004 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_STATUS);
<> 144:ef7eb2e8f9f7 2005
<> 144:ef7eb2e8f9f7 2006 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 2007 {
<> 144:ef7eb2e8f9f7 2008 return errorstate;
<> 144:ef7eb2e8f9f7 2009 }
<> 144:ef7eb2e8f9f7 2010
<> 144:ef7eb2e8f9f7 2011 /* Get status data */
<> 144:ef7eb2e8f9f7 2012 while(!__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND))
<> 144:ef7eb2e8f9f7 2013 {
<> 144:ef7eb2e8f9f7 2014 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
<> 144:ef7eb2e8f9f7 2015 {
<> 144:ef7eb2e8f9f7 2016 for (count = 0; count < 8; count++)
<> 144:ef7eb2e8f9f7 2017 {
<> 144:ef7eb2e8f9f7 2018 *(pSDstatus + count) = SDMMC_ReadFIFO(hsd->Instance);
<> 144:ef7eb2e8f9f7 2019 }
<> 144:ef7eb2e8f9f7 2020
<> 144:ef7eb2e8f9f7 2021 pSDstatus += 8;
<> 144:ef7eb2e8f9f7 2022 }
<> 144:ef7eb2e8f9f7 2023 }
<> 144:ef7eb2e8f9f7 2024
<> 144:ef7eb2e8f9f7 2025 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
<> 144:ef7eb2e8f9f7 2026 {
<> 144:ef7eb2e8f9f7 2027 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
<> 144:ef7eb2e8f9f7 2028
<> 144:ef7eb2e8f9f7 2029 errorstate = SD_DATA_TIMEOUT;
<> 144:ef7eb2e8f9f7 2030
<> 144:ef7eb2e8f9f7 2031 return errorstate;
<> 144:ef7eb2e8f9f7 2032 }
<> 144:ef7eb2e8f9f7 2033 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
<> 144:ef7eb2e8f9f7 2034 {
<> 144:ef7eb2e8f9f7 2035 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
<> 144:ef7eb2e8f9f7 2036
<> 144:ef7eb2e8f9f7 2037 errorstate = SD_DATA_CRC_FAIL;
<> 144:ef7eb2e8f9f7 2038
<> 144:ef7eb2e8f9f7 2039 return errorstate;
<> 144:ef7eb2e8f9f7 2040 }
<> 144:ef7eb2e8f9f7 2041 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
<> 144:ef7eb2e8f9f7 2042 {
<> 144:ef7eb2e8f9f7 2043 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
<> 144:ef7eb2e8f9f7 2044
<> 144:ef7eb2e8f9f7 2045 errorstate = SD_RX_OVERRUN;
<> 144:ef7eb2e8f9f7 2046
<> 144:ef7eb2e8f9f7 2047 return errorstate;
<> 144:ef7eb2e8f9f7 2048 }
<> 144:ef7eb2e8f9f7 2049 else
<> 144:ef7eb2e8f9f7 2050 {
<> 144:ef7eb2e8f9f7 2051 /* No error flag set */
<> 144:ef7eb2e8f9f7 2052 }
<> 144:ef7eb2e8f9f7 2053
<> 144:ef7eb2e8f9f7 2054 count = SD_DATATIMEOUT;
<> 144:ef7eb2e8f9f7 2055 while ((__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXDAVL)) && (count > 0))
<> 144:ef7eb2e8f9f7 2056 {
<> 144:ef7eb2e8f9f7 2057 *pSDstatus = SDMMC_ReadFIFO(hsd->Instance);
<> 144:ef7eb2e8f9f7 2058 pSDstatus++;
<> 144:ef7eb2e8f9f7 2059 count--;
<> 144:ef7eb2e8f9f7 2060 }
<> 144:ef7eb2e8f9f7 2061
<> 144:ef7eb2e8f9f7 2062 /* Clear all the static status flags*/
<> 144:ef7eb2e8f9f7 2063 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 2064
<> 144:ef7eb2e8f9f7 2065 return errorstate;
<> 144:ef7eb2e8f9f7 2066 }
<> 144:ef7eb2e8f9f7 2067
<> 144:ef7eb2e8f9f7 2068 /**
<> 144:ef7eb2e8f9f7 2069 * @brief Gets the current sd card data status.
<> 144:ef7eb2e8f9f7 2070 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2071 * @retval Data Transfer state
<> 144:ef7eb2e8f9f7 2072 */
<> 144:ef7eb2e8f9f7 2073 HAL_SD_TransferStateTypedef HAL_SD_GetStatus(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 2074 {
<> 144:ef7eb2e8f9f7 2075 HAL_SD_CardStateTypedef cardstate = SD_CARD_TRANSFER;
<> 144:ef7eb2e8f9f7 2076
<> 144:ef7eb2e8f9f7 2077 /* Get SD card state */
<> 144:ef7eb2e8f9f7 2078 cardstate = SD_GetState(hsd);
<> 144:ef7eb2e8f9f7 2079
<> 144:ef7eb2e8f9f7 2080 /* Find SD status according to card state*/
<> 144:ef7eb2e8f9f7 2081 if (cardstate == SD_CARD_TRANSFER)
<> 144:ef7eb2e8f9f7 2082 {
<> 144:ef7eb2e8f9f7 2083 return SD_TRANSFER_OK;
<> 144:ef7eb2e8f9f7 2084 }
<> 144:ef7eb2e8f9f7 2085 else if(cardstate == SD_CARD_ERROR)
<> 144:ef7eb2e8f9f7 2086 {
<> 144:ef7eb2e8f9f7 2087 return SD_TRANSFER_ERROR;
<> 144:ef7eb2e8f9f7 2088 }
<> 144:ef7eb2e8f9f7 2089 else
<> 144:ef7eb2e8f9f7 2090 {
<> 144:ef7eb2e8f9f7 2091 return SD_TRANSFER_BUSY;
<> 144:ef7eb2e8f9f7 2092 }
<> 144:ef7eb2e8f9f7 2093 }
<> 144:ef7eb2e8f9f7 2094
<> 144:ef7eb2e8f9f7 2095 /**
<> 144:ef7eb2e8f9f7 2096 * @brief Gets the SD card status.
<> 144:ef7eb2e8f9f7 2097 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2098 * @param pCardStatus: Pointer to the HAL_SD_CardStatusTypedef structure that
<> 144:ef7eb2e8f9f7 2099 * will contain the SD card status information
<> 144:ef7eb2e8f9f7 2100 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2101 */
<> 144:ef7eb2e8f9f7 2102 HAL_SD_ErrorTypedef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypedef *pCardStatus)
<> 144:ef7eb2e8f9f7 2103 {
<> 144:ef7eb2e8f9f7 2104 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2105 uint32_t tmp = 0;
<> 144:ef7eb2e8f9f7 2106 uint32_t sd_status[16];
<> 144:ef7eb2e8f9f7 2107
<> 144:ef7eb2e8f9f7 2108 errorstate = HAL_SD_SendSDStatus(hsd, sd_status);
<> 144:ef7eb2e8f9f7 2109
<> 144:ef7eb2e8f9f7 2110 if (errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 2111 {
<> 144:ef7eb2e8f9f7 2112 return errorstate;
<> 144:ef7eb2e8f9f7 2113 }
<> 144:ef7eb2e8f9f7 2114
<> 144:ef7eb2e8f9f7 2115 /* Byte 0 */
<> 144:ef7eb2e8f9f7 2116 tmp = (sd_status[0] & 0xC0) >> 6;
<> 144:ef7eb2e8f9f7 2117 pCardStatus->DAT_BUS_WIDTH = (uint8_t)tmp;
<> 144:ef7eb2e8f9f7 2118
<> 144:ef7eb2e8f9f7 2119 /* Byte 0 */
<> 144:ef7eb2e8f9f7 2120 tmp = (sd_status[0] & 0x20) >> 5;
<> 144:ef7eb2e8f9f7 2121 pCardStatus->SECURED_MODE = (uint8_t)tmp;
<> 144:ef7eb2e8f9f7 2122
<> 144:ef7eb2e8f9f7 2123 /* Byte 2 */
<> 144:ef7eb2e8f9f7 2124 tmp = (sd_status[0] & 0x00FF0000) >> 16;
<> 144:ef7eb2e8f9f7 2125 pCardStatus->SD_CARD_TYPE = (uint16_t)(tmp << 8);
<> 144:ef7eb2e8f9f7 2126
<> 144:ef7eb2e8f9f7 2127 /* Byte 3 */
<> 144:ef7eb2e8f9f7 2128 tmp = (sd_status[0] & 0xFF000000) >> 24;
<> 144:ef7eb2e8f9f7 2129 pCardStatus->SD_CARD_TYPE |= (uint16_t)tmp;
<> 144:ef7eb2e8f9f7 2130
<> 144:ef7eb2e8f9f7 2131 /* Byte 4 */
<> 144:ef7eb2e8f9f7 2132 tmp = (sd_status[1] & 0xFF);
<> 144:ef7eb2e8f9f7 2133 pCardStatus->SIZE_OF_PROTECTED_AREA = (uint32_t)(tmp << 24);
<> 144:ef7eb2e8f9f7 2134
<> 144:ef7eb2e8f9f7 2135 /* Byte 5 */
<> 144:ef7eb2e8f9f7 2136 tmp = (sd_status[1] & 0xFF00) >> 8;
<> 144:ef7eb2e8f9f7 2137 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint32_t)(tmp << 16);
<> 144:ef7eb2e8f9f7 2138
<> 144:ef7eb2e8f9f7 2139 /* Byte 6 */
<> 144:ef7eb2e8f9f7 2140 tmp = (sd_status[1] & 0xFF0000) >> 16;
<> 144:ef7eb2e8f9f7 2141 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint32_t)(tmp << 8);
<> 144:ef7eb2e8f9f7 2142
<> 144:ef7eb2e8f9f7 2143 /* Byte 7 */
<> 144:ef7eb2e8f9f7 2144 tmp = (sd_status[1] & 0xFF000000) >> 24;
<> 144:ef7eb2e8f9f7 2145 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint32_t)tmp;
<> 144:ef7eb2e8f9f7 2146
<> 144:ef7eb2e8f9f7 2147 /* Byte 8 */
<> 144:ef7eb2e8f9f7 2148 tmp = (sd_status[2] & 0xFF);
<> 144:ef7eb2e8f9f7 2149 pCardStatus->SPEED_CLASS = (uint8_t)tmp;
<> 144:ef7eb2e8f9f7 2150
<> 144:ef7eb2e8f9f7 2151 /* Byte 9 */
<> 144:ef7eb2e8f9f7 2152 tmp = (sd_status[2] & 0xFF00) >> 8;
<> 144:ef7eb2e8f9f7 2153 pCardStatus->PERFORMANCE_MOVE = (uint8_t)tmp;
<> 144:ef7eb2e8f9f7 2154
<> 144:ef7eb2e8f9f7 2155 /* Byte 10 */
<> 144:ef7eb2e8f9f7 2156 tmp = (sd_status[2] & 0xF00000) >> 20;
<> 144:ef7eb2e8f9f7 2157 pCardStatus->AU_SIZE = (uint8_t)tmp;
<> 144:ef7eb2e8f9f7 2158
<> 144:ef7eb2e8f9f7 2159 /* Byte 11 */
<> 144:ef7eb2e8f9f7 2160 tmp = (sd_status[2] & 0xFF000000) >> 24;
<> 144:ef7eb2e8f9f7 2161 pCardStatus->ERASE_SIZE = (uint16_t)(tmp << 8);
<> 144:ef7eb2e8f9f7 2162
<> 144:ef7eb2e8f9f7 2163 /* Byte 12 */
<> 144:ef7eb2e8f9f7 2164 tmp = (sd_status[3] & 0xFF);
<> 144:ef7eb2e8f9f7 2165 pCardStatus->ERASE_SIZE |= (uint16_t)tmp;
<> 144:ef7eb2e8f9f7 2166
<> 144:ef7eb2e8f9f7 2167 /* Byte 13 */
<> 144:ef7eb2e8f9f7 2168 tmp = (sd_status[3] & 0xFC00) >> 10;
<> 144:ef7eb2e8f9f7 2169 pCardStatus->ERASE_TIMEOUT = (uint8_t)tmp;
<> 144:ef7eb2e8f9f7 2170
<> 144:ef7eb2e8f9f7 2171 /* Byte 13 */
<> 144:ef7eb2e8f9f7 2172 tmp = (sd_status[3] & 0x0300) >> 8;
<> 144:ef7eb2e8f9f7 2173 pCardStatus->ERASE_OFFSET = (uint8_t)tmp;
<> 144:ef7eb2e8f9f7 2174
<> 144:ef7eb2e8f9f7 2175 return errorstate;
<> 144:ef7eb2e8f9f7 2176 }
<> 144:ef7eb2e8f9f7 2177
<> 144:ef7eb2e8f9f7 2178 /**
<> 144:ef7eb2e8f9f7 2179 * @}
<> 144:ef7eb2e8f9f7 2180 */
<> 144:ef7eb2e8f9f7 2181
<> 144:ef7eb2e8f9f7 2182 /**
<> 144:ef7eb2e8f9f7 2183 * @}
<> 144:ef7eb2e8f9f7 2184 */
<> 144:ef7eb2e8f9f7 2185
<> 144:ef7eb2e8f9f7 2186 /* Private function ----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 2187 /** @addtogroup SD_Private_Functions
<> 144:ef7eb2e8f9f7 2188 * @{
<> 144:ef7eb2e8f9f7 2189 */
<> 144:ef7eb2e8f9f7 2190
<> 144:ef7eb2e8f9f7 2191 /**
<> 144:ef7eb2e8f9f7 2192 * @brief SD DMA transfer complete Rx callback.
<> 144:ef7eb2e8f9f7 2193 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2194 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 2195 * @retval None
<> 144:ef7eb2e8f9f7 2196 */
<> 144:ef7eb2e8f9f7 2197 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 2198 {
<> 144:ef7eb2e8f9f7 2199 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
<> 144:ef7eb2e8f9f7 2200
<> 144:ef7eb2e8f9f7 2201 /* DMA transfer is complete */
<> 144:ef7eb2e8f9f7 2202 hsd->DmaTransferCplt = 1;
<> 144:ef7eb2e8f9f7 2203
<> 144:ef7eb2e8f9f7 2204 /* Wait until SD transfer is complete */
<> 144:ef7eb2e8f9f7 2205 while(hsd->SdTransferCplt == 0)
<> 144:ef7eb2e8f9f7 2206 {
<> 144:ef7eb2e8f9f7 2207 }
<> 144:ef7eb2e8f9f7 2208
<> 144:ef7eb2e8f9f7 2209 /* Disable the DMA channel */
<> 144:ef7eb2e8f9f7 2210 HAL_DMA_Abort(hdma);
<> 144:ef7eb2e8f9f7 2211
<> 144:ef7eb2e8f9f7 2212 /* Transfer complete user callback */
<> 144:ef7eb2e8f9f7 2213 HAL_SD_DMA_RxCpltCallback(hsd->hdmarx);
<> 144:ef7eb2e8f9f7 2214 }
<> 144:ef7eb2e8f9f7 2215
<> 144:ef7eb2e8f9f7 2216 /**
<> 144:ef7eb2e8f9f7 2217 * @brief SD DMA transfer Error Rx callback.
<> 144:ef7eb2e8f9f7 2218 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2219 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 2220 * @retval None
<> 144:ef7eb2e8f9f7 2221 */
<> 144:ef7eb2e8f9f7 2222 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 2223 {
<> 144:ef7eb2e8f9f7 2224 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
<> 144:ef7eb2e8f9f7 2225
<> 144:ef7eb2e8f9f7 2226 /* Transfer complete user callback */
<> 144:ef7eb2e8f9f7 2227 HAL_SD_DMA_RxErrorCallback(hsd->hdmarx);
<> 144:ef7eb2e8f9f7 2228 }
<> 144:ef7eb2e8f9f7 2229
<> 144:ef7eb2e8f9f7 2230 /**
<> 144:ef7eb2e8f9f7 2231 * @brief SD DMA transfer complete Tx callback.
<> 144:ef7eb2e8f9f7 2232 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2233 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 2234 * @retval None
<> 144:ef7eb2e8f9f7 2235 */
<> 144:ef7eb2e8f9f7 2236 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 2237 {
<> 144:ef7eb2e8f9f7 2238 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
<> 144:ef7eb2e8f9f7 2239
<> 144:ef7eb2e8f9f7 2240 /* DMA transfer is complete */
<> 144:ef7eb2e8f9f7 2241 hsd->DmaTransferCplt = 1;
<> 144:ef7eb2e8f9f7 2242
<> 144:ef7eb2e8f9f7 2243 /* Wait until SD transfer is complete */
<> 144:ef7eb2e8f9f7 2244 while(hsd->SdTransferCplt == 0)
<> 144:ef7eb2e8f9f7 2245 {
<> 144:ef7eb2e8f9f7 2246 }
<> 144:ef7eb2e8f9f7 2247
<> 144:ef7eb2e8f9f7 2248 /* Disable the DMA channel */
<> 144:ef7eb2e8f9f7 2249 HAL_DMA_Abort(hdma);
<> 144:ef7eb2e8f9f7 2250
<> 144:ef7eb2e8f9f7 2251 /* Transfer complete user callback */
<> 144:ef7eb2e8f9f7 2252 HAL_SD_DMA_TxCpltCallback(hsd->hdmatx);
<> 144:ef7eb2e8f9f7 2253 }
<> 144:ef7eb2e8f9f7 2254
<> 144:ef7eb2e8f9f7 2255 /**
<> 144:ef7eb2e8f9f7 2256 * @brief SD DMA transfer Error Tx callback.
<> 144:ef7eb2e8f9f7 2257 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2258 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 2259 * @retval None
<> 144:ef7eb2e8f9f7 2260 */
<> 144:ef7eb2e8f9f7 2261 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 2262 {
<> 144:ef7eb2e8f9f7 2263 SD_HandleTypeDef *hsd = ( SD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
<> 144:ef7eb2e8f9f7 2264
<> 144:ef7eb2e8f9f7 2265 /* Transfer complete user callback */
<> 144:ef7eb2e8f9f7 2266 HAL_SD_DMA_TxErrorCallback(hsd->hdmatx);
<> 144:ef7eb2e8f9f7 2267 }
<> 144:ef7eb2e8f9f7 2268
<> 144:ef7eb2e8f9f7 2269 /**
<> 144:ef7eb2e8f9f7 2270 * @brief Returns the SD current state.
<> 144:ef7eb2e8f9f7 2271 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2272 * @retval SD card current state
<> 144:ef7eb2e8f9f7 2273 */
<> 144:ef7eb2e8f9f7 2274 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 2275 {
<> 144:ef7eb2e8f9f7 2276 uint32_t resp1 = 0;
<> 144:ef7eb2e8f9f7 2277
<> 144:ef7eb2e8f9f7 2278 if (SD_SendStatus(hsd, &resp1) != SD_OK)
<> 144:ef7eb2e8f9f7 2279 {
<> 144:ef7eb2e8f9f7 2280 return SD_CARD_ERROR;
<> 144:ef7eb2e8f9f7 2281 }
<> 144:ef7eb2e8f9f7 2282 else
<> 144:ef7eb2e8f9f7 2283 {
<> 144:ef7eb2e8f9f7 2284 return (HAL_SD_CardStateTypedef)((resp1 >> 9) & 0x0F);
<> 144:ef7eb2e8f9f7 2285 }
<> 144:ef7eb2e8f9f7 2286 }
<> 144:ef7eb2e8f9f7 2287
<> 144:ef7eb2e8f9f7 2288 /**
<> 144:ef7eb2e8f9f7 2289 * @brief Initializes all cards or single card as the case may be Card(s) come
<> 144:ef7eb2e8f9f7 2290 * into standby state.
<> 144:ef7eb2e8f9f7 2291 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2292 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2293 */
<> 144:ef7eb2e8f9f7 2294 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 2295 {
<> 144:ef7eb2e8f9f7 2296 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 2297 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2298 uint16_t sd_rca = 1;
<> 144:ef7eb2e8f9f7 2299
<> 144:ef7eb2e8f9f7 2300 if(SDMMC_GetPowerState(hsd->Instance) == 0) /* Power off */
<> 144:ef7eb2e8f9f7 2301 {
<> 144:ef7eb2e8f9f7 2302 errorstate = SD_REQUEST_NOT_APPLICABLE;
<> 144:ef7eb2e8f9f7 2303
<> 144:ef7eb2e8f9f7 2304 return errorstate;
<> 144:ef7eb2e8f9f7 2305 }
<> 144:ef7eb2e8f9f7 2306
<> 144:ef7eb2e8f9f7 2307 if(hsd->CardType != SECURE_DIGITAL_IO_CARD)
<> 144:ef7eb2e8f9f7 2308 {
<> 144:ef7eb2e8f9f7 2309 /* Send CMD2 ALL_SEND_CID */
<> 144:ef7eb2e8f9f7 2310 sdmmc_cmdinitstructure.Argument = 0;
<> 144:ef7eb2e8f9f7 2311 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_ALL_SEND_CID;
<> 144:ef7eb2e8f9f7 2312 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_LONG;
<> 144:ef7eb2e8f9f7 2313 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 2314 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 2315 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 2316
<> 144:ef7eb2e8f9f7 2317 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 2318 errorstate = SD_CmdResp2Error(hsd);
<> 144:ef7eb2e8f9f7 2319
<> 144:ef7eb2e8f9f7 2320 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 2321 {
<> 144:ef7eb2e8f9f7 2322 return errorstate;
<> 144:ef7eb2e8f9f7 2323 }
<> 144:ef7eb2e8f9f7 2324
<> 144:ef7eb2e8f9f7 2325 /* Get Card identification number data */
<> 144:ef7eb2e8f9f7 2326 hsd->CID[0] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
<> 144:ef7eb2e8f9f7 2327 hsd->CID[1] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2);
<> 144:ef7eb2e8f9f7 2328 hsd->CID[2] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP3);
<> 144:ef7eb2e8f9f7 2329 hsd->CID[3] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP4);
<> 144:ef7eb2e8f9f7 2330 }
<> 144:ef7eb2e8f9f7 2331
<> 144:ef7eb2e8f9f7 2332 if((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
<> 144:ef7eb2e8f9f7 2333 (hsd->CardType == SECURE_DIGITAL_IO_COMBO_CARD) || (hsd->CardType == HIGH_CAPACITY_SD_CARD))
<> 144:ef7eb2e8f9f7 2334 {
<> 144:ef7eb2e8f9f7 2335 /* Send CMD3 SET_REL_ADDR with argument 0 */
<> 144:ef7eb2e8f9f7 2336 /* SD Card publishes its RCA. */
<> 144:ef7eb2e8f9f7 2337 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_REL_ADDR;
<> 144:ef7eb2e8f9f7 2338 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 2339 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 2340
<> 144:ef7eb2e8f9f7 2341 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 2342 errorstate = SD_CmdResp6Error(hsd, SD_CMD_SET_REL_ADDR, &sd_rca);
<> 144:ef7eb2e8f9f7 2343
<> 144:ef7eb2e8f9f7 2344 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 2345 {
<> 144:ef7eb2e8f9f7 2346 return errorstate;
<> 144:ef7eb2e8f9f7 2347 }
<> 144:ef7eb2e8f9f7 2348 }
<> 144:ef7eb2e8f9f7 2349
<> 144:ef7eb2e8f9f7 2350 if (hsd->CardType != SECURE_DIGITAL_IO_CARD)
<> 144:ef7eb2e8f9f7 2351 {
<> 144:ef7eb2e8f9f7 2352 /* Get the SD card RCA */
<> 144:ef7eb2e8f9f7 2353 hsd->RCA = sd_rca;
<> 144:ef7eb2e8f9f7 2354
<> 144:ef7eb2e8f9f7 2355 /* Send CMD9 SEND_CSD with argument as card's RCA */
<> 144:ef7eb2e8f9f7 2356 sdmmc_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
<> 144:ef7eb2e8f9f7 2357 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SEND_CSD;
<> 144:ef7eb2e8f9f7 2358 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_LONG;
<> 144:ef7eb2e8f9f7 2359 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 2360
<> 144:ef7eb2e8f9f7 2361 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 2362 errorstate = SD_CmdResp2Error(hsd);
<> 144:ef7eb2e8f9f7 2363
<> 144:ef7eb2e8f9f7 2364 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 2365 {
<> 144:ef7eb2e8f9f7 2366 return errorstate;
<> 144:ef7eb2e8f9f7 2367 }
<> 144:ef7eb2e8f9f7 2368
<> 144:ef7eb2e8f9f7 2369 /* Get Card Specific Data */
<> 144:ef7eb2e8f9f7 2370 hsd->CSD[0] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
<> 144:ef7eb2e8f9f7 2371 hsd->CSD[1] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2);
<> 144:ef7eb2e8f9f7 2372 hsd->CSD[2] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP3);
<> 144:ef7eb2e8f9f7 2373 hsd->CSD[3] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP4);
<> 144:ef7eb2e8f9f7 2374 }
<> 144:ef7eb2e8f9f7 2375
<> 144:ef7eb2e8f9f7 2376 /* All cards are initialized */
<> 144:ef7eb2e8f9f7 2377 return errorstate;
<> 144:ef7eb2e8f9f7 2378 }
<> 144:ef7eb2e8f9f7 2379
<> 144:ef7eb2e8f9f7 2380 /**
<> 144:ef7eb2e8f9f7 2381 * @brief Selects od Deselects the corresponding card.
<> 144:ef7eb2e8f9f7 2382 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2383 * @param addr: Address of the card to be selected
<> 144:ef7eb2e8f9f7 2384 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2385 */
<> 144:ef7eb2e8f9f7 2386 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr)
<> 144:ef7eb2e8f9f7 2387 {
<> 144:ef7eb2e8f9f7 2388 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 2389 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2390
<> 144:ef7eb2e8f9f7 2391 /* Send CMD7 SDMMC_SEL_DESEL_CARD */
<> 144:ef7eb2e8f9f7 2392 sdmmc_cmdinitstructure.Argument = (uint32_t)addr;
<> 144:ef7eb2e8f9f7 2393 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SEL_DESEL_CARD;
<> 144:ef7eb2e8f9f7 2394 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 2395 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 2396 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 2397 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 2398
<> 144:ef7eb2e8f9f7 2399 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 2400 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEL_DESEL_CARD);
<> 144:ef7eb2e8f9f7 2401
<> 144:ef7eb2e8f9f7 2402 return errorstate;
<> 144:ef7eb2e8f9f7 2403 }
<> 144:ef7eb2e8f9f7 2404
<> 144:ef7eb2e8f9f7 2405 /**
<> 144:ef7eb2e8f9f7 2406 * @brief Enquires cards about their operating voltage and configures clock
<> 144:ef7eb2e8f9f7 2407 * controls and stores SD information that will be needed in future
<> 144:ef7eb2e8f9f7 2408 * in the SD handle.
<> 144:ef7eb2e8f9f7 2409 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2410 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2411 */
<> 144:ef7eb2e8f9f7 2412 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 2413 {
<> 144:ef7eb2e8f9f7 2414 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 2415 __IO HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2416 uint32_t response = 0, count = 0, validvoltage = 0;
<> 144:ef7eb2e8f9f7 2417 uint32_t sdtype = SD_STD_CAPACITY;
<> 144:ef7eb2e8f9f7 2418
<> 144:ef7eb2e8f9f7 2419 /* Power ON Sequence -------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 2420 /* Disable SDMMC Clock */
<> 144:ef7eb2e8f9f7 2421 __HAL_SD_SDMMC_DISABLE(hsd);
<> 144:ef7eb2e8f9f7 2422
<> 144:ef7eb2e8f9f7 2423 /* Set Power State to ON */
<> 144:ef7eb2e8f9f7 2424 SDMMC_PowerState_ON(hsd->Instance);
<> 144:ef7eb2e8f9f7 2425
<> 144:ef7eb2e8f9f7 2426 /* 1ms: required power up waiting time before starting the SD initialization
<> 144:ef7eb2e8f9f7 2427 sequence */
<> 144:ef7eb2e8f9f7 2428 HAL_Delay(1);
<> 144:ef7eb2e8f9f7 2429
<> 144:ef7eb2e8f9f7 2430 /* Enable SDMMC Clock */
<> 144:ef7eb2e8f9f7 2431 __HAL_SD_SDMMC_ENABLE(hsd);
<> 144:ef7eb2e8f9f7 2432
<> 144:ef7eb2e8f9f7 2433 /* CMD0: GO_IDLE_STATE -----------------------------------------------------*/
<> 144:ef7eb2e8f9f7 2434 /* No CMD response required */
<> 144:ef7eb2e8f9f7 2435 sdmmc_cmdinitstructure.Argument = 0;
<> 144:ef7eb2e8f9f7 2436 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_GO_IDLE_STATE;
<> 144:ef7eb2e8f9f7 2437 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_NO;
<> 144:ef7eb2e8f9f7 2438 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 2439 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 2440 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 2441
<> 144:ef7eb2e8f9f7 2442 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 2443 errorstate = SD_CmdError(hsd);
<> 144:ef7eb2e8f9f7 2444
<> 144:ef7eb2e8f9f7 2445 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 2446 {
<> 144:ef7eb2e8f9f7 2447 /* CMD Response Timeout (wait for CMDSENT flag) */
<> 144:ef7eb2e8f9f7 2448 return errorstate;
<> 144:ef7eb2e8f9f7 2449 }
<> 144:ef7eb2e8f9f7 2450
<> 144:ef7eb2e8f9f7 2451 /* CMD8: SEND_IF_COND ------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 2452 /* Send CMD8 to verify SD card interface operating condition */
<> 144:ef7eb2e8f9f7 2453 /* Argument: - [31:12]: Reserved (shall be set to '0')
<> 144:ef7eb2e8f9f7 2454 - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
<> 144:ef7eb2e8f9f7 2455 - [7:0]: Check Pattern (recommended 0xAA) */
<> 144:ef7eb2e8f9f7 2456 /* CMD Response: R7 */
<> 144:ef7eb2e8f9f7 2457 sdmmc_cmdinitstructure.Argument = SD_CHECK_PATTERN;
<> 144:ef7eb2e8f9f7 2458 sdmmc_cmdinitstructure.CmdIndex = SD_SDMMC_SEND_IF_COND;
<> 144:ef7eb2e8f9f7 2459 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 2460 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 2461
<> 144:ef7eb2e8f9f7 2462 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 2463 errorstate = SD_CmdResp7Error(hsd);
<> 144:ef7eb2e8f9f7 2464
<> 144:ef7eb2e8f9f7 2465 if (errorstate == SD_OK)
<> 144:ef7eb2e8f9f7 2466 {
<> 144:ef7eb2e8f9f7 2467 /* SD Card 2.0 */
<> 144:ef7eb2e8f9f7 2468 hsd->CardType = STD_CAPACITY_SD_CARD_V2_0;
<> 144:ef7eb2e8f9f7 2469 sdtype = SD_HIGH_CAPACITY;
<> 144:ef7eb2e8f9f7 2470 }
<> 144:ef7eb2e8f9f7 2471
<> 144:ef7eb2e8f9f7 2472 /* Send CMD55 */
<> 144:ef7eb2e8f9f7 2473 sdmmc_cmdinitstructure.Argument = 0;
<> 144:ef7eb2e8f9f7 2474 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
<> 144:ef7eb2e8f9f7 2475 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 2476
<> 144:ef7eb2e8f9f7 2477 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 2478 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
<> 144:ef7eb2e8f9f7 2479
<> 144:ef7eb2e8f9f7 2480 /* If errorstate is Command Timeout, it is a MMC card */
<> 144:ef7eb2e8f9f7 2481 /* If errorstate is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)
<> 144:ef7eb2e8f9f7 2482 or SD card 1.x */
<> 144:ef7eb2e8f9f7 2483 if(errorstate == SD_OK)
<> 144:ef7eb2e8f9f7 2484 {
<> 144:ef7eb2e8f9f7 2485 /* SD CARD */
<> 144:ef7eb2e8f9f7 2486 /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
<> 144:ef7eb2e8f9f7 2487 while((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
<> 144:ef7eb2e8f9f7 2488 {
<> 144:ef7eb2e8f9f7 2489
<> 144:ef7eb2e8f9f7 2490 /* SEND CMD55 APP_CMD with RCA as 0 */
<> 144:ef7eb2e8f9f7 2491 sdmmc_cmdinitstructure.Argument = 0;
<> 144:ef7eb2e8f9f7 2492 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
<> 144:ef7eb2e8f9f7 2493 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 2494 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 2495 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 2496 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 2497
<> 144:ef7eb2e8f9f7 2498 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 2499 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
<> 144:ef7eb2e8f9f7 2500
<> 144:ef7eb2e8f9f7 2501 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 2502 {
<> 144:ef7eb2e8f9f7 2503 return errorstate;
<> 144:ef7eb2e8f9f7 2504 }
<> 144:ef7eb2e8f9f7 2505
<> 144:ef7eb2e8f9f7 2506 /* Send CMD41 */
<> 144:ef7eb2e8f9f7 2507 sdmmc_cmdinitstructure.Argument = SD_VOLTAGE_WINDOW_SD | sdtype;
<> 144:ef7eb2e8f9f7 2508 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_OP_COND;
<> 144:ef7eb2e8f9f7 2509 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 2510 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 2511 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 2512 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 2513
<> 144:ef7eb2e8f9f7 2514 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 2515 errorstate = SD_CmdResp3Error(hsd);
<> 144:ef7eb2e8f9f7 2516
<> 144:ef7eb2e8f9f7 2517 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 2518 {
<> 144:ef7eb2e8f9f7 2519 return errorstate;
<> 144:ef7eb2e8f9f7 2520 }
<> 144:ef7eb2e8f9f7 2521
<> 144:ef7eb2e8f9f7 2522 /* Get command response */
<> 144:ef7eb2e8f9f7 2523 response = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
<> 144:ef7eb2e8f9f7 2524
<> 144:ef7eb2e8f9f7 2525 /* Get operating voltage*/
<> 144:ef7eb2e8f9f7 2526 validvoltage = (((response >> 31) == 1) ? 1 : 0);
<> 144:ef7eb2e8f9f7 2527
<> 144:ef7eb2e8f9f7 2528 count++;
<> 144:ef7eb2e8f9f7 2529 }
<> 144:ef7eb2e8f9f7 2530
<> 144:ef7eb2e8f9f7 2531 if(count >= SD_MAX_VOLT_TRIAL)
<> 144:ef7eb2e8f9f7 2532 {
<> 144:ef7eb2e8f9f7 2533 errorstate = SD_INVALID_VOLTRANGE;
<> 144:ef7eb2e8f9f7 2534
<> 144:ef7eb2e8f9f7 2535 return errorstate;
<> 144:ef7eb2e8f9f7 2536 }
<> 144:ef7eb2e8f9f7 2537
<> 144:ef7eb2e8f9f7 2538 if((response & SD_HIGH_CAPACITY) == SD_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
<> 144:ef7eb2e8f9f7 2539 {
<> 144:ef7eb2e8f9f7 2540 hsd->CardType = HIGH_CAPACITY_SD_CARD;
<> 144:ef7eb2e8f9f7 2541 }
<> 144:ef7eb2e8f9f7 2542
<> 144:ef7eb2e8f9f7 2543 } /* else MMC Card */
<> 144:ef7eb2e8f9f7 2544
<> 144:ef7eb2e8f9f7 2545 return errorstate;
<> 144:ef7eb2e8f9f7 2546 }
<> 144:ef7eb2e8f9f7 2547
<> 144:ef7eb2e8f9f7 2548 /**
<> 144:ef7eb2e8f9f7 2549 * @brief Turns the SDMMC output signals off.
<> 144:ef7eb2e8f9f7 2550 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2551 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2552 */
<> 144:ef7eb2e8f9f7 2553 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 2554 {
<> 144:ef7eb2e8f9f7 2555 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2556
<> 144:ef7eb2e8f9f7 2557 /* Set Power State to OFF */
<> 144:ef7eb2e8f9f7 2558 SDMMC_PowerState_OFF(hsd->Instance);
<> 144:ef7eb2e8f9f7 2559
<> 144:ef7eb2e8f9f7 2560 return errorstate;
<> 144:ef7eb2e8f9f7 2561 }
<> 144:ef7eb2e8f9f7 2562
<> 144:ef7eb2e8f9f7 2563 /**
<> 144:ef7eb2e8f9f7 2564 * @brief Returns the current card's status.
<> 144:ef7eb2e8f9f7 2565 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2566 * @param pCardStatus: pointer to the buffer that will contain the SD card
<> 144:ef7eb2e8f9f7 2567 * status (Card Status register)
<> 144:ef7eb2e8f9f7 2568 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2569 */
<> 144:ef7eb2e8f9f7 2570 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
<> 144:ef7eb2e8f9f7 2571 {
<> 144:ef7eb2e8f9f7 2572 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 2573 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2574
<> 144:ef7eb2e8f9f7 2575 if(pCardStatus == NULL)
<> 144:ef7eb2e8f9f7 2576 {
<> 144:ef7eb2e8f9f7 2577 errorstate = SD_INVALID_PARAMETER;
<> 144:ef7eb2e8f9f7 2578
<> 144:ef7eb2e8f9f7 2579 return errorstate;
<> 144:ef7eb2e8f9f7 2580 }
<> 144:ef7eb2e8f9f7 2581
<> 144:ef7eb2e8f9f7 2582 /* Send Status command */
<> 144:ef7eb2e8f9f7 2583 sdmmc_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
<> 144:ef7eb2e8f9f7 2584 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SEND_STATUS;
<> 144:ef7eb2e8f9f7 2585 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 2586 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 2587 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 2588 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 2589
<> 144:ef7eb2e8f9f7 2590 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 2591 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SEND_STATUS);
<> 144:ef7eb2e8f9f7 2592
<> 144:ef7eb2e8f9f7 2593 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 2594 {
<> 144:ef7eb2e8f9f7 2595 return errorstate;
<> 144:ef7eb2e8f9f7 2596 }
<> 144:ef7eb2e8f9f7 2597
<> 144:ef7eb2e8f9f7 2598 /* Get SD card status */
<> 144:ef7eb2e8f9f7 2599 *pCardStatus = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
<> 144:ef7eb2e8f9f7 2600
<> 144:ef7eb2e8f9f7 2601 return errorstate;
<> 144:ef7eb2e8f9f7 2602 }
<> 144:ef7eb2e8f9f7 2603
<> 144:ef7eb2e8f9f7 2604 /**
<> 144:ef7eb2e8f9f7 2605 * @brief Checks for error conditions for CMD0.
<> 144:ef7eb2e8f9f7 2606 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2607 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2608 */
<> 144:ef7eb2e8f9f7 2609 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 2610 {
<> 144:ef7eb2e8f9f7 2611 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2612 uint32_t timeout, tmp;
<> 144:ef7eb2e8f9f7 2613
<> 144:ef7eb2e8f9f7 2614 timeout = SDMMC_CMD0TIMEOUT;
<> 144:ef7eb2e8f9f7 2615
<> 144:ef7eb2e8f9f7 2616 tmp = __HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CMDSENT);
<> 144:ef7eb2e8f9f7 2617
<> 144:ef7eb2e8f9f7 2618 while((timeout > 0) && (!tmp))
<> 144:ef7eb2e8f9f7 2619 {
<> 144:ef7eb2e8f9f7 2620 tmp = __HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CMDSENT);
<> 144:ef7eb2e8f9f7 2621 timeout--;
<> 144:ef7eb2e8f9f7 2622 }
<> 144:ef7eb2e8f9f7 2623
<> 144:ef7eb2e8f9f7 2624 if(timeout == 0)
<> 144:ef7eb2e8f9f7 2625 {
<> 144:ef7eb2e8f9f7 2626 errorstate = SD_CMD_RSP_TIMEOUT;
<> 144:ef7eb2e8f9f7 2627 return errorstate;
<> 144:ef7eb2e8f9f7 2628 }
<> 144:ef7eb2e8f9f7 2629
<> 144:ef7eb2e8f9f7 2630 /* Clear all the static flags */
<> 144:ef7eb2e8f9f7 2631 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 2632
<> 144:ef7eb2e8f9f7 2633 return errorstate;
<> 144:ef7eb2e8f9f7 2634 }
<> 144:ef7eb2e8f9f7 2635
<> 144:ef7eb2e8f9f7 2636 /**
<> 144:ef7eb2e8f9f7 2637 * @brief Checks for error conditions for R7 response.
<> 144:ef7eb2e8f9f7 2638 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2639 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2640 */
<> 144:ef7eb2e8f9f7 2641 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 2642 {
<> 144:ef7eb2e8f9f7 2643 HAL_SD_ErrorTypedef errorstate = SD_ERROR;
<> 144:ef7eb2e8f9f7 2644 uint32_t timeout = SDMMC_CMD0TIMEOUT, tmp;
<> 144:ef7eb2e8f9f7 2645
<> 144:ef7eb2e8f9f7 2646 tmp = __HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT);
<> 144:ef7eb2e8f9f7 2647
<> 144:ef7eb2e8f9f7 2648 while((!tmp) && (timeout > 0))
<> 144:ef7eb2e8f9f7 2649 {
<> 144:ef7eb2e8f9f7 2650 tmp = __HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT);
<> 144:ef7eb2e8f9f7 2651 timeout--;
<> 144:ef7eb2e8f9f7 2652 }
<> 144:ef7eb2e8f9f7 2653
<> 144:ef7eb2e8f9f7 2654 tmp = __HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CTIMEOUT);
<> 144:ef7eb2e8f9f7 2655
<> 144:ef7eb2e8f9f7 2656 if((timeout == 0) || tmp)
<> 144:ef7eb2e8f9f7 2657 {
<> 144:ef7eb2e8f9f7 2658 /* Card is not V2.0 compliant or card does not support the set voltage range */
<> 144:ef7eb2e8f9f7 2659 errorstate = SD_CMD_RSP_TIMEOUT;
<> 144:ef7eb2e8f9f7 2660
<> 144:ef7eb2e8f9f7 2661 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_CTIMEOUT);
<> 144:ef7eb2e8f9f7 2662
<> 144:ef7eb2e8f9f7 2663 return errorstate;
<> 144:ef7eb2e8f9f7 2664 }
<> 144:ef7eb2e8f9f7 2665
<> 144:ef7eb2e8f9f7 2666 if(__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CMDREND))
<> 144:ef7eb2e8f9f7 2667 {
<> 144:ef7eb2e8f9f7 2668 /* Card is SD V2.0 compliant */
<> 144:ef7eb2e8f9f7 2669 errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2670
<> 144:ef7eb2e8f9f7 2671 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_CMDREND);
<> 144:ef7eb2e8f9f7 2672
<> 144:ef7eb2e8f9f7 2673 return errorstate;
<> 144:ef7eb2e8f9f7 2674 }
<> 144:ef7eb2e8f9f7 2675
<> 144:ef7eb2e8f9f7 2676 return errorstate;
<> 144:ef7eb2e8f9f7 2677 }
<> 144:ef7eb2e8f9f7 2678
<> 144:ef7eb2e8f9f7 2679 /**
<> 144:ef7eb2e8f9f7 2680 * @brief Checks for error conditions for R1 response.
<> 144:ef7eb2e8f9f7 2681 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2682 * @param SD_CMD: The sent command index
<> 144:ef7eb2e8f9f7 2683 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2684 */
<> 144:ef7eb2e8f9f7 2685 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD)
<> 144:ef7eb2e8f9f7 2686 {
<> 144:ef7eb2e8f9f7 2687 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2688 uint32_t response_r1;
<> 144:ef7eb2e8f9f7 2689
<> 144:ef7eb2e8f9f7 2690 while(!__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT))
<> 144:ef7eb2e8f9f7 2691 {
<> 144:ef7eb2e8f9f7 2692 }
<> 144:ef7eb2e8f9f7 2693
<> 144:ef7eb2e8f9f7 2694 if(__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CTIMEOUT))
<> 144:ef7eb2e8f9f7 2695 {
<> 144:ef7eb2e8f9f7 2696 errorstate = SD_CMD_RSP_TIMEOUT;
<> 144:ef7eb2e8f9f7 2697
<> 144:ef7eb2e8f9f7 2698 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_CTIMEOUT);
<> 144:ef7eb2e8f9f7 2699
<> 144:ef7eb2e8f9f7 2700 return errorstate;
<> 144:ef7eb2e8f9f7 2701 }
<> 144:ef7eb2e8f9f7 2702 else if(__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CCRCFAIL))
<> 144:ef7eb2e8f9f7 2703 {
<> 144:ef7eb2e8f9f7 2704 errorstate = SD_CMD_CRC_FAIL;
<> 144:ef7eb2e8f9f7 2705
<> 144:ef7eb2e8f9f7 2706 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_CCRCFAIL);
<> 144:ef7eb2e8f9f7 2707
<> 144:ef7eb2e8f9f7 2708 return errorstate;
<> 144:ef7eb2e8f9f7 2709 }
<> 144:ef7eb2e8f9f7 2710
<> 144:ef7eb2e8f9f7 2711 /* Check response received is of desired command */
<> 144:ef7eb2e8f9f7 2712 if(SDMMC_GetCommandResponse(hsd->Instance) != SD_CMD)
<> 144:ef7eb2e8f9f7 2713 {
<> 144:ef7eb2e8f9f7 2714 errorstate = SD_ILLEGAL_CMD;
<> 144:ef7eb2e8f9f7 2715
<> 144:ef7eb2e8f9f7 2716 return errorstate;
<> 144:ef7eb2e8f9f7 2717 }
<> 144:ef7eb2e8f9f7 2718
<> 144:ef7eb2e8f9f7 2719 /* Clear all the static flags */
<> 144:ef7eb2e8f9f7 2720 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 2721
<> 144:ef7eb2e8f9f7 2722 /* We have received response, retrieve it for analysis */
<> 144:ef7eb2e8f9f7 2723 response_r1 = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
<> 144:ef7eb2e8f9f7 2724
<> 144:ef7eb2e8f9f7 2725 if((response_r1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
<> 144:ef7eb2e8f9f7 2726 {
<> 144:ef7eb2e8f9f7 2727 return errorstate;
<> 144:ef7eb2e8f9f7 2728 }
<> 144:ef7eb2e8f9f7 2729
<> 144:ef7eb2e8f9f7 2730 if((response_r1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
<> 144:ef7eb2e8f9f7 2731 {
<> 144:ef7eb2e8f9f7 2732 return(SD_ADDR_OUT_OF_RANGE);
<> 144:ef7eb2e8f9f7 2733 }
<> 144:ef7eb2e8f9f7 2734
<> 144:ef7eb2e8f9f7 2735 if((response_r1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
<> 144:ef7eb2e8f9f7 2736 {
<> 144:ef7eb2e8f9f7 2737 return(SD_ADDR_MISALIGNED);
<> 144:ef7eb2e8f9f7 2738 }
<> 144:ef7eb2e8f9f7 2739
<> 144:ef7eb2e8f9f7 2740 if((response_r1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
<> 144:ef7eb2e8f9f7 2741 {
<> 144:ef7eb2e8f9f7 2742 return(SD_BLOCK_LEN_ERR);
<> 144:ef7eb2e8f9f7 2743 }
<> 144:ef7eb2e8f9f7 2744
<> 144:ef7eb2e8f9f7 2745 if((response_r1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
<> 144:ef7eb2e8f9f7 2746 {
<> 144:ef7eb2e8f9f7 2747 return(SD_ERASE_SEQ_ERR);
<> 144:ef7eb2e8f9f7 2748 }
<> 144:ef7eb2e8f9f7 2749
<> 144:ef7eb2e8f9f7 2750 if((response_r1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
<> 144:ef7eb2e8f9f7 2751 {
<> 144:ef7eb2e8f9f7 2752 return(SD_BAD_ERASE_PARAM);
<> 144:ef7eb2e8f9f7 2753 }
<> 144:ef7eb2e8f9f7 2754
<> 144:ef7eb2e8f9f7 2755 if((response_r1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
<> 144:ef7eb2e8f9f7 2756 {
<> 144:ef7eb2e8f9f7 2757 return(SD_WRITE_PROT_VIOLATION);
<> 144:ef7eb2e8f9f7 2758 }
<> 144:ef7eb2e8f9f7 2759
<> 144:ef7eb2e8f9f7 2760 if((response_r1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
<> 144:ef7eb2e8f9f7 2761 {
<> 144:ef7eb2e8f9f7 2762 return(SD_LOCK_UNLOCK_FAILED);
<> 144:ef7eb2e8f9f7 2763 }
<> 144:ef7eb2e8f9f7 2764
<> 144:ef7eb2e8f9f7 2765 if((response_r1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
<> 144:ef7eb2e8f9f7 2766 {
<> 144:ef7eb2e8f9f7 2767 return(SD_COM_CRC_FAILED);
<> 144:ef7eb2e8f9f7 2768 }
<> 144:ef7eb2e8f9f7 2769
<> 144:ef7eb2e8f9f7 2770 if((response_r1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
<> 144:ef7eb2e8f9f7 2771 {
<> 144:ef7eb2e8f9f7 2772 return(SD_ILLEGAL_CMD);
<> 144:ef7eb2e8f9f7 2773 }
<> 144:ef7eb2e8f9f7 2774
<> 144:ef7eb2e8f9f7 2775 if((response_r1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
<> 144:ef7eb2e8f9f7 2776 {
<> 144:ef7eb2e8f9f7 2777 return(SD_CARD_ECC_FAILED);
<> 144:ef7eb2e8f9f7 2778 }
<> 144:ef7eb2e8f9f7 2779
<> 144:ef7eb2e8f9f7 2780 if((response_r1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
<> 144:ef7eb2e8f9f7 2781 {
<> 144:ef7eb2e8f9f7 2782 return(SD_CC_ERROR);
<> 144:ef7eb2e8f9f7 2783 }
<> 144:ef7eb2e8f9f7 2784
<> 144:ef7eb2e8f9f7 2785 if((response_r1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
<> 144:ef7eb2e8f9f7 2786 {
<> 144:ef7eb2e8f9f7 2787 return(SD_GENERAL_UNKNOWN_ERROR);
<> 144:ef7eb2e8f9f7 2788 }
<> 144:ef7eb2e8f9f7 2789
<> 144:ef7eb2e8f9f7 2790 if((response_r1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
<> 144:ef7eb2e8f9f7 2791 {
<> 144:ef7eb2e8f9f7 2792 return(SD_STREAM_READ_UNDERRUN);
<> 144:ef7eb2e8f9f7 2793 }
<> 144:ef7eb2e8f9f7 2794
<> 144:ef7eb2e8f9f7 2795 if((response_r1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
<> 144:ef7eb2e8f9f7 2796 {
<> 144:ef7eb2e8f9f7 2797 return(SD_STREAM_WRITE_OVERRUN);
<> 144:ef7eb2e8f9f7 2798 }
<> 144:ef7eb2e8f9f7 2799
<> 144:ef7eb2e8f9f7 2800 if((response_r1 & SD_OCR_CID_CSD_OVERWRITE) == SD_OCR_CID_CSD_OVERWRITE)
<> 144:ef7eb2e8f9f7 2801 {
<> 144:ef7eb2e8f9f7 2802 return(SD_CID_CSD_OVERWRITE);
<> 144:ef7eb2e8f9f7 2803 }
<> 144:ef7eb2e8f9f7 2804
<> 144:ef7eb2e8f9f7 2805 if((response_r1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
<> 144:ef7eb2e8f9f7 2806 {
<> 144:ef7eb2e8f9f7 2807 return(SD_WP_ERASE_SKIP);
<> 144:ef7eb2e8f9f7 2808 }
<> 144:ef7eb2e8f9f7 2809
<> 144:ef7eb2e8f9f7 2810 if((response_r1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
<> 144:ef7eb2e8f9f7 2811 {
<> 144:ef7eb2e8f9f7 2812 return(SD_CARD_ECC_DISABLED);
<> 144:ef7eb2e8f9f7 2813 }
<> 144:ef7eb2e8f9f7 2814
<> 144:ef7eb2e8f9f7 2815 if((response_r1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
<> 144:ef7eb2e8f9f7 2816 {
<> 144:ef7eb2e8f9f7 2817 return(SD_ERASE_RESET);
<> 144:ef7eb2e8f9f7 2818 }
<> 144:ef7eb2e8f9f7 2819
<> 144:ef7eb2e8f9f7 2820 if((response_r1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
<> 144:ef7eb2e8f9f7 2821 {
<> 144:ef7eb2e8f9f7 2822 return(SD_AKE_SEQ_ERROR);
<> 144:ef7eb2e8f9f7 2823 }
<> 144:ef7eb2e8f9f7 2824
<> 144:ef7eb2e8f9f7 2825 return errorstate;
<> 144:ef7eb2e8f9f7 2826 }
<> 144:ef7eb2e8f9f7 2827
<> 144:ef7eb2e8f9f7 2828 /**
<> 144:ef7eb2e8f9f7 2829 * @brief Checks for error conditions for R3 (OCR) response.
<> 144:ef7eb2e8f9f7 2830 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2831 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2832 */
<> 144:ef7eb2e8f9f7 2833 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 2834 {
<> 144:ef7eb2e8f9f7 2835 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2836
<> 144:ef7eb2e8f9f7 2837 while (!__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT))
<> 144:ef7eb2e8f9f7 2838 {
<> 144:ef7eb2e8f9f7 2839 }
<> 144:ef7eb2e8f9f7 2840
<> 144:ef7eb2e8f9f7 2841 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CTIMEOUT))
<> 144:ef7eb2e8f9f7 2842 {
<> 144:ef7eb2e8f9f7 2843 errorstate = SD_CMD_RSP_TIMEOUT;
<> 144:ef7eb2e8f9f7 2844
<> 144:ef7eb2e8f9f7 2845 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_CTIMEOUT);
<> 144:ef7eb2e8f9f7 2846
<> 144:ef7eb2e8f9f7 2847 return errorstate;
<> 144:ef7eb2e8f9f7 2848 }
<> 144:ef7eb2e8f9f7 2849
<> 144:ef7eb2e8f9f7 2850 /* Clear all the static flags */
<> 144:ef7eb2e8f9f7 2851 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 2852
<> 144:ef7eb2e8f9f7 2853 return errorstate;
<> 144:ef7eb2e8f9f7 2854 }
<> 144:ef7eb2e8f9f7 2855
<> 144:ef7eb2e8f9f7 2856 /**
<> 144:ef7eb2e8f9f7 2857 * @brief Checks for error conditions for R2 (CID or CSD) response.
<> 144:ef7eb2e8f9f7 2858 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2859 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2860 */
<> 144:ef7eb2e8f9f7 2861 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 2862 {
<> 144:ef7eb2e8f9f7 2863 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2864
<> 144:ef7eb2e8f9f7 2865 while (!__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT))
<> 144:ef7eb2e8f9f7 2866 {
<> 144:ef7eb2e8f9f7 2867 }
<> 144:ef7eb2e8f9f7 2868
<> 144:ef7eb2e8f9f7 2869 if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CTIMEOUT))
<> 144:ef7eb2e8f9f7 2870 {
<> 144:ef7eb2e8f9f7 2871 errorstate = SD_CMD_RSP_TIMEOUT;
<> 144:ef7eb2e8f9f7 2872
<> 144:ef7eb2e8f9f7 2873 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_CTIMEOUT);
<> 144:ef7eb2e8f9f7 2874
<> 144:ef7eb2e8f9f7 2875 return errorstate;
<> 144:ef7eb2e8f9f7 2876 }
<> 144:ef7eb2e8f9f7 2877 else if (__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CCRCFAIL))
<> 144:ef7eb2e8f9f7 2878 {
<> 144:ef7eb2e8f9f7 2879 errorstate = SD_CMD_CRC_FAIL;
<> 144:ef7eb2e8f9f7 2880
<> 144:ef7eb2e8f9f7 2881 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_CCRCFAIL);
<> 144:ef7eb2e8f9f7 2882
<> 144:ef7eb2e8f9f7 2883 return errorstate;
<> 144:ef7eb2e8f9f7 2884 }
<> 144:ef7eb2e8f9f7 2885 else
<> 144:ef7eb2e8f9f7 2886 {
<> 144:ef7eb2e8f9f7 2887 /* No error flag set */
<> 144:ef7eb2e8f9f7 2888 }
<> 144:ef7eb2e8f9f7 2889
<> 144:ef7eb2e8f9f7 2890 /* Clear all the static flags */
<> 144:ef7eb2e8f9f7 2891 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 2892
<> 144:ef7eb2e8f9f7 2893 return errorstate;
<> 144:ef7eb2e8f9f7 2894 }
<> 144:ef7eb2e8f9f7 2895
<> 144:ef7eb2e8f9f7 2896 /**
<> 144:ef7eb2e8f9f7 2897 * @brief Checks for error conditions for R6 (RCA) response.
<> 144:ef7eb2e8f9f7 2898 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2899 * @param SD_CMD: The sent command index
<> 144:ef7eb2e8f9f7 2900 * @param pRCA: Pointer to the variable that will contain the SD card relative
<> 144:ef7eb2e8f9f7 2901 * address RCA
<> 144:ef7eb2e8f9f7 2902 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2903 */
<> 144:ef7eb2e8f9f7 2904 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA)
<> 144:ef7eb2e8f9f7 2905 {
<> 144:ef7eb2e8f9f7 2906 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2907 uint32_t response_r1;
<> 144:ef7eb2e8f9f7 2908
<> 144:ef7eb2e8f9f7 2909 while(!__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT))
<> 144:ef7eb2e8f9f7 2910 {
<> 144:ef7eb2e8f9f7 2911 }
<> 144:ef7eb2e8f9f7 2912
<> 144:ef7eb2e8f9f7 2913 if(__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CTIMEOUT))
<> 144:ef7eb2e8f9f7 2914 {
<> 144:ef7eb2e8f9f7 2915 errorstate = SD_CMD_RSP_TIMEOUT;
<> 144:ef7eb2e8f9f7 2916
<> 144:ef7eb2e8f9f7 2917 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_CTIMEOUT);
<> 144:ef7eb2e8f9f7 2918
<> 144:ef7eb2e8f9f7 2919 return errorstate;
<> 144:ef7eb2e8f9f7 2920 }
<> 144:ef7eb2e8f9f7 2921 else if(__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CCRCFAIL))
<> 144:ef7eb2e8f9f7 2922 {
<> 144:ef7eb2e8f9f7 2923 errorstate = SD_CMD_CRC_FAIL;
<> 144:ef7eb2e8f9f7 2924
<> 144:ef7eb2e8f9f7 2925 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_CCRCFAIL);
<> 144:ef7eb2e8f9f7 2926
<> 144:ef7eb2e8f9f7 2927 return errorstate;
<> 144:ef7eb2e8f9f7 2928 }
<> 144:ef7eb2e8f9f7 2929 else
<> 144:ef7eb2e8f9f7 2930 {
<> 144:ef7eb2e8f9f7 2931 /* No error flag set */
<> 144:ef7eb2e8f9f7 2932 }
<> 144:ef7eb2e8f9f7 2933
<> 144:ef7eb2e8f9f7 2934 /* Check response received is of desired command */
<> 144:ef7eb2e8f9f7 2935 if(SDMMC_GetCommandResponse(hsd->Instance) != SD_CMD)
<> 144:ef7eb2e8f9f7 2936 {
<> 144:ef7eb2e8f9f7 2937 errorstate = SD_ILLEGAL_CMD;
<> 144:ef7eb2e8f9f7 2938
<> 144:ef7eb2e8f9f7 2939 return errorstate;
<> 144:ef7eb2e8f9f7 2940 }
<> 144:ef7eb2e8f9f7 2941
<> 144:ef7eb2e8f9f7 2942 /* Clear all the static flags */
<> 144:ef7eb2e8f9f7 2943 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 2944
<> 144:ef7eb2e8f9f7 2945 /* We have received response, retrieve it. */
<> 144:ef7eb2e8f9f7 2946 response_r1 = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
<> 144:ef7eb2e8f9f7 2947
<> 144:ef7eb2e8f9f7 2948 if((response_r1 & (SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD | SD_R6_COM_CRC_FAILED)) == SD_ALLZERO)
<> 144:ef7eb2e8f9f7 2949 {
<> 144:ef7eb2e8f9f7 2950 *pRCA = (uint16_t) (response_r1 >> 16);
<> 144:ef7eb2e8f9f7 2951
<> 144:ef7eb2e8f9f7 2952 return errorstate;
<> 144:ef7eb2e8f9f7 2953 }
<> 144:ef7eb2e8f9f7 2954
<> 144:ef7eb2e8f9f7 2955 if((response_r1 & SD_R6_GENERAL_UNKNOWN_ERROR) == SD_R6_GENERAL_UNKNOWN_ERROR)
<> 144:ef7eb2e8f9f7 2956 {
<> 144:ef7eb2e8f9f7 2957 return(SD_GENERAL_UNKNOWN_ERROR);
<> 144:ef7eb2e8f9f7 2958 }
<> 144:ef7eb2e8f9f7 2959
<> 144:ef7eb2e8f9f7 2960 if((response_r1 & SD_R6_ILLEGAL_CMD) == SD_R6_ILLEGAL_CMD)
<> 144:ef7eb2e8f9f7 2961 {
<> 144:ef7eb2e8f9f7 2962 return(SD_ILLEGAL_CMD);
<> 144:ef7eb2e8f9f7 2963 }
<> 144:ef7eb2e8f9f7 2964
<> 144:ef7eb2e8f9f7 2965 if((response_r1 & SD_R6_COM_CRC_FAILED) == SD_R6_COM_CRC_FAILED)
<> 144:ef7eb2e8f9f7 2966 {
<> 144:ef7eb2e8f9f7 2967 return(SD_COM_CRC_FAILED);
<> 144:ef7eb2e8f9f7 2968 }
<> 144:ef7eb2e8f9f7 2969
<> 144:ef7eb2e8f9f7 2970 return errorstate;
<> 144:ef7eb2e8f9f7 2971 }
<> 144:ef7eb2e8f9f7 2972
<> 144:ef7eb2e8f9f7 2973 /**
<> 144:ef7eb2e8f9f7 2974 * @brief Enables the SDMMC wide bus mode.
<> 144:ef7eb2e8f9f7 2975 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 2976 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 2977 */
<> 144:ef7eb2e8f9f7 2978 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 2979 {
<> 144:ef7eb2e8f9f7 2980 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 2981 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 2982
<> 144:ef7eb2e8f9f7 2983 uint32_t scr[2] = {0, 0};
<> 144:ef7eb2e8f9f7 2984
<> 144:ef7eb2e8f9f7 2985 if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
<> 144:ef7eb2e8f9f7 2986 {
<> 144:ef7eb2e8f9f7 2987 errorstate = SD_LOCK_UNLOCK_FAILED;
<> 144:ef7eb2e8f9f7 2988
<> 144:ef7eb2e8f9f7 2989 return errorstate;
<> 144:ef7eb2e8f9f7 2990 }
<> 144:ef7eb2e8f9f7 2991
<> 144:ef7eb2e8f9f7 2992 /* Get SCR Register */
<> 144:ef7eb2e8f9f7 2993 errorstate = SD_FindSCR(hsd, scr);
<> 144:ef7eb2e8f9f7 2994
<> 144:ef7eb2e8f9f7 2995 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 2996 {
<> 144:ef7eb2e8f9f7 2997 return errorstate;
<> 144:ef7eb2e8f9f7 2998 }
<> 144:ef7eb2e8f9f7 2999
<> 144:ef7eb2e8f9f7 3000 /* If requested card supports wide bus operation */
<> 144:ef7eb2e8f9f7 3001 if((scr[1] & SD_WIDE_BUS_SUPPORT) != SD_ALLZERO)
<> 144:ef7eb2e8f9f7 3002 {
<> 144:ef7eb2e8f9f7 3003 /* Send CMD55 APP_CMD with argument as card's RCA.*/
<> 144:ef7eb2e8f9f7 3004 sdmmc_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
<> 144:ef7eb2e8f9f7 3005 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
<> 144:ef7eb2e8f9f7 3006 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 3007 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 3008 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 3009 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 3010
<> 144:ef7eb2e8f9f7 3011 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 3012 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
<> 144:ef7eb2e8f9f7 3013
<> 144:ef7eb2e8f9f7 3014 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 3015 {
<> 144:ef7eb2e8f9f7 3016 return errorstate;
<> 144:ef7eb2e8f9f7 3017 }
<> 144:ef7eb2e8f9f7 3018
<> 144:ef7eb2e8f9f7 3019 /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
<> 144:ef7eb2e8f9f7 3020 sdmmc_cmdinitstructure.Argument = 2;
<> 144:ef7eb2e8f9f7 3021 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
<> 144:ef7eb2e8f9f7 3022 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 3023
<> 144:ef7eb2e8f9f7 3024 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 3025 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
<> 144:ef7eb2e8f9f7 3026
<> 144:ef7eb2e8f9f7 3027 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 3028 {
<> 144:ef7eb2e8f9f7 3029 return errorstate;
<> 144:ef7eb2e8f9f7 3030 }
<> 144:ef7eb2e8f9f7 3031
<> 144:ef7eb2e8f9f7 3032 return errorstate;
<> 144:ef7eb2e8f9f7 3033 }
<> 144:ef7eb2e8f9f7 3034 else
<> 144:ef7eb2e8f9f7 3035 {
<> 144:ef7eb2e8f9f7 3036 errorstate = SD_REQUEST_NOT_APPLICABLE;
<> 144:ef7eb2e8f9f7 3037
<> 144:ef7eb2e8f9f7 3038 return errorstate;
<> 144:ef7eb2e8f9f7 3039 }
<> 144:ef7eb2e8f9f7 3040 }
<> 144:ef7eb2e8f9f7 3041
<> 144:ef7eb2e8f9f7 3042 /**
<> 144:ef7eb2e8f9f7 3043 * @brief Disables the SDMMC wide bus mode.
<> 144:ef7eb2e8f9f7 3044 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 3045 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 3046 */
<> 144:ef7eb2e8f9f7 3047 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd)
<> 144:ef7eb2e8f9f7 3048 {
<> 144:ef7eb2e8f9f7 3049 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 3050 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 3051
<> 144:ef7eb2e8f9f7 3052 uint32_t scr[2] = {0, 0};
<> 144:ef7eb2e8f9f7 3053
<> 144:ef7eb2e8f9f7 3054 if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
<> 144:ef7eb2e8f9f7 3055 {
<> 144:ef7eb2e8f9f7 3056 errorstate = SD_LOCK_UNLOCK_FAILED;
<> 144:ef7eb2e8f9f7 3057
<> 144:ef7eb2e8f9f7 3058 return errorstate;
<> 144:ef7eb2e8f9f7 3059 }
<> 144:ef7eb2e8f9f7 3060
<> 144:ef7eb2e8f9f7 3061 /* Get SCR Register */
<> 144:ef7eb2e8f9f7 3062 errorstate = SD_FindSCR(hsd, scr);
<> 144:ef7eb2e8f9f7 3063
<> 144:ef7eb2e8f9f7 3064 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 3065 {
<> 144:ef7eb2e8f9f7 3066 return errorstate;
<> 144:ef7eb2e8f9f7 3067 }
<> 144:ef7eb2e8f9f7 3068
<> 144:ef7eb2e8f9f7 3069 /* If requested card supports 1 bit mode operation */
<> 144:ef7eb2e8f9f7 3070 if((scr[1] & SD_SINGLE_BUS_SUPPORT) != SD_ALLZERO)
<> 144:ef7eb2e8f9f7 3071 {
<> 144:ef7eb2e8f9f7 3072 /* Send CMD55 APP_CMD with argument as card's RCA */
<> 144:ef7eb2e8f9f7 3073 sdmmc_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
<> 144:ef7eb2e8f9f7 3074 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
<> 144:ef7eb2e8f9f7 3075 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 3076 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 3077 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 3078 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 3079
<> 144:ef7eb2e8f9f7 3080 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 3081 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
<> 144:ef7eb2e8f9f7 3082
<> 144:ef7eb2e8f9f7 3083 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 3084 {
<> 144:ef7eb2e8f9f7 3085 return errorstate;
<> 144:ef7eb2e8f9f7 3086 }
<> 144:ef7eb2e8f9f7 3087
<> 144:ef7eb2e8f9f7 3088 /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
<> 144:ef7eb2e8f9f7 3089 sdmmc_cmdinitstructure.Argument = 0;
<> 144:ef7eb2e8f9f7 3090 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
<> 144:ef7eb2e8f9f7 3091 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 3092
<> 144:ef7eb2e8f9f7 3093 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 3094 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
<> 144:ef7eb2e8f9f7 3095
<> 144:ef7eb2e8f9f7 3096 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 3097 {
<> 144:ef7eb2e8f9f7 3098 return errorstate;
<> 144:ef7eb2e8f9f7 3099 }
<> 144:ef7eb2e8f9f7 3100
<> 144:ef7eb2e8f9f7 3101 return errorstate;
<> 144:ef7eb2e8f9f7 3102 }
<> 144:ef7eb2e8f9f7 3103 else
<> 144:ef7eb2e8f9f7 3104 {
<> 144:ef7eb2e8f9f7 3105 errorstate = SD_REQUEST_NOT_APPLICABLE;
<> 144:ef7eb2e8f9f7 3106
<> 144:ef7eb2e8f9f7 3107 return errorstate;
<> 144:ef7eb2e8f9f7 3108 }
<> 144:ef7eb2e8f9f7 3109 }
<> 144:ef7eb2e8f9f7 3110
<> 144:ef7eb2e8f9f7 3111
<> 144:ef7eb2e8f9f7 3112 /**
<> 144:ef7eb2e8f9f7 3113 * @brief Finds the SD card SCR register value.
<> 144:ef7eb2e8f9f7 3114 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 3115 * @param pSCR: pointer to the buffer that will contain the SCR value
<> 144:ef7eb2e8f9f7 3116 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 3117 */
<> 144:ef7eb2e8f9f7 3118 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
<> 144:ef7eb2e8f9f7 3119 {
<> 144:ef7eb2e8f9f7 3120 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 3121 SDMMC_DataInitTypeDef sdmmc_datainitstructure;
<> 144:ef7eb2e8f9f7 3122 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 3123 uint32_t index = 0;
<> 144:ef7eb2e8f9f7 3124 uint32_t tempscr[2] = {0, 0};
<> 144:ef7eb2e8f9f7 3125
<> 144:ef7eb2e8f9f7 3126 /* Set Block Size To 8 Bytes */
<> 144:ef7eb2e8f9f7 3127 /* Send CMD55 APP_CMD with argument as card's RCA */
<> 144:ef7eb2e8f9f7 3128 sdmmc_cmdinitstructure.Argument = (uint32_t)8;
<> 144:ef7eb2e8f9f7 3129 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
<> 144:ef7eb2e8f9f7 3130 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 3131 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 3132 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 3133 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 3134
<> 144:ef7eb2e8f9f7 3135 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 3136 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
<> 144:ef7eb2e8f9f7 3137
<> 144:ef7eb2e8f9f7 3138 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 3139 {
<> 144:ef7eb2e8f9f7 3140 return errorstate;
<> 144:ef7eb2e8f9f7 3141 }
<> 144:ef7eb2e8f9f7 3142
<> 144:ef7eb2e8f9f7 3143 /* Send CMD55 APP_CMD with argument as card's RCA */
<> 144:ef7eb2e8f9f7 3144 sdmmc_cmdinitstructure.Argument = (uint32_t)((hsd->RCA) << 16);
<> 144:ef7eb2e8f9f7 3145 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_APP_CMD;
<> 144:ef7eb2e8f9f7 3146 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 3147
<> 144:ef7eb2e8f9f7 3148 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 3149 errorstate = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
<> 144:ef7eb2e8f9f7 3150
<> 144:ef7eb2e8f9f7 3151 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 3152 {
<> 144:ef7eb2e8f9f7 3153 return errorstate;
<> 144:ef7eb2e8f9f7 3154 }
<> 144:ef7eb2e8f9f7 3155 sdmmc_datainitstructure.DataTimeOut = SD_DATATIMEOUT;
<> 144:ef7eb2e8f9f7 3156 sdmmc_datainitstructure.DataLength = 8;
<> 144:ef7eb2e8f9f7 3157 sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_8B;
<> 144:ef7eb2e8f9f7 3158 sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
<> 144:ef7eb2e8f9f7 3159 sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
<> 144:ef7eb2e8f9f7 3160 sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
<> 144:ef7eb2e8f9f7 3161 SDMMC_DataConfig(hsd->Instance, &sdmmc_datainitstructure);
<> 144:ef7eb2e8f9f7 3162
<> 144:ef7eb2e8f9f7 3163 /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
<> 144:ef7eb2e8f9f7 3164 sdmmc_cmdinitstructure.Argument = 0;
<> 144:ef7eb2e8f9f7 3165 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SD_APP_SEND_SCR;
<> 144:ef7eb2e8f9f7 3166 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 3167
<> 144:ef7eb2e8f9f7 3168 /* Check for error conditions */
<> 144:ef7eb2e8f9f7 3169 errorstate = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_SEND_SCR);
<> 144:ef7eb2e8f9f7 3170
<> 144:ef7eb2e8f9f7 3171 if(errorstate != SD_OK)
<> 144:ef7eb2e8f9f7 3172 {
<> 144:ef7eb2e8f9f7 3173 return errorstate;
<> 144:ef7eb2e8f9f7 3174 }
<> 144:ef7eb2e8f9f7 3175
<> 144:ef7eb2e8f9f7 3176 while(!__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND))
<> 144:ef7eb2e8f9f7 3177 {
<> 144:ef7eb2e8f9f7 3178 if(__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXDAVL))
<> 144:ef7eb2e8f9f7 3179 {
<> 144:ef7eb2e8f9f7 3180 *(tempscr + index) = SDMMC_ReadFIFO(hsd->Instance);
<> 144:ef7eb2e8f9f7 3181 index++;
<> 144:ef7eb2e8f9f7 3182 }
<> 144:ef7eb2e8f9f7 3183 }
<> 144:ef7eb2e8f9f7 3184
<> 144:ef7eb2e8f9f7 3185 if(__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
<> 144:ef7eb2e8f9f7 3186 {
<> 144:ef7eb2e8f9f7 3187 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
<> 144:ef7eb2e8f9f7 3188
<> 144:ef7eb2e8f9f7 3189 errorstate = SD_DATA_TIMEOUT;
<> 144:ef7eb2e8f9f7 3190
<> 144:ef7eb2e8f9f7 3191 return errorstate;
<> 144:ef7eb2e8f9f7 3192 }
<> 144:ef7eb2e8f9f7 3193 else if(__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
<> 144:ef7eb2e8f9f7 3194 {
<> 144:ef7eb2e8f9f7 3195 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
<> 144:ef7eb2e8f9f7 3196
<> 144:ef7eb2e8f9f7 3197 errorstate = SD_DATA_CRC_FAIL;
<> 144:ef7eb2e8f9f7 3198
<> 144:ef7eb2e8f9f7 3199 return errorstate;
<> 144:ef7eb2e8f9f7 3200 }
<> 144:ef7eb2e8f9f7 3201 else if(__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
<> 144:ef7eb2e8f9f7 3202 {
<> 144:ef7eb2e8f9f7 3203 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
<> 144:ef7eb2e8f9f7 3204
<> 144:ef7eb2e8f9f7 3205 errorstate = SD_RX_OVERRUN;
<> 144:ef7eb2e8f9f7 3206
<> 144:ef7eb2e8f9f7 3207 return errorstate;
<> 144:ef7eb2e8f9f7 3208 }
<> 144:ef7eb2e8f9f7 3209 else
<> 144:ef7eb2e8f9f7 3210 {
<> 144:ef7eb2e8f9f7 3211 /* No error flag set */
<> 144:ef7eb2e8f9f7 3212 }
<> 144:ef7eb2e8f9f7 3213
<> 144:ef7eb2e8f9f7 3214 /* Clear all the static flags */
<> 144:ef7eb2e8f9f7 3215 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 3216
<> 144:ef7eb2e8f9f7 3217 *(pSCR + 1) = ((tempscr[0] & SD_0TO7BITS) << 24) | ((tempscr[0] & SD_8TO15BITS) << 8) |\
<> 144:ef7eb2e8f9f7 3218 ((tempscr[0] & SD_16TO23BITS) >> 8) | ((tempscr[0] & SD_24TO31BITS) >> 24);
<> 144:ef7eb2e8f9f7 3219
<> 144:ef7eb2e8f9f7 3220 *(pSCR) = ((tempscr[1] & SD_0TO7BITS) << 24) | ((tempscr[1] & SD_8TO15BITS) << 8) |\
<> 144:ef7eb2e8f9f7 3221 ((tempscr[1] & SD_16TO23BITS) >> 8) | ((tempscr[1] & SD_24TO31BITS) >> 24);
<> 144:ef7eb2e8f9f7 3222
<> 144:ef7eb2e8f9f7 3223 return errorstate;
<> 144:ef7eb2e8f9f7 3224 }
<> 144:ef7eb2e8f9f7 3225
<> 144:ef7eb2e8f9f7 3226 /**
<> 144:ef7eb2e8f9f7 3227 * @brief Checks if the SD card is in programming state.
<> 144:ef7eb2e8f9f7 3228 * @param hsd: SD handle
<> 144:ef7eb2e8f9f7 3229 * @param pStatus: pointer to the variable that will contain the SD card state
<> 144:ef7eb2e8f9f7 3230 * @retval SD Card error state
<> 144:ef7eb2e8f9f7 3231 */
<> 144:ef7eb2e8f9f7 3232 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus)
<> 144:ef7eb2e8f9f7 3233 {
<> 144:ef7eb2e8f9f7 3234 SDMMC_CmdInitTypeDef sdmmc_cmdinitstructure;
<> 144:ef7eb2e8f9f7 3235 HAL_SD_ErrorTypedef errorstate = SD_OK;
<> 144:ef7eb2e8f9f7 3236 __IO uint32_t responseR1 = 0;
<> 144:ef7eb2e8f9f7 3237
<> 144:ef7eb2e8f9f7 3238 sdmmc_cmdinitstructure.Argument = (uint32_t)(hsd->RCA << 16);
<> 144:ef7eb2e8f9f7 3239 sdmmc_cmdinitstructure.CmdIndex = SD_CMD_SEND_STATUS;
<> 144:ef7eb2e8f9f7 3240 sdmmc_cmdinitstructure.Response = SDMMC_RESPONSE_SHORT;
<> 144:ef7eb2e8f9f7 3241 sdmmc_cmdinitstructure.WaitForInterrupt = SDMMC_WAIT_NO;
<> 144:ef7eb2e8f9f7 3242 sdmmc_cmdinitstructure.CPSM = SDMMC_CPSM_ENABLE;
<> 144:ef7eb2e8f9f7 3243 SDMMC_SendCommand(hsd->Instance, &sdmmc_cmdinitstructure);
<> 144:ef7eb2e8f9f7 3244
<> 144:ef7eb2e8f9f7 3245 while(!__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CCRCFAIL | SDMMC_FLAG_CMDREND | SDMMC_FLAG_CTIMEOUT))
<> 144:ef7eb2e8f9f7 3246 {
<> 144:ef7eb2e8f9f7 3247 }
<> 144:ef7eb2e8f9f7 3248
<> 144:ef7eb2e8f9f7 3249 if(__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CTIMEOUT))
<> 144:ef7eb2e8f9f7 3250 {
<> 144:ef7eb2e8f9f7 3251 errorstate = SD_CMD_RSP_TIMEOUT;
<> 144:ef7eb2e8f9f7 3252
<> 144:ef7eb2e8f9f7 3253 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_CTIMEOUT);
<> 144:ef7eb2e8f9f7 3254
<> 144:ef7eb2e8f9f7 3255 return errorstate;
<> 144:ef7eb2e8f9f7 3256 }
<> 144:ef7eb2e8f9f7 3257 else if(__HAL_SD_SDMMC_GET_FLAG(hsd, SDMMC_FLAG_CCRCFAIL))
<> 144:ef7eb2e8f9f7 3258 {
<> 144:ef7eb2e8f9f7 3259 errorstate = SD_CMD_CRC_FAIL;
<> 144:ef7eb2e8f9f7 3260
<> 144:ef7eb2e8f9f7 3261 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_FLAG_CCRCFAIL);
<> 144:ef7eb2e8f9f7 3262
<> 144:ef7eb2e8f9f7 3263 return errorstate;
<> 144:ef7eb2e8f9f7 3264 }
<> 144:ef7eb2e8f9f7 3265 else
<> 144:ef7eb2e8f9f7 3266 {
<> 144:ef7eb2e8f9f7 3267 /* No error flag set */
<> 144:ef7eb2e8f9f7 3268 }
<> 144:ef7eb2e8f9f7 3269
<> 144:ef7eb2e8f9f7 3270 /* Check response received is of desired command */
<> 144:ef7eb2e8f9f7 3271 if((uint32_t)SDMMC_GetCommandResponse(hsd->Instance) != SD_CMD_SEND_STATUS)
<> 144:ef7eb2e8f9f7 3272 {
<> 144:ef7eb2e8f9f7 3273 errorstate = SD_ILLEGAL_CMD;
<> 144:ef7eb2e8f9f7 3274
<> 144:ef7eb2e8f9f7 3275 return errorstate;
<> 144:ef7eb2e8f9f7 3276 }
<> 144:ef7eb2e8f9f7 3277
<> 144:ef7eb2e8f9f7 3278 /* Clear all the static flags */
<> 144:ef7eb2e8f9f7 3279 __HAL_SD_SDMMC_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
<> 144:ef7eb2e8f9f7 3280
<> 144:ef7eb2e8f9f7 3281
<> 144:ef7eb2e8f9f7 3282 /* We have received response, retrieve it for analysis */
<> 144:ef7eb2e8f9f7 3283 responseR1 = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
<> 144:ef7eb2e8f9f7 3284
<> 144:ef7eb2e8f9f7 3285 /* Find out card status */
<> 144:ef7eb2e8f9f7 3286 *pStatus = (uint8_t)((responseR1 >> 9) & 0x0000000F);
<> 144:ef7eb2e8f9f7 3287
<> 144:ef7eb2e8f9f7 3288 if((responseR1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
<> 144:ef7eb2e8f9f7 3289 {
<> 144:ef7eb2e8f9f7 3290 return errorstate;
<> 144:ef7eb2e8f9f7 3291 }
<> 144:ef7eb2e8f9f7 3292
<> 144:ef7eb2e8f9f7 3293 if((responseR1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
<> 144:ef7eb2e8f9f7 3294 {
<> 144:ef7eb2e8f9f7 3295 return(SD_ADDR_OUT_OF_RANGE);
<> 144:ef7eb2e8f9f7 3296 }
<> 144:ef7eb2e8f9f7 3297
<> 144:ef7eb2e8f9f7 3298 if((responseR1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
<> 144:ef7eb2e8f9f7 3299 {
<> 144:ef7eb2e8f9f7 3300 return(SD_ADDR_MISALIGNED);
<> 144:ef7eb2e8f9f7 3301 }
<> 144:ef7eb2e8f9f7 3302
<> 144:ef7eb2e8f9f7 3303 if((responseR1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
<> 144:ef7eb2e8f9f7 3304 {
<> 144:ef7eb2e8f9f7 3305 return(SD_BLOCK_LEN_ERR);
<> 144:ef7eb2e8f9f7 3306 }
<> 144:ef7eb2e8f9f7 3307
<> 144:ef7eb2e8f9f7 3308 if((responseR1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
<> 144:ef7eb2e8f9f7 3309 {
<> 144:ef7eb2e8f9f7 3310 return(SD_ERASE_SEQ_ERR);
<> 144:ef7eb2e8f9f7 3311 }
<> 144:ef7eb2e8f9f7 3312
<> 144:ef7eb2e8f9f7 3313 if((responseR1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
<> 144:ef7eb2e8f9f7 3314 {
<> 144:ef7eb2e8f9f7 3315 return(SD_BAD_ERASE_PARAM);
<> 144:ef7eb2e8f9f7 3316 }
<> 144:ef7eb2e8f9f7 3317
<> 144:ef7eb2e8f9f7 3318 if((responseR1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
<> 144:ef7eb2e8f9f7 3319 {
<> 144:ef7eb2e8f9f7 3320 return(SD_WRITE_PROT_VIOLATION);
<> 144:ef7eb2e8f9f7 3321 }
<> 144:ef7eb2e8f9f7 3322
<> 144:ef7eb2e8f9f7 3323 if((responseR1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
<> 144:ef7eb2e8f9f7 3324 {
<> 144:ef7eb2e8f9f7 3325 return(SD_LOCK_UNLOCK_FAILED);
<> 144:ef7eb2e8f9f7 3326 }
<> 144:ef7eb2e8f9f7 3327
<> 144:ef7eb2e8f9f7 3328 if((responseR1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
<> 144:ef7eb2e8f9f7 3329 {
<> 144:ef7eb2e8f9f7 3330 return(SD_COM_CRC_FAILED);
<> 144:ef7eb2e8f9f7 3331 }
<> 144:ef7eb2e8f9f7 3332
<> 144:ef7eb2e8f9f7 3333 if((responseR1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
<> 144:ef7eb2e8f9f7 3334 {
<> 144:ef7eb2e8f9f7 3335 return(SD_ILLEGAL_CMD);
<> 144:ef7eb2e8f9f7 3336 }
<> 144:ef7eb2e8f9f7 3337
<> 144:ef7eb2e8f9f7 3338 if((responseR1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
<> 144:ef7eb2e8f9f7 3339 {
<> 144:ef7eb2e8f9f7 3340 return(SD_CARD_ECC_FAILED);
<> 144:ef7eb2e8f9f7 3341 }
<> 144:ef7eb2e8f9f7 3342
<> 144:ef7eb2e8f9f7 3343 if((responseR1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
<> 144:ef7eb2e8f9f7 3344 {
<> 144:ef7eb2e8f9f7 3345 return(SD_CC_ERROR);
<> 144:ef7eb2e8f9f7 3346 }
<> 144:ef7eb2e8f9f7 3347
<> 144:ef7eb2e8f9f7 3348 if((responseR1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
<> 144:ef7eb2e8f9f7 3349 {
<> 144:ef7eb2e8f9f7 3350 return(SD_GENERAL_UNKNOWN_ERROR);
<> 144:ef7eb2e8f9f7 3351 }
<> 144:ef7eb2e8f9f7 3352
<> 144:ef7eb2e8f9f7 3353 if((responseR1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
<> 144:ef7eb2e8f9f7 3354 {
<> 144:ef7eb2e8f9f7 3355 return(SD_STREAM_READ_UNDERRUN);
<> 144:ef7eb2e8f9f7 3356 }
<> 144:ef7eb2e8f9f7 3357
<> 144:ef7eb2e8f9f7 3358 if((responseR1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
<> 144:ef7eb2e8f9f7 3359 {
<> 144:ef7eb2e8f9f7 3360 return(SD_STREAM_WRITE_OVERRUN);
<> 144:ef7eb2e8f9f7 3361 }
<> 144:ef7eb2e8f9f7 3362
<> 144:ef7eb2e8f9f7 3363 if((responseR1 & SD_OCR_CID_CSD_OVERWRITE) == SD_OCR_CID_CSD_OVERWRITE)
<> 144:ef7eb2e8f9f7 3364 {
<> 144:ef7eb2e8f9f7 3365 return(SD_CID_CSD_OVERWRITE);
<> 144:ef7eb2e8f9f7 3366 }
<> 144:ef7eb2e8f9f7 3367
<> 144:ef7eb2e8f9f7 3368 if((responseR1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
<> 144:ef7eb2e8f9f7 3369 {
<> 144:ef7eb2e8f9f7 3370 return(SD_WP_ERASE_SKIP);
<> 144:ef7eb2e8f9f7 3371 }
<> 144:ef7eb2e8f9f7 3372
<> 144:ef7eb2e8f9f7 3373 if((responseR1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
<> 144:ef7eb2e8f9f7 3374 {
<> 144:ef7eb2e8f9f7 3375 return(SD_CARD_ECC_DISABLED);
<> 144:ef7eb2e8f9f7 3376 }
<> 144:ef7eb2e8f9f7 3377
<> 144:ef7eb2e8f9f7 3378 if((responseR1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
<> 144:ef7eb2e8f9f7 3379 {
<> 144:ef7eb2e8f9f7 3380 return(SD_ERASE_RESET);
<> 144:ef7eb2e8f9f7 3381 }
<> 144:ef7eb2e8f9f7 3382
<> 144:ef7eb2e8f9f7 3383 if((responseR1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
<> 144:ef7eb2e8f9f7 3384 {
<> 144:ef7eb2e8f9f7 3385 return(SD_AKE_SEQ_ERROR);
<> 144:ef7eb2e8f9f7 3386 }
<> 144:ef7eb2e8f9f7 3387
<> 144:ef7eb2e8f9f7 3388 return errorstate;
<> 144:ef7eb2e8f9f7 3389 }
<> 144:ef7eb2e8f9f7 3390
<> 144:ef7eb2e8f9f7 3391 /**
<> 144:ef7eb2e8f9f7 3392 * @}
<> 144:ef7eb2e8f9f7 3393 */
<> 144:ef7eb2e8f9f7 3394
<> 144:ef7eb2e8f9f7 3395 #endif /* HAL_SD_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 3396
<> 144:ef7eb2e8f9f7 3397 /**
<> 144:ef7eb2e8f9f7 3398 * @}
<> 144:ef7eb2e8f9f7 3399 */
<> 144:ef7eb2e8f9f7 3400
<> 144:ef7eb2e8f9f7 3401 /**
<> 144:ef7eb2e8f9f7 3402 * @}
<> 144:ef7eb2e8f9f7 3403 */
<> 144:ef7eb2e8f9f7 3404
<> 144:ef7eb2e8f9f7 3405 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/