mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_sd.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
573:ad23fe03a082
Child:
610:813dcc80987e
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



Full URL: https://github.com/mbedmicro/mbed/commit/d5b4d2ab9c47edb4dc5776e7177b0c2263459081/



Initial version of drivers for SAMR21

Who changed what in which revision?

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