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_NUCLEO_F401RE/stm32f4xx_hal_sd.c@87:085cde657901, 2014-02-08 (annotated)

Committer:
mbed_official
Date:
Sat Feb 08 19:45:06 2014 +0000
Revision:
87:085cde657901
Child:
106:ced8cbb51063
Synchronized with git revision 9272cdeb45ec7e6077641536509413da8fd2ebc2



Full URL: https://github.com/mbedmicro/mbed/commit/9272cdeb45ec7e6077641536509413da8fd2ebc2/



Add NUCLEO_F401RE, improvements

Who changed what in which revision?

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