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_STM32F4/stm32f4xx_hal_sd.c@581:39197bcd20f2, 2015-07-02 (annotated)

Committer:
mbed_official
Date:
Thu Jul 02 16:30:08 2015 +0100
Revision:
581:39197bcd20f2
Parent:
532:fe11edbda85c
Child:
613:bc40b8d2aec4
Synchronized with git revision ae2d3cdffe70184eb8736d94f76c45c93f4b7724



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



Make it possible to build the core mbed library with yotta

Who changed what in which revision?

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