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@274:6937b19af361, 2014-08-06 (annotated)

Committer:
mbed_official
Date:
Wed Aug 06 08:15:07 2014 +0100
Revision:
274:6937b19af361
Parent:
226:b062af740e40
Child:
369:2e96f1b71984
Synchronized with git revision 5b145e4f6c509376173c3ea2aa35a6da879a2124



Full URL: https://github.com/mbedmicro/mbed/commit/5b145e4f6c509376173c3ea2aa35a6da879a2124/



[TARGET_LPC11UXX] PeripheralNames.h and PinMap definitions separation for LPC11UXX platforms

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 226:b062af740e40 5 * @version V1.1.0RC2
mbed_official 226:b062af740e40 6 * @date 14-May-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 226:b062af740e40 1391 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 226:b062af740e40 1392 * the configuration information for the specified DMA module.
mbed_official 87:085cde657901 1393 * @retval None
mbed_official 87:085cde657901 1394 */
mbed_official 87:085cde657901 1395 __weak void HAL_SD_DMA_RxCpltCallback(DMA_HandleTypeDef *hdma)
mbed_official 87:085cde657901 1396 {
mbed_official 87:085cde657901 1397 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 87:085cde657901 1398 the HAL_SD_DMA_RxCpltCallback could be implemented in the user file
mbed_official 87:085cde657901 1399 */
mbed_official 87:085cde657901 1400 }
mbed_official 87:085cde657901 1401
mbed_official 87:085cde657901 1402 /**
mbed_official 87:085cde657901 1403 * @brief SD DMA transfer complete Rx error callback.
mbed_official 226:b062af740e40 1404 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 226:b062af740e40 1405 * the configuration information for the specified DMA module.
mbed_official 87:085cde657901 1406 * @retval None
mbed_official 87:085cde657901 1407 */
mbed_official 87:085cde657901 1408 __weak void HAL_SD_DMA_RxErrorCallback(DMA_HandleTypeDef *hdma)
mbed_official 87:085cde657901 1409 {
mbed_official 87:085cde657901 1410 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 87:085cde657901 1411 the HAL_SD_DMA_RxErrorCallback could be implemented in the user file
mbed_official 87:085cde657901 1412 */
mbed_official 87:085cde657901 1413 }
mbed_official 87:085cde657901 1414
mbed_official 87:085cde657901 1415 /**
mbed_official 87:085cde657901 1416 * @brief SD Transfer complete Tx callback in non blocking mode.
mbed_official 226:b062af740e40 1417 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 226:b062af740e40 1418 * the configuration information for the specified DMA module.
mbed_official 87:085cde657901 1419 * @retval None
mbed_official 87:085cde657901 1420 */
mbed_official 87:085cde657901 1421 __weak void HAL_SD_DMA_TxCpltCallback(DMA_HandleTypeDef *hdma)
mbed_official 87:085cde657901 1422 {
mbed_official 87:085cde657901 1423 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 87:085cde657901 1424 the HAL_SD_DMA_TxCpltCallback could be implemented in the user file
mbed_official 87:085cde657901 1425 */
mbed_official 87:085cde657901 1426 }
mbed_official 87:085cde657901 1427
mbed_official 87:085cde657901 1428 /**
mbed_official 87:085cde657901 1429 * @brief SD DMA transfer complete error Tx callback.
mbed_official 226:b062af740e40 1430 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 226:b062af740e40 1431 * the configuration information for the specified DMA module.
mbed_official 87:085cde657901 1432 * @retval None
mbed_official 87:085cde657901 1433 */
mbed_official 87:085cde657901 1434 __weak void HAL_SD_DMA_TxErrorCallback(DMA_HandleTypeDef *hdma)
mbed_official 87:085cde657901 1435 {
mbed_official 87:085cde657901 1436 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 87:085cde657901 1437 the HAL_SD_DMA_TxErrorCallback could be implemented in the user file
mbed_official 87:085cde657901 1438 */
mbed_official 87:085cde657901 1439 }
mbed_official 87:085cde657901 1440
mbed_official 87:085cde657901 1441 /**
mbed_official 87:085cde657901 1442 * @}
mbed_official 87:085cde657901 1443 */
mbed_official 87:085cde657901 1444
mbed_official 87:085cde657901 1445 /** @defgroup SD_Group3 Peripheral Control functions
mbed_official 87:085cde657901 1446 * @brief management functions
mbed_official 87:085cde657901 1447 *
mbed_official 87:085cde657901 1448 @verbatim
mbed_official 87:085cde657901 1449 ==============================================================================
mbed_official 87:085cde657901 1450 ##### Peripheral Control functions #####
mbed_official 87:085cde657901 1451 ==============================================================================
mbed_official 87:085cde657901 1452 [..]
mbed_official 87:085cde657901 1453 This subsection provides a set of functions allowing to control the SD card
mbed_official 87:085cde657901 1454 operations.
mbed_official 87:085cde657901 1455
mbed_official 87:085cde657901 1456 @endverbatim
mbed_official 87:085cde657901 1457 * @{
mbed_official 87:085cde657901 1458 */
mbed_official 87:085cde657901 1459
mbed_official 87:085cde657901 1460 /**
mbed_official 87:085cde657901 1461 * @brief Returns information about specific card.
mbed_official 87:085cde657901 1462 * @param hsd: SD handle
mbed_official 87:085cde657901 1463 * @param pCardInfo: Pointer to a HAL_SD_CardInfoTypedef structure that
mbed_official 87:085cde657901 1464 * contains all SD cardinformation
mbed_official 87:085cde657901 1465 * @retval SD Card error state
mbed_official 87:085cde657901 1466 */
mbed_official 87:085cde657901 1467 HAL_SD_ErrorTypedef HAL_SD_Get_CardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *pCardInfo)
mbed_official 87:085cde657901 1468 {
mbed_official 87:085cde657901 1469 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 1470 uint32_t tmp = 0;
mbed_official 87:085cde657901 1471
mbed_official 87:085cde657901 1472 pCardInfo->CardType = (uint8_t)(hsd->CardType);
mbed_official 87:085cde657901 1473 pCardInfo->RCA = (uint16_t)(hsd->RCA);
mbed_official 87:085cde657901 1474
mbed_official 87:085cde657901 1475 /* Byte 0 */
mbed_official 87:085cde657901 1476 tmp = (hsd->CSD[0] & 0xFF000000) >> 24;
mbed_official 87:085cde657901 1477 pCardInfo->SD_csd.CSDStruct = (uint8_t)((tmp & 0xC0) >> 6);
mbed_official 87:085cde657901 1478 pCardInfo->SD_csd.SysSpecVersion = (uint8_t)((tmp & 0x3C) >> 2);
mbed_official 87:085cde657901 1479 pCardInfo->SD_csd.Reserved1 = tmp & 0x03;
mbed_official 87:085cde657901 1480
mbed_official 87:085cde657901 1481 /* Byte 1 */
mbed_official 87:085cde657901 1482 tmp = (hsd->CSD[0] & 0x00FF0000) >> 16;
mbed_official 87:085cde657901 1483 pCardInfo->SD_csd.TAAC = (uint8_t)tmp;
mbed_official 87:085cde657901 1484
mbed_official 87:085cde657901 1485 /* Byte 2 */
mbed_official 87:085cde657901 1486 tmp = (hsd->CSD[0] & 0x0000FF00) >> 8;
mbed_official 87:085cde657901 1487 pCardInfo->SD_csd.NSAC = (uint8_t)tmp;
mbed_official 87:085cde657901 1488
mbed_official 87:085cde657901 1489 /* Byte 3 */
mbed_official 87:085cde657901 1490 tmp = hsd->CSD[0] & 0x000000FF;
mbed_official 87:085cde657901 1491 pCardInfo->SD_csd.MaxBusClkFrec = (uint8_t)tmp;
mbed_official 87:085cde657901 1492
mbed_official 87:085cde657901 1493 /* Byte 4 */
mbed_official 87:085cde657901 1494 tmp = (hsd->CSD[1] & 0xFF000000) >> 24;
mbed_official 87:085cde657901 1495 pCardInfo->SD_csd.CardComdClasses = (uint16_t)(tmp << 4);
mbed_official 87:085cde657901 1496
mbed_official 87:085cde657901 1497 /* Byte 5 */
mbed_official 87:085cde657901 1498 tmp = (hsd->CSD[1] & 0x00FF0000) >> 16;
mbed_official 87:085cde657901 1499 pCardInfo->SD_csd.CardComdClasses |= (uint16_t)((tmp & 0xF0) >> 4);
mbed_official 87:085cde657901 1500 pCardInfo->SD_csd.RdBlockLen = (uint8_t)(tmp & 0x0F);
mbed_official 87:085cde657901 1501
mbed_official 87:085cde657901 1502 /* Byte 6 */
mbed_official 87:085cde657901 1503 tmp = (hsd->CSD[1] & 0x0000FF00) >> 8;
mbed_official 87:085cde657901 1504 pCardInfo->SD_csd.PartBlockRead = (uint8_t)((tmp & 0x80) >> 7);
mbed_official 87:085cde657901 1505 pCardInfo->SD_csd.WrBlockMisalign = (uint8_t)((tmp & 0x40) >> 6);
mbed_official 87:085cde657901 1506 pCardInfo->SD_csd.RdBlockMisalign = (uint8_t)((tmp & 0x20) >> 5);
mbed_official 87:085cde657901 1507 pCardInfo->SD_csd.DSRImpl = (uint8_t)((tmp & 0x10) >> 4);
mbed_official 87:085cde657901 1508 pCardInfo->SD_csd.Reserved2 = 0; /*!< Reserved */
mbed_official 87:085cde657901 1509
mbed_official 87:085cde657901 1510 if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0))
mbed_official 87:085cde657901 1511 {
mbed_official 87:085cde657901 1512 pCardInfo->SD_csd.DeviceSize = (tmp & 0x03) << 10;
mbed_official 87:085cde657901 1513
mbed_official 87:085cde657901 1514 /* Byte 7 */
mbed_official 87:085cde657901 1515 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
mbed_official 87:085cde657901 1516 pCardInfo->SD_csd.DeviceSize |= (tmp) << 2;
mbed_official 87:085cde657901 1517
mbed_official 87:085cde657901 1518 /* Byte 8 */
mbed_official 87:085cde657901 1519 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
mbed_official 87:085cde657901 1520 pCardInfo->SD_csd.DeviceSize |= (tmp & 0xC0) >> 6;
mbed_official 87:085cde657901 1521
mbed_official 87:085cde657901 1522 pCardInfo->SD_csd.MaxRdCurrentVDDMin = (tmp & 0x38) >> 3;
mbed_official 87:085cde657901 1523 pCardInfo->SD_csd.MaxRdCurrentVDDMax = (tmp & 0x07);
mbed_official 87:085cde657901 1524
mbed_official 87:085cde657901 1525 /* Byte 9 */
mbed_official 87:085cde657901 1526 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
mbed_official 87:085cde657901 1527 pCardInfo->SD_csd.MaxWrCurrentVDDMin = (tmp & 0xE0) >> 5;
mbed_official 87:085cde657901 1528 pCardInfo->SD_csd.MaxWrCurrentVDDMax = (tmp & 0x1C) >> 2;
mbed_official 87:085cde657901 1529 pCardInfo->SD_csd.DeviceSizeMul = (tmp & 0x03) << 1;
mbed_official 87:085cde657901 1530 /* Byte 10 */
mbed_official 87:085cde657901 1531 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
mbed_official 87:085cde657901 1532 pCardInfo->SD_csd.DeviceSizeMul |= (tmp & 0x80) >> 7;
mbed_official 87:085cde657901 1533
mbed_official 87:085cde657901 1534 pCardInfo->CardCapacity = (pCardInfo->SD_csd.DeviceSize + 1) ;
mbed_official 87:085cde657901 1535 pCardInfo->CardCapacity *= (1 << (pCardInfo->SD_csd.DeviceSizeMul + 2));
mbed_official 87:085cde657901 1536 pCardInfo->CardBlockSize = 1 << (pCardInfo->SD_csd.RdBlockLen);
mbed_official 87:085cde657901 1537 pCardInfo->CardCapacity *= pCardInfo->CardBlockSize;
mbed_official 87:085cde657901 1538 }
mbed_official 87:085cde657901 1539 else if (hsd->CardType == HIGH_CAPACITY_SD_CARD)
mbed_official 87:085cde657901 1540 {
mbed_official 87:085cde657901 1541 /* Byte 7 */
mbed_official 87:085cde657901 1542 tmp = (uint8_t)(hsd->CSD[1] & 0x000000FF);
mbed_official 87:085cde657901 1543 pCardInfo->SD_csd.DeviceSize = (tmp & 0x3F) << 16;
mbed_official 87:085cde657901 1544
mbed_official 87:085cde657901 1545 /* Byte 8 */
mbed_official 87:085cde657901 1546 tmp = (uint8_t)((hsd->CSD[2] & 0xFF000000) >> 24);
mbed_official 87:085cde657901 1547
mbed_official 87:085cde657901 1548 pCardInfo->SD_csd.DeviceSize |= (tmp << 8);
mbed_official 87:085cde657901 1549
mbed_official 87:085cde657901 1550 /* Byte 9 */
mbed_official 87:085cde657901 1551 tmp = (uint8_t)((hsd->CSD[2] & 0x00FF0000) >> 16);
mbed_official 87:085cde657901 1552
mbed_official 87:085cde657901 1553 pCardInfo->SD_csd.DeviceSize |= (tmp);
mbed_official 87:085cde657901 1554
mbed_official 87:085cde657901 1555 /* Byte 10 */
mbed_official 87:085cde657901 1556 tmp = (uint8_t)((hsd->CSD[2] & 0x0000FF00) >> 8);
mbed_official 87:085cde657901 1557
mbed_official 87:085cde657901 1558 pCardInfo->CardCapacity = ((pCardInfo->SD_csd.DeviceSize + 1)) * 512 * 1024;
mbed_official 87:085cde657901 1559 pCardInfo->CardBlockSize = 512;
mbed_official 87:085cde657901 1560 }
mbed_official 87:085cde657901 1561
mbed_official 87:085cde657901 1562 pCardInfo->SD_csd.EraseGrSize = (tmp & 0x40) >> 6;
mbed_official 87:085cde657901 1563 pCardInfo->SD_csd.EraseGrMul = (tmp & 0x3F) << 1;
mbed_official 87:085cde657901 1564
mbed_official 87:085cde657901 1565 /* Byte 11 */
mbed_official 87:085cde657901 1566 tmp = (uint8_t)(hsd->CSD[2] & 0x000000FF);
mbed_official 87:085cde657901 1567 pCardInfo->SD_csd.EraseGrMul |= (tmp & 0x80) >> 7;
mbed_official 87:085cde657901 1568 pCardInfo->SD_csd.WrProtectGrSize = (tmp & 0x7F);
mbed_official 87:085cde657901 1569
mbed_official 87:085cde657901 1570 /* Byte 12 */
mbed_official 87:085cde657901 1571 tmp = (uint8_t)((hsd->CSD[3] & 0xFF000000) >> 24);
mbed_official 87:085cde657901 1572 pCardInfo->SD_csd.WrProtectGrEnable = (tmp & 0x80) >> 7;
mbed_official 87:085cde657901 1573 pCardInfo->SD_csd.ManDeflECC = (tmp & 0x60) >> 5;
mbed_official 87:085cde657901 1574 pCardInfo->SD_csd.WrSpeedFact = (tmp & 0x1C) >> 2;
mbed_official 87:085cde657901 1575 pCardInfo->SD_csd.MaxWrBlockLen = (tmp & 0x03) << 2;
mbed_official 87:085cde657901 1576
mbed_official 87:085cde657901 1577 /* Byte 13 */
mbed_official 87:085cde657901 1578 tmp = (uint8_t)((hsd->CSD[3] & 0x00FF0000) >> 16);
mbed_official 87:085cde657901 1579 pCardInfo->SD_csd.MaxWrBlockLen |= (tmp & 0xC0) >> 6;
mbed_official 87:085cde657901 1580 pCardInfo->SD_csd.WriteBlockPaPartial = (tmp & 0x20) >> 5;
mbed_official 87:085cde657901 1581 pCardInfo->SD_csd.Reserved3 = 0;
mbed_official 87:085cde657901 1582 pCardInfo->SD_csd.ContentProtectAppli = (tmp & 0x01);
mbed_official 87:085cde657901 1583
mbed_official 87:085cde657901 1584 /* Byte 14 */
mbed_official 87:085cde657901 1585 tmp = (uint8_t)((hsd->CSD[3] & 0x0000FF00) >> 8);
mbed_official 87:085cde657901 1586 pCardInfo->SD_csd.FileFormatGrouop = (tmp & 0x80) >> 7;
mbed_official 87:085cde657901 1587 pCardInfo->SD_csd.CopyFlag = (tmp & 0x40) >> 6;
mbed_official 87:085cde657901 1588 pCardInfo->SD_csd.PermWrProtect = (tmp & 0x20) >> 5;
mbed_official 87:085cde657901 1589 pCardInfo->SD_csd.TempWrProtect = (tmp & 0x10) >> 4;
mbed_official 87:085cde657901 1590 pCardInfo->SD_csd.FileFormat = (tmp & 0x0C) >> 2;
mbed_official 87:085cde657901 1591 pCardInfo->SD_csd.ECC = (tmp & 0x03);
mbed_official 87:085cde657901 1592
mbed_official 87:085cde657901 1593 /* Byte 15 */
mbed_official 87:085cde657901 1594 tmp = (uint8_t)(hsd->CSD[3] & 0x000000FF);
mbed_official 87:085cde657901 1595 pCardInfo->SD_csd.CSD_CRC = (tmp & 0xFE) >> 1;
mbed_official 87:085cde657901 1596 pCardInfo->SD_csd.Reserved4 = 1;
mbed_official 87:085cde657901 1597
mbed_official 87:085cde657901 1598 /* Byte 0 */
mbed_official 87:085cde657901 1599 tmp = (uint8_t)((hsd->CID[0] & 0xFF000000) >> 24);
mbed_official 87:085cde657901 1600 pCardInfo->SD_cid.ManufacturerID = tmp;
mbed_official 87:085cde657901 1601
mbed_official 87:085cde657901 1602 /* Byte 1 */
mbed_official 87:085cde657901 1603 tmp = (uint8_t)((hsd->CID[0] & 0x00FF0000) >> 16);
mbed_official 87:085cde657901 1604 pCardInfo->SD_cid.OEM_AppliID = tmp << 8;
mbed_official 87:085cde657901 1605
mbed_official 87:085cde657901 1606 /* Byte 2 */
mbed_official 87:085cde657901 1607 tmp = (uint8_t)((hsd->CID[0] & 0x000000FF00) >> 8);
mbed_official 87:085cde657901 1608 pCardInfo->SD_cid.OEM_AppliID |= tmp;
mbed_official 87:085cde657901 1609
mbed_official 87:085cde657901 1610 /* Byte 3 */
mbed_official 87:085cde657901 1611 tmp = (uint8_t)(hsd->CID[0] & 0x000000FF);
mbed_official 87:085cde657901 1612 pCardInfo->SD_cid.ProdName1 = tmp << 24;
mbed_official 87:085cde657901 1613
mbed_official 87:085cde657901 1614 /* Byte 4 */
mbed_official 87:085cde657901 1615 tmp = (uint8_t)((hsd->CID[1] & 0xFF000000) >> 24);
mbed_official 87:085cde657901 1616 pCardInfo->SD_cid.ProdName1 |= tmp << 16;
mbed_official 87:085cde657901 1617
mbed_official 87:085cde657901 1618 /* Byte 5 */
mbed_official 87:085cde657901 1619 tmp = (uint8_t)((hsd->CID[1] & 0x00FF0000) >> 16);
mbed_official 87:085cde657901 1620 pCardInfo->SD_cid.ProdName1 |= tmp << 8;
mbed_official 87:085cde657901 1621
mbed_official 87:085cde657901 1622 /* Byte 6 */
mbed_official 87:085cde657901 1623 tmp = (uint8_t)((hsd->CID[1] & 0x0000FF00) >> 8);
mbed_official 87:085cde657901 1624 pCardInfo->SD_cid.ProdName1 |= tmp;
mbed_official 87:085cde657901 1625
mbed_official 87:085cde657901 1626 /* Byte 7 */
mbed_official 87:085cde657901 1627 tmp = (uint8_t)(hsd->CID[1] & 0x000000FF);
mbed_official 87:085cde657901 1628 pCardInfo->SD_cid.ProdName2 = tmp;
mbed_official 87:085cde657901 1629
mbed_official 87:085cde657901 1630 /* Byte 8 */
mbed_official 87:085cde657901 1631 tmp = (uint8_t)((hsd->CID[2] & 0xFF000000) >> 24);
mbed_official 87:085cde657901 1632 pCardInfo->SD_cid.ProdRev = tmp;
mbed_official 87:085cde657901 1633
mbed_official 87:085cde657901 1634 /* Byte 9 */
mbed_official 87:085cde657901 1635 tmp = (uint8_t)((hsd->CID[2] & 0x00FF0000) >> 16);
mbed_official 87:085cde657901 1636 pCardInfo->SD_cid.ProdSN = tmp << 24;
mbed_official 87:085cde657901 1637
mbed_official 87:085cde657901 1638 /* Byte 10 */
mbed_official 87:085cde657901 1639 tmp = (uint8_t)((hsd->CID[2] & 0x0000FF00) >> 8);
mbed_official 87:085cde657901 1640 pCardInfo->SD_cid.ProdSN |= tmp << 16;
mbed_official 87:085cde657901 1641
mbed_official 87:085cde657901 1642 /* Byte 11 */
mbed_official 87:085cde657901 1643 tmp = (uint8_t)(hsd->CID[2] & 0x000000FF);
mbed_official 87:085cde657901 1644 pCardInfo->SD_cid.ProdSN |= tmp << 8;
mbed_official 87:085cde657901 1645
mbed_official 87:085cde657901 1646 /* Byte 12 */
mbed_official 87:085cde657901 1647 tmp = (uint8_t)((hsd->CID[3] & 0xFF000000) >> 24);
mbed_official 87:085cde657901 1648 pCardInfo->SD_cid.ProdSN |= tmp;
mbed_official 87:085cde657901 1649
mbed_official 87:085cde657901 1650 /* Byte 13 */
mbed_official 87:085cde657901 1651 tmp = (uint8_t)((hsd->CID[3] & 0x00FF0000) >> 16);
mbed_official 87:085cde657901 1652 pCardInfo->SD_cid.Reserved1 |= (tmp & 0xF0) >> 4;
mbed_official 87:085cde657901 1653 pCardInfo->SD_cid.ManufactDate = (tmp & 0x0F) << 8;
mbed_official 87:085cde657901 1654
mbed_official 87:085cde657901 1655 /* Byte 14 */
mbed_official 87:085cde657901 1656 tmp = (uint8_t)((hsd->CID[3] & 0x0000FF00) >> 8);
mbed_official 87:085cde657901 1657 pCardInfo->SD_cid.ManufactDate |= tmp;
mbed_official 87:085cde657901 1658
mbed_official 87:085cde657901 1659 /* Byte 15 */
mbed_official 87:085cde657901 1660 tmp = (uint8_t)(hsd->CID[3] & 0x000000FF);
mbed_official 87:085cde657901 1661 pCardInfo->SD_cid.CID_CRC = (tmp & 0xFE) >> 1;
mbed_official 87:085cde657901 1662 pCardInfo->SD_cid.Reserved2 = 1;
mbed_official 87:085cde657901 1663
mbed_official 87:085cde657901 1664 return errorState;
mbed_official 87:085cde657901 1665 }
mbed_official 87:085cde657901 1666
mbed_official 87:085cde657901 1667 /**
mbed_official 87:085cde657901 1668 * @brief Enables wide bus operation for the requested card if supported by
mbed_official 87:085cde657901 1669 * card.
mbed_official 87:085cde657901 1670 * @param hsd: SD handle
mbed_official 87:085cde657901 1671 * @param WideMode: Specifies the SD card wide bus mode
mbed_official 87:085cde657901 1672 * This parameter can be one of the following values:
mbed_official 87:085cde657901 1673 * @arg SDIO_BUS_WIDE_8B: 8-bit data transfer (Only for MMC)
mbed_official 87:085cde657901 1674 * @arg SDIO_BUS_WIDE_4B: 4-bit data transfer
mbed_official 87:085cde657901 1675 * @arg SDIO_BUS_WIDE_1B: 1-bit data transfer
mbed_official 87:085cde657901 1676 * @retval SD Card error state
mbed_official 87:085cde657901 1677 */
mbed_official 87:085cde657901 1678 HAL_SD_ErrorTypedef HAL_SD_WideBusOperation_Config(SD_HandleTypeDef *hsd, uint32_t WideMode)
mbed_official 87:085cde657901 1679 {
mbed_official 87:085cde657901 1680 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 1681 SDIO_InitTypeDef Init;
mbed_official 87:085cde657901 1682
mbed_official 87:085cde657901 1683 /* MMC Card does not support this feature */
mbed_official 87:085cde657901 1684 if (hsd->CardType == MULTIMEDIA_CARD)
mbed_official 87:085cde657901 1685 {
mbed_official 87:085cde657901 1686 errorState = SD_UNSUPPORTED_FEATURE;
mbed_official 87:085cde657901 1687
mbed_official 87:085cde657901 1688 return errorState;
mbed_official 87:085cde657901 1689 }
mbed_official 87:085cde657901 1690 else if ((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
mbed_official 87:085cde657901 1691 (hsd->CardType == HIGH_CAPACITY_SD_CARD))
mbed_official 87:085cde657901 1692 {
mbed_official 87:085cde657901 1693 if (WideMode == SDIO_BUS_WIDE_8B)
mbed_official 87:085cde657901 1694 {
mbed_official 87:085cde657901 1695 errorState = SD_UNSUPPORTED_FEATURE;
mbed_official 87:085cde657901 1696
mbed_official 87:085cde657901 1697 return errorState;
mbed_official 87:085cde657901 1698 }
mbed_official 87:085cde657901 1699 else if (WideMode == SDIO_BUS_WIDE_4B)
mbed_official 87:085cde657901 1700 {
mbed_official 87:085cde657901 1701 errorState = SD_WideBus_Enable(hsd);
mbed_official 87:085cde657901 1702
mbed_official 87:085cde657901 1703 if (errorState == SD_OK)
mbed_official 87:085cde657901 1704 {
mbed_official 87:085cde657901 1705 /* Configure the SDIO peripheral */
mbed_official 87:085cde657901 1706 Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
mbed_official 87:085cde657901 1707 Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
mbed_official 87:085cde657901 1708 Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
mbed_official 87:085cde657901 1709 Init.BusWide = SDIO_BUS_WIDE_4B;
mbed_official 87:085cde657901 1710 Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
mbed_official 87:085cde657901 1711 Init.ClockDiv = SDIO_TRANSFER_CLK_DIV;
mbed_official 87:085cde657901 1712
mbed_official 87:085cde657901 1713 /* Configure SDIO peripheral interface */
mbed_official 87:085cde657901 1714 SDIO_Init(hsd->Instance, Init);
mbed_official 87:085cde657901 1715 }
mbed_official 87:085cde657901 1716 }
mbed_official 87:085cde657901 1717 else
mbed_official 87:085cde657901 1718 {
mbed_official 87:085cde657901 1719 errorState = SD_WideBus_Disable(hsd);
mbed_official 87:085cde657901 1720
mbed_official 87:085cde657901 1721 if (errorState == SD_OK)
mbed_official 87:085cde657901 1722 {
mbed_official 87:085cde657901 1723 /* Configure the SDIO peripheral */
mbed_official 87:085cde657901 1724 Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
mbed_official 87:085cde657901 1725 Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
mbed_official 87:085cde657901 1726 Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
mbed_official 87:085cde657901 1727 Init.BusWide = SDIO_BUS_WIDE_1B;
mbed_official 87:085cde657901 1728 Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
mbed_official 87:085cde657901 1729 Init.ClockDiv = SDIO_TRANSFER_CLK_DIV;
mbed_official 87:085cde657901 1730
mbed_official 87:085cde657901 1731 /* Configure SDIO peripheral interface */
mbed_official 87:085cde657901 1732 SDIO_Init(hsd->Instance, Init);
mbed_official 87:085cde657901 1733 }
mbed_official 87:085cde657901 1734 }
mbed_official 87:085cde657901 1735 }
mbed_official 87:085cde657901 1736
mbed_official 87:085cde657901 1737 return errorState;
mbed_official 87:085cde657901 1738 }
mbed_official 87:085cde657901 1739
mbed_official 87:085cde657901 1740 /**
mbed_official 87:085cde657901 1741 * @brief Aborts an ongoing data transfer.
mbed_official 87:085cde657901 1742 * @param hsd: SD handle
mbed_official 87:085cde657901 1743 * @retval SD Card error state
mbed_official 87:085cde657901 1744 */
mbed_official 87:085cde657901 1745 HAL_SD_ErrorTypedef HAL_SD_StopTransfer(SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 1746 {
mbed_official 87:085cde657901 1747 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
mbed_official 87:085cde657901 1748 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 1749
mbed_official 87:085cde657901 1750 /* Send CMD12 STOP_TRANSMISSION */
mbed_official 87:085cde657901 1751 SDIO_CmdInitStructure.Argument = 0;
mbed_official 87:085cde657901 1752 SDIO_CmdInitStructure.CmdIndex = SD_CMD_STOP_TRANSMISSION;
mbed_official 87:085cde657901 1753 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 1754 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 1755 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 1756 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 1757
mbed_official 87:085cde657901 1758 /* Check for error conditions */
mbed_official 87:085cde657901 1759 errorState = SD_CmdResp1Error(hsd, SD_CMD_STOP_TRANSMISSION);
mbed_official 87:085cde657901 1760
mbed_official 87:085cde657901 1761 return errorState;
mbed_official 87:085cde657901 1762 }
mbed_official 87:085cde657901 1763
mbed_official 87:085cde657901 1764 /**
mbed_official 87:085cde657901 1765 * @brief Switches the SD card to High Speed mode.
mbed_official 87:085cde657901 1766 * This API must be used after "Transfer State"
mbed_official 87:085cde657901 1767 * @note This operation should be followed by the configuration
mbed_official 87:085cde657901 1768 * of PLL to have SDIOCK clock between 67 and 75 MHz
mbed_official 87:085cde657901 1769 * @param hsd: SD handle
mbed_official 87:085cde657901 1770 * @retval SD Card error state
mbed_official 87:085cde657901 1771 */
mbed_official 87:085cde657901 1772 HAL_SD_ErrorTypedef HAL_SD_HighSpeed (SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 1773 {
mbed_official 87:085cde657901 1774 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 1775 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
mbed_official 87:085cde657901 1776 SDIO_DataInitTypeDef SDIO_DataInitStructure;
mbed_official 87:085cde657901 1777
mbed_official 87:085cde657901 1778 uint8_t SD_hs[64] = {0};
mbed_official 87:085cde657901 1779 uint32_t SD_scr[2] = {0, 0};
mbed_official 87:085cde657901 1780 uint32_t SD_SPEC = 0 ;
mbed_official 87:085cde657901 1781 uint32_t count = 0, *tempbuff = (uint32_t *)SD_hs;
mbed_official 87:085cde657901 1782
mbed_official 87:085cde657901 1783 /* Initialize the Data control register */
mbed_official 87:085cde657901 1784 hsd->Instance->DCTRL = 0;
mbed_official 87:085cde657901 1785
mbed_official 87:085cde657901 1786 /* Get SCR Register */
mbed_official 87:085cde657901 1787 errorState = SD_FindSCR(hsd, SD_scr);
mbed_official 87:085cde657901 1788
mbed_official 87:085cde657901 1789 if (errorState != SD_OK)
mbed_official 87:085cde657901 1790 {
mbed_official 87:085cde657901 1791 return errorState;
mbed_official 87:085cde657901 1792 }
mbed_official 87:085cde657901 1793
mbed_official 87:085cde657901 1794 /* Test the Version supported by the card*/
mbed_official 87:085cde657901 1795 SD_SPEC = (SD_scr[1] & 0x01000000) | (SD_scr[1] & 0x02000000);
mbed_official 87:085cde657901 1796
mbed_official 87:085cde657901 1797 if (SD_SPEC != SD_ALLZERO)
mbed_official 87:085cde657901 1798 {
mbed_official 87:085cde657901 1799 /* Set Block Size for Card */
mbed_official 87:085cde657901 1800 SDIO_CmdInitStructure.Argument = (uint32_t)64;
mbed_official 87:085cde657901 1801 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
mbed_official 87:085cde657901 1802 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 1803 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 1804 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 1805 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 1806
mbed_official 87:085cde657901 1807 /* Check for error conditions */
mbed_official 87:085cde657901 1808 errorState = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
mbed_official 87:085cde657901 1809
mbed_official 87:085cde657901 1810 if (errorState != SD_OK)
mbed_official 87:085cde657901 1811 {
mbed_official 87:085cde657901 1812 return errorState;
mbed_official 87:085cde657901 1813 }
mbed_official 87:085cde657901 1814
mbed_official 87:085cde657901 1815 /* Configure the SD DPSM (Data Path State Machine) */
mbed_official 87:085cde657901 1816 SDIO_DataInitStructure.DataTimeOut = SD_DATATIMEOUT;
mbed_official 87:085cde657901 1817 SDIO_DataInitStructure.DataLength = 64;
mbed_official 87:085cde657901 1818 SDIO_DataInitStructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B ;
mbed_official 87:085cde657901 1819 SDIO_DataInitStructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
mbed_official 87:085cde657901 1820 SDIO_DataInitStructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
mbed_official 87:085cde657901 1821 SDIO_DataInitStructure.DPSM = SDIO_DPSM_ENABLE;
mbed_official 87:085cde657901 1822 SDIO_DataConfig(hsd->Instance, &SDIO_DataInitStructure);
mbed_official 87:085cde657901 1823
mbed_official 87:085cde657901 1824 /* Send CMD6 switch mode */
mbed_official 87:085cde657901 1825 SDIO_CmdInitStructure.Argument = 0x80FFFF01;
mbed_official 87:085cde657901 1826 SDIO_CmdInitStructure.CmdIndex = SD_CMD_HS_SWITCH;
mbed_official 87:085cde657901 1827 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 1828
mbed_official 87:085cde657901 1829 /* Check for error conditions */
mbed_official 87:085cde657901 1830 errorState = SD_CmdResp1Error(hsd, SD_CMD_HS_SWITCH);
mbed_official 87:085cde657901 1831
mbed_official 87:085cde657901 1832 if (errorState != SD_OK)
mbed_official 87:085cde657901 1833 {
mbed_official 87:085cde657901 1834 return errorState;
mbed_official 87:085cde657901 1835 }
mbed_official 87:085cde657901 1836
mbed_official 87:085cde657901 1837 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 1838 {
mbed_official 87:085cde657901 1839 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
mbed_official 87:085cde657901 1840 {
mbed_official 87:085cde657901 1841 for (count = 0; count < 8; count++)
mbed_official 87:085cde657901 1842 {
mbed_official 87:085cde657901 1843 *(tempbuff + count) = SDIO_ReadFIFO(hsd->Instance);
mbed_official 87:085cde657901 1844 }
mbed_official 87:085cde657901 1845
mbed_official 87:085cde657901 1846 tempbuff += 8;
mbed_official 87:085cde657901 1847 }
mbed_official 87:085cde657901 1848 }
mbed_official 87:085cde657901 1849
mbed_official 87:085cde657901 1850 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
mbed_official 87:085cde657901 1851 {
mbed_official 87:085cde657901 1852 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
mbed_official 87:085cde657901 1853
mbed_official 87:085cde657901 1854 errorState = SD_DATA_TIMEOUT;
mbed_official 87:085cde657901 1855
mbed_official 87:085cde657901 1856 return errorState;
mbed_official 87:085cde657901 1857 }
mbed_official 87:085cde657901 1858 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
mbed_official 87:085cde657901 1859 {
mbed_official 87:085cde657901 1860 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
mbed_official 87:085cde657901 1861
mbed_official 87:085cde657901 1862 errorState = SD_DATA_CRC_FAIL;
mbed_official 87:085cde657901 1863
mbed_official 87:085cde657901 1864 return errorState;
mbed_official 87:085cde657901 1865 }
mbed_official 87:085cde657901 1866 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
mbed_official 87:085cde657901 1867 {
mbed_official 87:085cde657901 1868 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
mbed_official 87:085cde657901 1869
mbed_official 87:085cde657901 1870 errorState = SD_RX_OVERRUN;
mbed_official 87:085cde657901 1871
mbed_official 87:085cde657901 1872 return errorState;
mbed_official 87:085cde657901 1873 }
mbed_official 87:085cde657901 1874 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
mbed_official 87:085cde657901 1875 {
mbed_official 87:085cde657901 1876 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
mbed_official 87:085cde657901 1877
mbed_official 87:085cde657901 1878 errorState = SD_START_BIT_ERR;
mbed_official 87:085cde657901 1879
mbed_official 87:085cde657901 1880 return errorState;
mbed_official 87:085cde657901 1881 }
mbed_official 87:085cde657901 1882
mbed_official 87:085cde657901 1883 count = SD_DATATIMEOUT;
mbed_official 87:085cde657901 1884
mbed_official 87:085cde657901 1885 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
mbed_official 87:085cde657901 1886 {
mbed_official 87:085cde657901 1887 *tempbuff = SDIO_ReadFIFO(hsd->Instance);
mbed_official 87:085cde657901 1888 tempbuff++;
mbed_official 87:085cde657901 1889 count--;
mbed_official 87:085cde657901 1890 }
mbed_official 87:085cde657901 1891
mbed_official 87:085cde657901 1892 /* Clear all the static flags */
mbed_official 87:085cde657901 1893 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
mbed_official 87:085cde657901 1894
mbed_official 87:085cde657901 1895 /* Test if the switch mode HS is ok */
mbed_official 87:085cde657901 1896 if ((SD_hs[13]& 2) != 2)
mbed_official 87:085cde657901 1897 {
mbed_official 87:085cde657901 1898 errorState = SD_UNSUPPORTED_FEATURE;
mbed_official 87:085cde657901 1899 }
mbed_official 87:085cde657901 1900 }
mbed_official 87:085cde657901 1901
mbed_official 87:085cde657901 1902 return errorState;
mbed_official 87:085cde657901 1903 }
mbed_official 87:085cde657901 1904
mbed_official 87:085cde657901 1905 /**
mbed_official 87:085cde657901 1906 * @}
mbed_official 87:085cde657901 1907 */
mbed_official 87:085cde657901 1908
mbed_official 87:085cde657901 1909 /** @defgroup SD_Group4 Peripheral State functions
mbed_official 87:085cde657901 1910 * @brief Peripheral State functions
mbed_official 87:085cde657901 1911 *
mbed_official 87:085cde657901 1912 @verbatim
mbed_official 87:085cde657901 1913 ==============================================================================
mbed_official 87:085cde657901 1914 ##### Peripheral State functions #####
mbed_official 87:085cde657901 1915 ==============================================================================
mbed_official 87:085cde657901 1916 [..]
mbed_official 87:085cde657901 1917 This subsection permits to get in runtime the status of the peripheral
mbed_official 87:085cde657901 1918 and the data flow.
mbed_official 87:085cde657901 1919
mbed_official 87:085cde657901 1920 @endverbatim
mbed_official 87:085cde657901 1921 * @{
mbed_official 87:085cde657901 1922 */
mbed_official 87:085cde657901 1923
mbed_official 87:085cde657901 1924 /**
mbed_official 87:085cde657901 1925 * @brief Returns the current SD card's status.
mbed_official 87:085cde657901 1926 * @param hsd: SD handle
mbed_official 87:085cde657901 1927 * @param pSDstatus: Pointer to the buffer that will contain the SD card status
mbed_official 87:085cde657901 1928 * SD Status register)
mbed_official 87:085cde657901 1929 * @retval SD Card error state
mbed_official 87:085cde657901 1930 */
mbed_official 87:085cde657901 1931 HAL_SD_ErrorTypedef HAL_SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
mbed_official 87:085cde657901 1932 {
mbed_official 87:085cde657901 1933 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
mbed_official 87:085cde657901 1934 SDIO_DataInitTypeDef SDIO_DataInitStructure;
mbed_official 87:085cde657901 1935 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 1936 uint32_t count = 0;
mbed_official 87:085cde657901 1937
mbed_official 87:085cde657901 1938 /* Check SD response */
mbed_official 87:085cde657901 1939 if ((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
mbed_official 87:085cde657901 1940 {
mbed_official 87:085cde657901 1941 errorState = SD_LOCK_UNLOCK_FAILED;
mbed_official 87:085cde657901 1942
mbed_official 87:085cde657901 1943 return errorState;
mbed_official 87:085cde657901 1944 }
mbed_official 87:085cde657901 1945
mbed_official 87:085cde657901 1946 /* Set block size for card if it is not equal to current block size for card */
mbed_official 87:085cde657901 1947 SDIO_CmdInitStructure.Argument = 64;
mbed_official 87:085cde657901 1948 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
mbed_official 87:085cde657901 1949 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 1950 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 1951 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 1952 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 1953
mbed_official 87:085cde657901 1954 /* Check for error conditions */
mbed_official 87:085cde657901 1955 errorState = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
mbed_official 87:085cde657901 1956
mbed_official 87:085cde657901 1957 if (errorState != SD_OK)
mbed_official 87:085cde657901 1958 {
mbed_official 87:085cde657901 1959 return errorState;
mbed_official 87:085cde657901 1960 }
mbed_official 87:085cde657901 1961
mbed_official 87:085cde657901 1962 /* Send CMD55 */
mbed_official 87:085cde657901 1963 SDIO_CmdInitStructure.Argument = (uint32_t)(hsd->RCA << 16);
mbed_official 87:085cde657901 1964 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_CMD;
mbed_official 87:085cde657901 1965 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 1966
mbed_official 87:085cde657901 1967 /* Check for error conditions */
mbed_official 87:085cde657901 1968 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
mbed_official 87:085cde657901 1969
mbed_official 87:085cde657901 1970 if (errorState != SD_OK)
mbed_official 87:085cde657901 1971 {
mbed_official 87:085cde657901 1972 return errorState;
mbed_official 87:085cde657901 1973 }
mbed_official 87:085cde657901 1974
mbed_official 87:085cde657901 1975 /* Configure the SD DPSM (Data Path State Machine) */
mbed_official 87:085cde657901 1976 SDIO_DataInitStructure.DataTimeOut = SD_DATATIMEOUT;
mbed_official 87:085cde657901 1977 SDIO_DataInitStructure.DataLength = 64;
mbed_official 87:085cde657901 1978 SDIO_DataInitStructure.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
mbed_official 87:085cde657901 1979 SDIO_DataInitStructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
mbed_official 87:085cde657901 1980 SDIO_DataInitStructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
mbed_official 87:085cde657901 1981 SDIO_DataInitStructure.DPSM = SDIO_DPSM_ENABLE;
mbed_official 87:085cde657901 1982 SDIO_DataConfig(hsd->Instance, &SDIO_DataInitStructure);
mbed_official 87:085cde657901 1983
mbed_official 87:085cde657901 1984 /* Send ACMD13 (SD_APP_STAUS) with argument as card's RCA */
mbed_official 87:085cde657901 1985 SDIO_CmdInitStructure.Argument = 0;
mbed_official 87:085cde657901 1986 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SD_APP_STAUS;
mbed_official 87:085cde657901 1987 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 1988
mbed_official 87:085cde657901 1989 /* Check for error conditions */
mbed_official 87:085cde657901 1990 errorState = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_STAUS);
mbed_official 87:085cde657901 1991
mbed_official 87:085cde657901 1992 if (errorState != SD_OK)
mbed_official 87:085cde657901 1993 {
mbed_official 87:085cde657901 1994 return errorState;
mbed_official 87:085cde657901 1995 }
mbed_official 87:085cde657901 1996
mbed_official 87:085cde657901 1997 /* Get status data */
mbed_official 87:085cde657901 1998 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 1999 {
mbed_official 87:085cde657901 2000 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
mbed_official 87:085cde657901 2001 {
mbed_official 87:085cde657901 2002 for (count = 0; count < 8; count++)
mbed_official 87:085cde657901 2003 {
mbed_official 87:085cde657901 2004 *(pSDstatus + count) = SDIO_ReadFIFO(hsd->Instance);
mbed_official 87:085cde657901 2005 }
mbed_official 87:085cde657901 2006
mbed_official 87:085cde657901 2007 pSDstatus += 8;
mbed_official 87:085cde657901 2008 }
mbed_official 87:085cde657901 2009 }
mbed_official 87:085cde657901 2010
mbed_official 87:085cde657901 2011 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
mbed_official 87:085cde657901 2012 {
mbed_official 87:085cde657901 2013 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
mbed_official 87:085cde657901 2014
mbed_official 87:085cde657901 2015 errorState = SD_DATA_TIMEOUT;
mbed_official 87:085cde657901 2016
mbed_official 87:085cde657901 2017 return errorState;
mbed_official 87:085cde657901 2018 }
mbed_official 87:085cde657901 2019 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
mbed_official 87:085cde657901 2020 {
mbed_official 87:085cde657901 2021 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
mbed_official 87:085cde657901 2022
mbed_official 87:085cde657901 2023 errorState = SD_DATA_CRC_FAIL;
mbed_official 87:085cde657901 2024
mbed_official 87:085cde657901 2025 return errorState;
mbed_official 87:085cde657901 2026 }
mbed_official 87:085cde657901 2027 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
mbed_official 87:085cde657901 2028 {
mbed_official 87:085cde657901 2029 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
mbed_official 87:085cde657901 2030
mbed_official 87:085cde657901 2031 errorState = SD_RX_OVERRUN;
mbed_official 87:085cde657901 2032
mbed_official 87:085cde657901 2033 return errorState;
mbed_official 87:085cde657901 2034 }
mbed_official 87:085cde657901 2035 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
mbed_official 87:085cde657901 2036 {
mbed_official 87:085cde657901 2037 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
mbed_official 87:085cde657901 2038
mbed_official 87:085cde657901 2039 errorState = SD_START_BIT_ERR;
mbed_official 87:085cde657901 2040
mbed_official 87:085cde657901 2041 return errorState;
mbed_official 87:085cde657901 2042 }
mbed_official 87:085cde657901 2043
mbed_official 87:085cde657901 2044 count = SD_DATATIMEOUT;
mbed_official 87:085cde657901 2045 while ((__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (count > 0))
mbed_official 87:085cde657901 2046 {
mbed_official 87:085cde657901 2047 *pSDstatus = SDIO_ReadFIFO(hsd->Instance);
mbed_official 87:085cde657901 2048 pSDstatus++;
mbed_official 87:085cde657901 2049 count--;
mbed_official 87:085cde657901 2050 }
mbed_official 87:085cde657901 2051
mbed_official 87:085cde657901 2052 /* Clear all the static status flags*/
mbed_official 87:085cde657901 2053 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
mbed_official 87:085cde657901 2054
mbed_official 87:085cde657901 2055 return errorState;
mbed_official 87:085cde657901 2056 }
mbed_official 87:085cde657901 2057
mbed_official 87:085cde657901 2058 /**
mbed_official 87:085cde657901 2059 * @brief Gets the current sd card data status.
mbed_official 87:085cde657901 2060 * @param hsd: SD handle
mbed_official 87:085cde657901 2061 * @retval Data Transfer state
mbed_official 87:085cde657901 2062 */
mbed_official 87:085cde657901 2063 HAL_SD_TransferStateTypedef HAL_SD_GetStatus(SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 2064 {
mbed_official 87:085cde657901 2065 HAL_SD_CardStateTypedef cardstate = SD_CARD_TRANSFER;
mbed_official 87:085cde657901 2066
mbed_official 87:085cde657901 2067 /* Get SD card state */
mbed_official 87:085cde657901 2068 cardstate = SD_GetState(hsd);
mbed_official 87:085cde657901 2069
mbed_official 87:085cde657901 2070 /* Find SD status according to card state*/
mbed_official 87:085cde657901 2071 if (cardstate == SD_CARD_TRANSFER)
mbed_official 87:085cde657901 2072 {
mbed_official 87:085cde657901 2073 return SD_TRANSFER_OK;
mbed_official 87:085cde657901 2074 }
mbed_official 87:085cde657901 2075 else if(cardstate == SD_CARD_ERROR)
mbed_official 87:085cde657901 2076 {
mbed_official 87:085cde657901 2077 return SD_TRANSFER_ERROR;
mbed_official 87:085cde657901 2078 }
mbed_official 87:085cde657901 2079 else
mbed_official 87:085cde657901 2080 {
mbed_official 87:085cde657901 2081 return SD_TRANSFER_BUSY;
mbed_official 87:085cde657901 2082 }
mbed_official 87:085cde657901 2083 }
mbed_official 87:085cde657901 2084
mbed_official 87:085cde657901 2085 /**
mbed_official 87:085cde657901 2086 * @brief Gets the SD card status.
mbed_official 87:085cde657901 2087 * @param hsd: SD handle
mbed_official 87:085cde657901 2088 * @param pCardStatus: Pointer to the HAL_SD_CardStatusTypedef structure that
mbed_official 87:085cde657901 2089 * will contain the SD card status information
mbed_official 87:085cde657901 2090 * @retval SD Card error state
mbed_official 87:085cde657901 2091 */
mbed_official 87:085cde657901 2092 HAL_SD_ErrorTypedef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypedef *pCardStatus)
mbed_official 87:085cde657901 2093 {
mbed_official 87:085cde657901 2094 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 2095 uint32_t tmp = 0;
mbed_official 87:085cde657901 2096 uint32_t SD_STATUS[16];
mbed_official 87:085cde657901 2097
mbed_official 87:085cde657901 2098 errorState = HAL_SD_SendSDStatus(hsd, SD_STATUS);
mbed_official 87:085cde657901 2099
mbed_official 87:085cde657901 2100 if (errorState != SD_OK)
mbed_official 87:085cde657901 2101 {
mbed_official 87:085cde657901 2102 return errorState;
mbed_official 87:085cde657901 2103 }
mbed_official 87:085cde657901 2104
mbed_official 87:085cde657901 2105 /* Byte 0 */
mbed_official 87:085cde657901 2106 tmp = (SD_STATUS[0] & 0xC0) >> 6;
mbed_official 87:085cde657901 2107 pCardStatus->DAT_BUS_WIDTH = (uint8_t)tmp;
mbed_official 87:085cde657901 2108
mbed_official 87:085cde657901 2109 /* Byte 0 */
mbed_official 87:085cde657901 2110 tmp = (SD_STATUS[0] & 0x20) >> 5;
mbed_official 87:085cde657901 2111 pCardStatus->SECURED_MODE = (uint8_t)tmp;
mbed_official 87:085cde657901 2112
mbed_official 87:085cde657901 2113 /* Byte 2 */
mbed_official 87:085cde657901 2114 tmp = (SD_STATUS[2] & 0xFF);
mbed_official 87:085cde657901 2115 pCardStatus->SD_CARD_TYPE = (uint8_t)(tmp << 8);
mbed_official 87:085cde657901 2116
mbed_official 87:085cde657901 2117 /* Byte 3 */
mbed_official 87:085cde657901 2118 tmp = (SD_STATUS[3] & 0xFF);
mbed_official 87:085cde657901 2119 pCardStatus->SD_CARD_TYPE |= (uint8_t)tmp;
mbed_official 87:085cde657901 2120
mbed_official 87:085cde657901 2121 /* Byte 4 */
mbed_official 87:085cde657901 2122 tmp = (SD_STATUS[4] & 0xFF);
mbed_official 87:085cde657901 2123 pCardStatus->SIZE_OF_PROTECTED_AREA = (uint8_t)(tmp << 24);
mbed_official 87:085cde657901 2124
mbed_official 87:085cde657901 2125 /* Byte 5 */
mbed_official 87:085cde657901 2126 tmp = (SD_STATUS[5] & 0xFF);
mbed_official 87:085cde657901 2127 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 16);
mbed_official 87:085cde657901 2128
mbed_official 87:085cde657901 2129 /* Byte 6 */
mbed_official 87:085cde657901 2130 tmp = (SD_STATUS[6] & 0xFF);
mbed_official 87:085cde657901 2131 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)(tmp << 8);
mbed_official 87:085cde657901 2132
mbed_official 87:085cde657901 2133 /* Byte 7 */
mbed_official 87:085cde657901 2134 tmp = (SD_STATUS[7] & 0xFF);
mbed_official 87:085cde657901 2135 pCardStatus->SIZE_OF_PROTECTED_AREA |= (uint8_t)tmp;
mbed_official 87:085cde657901 2136
mbed_official 87:085cde657901 2137 /* Byte 8 */
mbed_official 87:085cde657901 2138 tmp = (SD_STATUS[8] & 0xFF);
mbed_official 87:085cde657901 2139 pCardStatus->SPEED_CLASS = (uint8_t)tmp;
mbed_official 87:085cde657901 2140
mbed_official 87:085cde657901 2141 /* Byte 9 */
mbed_official 87:085cde657901 2142 tmp = (SD_STATUS[9] & 0xFF);
mbed_official 87:085cde657901 2143 pCardStatus->PERFORMANCE_MOVE = (uint8_t)tmp;
mbed_official 87:085cde657901 2144
mbed_official 87:085cde657901 2145 /* Byte 10 */
mbed_official 87:085cde657901 2146 tmp = (SD_STATUS[10] & 0xF0) >> 4;
mbed_official 87:085cde657901 2147 pCardStatus->AU_SIZE = (uint8_t)tmp;
mbed_official 87:085cde657901 2148
mbed_official 87:085cde657901 2149 /* Byte 11 */
mbed_official 87:085cde657901 2150 tmp = (SD_STATUS[11] & 0xFF);
mbed_official 87:085cde657901 2151 pCardStatus->ERASE_SIZE = (uint8_t)(tmp << 8);
mbed_official 87:085cde657901 2152
mbed_official 87:085cde657901 2153 /* Byte 12 */
mbed_official 87:085cde657901 2154 tmp = (SD_STATUS[12] & 0xFF);
mbed_official 87:085cde657901 2155 pCardStatus->ERASE_SIZE |= (uint8_t)tmp;
mbed_official 87:085cde657901 2156
mbed_official 87:085cde657901 2157 /* Byte 13 */
mbed_official 87:085cde657901 2158 tmp = (SD_STATUS[13] & 0xFC) >> 2;
mbed_official 87:085cde657901 2159 pCardStatus->ERASE_TIMEOUT = (uint8_t)tmp;
mbed_official 87:085cde657901 2160
mbed_official 87:085cde657901 2161 /* Byte 13 */
mbed_official 87:085cde657901 2162 tmp = (SD_STATUS[13] & 0x3);
mbed_official 87:085cde657901 2163 pCardStatus->ERASE_OFFSET = (uint8_t)tmp;
mbed_official 87:085cde657901 2164
mbed_official 87:085cde657901 2165 return errorState;
mbed_official 87:085cde657901 2166 }
mbed_official 87:085cde657901 2167
mbed_official 87:085cde657901 2168 /**
mbed_official 87:085cde657901 2169 * @}
mbed_official 87:085cde657901 2170 */
mbed_official 87:085cde657901 2171
mbed_official 87:085cde657901 2172 /**
mbed_official 87:085cde657901 2173 * @brief SD DMA transfer complete Rx callback.
mbed_official 226:b062af740e40 2174 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 226:b062af740e40 2175 * the configuration information for the specified DMA module.
mbed_official 87:085cde657901 2176 * @retval None
mbed_official 87:085cde657901 2177 */
mbed_official 87:085cde657901 2178 static void SD_DMA_RxCplt(DMA_HandleTypeDef *hdma)
mbed_official 87:085cde657901 2179 {
mbed_official 87:085cde657901 2180 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 87:085cde657901 2181
mbed_official 87:085cde657901 2182 /* DMA transfer is complete */
mbed_official 87:085cde657901 2183 hsd->DmaTransferCplt = 1;
mbed_official 87:085cde657901 2184
mbed_official 87:085cde657901 2185 /* Wait until SD transfer is complete */
mbed_official 87:085cde657901 2186 while(hsd->SdTransferCplt == 0)
mbed_official 87:085cde657901 2187 {
mbed_official 87:085cde657901 2188 }
mbed_official 87:085cde657901 2189
mbed_official 87:085cde657901 2190 /* Transfer complete user callback */
mbed_official 87:085cde657901 2191 HAL_SD_DMA_RxCpltCallback(hsd->hdmarx);
mbed_official 87:085cde657901 2192 }
mbed_official 87:085cde657901 2193
mbed_official 87:085cde657901 2194 /**
mbed_official 87:085cde657901 2195 * @brief SD DMA transfer Error Rx callback.
mbed_official 226:b062af740e40 2196 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 226:b062af740e40 2197 * the configuration information for the specified DMA module.
mbed_official 87:085cde657901 2198 * @retval None
mbed_official 87:085cde657901 2199 */
mbed_official 87:085cde657901 2200 static void SD_DMA_RxError(DMA_HandleTypeDef *hdma)
mbed_official 87:085cde657901 2201 {
mbed_official 87:085cde657901 2202 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 87:085cde657901 2203
mbed_official 87:085cde657901 2204 /* Transfer complete user callback */
mbed_official 87:085cde657901 2205 HAL_SD_DMA_RxErrorCallback(hsd->hdmarx);
mbed_official 87:085cde657901 2206 }
mbed_official 87:085cde657901 2207
mbed_official 87:085cde657901 2208 /**
mbed_official 87:085cde657901 2209 * @brief SD DMA transfer complete Tx callback.
mbed_official 226:b062af740e40 2210 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 226:b062af740e40 2211 * the configuration information for the specified DMA module.
mbed_official 87:085cde657901 2212 * @retval None
mbed_official 87:085cde657901 2213 */
mbed_official 87:085cde657901 2214 static void SD_DMA_TxCplt(DMA_HandleTypeDef *hdma)
mbed_official 87:085cde657901 2215 {
mbed_official 87:085cde657901 2216 SD_HandleTypeDef *hsd = (SD_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 87:085cde657901 2217
mbed_official 87:085cde657901 2218 /* DMA transfer is complete */
mbed_official 87:085cde657901 2219 hsd->DmaTransferCplt = 1;
mbed_official 87:085cde657901 2220
mbed_official 87:085cde657901 2221 /* Wait until SD transfer is complete */
mbed_official 87:085cde657901 2222 while(hsd->SdTransferCplt == 0)
mbed_official 87:085cde657901 2223 {
mbed_official 87:085cde657901 2224 }
mbed_official 87:085cde657901 2225
mbed_official 87:085cde657901 2226 /* Transfer complete user callback */
mbed_official 87:085cde657901 2227 HAL_SD_DMA_TxCpltCallback(hsd->hdmatx);
mbed_official 87:085cde657901 2228 }
mbed_official 87:085cde657901 2229
mbed_official 87:085cde657901 2230 /**
mbed_official 87:085cde657901 2231 * @brief SD DMA transfer Error Tx callback.
mbed_official 226:b062af740e40 2232 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
mbed_official 226:b062af740e40 2233 * the configuration information for the specified DMA module.
mbed_official 87:085cde657901 2234 * @retval None
mbed_official 87:085cde657901 2235 */
mbed_official 87:085cde657901 2236 static void SD_DMA_TxError(DMA_HandleTypeDef *hdma)
mbed_official 87:085cde657901 2237 {
mbed_official 87:085cde657901 2238 SD_HandleTypeDef *hsd = ( SD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 87:085cde657901 2239
mbed_official 87:085cde657901 2240 /* Transfer complete user callback */
mbed_official 87:085cde657901 2241 HAL_SD_DMA_TxErrorCallback(hsd->hdmatx);
mbed_official 87:085cde657901 2242 }
mbed_official 87:085cde657901 2243
mbed_official 87:085cde657901 2244 /**
mbed_official 87:085cde657901 2245 * @brief Returns the SD current state.
mbed_official 87:085cde657901 2246 * @param hsd: SD handle
mbed_official 87:085cde657901 2247 * @retval SD card current state
mbed_official 87:085cde657901 2248 */
mbed_official 87:085cde657901 2249 static HAL_SD_CardStateTypedef SD_GetState(SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 2250 {
mbed_official 87:085cde657901 2251 uint32_t resp1 = 0;
mbed_official 87:085cde657901 2252
mbed_official 87:085cde657901 2253 if (SD_SendStatus(hsd, &resp1) != SD_OK)
mbed_official 87:085cde657901 2254 {
mbed_official 87:085cde657901 2255 return SD_CARD_ERROR;
mbed_official 87:085cde657901 2256 }
mbed_official 87:085cde657901 2257 else
mbed_official 87:085cde657901 2258 {
mbed_official 87:085cde657901 2259 return (HAL_SD_CardStateTypedef)((resp1 >> 9) & 0x0F);
mbed_official 87:085cde657901 2260 }
mbed_official 87:085cde657901 2261 }
mbed_official 87:085cde657901 2262
mbed_official 87:085cde657901 2263 /**
mbed_official 87:085cde657901 2264 * @brief Initializes all cards or single card as the case may be Card(s) come
mbed_official 87:085cde657901 2265 * into standby state.
mbed_official 87:085cde657901 2266 * @param hsd: SD handle
mbed_official 87:085cde657901 2267 * @retval SD Card error state
mbed_official 87:085cde657901 2268 */
mbed_official 87:085cde657901 2269 static HAL_SD_ErrorTypedef SD_Initialize_Cards(SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 2270 {
mbed_official 87:085cde657901 2271 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
mbed_official 87:085cde657901 2272 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 2273 uint16_t sd_rca = 1;
mbed_official 87:085cde657901 2274
mbed_official 87:085cde657901 2275 if(SDIO_GetPowerState(hsd->Instance) == 0) /* Power off */
mbed_official 87:085cde657901 2276 {
mbed_official 87:085cde657901 2277 errorState = SD_REQUEST_NOT_APPLICABLE;
mbed_official 87:085cde657901 2278
mbed_official 87:085cde657901 2279 return errorState;
mbed_official 87:085cde657901 2280 }
mbed_official 87:085cde657901 2281
mbed_official 87:085cde657901 2282 if(hsd->CardType != SECURE_DIGITAL_IO_CARD)
mbed_official 87:085cde657901 2283 {
mbed_official 87:085cde657901 2284 /* Send CMD2 ALL_SEND_CID */
mbed_official 87:085cde657901 2285 SDIO_CmdInitStructure.Argument = 0;
mbed_official 87:085cde657901 2286 SDIO_CmdInitStructure.CmdIndex = SD_CMD_ALL_SEND_CID;
mbed_official 87:085cde657901 2287 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_LONG;
mbed_official 87:085cde657901 2288 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 2289 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 2290 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 2291
mbed_official 87:085cde657901 2292 /* Check for error conditions */
mbed_official 87:085cde657901 2293 errorState = SD_CmdResp2Error(hsd);
mbed_official 87:085cde657901 2294
mbed_official 87:085cde657901 2295 if(errorState != SD_OK)
mbed_official 87:085cde657901 2296 {
mbed_official 87:085cde657901 2297 return errorState;
mbed_official 87:085cde657901 2298 }
mbed_official 87:085cde657901 2299
mbed_official 87:085cde657901 2300 /* Get Card identification number data */
mbed_official 87:085cde657901 2301 hsd->CID[0] = SDIO_GetResponse(SDIO_RESP1);
mbed_official 87:085cde657901 2302 hsd->CID[1] = SDIO_GetResponse(SDIO_RESP2);
mbed_official 87:085cde657901 2303 hsd->CID[2] = SDIO_GetResponse(SDIO_RESP3);
mbed_official 87:085cde657901 2304 hsd->CID[3] = SDIO_GetResponse(SDIO_RESP4);
mbed_official 87:085cde657901 2305 }
mbed_official 87:085cde657901 2306
mbed_official 87:085cde657901 2307 if((hsd->CardType == STD_CAPACITY_SD_CARD_V1_1) || (hsd->CardType == STD_CAPACITY_SD_CARD_V2_0) ||\
mbed_official 87:085cde657901 2308 (hsd->CardType == SECURE_DIGITAL_IO_COMBO_CARD) || (hsd->CardType == HIGH_CAPACITY_SD_CARD))
mbed_official 87:085cde657901 2309 {
mbed_official 87:085cde657901 2310 /* Send CMD3 SET_REL_ADDR with argument 0 */
mbed_official 87:085cde657901 2311 /* SD Card publishes its RCA. */
mbed_official 87:085cde657901 2312 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SET_REL_ADDR;
mbed_official 87:085cde657901 2313 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 2314 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 2315
mbed_official 87:085cde657901 2316 /* Check for error conditions */
mbed_official 87:085cde657901 2317 errorState = SD_CmdResp6Error(hsd, SD_CMD_SET_REL_ADDR, &sd_rca);
mbed_official 87:085cde657901 2318
mbed_official 87:085cde657901 2319 if(errorState != SD_OK)
mbed_official 87:085cde657901 2320 {
mbed_official 87:085cde657901 2321 return errorState;
mbed_official 87:085cde657901 2322 }
mbed_official 87:085cde657901 2323 }
mbed_official 87:085cde657901 2324
mbed_official 87:085cde657901 2325 if (hsd->CardType != SECURE_DIGITAL_IO_CARD)
mbed_official 87:085cde657901 2326 {
mbed_official 87:085cde657901 2327 /* Get the SD card RCA */
mbed_official 87:085cde657901 2328 hsd->RCA = sd_rca;
mbed_official 87:085cde657901 2329
mbed_official 87:085cde657901 2330 /* Send CMD9 SEND_CSD with argument as card's RCA */
mbed_official 87:085cde657901 2331 SDIO_CmdInitStructure.Argument = (uint32_t)(hsd->RCA << 16);
mbed_official 87:085cde657901 2332 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SEND_CSD;
mbed_official 87:085cde657901 2333 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_LONG;
mbed_official 87:085cde657901 2334 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 2335
mbed_official 87:085cde657901 2336 /* Check for error conditions */
mbed_official 87:085cde657901 2337 errorState = SD_CmdResp2Error(hsd);
mbed_official 87:085cde657901 2338
mbed_official 87:085cde657901 2339 if(errorState != SD_OK)
mbed_official 87:085cde657901 2340 {
mbed_official 87:085cde657901 2341 return errorState;
mbed_official 87:085cde657901 2342 }
mbed_official 87:085cde657901 2343
mbed_official 87:085cde657901 2344 /* Get Card Specific Data */
mbed_official 87:085cde657901 2345 hsd->CSD[0] = SDIO_GetResponse(SDIO_RESP1);
mbed_official 87:085cde657901 2346 hsd->CSD[1] = SDIO_GetResponse(SDIO_RESP2);
mbed_official 87:085cde657901 2347 hsd->CSD[2] = SDIO_GetResponse(SDIO_RESP3);
mbed_official 87:085cde657901 2348 hsd->CSD[3] = SDIO_GetResponse(SDIO_RESP4);
mbed_official 87:085cde657901 2349 }
mbed_official 87:085cde657901 2350
mbed_official 87:085cde657901 2351 /* All cards are initialized */
mbed_official 87:085cde657901 2352 return errorState;
mbed_official 87:085cde657901 2353 }
mbed_official 87:085cde657901 2354
mbed_official 87:085cde657901 2355 /**
mbed_official 87:085cde657901 2356 * @brief Selects od Deselects the corresponding card.
mbed_official 87:085cde657901 2357 * @param hsd: SD handle
mbed_official 87:085cde657901 2358 * @param addr: Address of the card to be selected
mbed_official 87:085cde657901 2359 * @retval SD Card error state
mbed_official 87:085cde657901 2360 */
mbed_official 87:085cde657901 2361 static HAL_SD_ErrorTypedef SD_Select_Deselect(SD_HandleTypeDef *hsd, uint64_t addr)
mbed_official 87:085cde657901 2362 {
mbed_official 87:085cde657901 2363 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
mbed_official 87:085cde657901 2364 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 2365
mbed_official 87:085cde657901 2366 /* Send CMD7 SDIO_SEL_DESEL_CARD */
mbed_official 87:085cde657901 2367 SDIO_CmdInitStructure.Argument = (uint32_t)addr;
mbed_official 87:085cde657901 2368 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SEL_DESEL_CARD;
mbed_official 87:085cde657901 2369 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 2370 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 2371 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 2372 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 2373
mbed_official 87:085cde657901 2374 /* Check for error conditions */
mbed_official 87:085cde657901 2375 errorState = SD_CmdResp1Error(hsd, SD_CMD_SEL_DESEL_CARD);
mbed_official 87:085cde657901 2376
mbed_official 87:085cde657901 2377 return errorState;
mbed_official 87:085cde657901 2378 }
mbed_official 87:085cde657901 2379
mbed_official 87:085cde657901 2380 /**
mbed_official 87:085cde657901 2381 * @brief Enquires cards about their operating voltage and configures clock
mbed_official 87:085cde657901 2382 * controls and stores SD information that will be needed in future
mbed_official 87:085cde657901 2383 * in the SD handle.
mbed_official 87:085cde657901 2384 * @param hsd: SD handle
mbed_official 87:085cde657901 2385 * @retval SD Card error state
mbed_official 87:085cde657901 2386 */
mbed_official 87:085cde657901 2387 static HAL_SD_ErrorTypedef SD_PowerON(SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 2388 {
mbed_official 87:085cde657901 2389 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
mbed_official 87:085cde657901 2390 __IO HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 2391 uint32_t response = 0, count = 0, validvoltage = 0;
mbed_official 87:085cde657901 2392 uint32_t SDType = SD_STD_CAPACITY;
mbed_official 87:085cde657901 2393
mbed_official 87:085cde657901 2394 /* Power ON Sequence -------------------------------------------------------*/
mbed_official 87:085cde657901 2395 /* Disable SDIO Clock */
mbed_official 87:085cde657901 2396 __HAL_SD_SDIO_DISABLE();
mbed_official 87:085cde657901 2397
mbed_official 87:085cde657901 2398 /* Set Power State to ON */
mbed_official 87:085cde657901 2399 SDIO_PowerState_ON(hsd->Instance);
mbed_official 87:085cde657901 2400
mbed_official 87:085cde657901 2401 /* Enable SDIO Clock */
mbed_official 87:085cde657901 2402 __HAL_SD_SDIO_ENABLE();
mbed_official 87:085cde657901 2403
mbed_official 87:085cde657901 2404 /* CMD0: GO_IDLE_STATE -----------------------------------------------------*/
mbed_official 87:085cde657901 2405 /* No CMD response required */
mbed_official 87:085cde657901 2406 SDIO_CmdInitStructure.Argument = 0;
mbed_official 87:085cde657901 2407 SDIO_CmdInitStructure.CmdIndex = SD_CMD_GO_IDLE_STATE;
mbed_official 87:085cde657901 2408 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_NO;
mbed_official 87:085cde657901 2409 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 2410 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 2411 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 2412
mbed_official 87:085cde657901 2413 /* Check for error conditions */
mbed_official 87:085cde657901 2414 errorState = SD_CmdError(hsd);
mbed_official 87:085cde657901 2415
mbed_official 87:085cde657901 2416 if(errorState != SD_OK)
mbed_official 87:085cde657901 2417 {
mbed_official 87:085cde657901 2418 /* CMD Response TimeOut (wait for CMDSENT flag) */
mbed_official 87:085cde657901 2419 return errorState;
mbed_official 87:085cde657901 2420 }
mbed_official 87:085cde657901 2421
mbed_official 87:085cde657901 2422 /* CMD8: SEND_IF_COND ------------------------------------------------------*/
mbed_official 87:085cde657901 2423 /* Send CMD8 to verify SD card interface operating condition */
mbed_official 87:085cde657901 2424 /* Argument: - [31:12]: Reserved (shall be set to '0')
mbed_official 87:085cde657901 2425 - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
mbed_official 87:085cde657901 2426 - [7:0]: Check Pattern (recommended 0xAA) */
mbed_official 87:085cde657901 2427 /* CMD Response: R7 */
mbed_official 87:085cde657901 2428 SDIO_CmdInitStructure.Argument = SD_CHECK_PATTERN;
mbed_official 87:085cde657901 2429 SDIO_CmdInitStructure.CmdIndex = SD_SDIO_SEND_IF_COND;
mbed_official 87:085cde657901 2430 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 2431 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 2432
mbed_official 87:085cde657901 2433 /* Check for error conditions */
mbed_official 87:085cde657901 2434 errorState = SD_CmdResp7Error(hsd);
mbed_official 87:085cde657901 2435
mbed_official 87:085cde657901 2436 if (errorState == SD_OK)
mbed_official 87:085cde657901 2437 {
mbed_official 87:085cde657901 2438 /* SD Card 2.0 */
mbed_official 87:085cde657901 2439 hsd->CardType = STD_CAPACITY_SD_CARD_V2_0;
mbed_official 87:085cde657901 2440 SDType = SD_HIGH_CAPACITY;
mbed_official 87:085cde657901 2441 }
mbed_official 87:085cde657901 2442
mbed_official 87:085cde657901 2443 /* Send CMD55 */
mbed_official 87:085cde657901 2444 SDIO_CmdInitStructure.Argument = 0;
mbed_official 87:085cde657901 2445 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_CMD;
mbed_official 87:085cde657901 2446 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 2447
mbed_official 87:085cde657901 2448 /* Check for error conditions */
mbed_official 87:085cde657901 2449 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
mbed_official 87:085cde657901 2450
mbed_official 87:085cde657901 2451 /* If errorState is Command TimeOut, it is a MMC card */
mbed_official 87:085cde657901 2452 /* If errorState is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)
mbed_official 87:085cde657901 2453 or SD card 1.x */
mbed_official 87:085cde657901 2454 if(errorState == SD_OK)
mbed_official 87:085cde657901 2455 {
mbed_official 87:085cde657901 2456 /* SD CARD */
mbed_official 87:085cde657901 2457 /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
mbed_official 87:085cde657901 2458 while((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
mbed_official 87:085cde657901 2459 {
mbed_official 87:085cde657901 2460
mbed_official 87:085cde657901 2461 /* SEND CMD55 APP_CMD with RCA as 0 */
mbed_official 87:085cde657901 2462 SDIO_CmdInitStructure.Argument = 0;
mbed_official 87:085cde657901 2463 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_CMD;
mbed_official 87:085cde657901 2464 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 2465 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 2466 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 2467 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 2468
mbed_official 87:085cde657901 2469 /* Check for error conditions */
mbed_official 87:085cde657901 2470 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
mbed_official 87:085cde657901 2471
mbed_official 87:085cde657901 2472 if(errorState != SD_OK)
mbed_official 87:085cde657901 2473 {
mbed_official 87:085cde657901 2474 return errorState;
mbed_official 87:085cde657901 2475 }
mbed_official 87:085cde657901 2476
mbed_official 87:085cde657901 2477 /* Send CMD41 */
mbed_official 87:085cde657901 2478 SDIO_CmdInitStructure.Argument = SD_VOLTAGE_WINDOW_SD | SDType;
mbed_official 87:085cde657901 2479 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SD_APP_OP_COND;
mbed_official 87:085cde657901 2480 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 2481 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 2482 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 2483 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 2484
mbed_official 87:085cde657901 2485 /* Check for error conditions */
mbed_official 87:085cde657901 2486 errorState = SD_CmdResp3Error(hsd);
mbed_official 87:085cde657901 2487
mbed_official 87:085cde657901 2488 if(errorState != SD_OK)
mbed_official 87:085cde657901 2489 {
mbed_official 87:085cde657901 2490 return errorState;
mbed_official 87:085cde657901 2491 }
mbed_official 87:085cde657901 2492
mbed_official 87:085cde657901 2493 /* Get command response */
mbed_official 87:085cde657901 2494 response = SDIO_GetResponse(SDIO_RESP1);
mbed_official 87:085cde657901 2495
mbed_official 87:085cde657901 2496 /* Get operating voltage*/
mbed_official 87:085cde657901 2497 validvoltage = (((response >> 31) == 1) ? 1 : 0);
mbed_official 87:085cde657901 2498
mbed_official 87:085cde657901 2499 count++;
mbed_official 87:085cde657901 2500 }
mbed_official 87:085cde657901 2501
mbed_official 87:085cde657901 2502 if(count >= SD_MAX_VOLT_TRIAL)
mbed_official 87:085cde657901 2503 {
mbed_official 87:085cde657901 2504 errorState = SD_INVALID_VOLTRANGE;
mbed_official 87:085cde657901 2505
mbed_official 87:085cde657901 2506 return errorState;
mbed_official 87:085cde657901 2507 }
mbed_official 87:085cde657901 2508
mbed_official 87:085cde657901 2509 if((response & SD_HIGH_CAPACITY) == SD_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
mbed_official 87:085cde657901 2510 {
mbed_official 87:085cde657901 2511 hsd->CardType = HIGH_CAPACITY_SD_CARD;
mbed_official 87:085cde657901 2512 }
mbed_official 87:085cde657901 2513
mbed_official 87:085cde657901 2514 } /* else MMC Card */
mbed_official 87:085cde657901 2515
mbed_official 87:085cde657901 2516 return errorState;
mbed_official 87:085cde657901 2517 }
mbed_official 87:085cde657901 2518
mbed_official 87:085cde657901 2519 /**
mbed_official 87:085cde657901 2520 * @brief Turns the SDIO output signals off.
mbed_official 87:085cde657901 2521 * @param hsd: SD handle
mbed_official 87:085cde657901 2522 * @retval SD Card error state
mbed_official 87:085cde657901 2523 */
mbed_official 87:085cde657901 2524 static HAL_SD_ErrorTypedef SD_PowerOFF(SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 2525 {
mbed_official 87:085cde657901 2526 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 2527
mbed_official 87:085cde657901 2528 /* Set Power State to OFF */
mbed_official 87:085cde657901 2529 SDIO_PowerState_OFF(hsd->Instance);
mbed_official 87:085cde657901 2530
mbed_official 87:085cde657901 2531 return errorState;
mbed_official 87:085cde657901 2532 }
mbed_official 87:085cde657901 2533
mbed_official 87:085cde657901 2534 /**
mbed_official 87:085cde657901 2535 * @brief Returns the current card's status.
mbed_official 87:085cde657901 2536 * @param hsd: SD handle
mbed_official 87:085cde657901 2537 * @param pCardStatus: pointer to the buffer that will contain the SD card
mbed_official 87:085cde657901 2538 * status (Card Status register)
mbed_official 87:085cde657901 2539 * @retval SD Card error state
mbed_official 87:085cde657901 2540 */
mbed_official 87:085cde657901 2541 static HAL_SD_ErrorTypedef SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
mbed_official 87:085cde657901 2542 {
mbed_official 87:085cde657901 2543 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
mbed_official 87:085cde657901 2544 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 2545
mbed_official 87:085cde657901 2546 if(pCardStatus == NULL)
mbed_official 87:085cde657901 2547 {
mbed_official 87:085cde657901 2548 errorState = SD_INVALID_PARAMETER;
mbed_official 87:085cde657901 2549
mbed_official 87:085cde657901 2550 return errorState;
mbed_official 87:085cde657901 2551 }
mbed_official 87:085cde657901 2552
mbed_official 87:085cde657901 2553 /* Send Status command */
mbed_official 87:085cde657901 2554 SDIO_CmdInitStructure.Argument = (uint32_t)(hsd->RCA << 16);
mbed_official 87:085cde657901 2555 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SEND_STATUS;
mbed_official 87:085cde657901 2556 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 2557 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 2558 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 2559 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 2560
mbed_official 87:085cde657901 2561 /* Check for error conditions */
mbed_official 87:085cde657901 2562 errorState = SD_CmdResp1Error(hsd, SD_CMD_SEND_STATUS);
mbed_official 87:085cde657901 2563
mbed_official 87:085cde657901 2564 if(errorState != SD_OK)
mbed_official 87:085cde657901 2565 {
mbed_official 87:085cde657901 2566 return errorState;
mbed_official 87:085cde657901 2567 }
mbed_official 87:085cde657901 2568
mbed_official 87:085cde657901 2569 /* Get SD card status */
mbed_official 87:085cde657901 2570 *pCardStatus = SDIO_GetResponse(SDIO_RESP1);
mbed_official 87:085cde657901 2571
mbed_official 87:085cde657901 2572 return errorState;
mbed_official 87:085cde657901 2573 }
mbed_official 87:085cde657901 2574
mbed_official 87:085cde657901 2575 /**
mbed_official 87:085cde657901 2576 * @brief Checks for error conditions for CMD0.
mbed_official 87:085cde657901 2577 * @param hsd: SD handle
mbed_official 87:085cde657901 2578 * @retval SD Card error state
mbed_official 87:085cde657901 2579 */
mbed_official 87:085cde657901 2580 static HAL_SD_ErrorTypedef SD_CmdError(SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 2581 {
mbed_official 87:085cde657901 2582 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 2583 uint32_t timeout, tmp;
mbed_official 87:085cde657901 2584
mbed_official 87:085cde657901 2585 timeout = SDIO_CMD0TIMEOUT;
mbed_official 87:085cde657901 2586
mbed_official 87:085cde657901 2587 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
mbed_official 87:085cde657901 2588
mbed_official 87:085cde657901 2589 while((timeout > 0) && (!tmp))
mbed_official 87:085cde657901 2590 {
mbed_official 87:085cde657901 2591 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDSENT);
mbed_official 87:085cde657901 2592 timeout--;
mbed_official 87:085cde657901 2593 }
mbed_official 87:085cde657901 2594
mbed_official 87:085cde657901 2595 if(timeout == 0)
mbed_official 87:085cde657901 2596 {
mbed_official 87:085cde657901 2597 errorState = SD_CMD_RSP_TIMEOUT;
mbed_official 87:085cde657901 2598 return errorState;
mbed_official 87:085cde657901 2599 }
mbed_official 87:085cde657901 2600
mbed_official 87:085cde657901 2601 /* Clear all the static flags */
mbed_official 87:085cde657901 2602 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
mbed_official 87:085cde657901 2603
mbed_official 87:085cde657901 2604 return errorState;
mbed_official 87:085cde657901 2605 }
mbed_official 87:085cde657901 2606
mbed_official 87:085cde657901 2607 /**
mbed_official 87:085cde657901 2608 * @brief Checks for error conditions for R7 response.
mbed_official 87:085cde657901 2609 * @param hsd: SD handle
mbed_official 87:085cde657901 2610 * @retval SD Card error state
mbed_official 87:085cde657901 2611 */
mbed_official 87:085cde657901 2612 static HAL_SD_ErrorTypedef SD_CmdResp7Error(SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 2613 {
mbed_official 87:085cde657901 2614 HAL_SD_ErrorTypedef errorState = SD_ERROR;
mbed_official 87:085cde657901 2615 uint32_t timeout = SDIO_CMD0TIMEOUT, tmp;
mbed_official 87:085cde657901 2616
mbed_official 87:085cde657901 2617 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
mbed_official 87:085cde657901 2618
mbed_official 87:085cde657901 2619 while((!tmp) && (timeout > 0))
mbed_official 87:085cde657901 2620 {
mbed_official 87:085cde657901 2621 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT);
mbed_official 87:085cde657901 2622 timeout--;
mbed_official 87:085cde657901 2623 }
mbed_official 87:085cde657901 2624
mbed_official 87:085cde657901 2625 tmp = __HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
mbed_official 87:085cde657901 2626
mbed_official 87:085cde657901 2627 if((timeout == 0) || tmp)
mbed_official 87:085cde657901 2628 {
mbed_official 87:085cde657901 2629 /* Card is not V2.0 compliant or card does not support the set voltage range */
mbed_official 87:085cde657901 2630 errorState = SD_CMD_RSP_TIMEOUT;
mbed_official 87:085cde657901 2631
mbed_official 87:085cde657901 2632 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
mbed_official 87:085cde657901 2633
mbed_official 87:085cde657901 2634 return errorState;
mbed_official 87:085cde657901 2635 }
mbed_official 87:085cde657901 2636
mbed_official 87:085cde657901 2637 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CMDREND))
mbed_official 87:085cde657901 2638 {
mbed_official 87:085cde657901 2639 /* Card is SD V2.0 compliant */
mbed_official 87:085cde657901 2640 errorState = SD_OK;
mbed_official 87:085cde657901 2641
mbed_official 87:085cde657901 2642 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CMDREND);
mbed_official 87:085cde657901 2643
mbed_official 87:085cde657901 2644 return errorState;
mbed_official 87:085cde657901 2645 }
mbed_official 87:085cde657901 2646
mbed_official 87:085cde657901 2647 return errorState;
mbed_official 87:085cde657901 2648 }
mbed_official 87:085cde657901 2649
mbed_official 87:085cde657901 2650 /**
mbed_official 87:085cde657901 2651 * @brief Checks for error conditions for R1 response.
mbed_official 87:085cde657901 2652 * @param hsd: SD handle
mbed_official 87:085cde657901 2653 * @param SD_CMD: The sent command index
mbed_official 87:085cde657901 2654 * @retval SD Card error state
mbed_official 87:085cde657901 2655 */
mbed_official 87:085cde657901 2656 static HAL_SD_ErrorTypedef SD_CmdResp1Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD)
mbed_official 87:085cde657901 2657 {
mbed_official 87:085cde657901 2658 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 2659 uint32_t response_R1;
mbed_official 87:085cde657901 2660
mbed_official 87:085cde657901 2661 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
mbed_official 87:085cde657901 2662 {
mbed_official 87:085cde657901 2663 }
mbed_official 87:085cde657901 2664
mbed_official 87:085cde657901 2665 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
mbed_official 87:085cde657901 2666 {
mbed_official 87:085cde657901 2667 errorState = SD_CMD_RSP_TIMEOUT;
mbed_official 87:085cde657901 2668
mbed_official 87:085cde657901 2669 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
mbed_official 87:085cde657901 2670
mbed_official 87:085cde657901 2671 return errorState;
mbed_official 87:085cde657901 2672 }
mbed_official 87:085cde657901 2673 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
mbed_official 87:085cde657901 2674 {
mbed_official 87:085cde657901 2675 errorState = SD_CMD_CRC_FAIL;
mbed_official 87:085cde657901 2676
mbed_official 87:085cde657901 2677 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
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 /* Check response received is of desired command */
mbed_official 87:085cde657901 2683 if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
mbed_official 87:085cde657901 2684 {
mbed_official 87:085cde657901 2685 errorState = SD_ILLEGAL_CMD;
mbed_official 87:085cde657901 2686
mbed_official 87:085cde657901 2687 return errorState;
mbed_official 87:085cde657901 2688 }
mbed_official 87:085cde657901 2689
mbed_official 87:085cde657901 2690 /* Clear all the static flags */
mbed_official 87:085cde657901 2691 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
mbed_official 87:085cde657901 2692
mbed_official 87:085cde657901 2693 /* We have received response, retrieve it for analysis */
mbed_official 87:085cde657901 2694 response_R1 = SDIO_GetResponse(SDIO_RESP1);
mbed_official 87:085cde657901 2695
mbed_official 87:085cde657901 2696 if((response_R1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
mbed_official 87:085cde657901 2697 {
mbed_official 87:085cde657901 2698 return errorState;
mbed_official 87:085cde657901 2699 }
mbed_official 87:085cde657901 2700
mbed_official 87:085cde657901 2701 if((response_R1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
mbed_official 87:085cde657901 2702 {
mbed_official 87:085cde657901 2703 return(SD_ADDR_OUT_OF_RANGE);
mbed_official 87:085cde657901 2704 }
mbed_official 87:085cde657901 2705
mbed_official 87:085cde657901 2706 if((response_R1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
mbed_official 87:085cde657901 2707 {
mbed_official 87:085cde657901 2708 return(SD_ADDR_MISALIGNED);
mbed_official 87:085cde657901 2709 }
mbed_official 87:085cde657901 2710
mbed_official 87:085cde657901 2711 if((response_R1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
mbed_official 87:085cde657901 2712 {
mbed_official 87:085cde657901 2713 return(SD_BLOCK_LEN_ERR);
mbed_official 87:085cde657901 2714 }
mbed_official 87:085cde657901 2715
mbed_official 87:085cde657901 2716 if((response_R1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
mbed_official 87:085cde657901 2717 {
mbed_official 87:085cde657901 2718 return(SD_ERASE_SEQ_ERR);
mbed_official 87:085cde657901 2719 }
mbed_official 87:085cde657901 2720
mbed_official 87:085cde657901 2721 if((response_R1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
mbed_official 87:085cde657901 2722 {
mbed_official 87:085cde657901 2723 return(SD_BAD_ERASE_PARAM);
mbed_official 87:085cde657901 2724 }
mbed_official 87:085cde657901 2725
mbed_official 87:085cde657901 2726 if((response_R1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
mbed_official 87:085cde657901 2727 {
mbed_official 87:085cde657901 2728 return(SD_WRITE_PROT_VIOLATION);
mbed_official 87:085cde657901 2729 }
mbed_official 87:085cde657901 2730
mbed_official 87:085cde657901 2731 if((response_R1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
mbed_official 87:085cde657901 2732 {
mbed_official 87:085cde657901 2733 return(SD_LOCK_UNLOCK_FAILED);
mbed_official 87:085cde657901 2734 }
mbed_official 87:085cde657901 2735
mbed_official 87:085cde657901 2736 if((response_R1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
mbed_official 87:085cde657901 2737 {
mbed_official 87:085cde657901 2738 return(SD_COM_CRC_FAILED);
mbed_official 87:085cde657901 2739 }
mbed_official 87:085cde657901 2740
mbed_official 87:085cde657901 2741 if((response_R1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
mbed_official 87:085cde657901 2742 {
mbed_official 87:085cde657901 2743 return(SD_ILLEGAL_CMD);
mbed_official 87:085cde657901 2744 }
mbed_official 87:085cde657901 2745
mbed_official 87:085cde657901 2746 if((response_R1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
mbed_official 87:085cde657901 2747 {
mbed_official 87:085cde657901 2748 return(SD_CARD_ECC_FAILED);
mbed_official 87:085cde657901 2749 }
mbed_official 87:085cde657901 2750
mbed_official 87:085cde657901 2751 if((response_R1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
mbed_official 87:085cde657901 2752 {
mbed_official 87:085cde657901 2753 return(SD_CC_ERROR);
mbed_official 87:085cde657901 2754 }
mbed_official 87:085cde657901 2755
mbed_official 87:085cde657901 2756 if((response_R1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
mbed_official 87:085cde657901 2757 {
mbed_official 87:085cde657901 2758 return(SD_GENERAL_UNKNOWN_ERROR);
mbed_official 87:085cde657901 2759 }
mbed_official 87:085cde657901 2760
mbed_official 87:085cde657901 2761 if((response_R1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
mbed_official 87:085cde657901 2762 {
mbed_official 87:085cde657901 2763 return(SD_STREAM_READ_UNDERRUN);
mbed_official 87:085cde657901 2764 }
mbed_official 87:085cde657901 2765
mbed_official 87:085cde657901 2766 if((response_R1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
mbed_official 87:085cde657901 2767 {
mbed_official 87:085cde657901 2768 return(SD_STREAM_WRITE_OVERRUN);
mbed_official 87:085cde657901 2769 }
mbed_official 87:085cde657901 2770
mbed_official 87:085cde657901 2771 if((response_R1 & SD_OCR_CID_CSD_OVERWRIETE) == SD_OCR_CID_CSD_OVERWRIETE)
mbed_official 87:085cde657901 2772 {
mbed_official 87:085cde657901 2773 return(SD_CID_CSD_OVERWRITE);
mbed_official 87:085cde657901 2774 }
mbed_official 87:085cde657901 2775
mbed_official 87:085cde657901 2776 if((response_R1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
mbed_official 87:085cde657901 2777 {
mbed_official 87:085cde657901 2778 return(SD_WP_ERASE_SKIP);
mbed_official 87:085cde657901 2779 }
mbed_official 87:085cde657901 2780
mbed_official 87:085cde657901 2781 if((response_R1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
mbed_official 87:085cde657901 2782 {
mbed_official 87:085cde657901 2783 return(SD_CARD_ECC_DISABLED);
mbed_official 87:085cde657901 2784 }
mbed_official 87:085cde657901 2785
mbed_official 87:085cde657901 2786 if((response_R1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
mbed_official 87:085cde657901 2787 {
mbed_official 87:085cde657901 2788 return(SD_ERASE_RESET);
mbed_official 87:085cde657901 2789 }
mbed_official 87:085cde657901 2790
mbed_official 87:085cde657901 2791 if((response_R1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
mbed_official 87:085cde657901 2792 {
mbed_official 87:085cde657901 2793 return(SD_AKE_SEQ_ERROR);
mbed_official 87:085cde657901 2794 }
mbed_official 87:085cde657901 2795
mbed_official 87:085cde657901 2796 return errorState;
mbed_official 87:085cde657901 2797 }
mbed_official 87:085cde657901 2798
mbed_official 87:085cde657901 2799 /**
mbed_official 87:085cde657901 2800 * @brief Checks for error conditions for R3 (OCR) response.
mbed_official 87:085cde657901 2801 * @param hsd: SD handle
mbed_official 87:085cde657901 2802 * @retval SD Card error state
mbed_official 87:085cde657901 2803 */
mbed_official 87:085cde657901 2804 static HAL_SD_ErrorTypedef SD_CmdResp3Error(SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 2805 {
mbed_official 87:085cde657901 2806 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 2807
mbed_official 87:085cde657901 2808 while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
mbed_official 87:085cde657901 2809 {
mbed_official 87:085cde657901 2810 }
mbed_official 87:085cde657901 2811
mbed_official 87:085cde657901 2812 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
mbed_official 87:085cde657901 2813 {
mbed_official 87:085cde657901 2814 errorState = SD_CMD_RSP_TIMEOUT;
mbed_official 87:085cde657901 2815
mbed_official 87:085cde657901 2816 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
mbed_official 87:085cde657901 2817
mbed_official 87:085cde657901 2818 return errorState;
mbed_official 87:085cde657901 2819 }
mbed_official 87:085cde657901 2820
mbed_official 87:085cde657901 2821 /* Clear all the static flags */
mbed_official 87:085cde657901 2822 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
mbed_official 87:085cde657901 2823
mbed_official 87:085cde657901 2824 return errorState;
mbed_official 87:085cde657901 2825 }
mbed_official 87:085cde657901 2826
mbed_official 87:085cde657901 2827 /**
mbed_official 87:085cde657901 2828 * @brief Checks for error conditions for R2 (CID or CSD) response.
mbed_official 87:085cde657901 2829 * @param hsd: SD handle
mbed_official 87:085cde657901 2830 * @retval SD Card error state
mbed_official 87:085cde657901 2831 */
mbed_official 87:085cde657901 2832 static HAL_SD_ErrorTypedef SD_CmdResp2Error(SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 2833 {
mbed_official 87:085cde657901 2834 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 2835
mbed_official 87:085cde657901 2836 while (!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
mbed_official 87:085cde657901 2837 {
mbed_official 87:085cde657901 2838 }
mbed_official 87:085cde657901 2839
mbed_official 87:085cde657901 2840 if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
mbed_official 87:085cde657901 2841 {
mbed_official 87:085cde657901 2842 errorState = SD_CMD_RSP_TIMEOUT;
mbed_official 87:085cde657901 2843
mbed_official 87:085cde657901 2844 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
mbed_official 87:085cde657901 2845
mbed_official 87:085cde657901 2846 return errorState;
mbed_official 87:085cde657901 2847 }
mbed_official 87:085cde657901 2848 else if (__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
mbed_official 87:085cde657901 2849 {
mbed_official 87:085cde657901 2850 errorState = SD_CMD_CRC_FAIL;
mbed_official 87:085cde657901 2851
mbed_official 87:085cde657901 2852 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
mbed_official 87:085cde657901 2853
mbed_official 87:085cde657901 2854 return errorState;
mbed_official 87:085cde657901 2855 }
mbed_official 87:085cde657901 2856
mbed_official 87:085cde657901 2857 /* Clear all the static flags */
mbed_official 87:085cde657901 2858 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
mbed_official 87:085cde657901 2859
mbed_official 87:085cde657901 2860 return errorState;
mbed_official 87:085cde657901 2861 }
mbed_official 87:085cde657901 2862
mbed_official 87:085cde657901 2863 /**
mbed_official 87:085cde657901 2864 * @brief Checks for error conditions for R6 (RCA) response.
mbed_official 87:085cde657901 2865 * @param hsd: SD handle
mbed_official 87:085cde657901 2866 * @param SD_CMD: The sent command index
mbed_official 87:085cde657901 2867 * @param pRCA: Pointer to the variable that will contain the SD card relative
mbed_official 87:085cde657901 2868 * address RCA
mbed_official 87:085cde657901 2869 * @retval SD Card error state
mbed_official 87:085cde657901 2870 */
mbed_official 87:085cde657901 2871 static HAL_SD_ErrorTypedef SD_CmdResp6Error(SD_HandleTypeDef *hsd, uint8_t SD_CMD, uint16_t *pRCA)
mbed_official 87:085cde657901 2872 {
mbed_official 87:085cde657901 2873 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 2874 uint32_t response_R1;
mbed_official 87:085cde657901 2875
mbed_official 87:085cde657901 2876 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
mbed_official 87:085cde657901 2877 {
mbed_official 87:085cde657901 2878 }
mbed_official 87:085cde657901 2879
mbed_official 87:085cde657901 2880 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
mbed_official 87:085cde657901 2881 {
mbed_official 87:085cde657901 2882 errorState = SD_CMD_RSP_TIMEOUT;
mbed_official 87:085cde657901 2883
mbed_official 87:085cde657901 2884 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
mbed_official 87:085cde657901 2885
mbed_official 87:085cde657901 2886 return errorState;
mbed_official 87:085cde657901 2887 }
mbed_official 87:085cde657901 2888 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
mbed_official 87:085cde657901 2889 {
mbed_official 87:085cde657901 2890 errorState = SD_CMD_CRC_FAIL;
mbed_official 87:085cde657901 2891
mbed_official 87:085cde657901 2892 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
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 /* Check response received is of desired command */
mbed_official 87:085cde657901 2898 if(SDIO_GetCommandResponse(hsd->Instance) != SD_CMD)
mbed_official 87:085cde657901 2899 {
mbed_official 87:085cde657901 2900 errorState = SD_ILLEGAL_CMD;
mbed_official 87:085cde657901 2901
mbed_official 87:085cde657901 2902 return errorState;
mbed_official 87:085cde657901 2903 }
mbed_official 87:085cde657901 2904
mbed_official 87:085cde657901 2905 /* Clear all the static flags */
mbed_official 87:085cde657901 2906 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
mbed_official 87:085cde657901 2907
mbed_official 87:085cde657901 2908 /* We have received response, retrieve it. */
mbed_official 87:085cde657901 2909 response_R1 = SDIO_GetResponse(SDIO_RESP1);
mbed_official 87:085cde657901 2910
mbed_official 87:085cde657901 2911 if((response_R1 & (SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD | SD_R6_COM_CRC_FAILED)) == SD_ALLZERO)
mbed_official 87:085cde657901 2912 {
mbed_official 87:085cde657901 2913 *pRCA = (uint16_t) (response_R1 >> 16);
mbed_official 87:085cde657901 2914
mbed_official 87:085cde657901 2915 return errorState;
mbed_official 87:085cde657901 2916 }
mbed_official 87:085cde657901 2917
mbed_official 87:085cde657901 2918 if((response_R1 & SD_R6_GENERAL_UNKNOWN_ERROR) == SD_R6_GENERAL_UNKNOWN_ERROR)
mbed_official 87:085cde657901 2919 {
mbed_official 87:085cde657901 2920 return(SD_GENERAL_UNKNOWN_ERROR);
mbed_official 87:085cde657901 2921 }
mbed_official 87:085cde657901 2922
mbed_official 87:085cde657901 2923 if((response_R1 & SD_R6_ILLEGAL_CMD) == SD_R6_ILLEGAL_CMD)
mbed_official 87:085cde657901 2924 {
mbed_official 87:085cde657901 2925 return(SD_ILLEGAL_CMD);
mbed_official 87:085cde657901 2926 }
mbed_official 87:085cde657901 2927
mbed_official 87:085cde657901 2928 if((response_R1 & SD_R6_COM_CRC_FAILED) == SD_R6_COM_CRC_FAILED)
mbed_official 87:085cde657901 2929 {
mbed_official 87:085cde657901 2930 return(SD_COM_CRC_FAILED);
mbed_official 87:085cde657901 2931 }
mbed_official 87:085cde657901 2932
mbed_official 87:085cde657901 2933 return errorState;
mbed_official 87:085cde657901 2934 }
mbed_official 87:085cde657901 2935
mbed_official 87:085cde657901 2936 /**
mbed_official 87:085cde657901 2937 * @brief Enables the SDIO wide bus mode.
mbed_official 87:085cde657901 2938 * @param hsd: SD handle
mbed_official 87:085cde657901 2939 * @retval SD Card error state
mbed_official 87:085cde657901 2940 */
mbed_official 87:085cde657901 2941 static HAL_SD_ErrorTypedef SD_WideBus_Enable(SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 2942 {
mbed_official 87:085cde657901 2943 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
mbed_official 87:085cde657901 2944 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 2945
mbed_official 87:085cde657901 2946 uint32_t scr[2] = {0, 0};
mbed_official 87:085cde657901 2947
mbed_official 87:085cde657901 2948 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
mbed_official 87:085cde657901 2949 {
mbed_official 87:085cde657901 2950 errorState = SD_LOCK_UNLOCK_FAILED;
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 /* Get SCR Register */
mbed_official 87:085cde657901 2956 errorState = SD_FindSCR(hsd, scr);
mbed_official 87:085cde657901 2957
mbed_official 87:085cde657901 2958 if(errorState != SD_OK)
mbed_official 87:085cde657901 2959 {
mbed_official 87:085cde657901 2960 return errorState;
mbed_official 87:085cde657901 2961 }
mbed_official 87:085cde657901 2962
mbed_official 87:085cde657901 2963 /* If requested card supports wide bus operation */
mbed_official 87:085cde657901 2964 if((scr[1] & SD_WIDE_BUS_SUPPORT) != SD_ALLZERO)
mbed_official 87:085cde657901 2965 {
mbed_official 87:085cde657901 2966 /* Send CMD55 APP_CMD with argument as card's RCA.*/
mbed_official 87:085cde657901 2967 SDIO_CmdInitStructure.Argument = (uint32_t)(hsd->RCA << 16);
mbed_official 87:085cde657901 2968 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_CMD;
mbed_official 87:085cde657901 2969 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 2970 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 2971 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 2972 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 2973
mbed_official 87:085cde657901 2974 /* Check for error conditions */
mbed_official 87:085cde657901 2975 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
mbed_official 87:085cde657901 2976
mbed_official 87:085cde657901 2977 if(errorState != SD_OK)
mbed_official 87:085cde657901 2978 {
mbed_official 87:085cde657901 2979 return errorState;
mbed_official 87:085cde657901 2980 }
mbed_official 87:085cde657901 2981
mbed_official 87:085cde657901 2982 /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
mbed_official 87:085cde657901 2983 SDIO_CmdInitStructure.Argument = 2;
mbed_official 87:085cde657901 2984 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
mbed_official 87:085cde657901 2985 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 2986
mbed_official 87:085cde657901 2987 /* Check for error conditions */
mbed_official 87:085cde657901 2988 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
mbed_official 87:085cde657901 2989
mbed_official 87:085cde657901 2990 if(errorState != SD_OK)
mbed_official 87:085cde657901 2991 {
mbed_official 87:085cde657901 2992 return errorState;
mbed_official 87:085cde657901 2993 }
mbed_official 87:085cde657901 2994
mbed_official 87:085cde657901 2995 return errorState;
mbed_official 87:085cde657901 2996 }
mbed_official 87:085cde657901 2997 else
mbed_official 87:085cde657901 2998 {
mbed_official 87:085cde657901 2999 errorState = SD_REQUEST_NOT_APPLICABLE;
mbed_official 87:085cde657901 3000
mbed_official 87:085cde657901 3001 return errorState;
mbed_official 87:085cde657901 3002 }
mbed_official 87:085cde657901 3003 }
mbed_official 87:085cde657901 3004
mbed_official 87:085cde657901 3005 /**
mbed_official 87:085cde657901 3006 * @brief Disables the SDIO wide bus mode.
mbed_official 87:085cde657901 3007 * @param hsd: SD handle
mbed_official 87:085cde657901 3008 * @retval SD Card error state
mbed_official 87:085cde657901 3009 */
mbed_official 87:085cde657901 3010 static HAL_SD_ErrorTypedef SD_WideBus_Disable(SD_HandleTypeDef *hsd)
mbed_official 87:085cde657901 3011 {
mbed_official 87:085cde657901 3012 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
mbed_official 87:085cde657901 3013 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 3014
mbed_official 87:085cde657901 3015 uint32_t scr[2] = {0, 0};
mbed_official 87:085cde657901 3016
mbed_official 87:085cde657901 3017 if((SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED) == SD_CARD_LOCKED)
mbed_official 87:085cde657901 3018 {
mbed_official 87:085cde657901 3019 errorState = SD_LOCK_UNLOCK_FAILED;
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 /* Get SCR Register */
mbed_official 87:085cde657901 3025 errorState = SD_FindSCR(hsd, scr);
mbed_official 87:085cde657901 3026
mbed_official 87:085cde657901 3027 if(errorState != SD_OK)
mbed_official 87:085cde657901 3028 {
mbed_official 87:085cde657901 3029 return errorState;
mbed_official 87:085cde657901 3030 }
mbed_official 87:085cde657901 3031
mbed_official 87:085cde657901 3032 /* If requested card supports 1 bit mode operation */
mbed_official 87:085cde657901 3033 if((scr[1] & SD_SINGLE_BUS_SUPPORT) != SD_ALLZERO)
mbed_official 87:085cde657901 3034 {
mbed_official 87:085cde657901 3035 /* Send CMD55 APP_CMD with argument as card's RCA */
mbed_official 87:085cde657901 3036 SDIO_CmdInitStructure.Argument = (uint32_t)(hsd->RCA << 16);
mbed_official 87:085cde657901 3037 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_CMD;
mbed_official 87:085cde657901 3038 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 3039 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 3040 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 3041 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 3042
mbed_official 87:085cde657901 3043 /* Check for error conditions */
mbed_official 87:085cde657901 3044 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
mbed_official 87:085cde657901 3045
mbed_official 87:085cde657901 3046 if(errorState != SD_OK)
mbed_official 87:085cde657901 3047 {
mbed_official 87:085cde657901 3048 return errorState;
mbed_official 87:085cde657901 3049 }
mbed_official 87:085cde657901 3050
mbed_official 87:085cde657901 3051 /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
mbed_official 87:085cde657901 3052 SDIO_CmdInitStructure.Argument = 0;
mbed_official 87:085cde657901 3053 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
mbed_official 87:085cde657901 3054 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 3055
mbed_official 87:085cde657901 3056 /* Check for error conditions */
mbed_official 87:085cde657901 3057 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_SD_SET_BUSWIDTH);
mbed_official 87:085cde657901 3058
mbed_official 87:085cde657901 3059 if(errorState != SD_OK)
mbed_official 87:085cde657901 3060 {
mbed_official 87:085cde657901 3061 return errorState;
mbed_official 87:085cde657901 3062 }
mbed_official 87:085cde657901 3063
mbed_official 87:085cde657901 3064 return errorState;
mbed_official 87:085cde657901 3065 }
mbed_official 87:085cde657901 3066 else
mbed_official 87:085cde657901 3067 {
mbed_official 87:085cde657901 3068 errorState = SD_REQUEST_NOT_APPLICABLE;
mbed_official 87:085cde657901 3069
mbed_official 87:085cde657901 3070 return errorState;
mbed_official 87:085cde657901 3071 }
mbed_official 87:085cde657901 3072 }
mbed_official 87:085cde657901 3073
mbed_official 87:085cde657901 3074
mbed_official 87:085cde657901 3075 /**
mbed_official 87:085cde657901 3076 * @brief Finds the SD card SCR register value.
mbed_official 87:085cde657901 3077 * @param hsd: SD handle
mbed_official 87:085cde657901 3078 * @param pSCR: pointer to the buffer that will contain the SCR value
mbed_official 87:085cde657901 3079 * @retval SD Card error state
mbed_official 87:085cde657901 3080 */
mbed_official 87:085cde657901 3081 static HAL_SD_ErrorTypedef SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
mbed_official 87:085cde657901 3082 {
mbed_official 87:085cde657901 3083 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
mbed_official 87:085cde657901 3084 SDIO_DataInitTypeDef SDIO_DataInitStructure;
mbed_official 87:085cde657901 3085 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 3086 uint32_t index = 0;
mbed_official 87:085cde657901 3087 uint32_t tempscr[2] = {0, 0};
mbed_official 87:085cde657901 3088
mbed_official 87:085cde657901 3089 /* Set Block Size To 8 Bytes */
mbed_official 87:085cde657901 3090 /* Send CMD55 APP_CMD with argument as card's RCA */
mbed_official 87:085cde657901 3091 SDIO_CmdInitStructure.Argument = (uint32_t)8;
mbed_official 87:085cde657901 3092 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SET_BLOCKLEN;
mbed_official 87:085cde657901 3093 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 3094 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 3095 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 3096 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 3097
mbed_official 87:085cde657901 3098 /* Check for error conditions */
mbed_official 87:085cde657901 3099 errorState = SD_CmdResp1Error(hsd, SD_CMD_SET_BLOCKLEN);
mbed_official 87:085cde657901 3100
mbed_official 87:085cde657901 3101 if(errorState != SD_OK)
mbed_official 87:085cde657901 3102 {
mbed_official 87:085cde657901 3103 return errorState;
mbed_official 87:085cde657901 3104 }
mbed_official 87:085cde657901 3105
mbed_official 87:085cde657901 3106 /* Send CMD55 APP_CMD with argument as card's RCA */
mbed_official 87:085cde657901 3107 SDIO_CmdInitStructure.Argument = (uint32_t)((hsd->RCA) << 16);
mbed_official 87:085cde657901 3108 SDIO_CmdInitStructure.CmdIndex = SD_CMD_APP_CMD;
mbed_official 87:085cde657901 3109 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 3110
mbed_official 87:085cde657901 3111 /* Check for error conditions */
mbed_official 87:085cde657901 3112 errorState = SD_CmdResp1Error(hsd, SD_CMD_APP_CMD);
mbed_official 87:085cde657901 3113
mbed_official 87:085cde657901 3114 if(errorState != SD_OK)
mbed_official 87:085cde657901 3115 {
mbed_official 87:085cde657901 3116 return errorState;
mbed_official 87:085cde657901 3117 }
mbed_official 87:085cde657901 3118 SDIO_DataInitStructure.DataTimeOut = SD_DATATIMEOUT;
mbed_official 87:085cde657901 3119 SDIO_DataInitStructure.DataLength = 8;
mbed_official 87:085cde657901 3120 SDIO_DataInitStructure.DataBlockSize = SDIO_DATABLOCK_SIZE_8B;
mbed_official 87:085cde657901 3121 SDIO_DataInitStructure.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
mbed_official 87:085cde657901 3122 SDIO_DataInitStructure.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
mbed_official 87:085cde657901 3123 SDIO_DataInitStructure.DPSM = SDIO_DPSM_ENABLE;
mbed_official 87:085cde657901 3124 SDIO_DataConfig(hsd->Instance, &SDIO_DataInitStructure);
mbed_official 87:085cde657901 3125
mbed_official 87:085cde657901 3126 /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
mbed_official 87:085cde657901 3127 SDIO_CmdInitStructure.Argument = 0;
mbed_official 87:085cde657901 3128 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SD_APP_SEND_SCR;
mbed_official 87:085cde657901 3129 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 3130
mbed_official 87:085cde657901 3131 /* Check for error conditions */
mbed_official 87:085cde657901 3132 errorState = SD_CmdResp1Error(hsd, SD_CMD_SD_APP_SEND_SCR);
mbed_official 87:085cde657901 3133
mbed_official 87:085cde657901 3134 if(errorState != SD_OK)
mbed_official 87:085cde657901 3135 {
mbed_official 87:085cde657901 3136 return errorState;
mbed_official 87:085cde657901 3137 }
mbed_official 87:085cde657901 3138
mbed_official 87:085cde657901 3139 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 3140 {
mbed_official 87:085cde657901 3141 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_RXDAVL))
mbed_official 87:085cde657901 3142 {
mbed_official 87:085cde657901 3143 *(tempscr + index) = SDIO_ReadFIFO(hsd->Instance);
mbed_official 87:085cde657901 3144 index++;
mbed_official 87:085cde657901 3145 }
mbed_official 87:085cde657901 3146 }
mbed_official 87:085cde657901 3147
mbed_official 87:085cde657901 3148 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
mbed_official 87:085cde657901 3149 {
mbed_official 87:085cde657901 3150 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
mbed_official 87:085cde657901 3151
mbed_official 87:085cde657901 3152 errorState = SD_DATA_TIMEOUT;
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_DCRCFAIL))
mbed_official 87:085cde657901 3157 {
mbed_official 87:085cde657901 3158 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
mbed_official 87:085cde657901 3159
mbed_official 87:085cde657901 3160 errorState = SD_DATA_CRC_FAIL;
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_RXOVERR))
mbed_official 87:085cde657901 3165 {
mbed_official 87:085cde657901 3166 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
mbed_official 87:085cde657901 3167
mbed_official 87:085cde657901 3168 errorState = SD_RX_OVERRUN;
mbed_official 87:085cde657901 3169
mbed_official 87:085cde657901 3170 return errorState;
mbed_official 87:085cde657901 3171 }
mbed_official 87:085cde657901 3172 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_STBITERR))
mbed_official 87:085cde657901 3173 {
mbed_official 87:085cde657901 3174 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_STBITERR);
mbed_official 87:085cde657901 3175
mbed_official 87:085cde657901 3176 errorState = SD_START_BIT_ERR;
mbed_official 87:085cde657901 3177
mbed_official 87:085cde657901 3178 return errorState;
mbed_official 87:085cde657901 3179 }
mbed_official 87:085cde657901 3180
mbed_official 87:085cde657901 3181 /* Clear all the static flags */
mbed_official 87:085cde657901 3182 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
mbed_official 87:085cde657901 3183
mbed_official 87:085cde657901 3184 *(pSCR + 1) = ((tempscr[0] & SD_0TO7BITS) << 24) | ((tempscr[0] & SD_8TO15BITS) << 8) |\
mbed_official 87:085cde657901 3185 ((tempscr[0] & SD_16TO23BITS) >> 8) | ((tempscr[0] & SD_24TO31BITS) >> 24);
mbed_official 87:085cde657901 3186
mbed_official 87:085cde657901 3187 *(pSCR) = ((tempscr[1] & SD_0TO7BITS) << 24) | ((tempscr[1] & SD_8TO15BITS) << 8) |\
mbed_official 87:085cde657901 3188 ((tempscr[1] & SD_16TO23BITS) >> 8) | ((tempscr[1] & SD_24TO31BITS) >> 24);
mbed_official 87:085cde657901 3189
mbed_official 87:085cde657901 3190 return errorState;
mbed_official 87:085cde657901 3191 }
mbed_official 87:085cde657901 3192
mbed_official 87:085cde657901 3193 /**
mbed_official 87:085cde657901 3194 * @brief Checks if the SD card is in programming state.
mbed_official 87:085cde657901 3195 * @param hsd: SD handle
mbed_official 87:085cde657901 3196 * @param pStatus: pointer to the variable that will contain the SD card state
mbed_official 87:085cde657901 3197 * @retval SD Card error state
mbed_official 87:085cde657901 3198 */
mbed_official 87:085cde657901 3199 static HAL_SD_ErrorTypedef SD_IsCardProgramming(SD_HandleTypeDef *hsd, uint8_t *pStatus)
mbed_official 87:085cde657901 3200 {
mbed_official 87:085cde657901 3201 SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
mbed_official 87:085cde657901 3202 HAL_SD_ErrorTypedef errorState = SD_OK;
mbed_official 87:085cde657901 3203 __IO uint32_t responseR1 = 0;
mbed_official 87:085cde657901 3204
mbed_official 87:085cde657901 3205 SDIO_CmdInitStructure.Argument = (uint32_t)(hsd->RCA << 16);
mbed_official 87:085cde657901 3206 SDIO_CmdInitStructure.CmdIndex = SD_CMD_SEND_STATUS;
mbed_official 87:085cde657901 3207 SDIO_CmdInitStructure.Response = SDIO_RESPONSE_SHORT;
mbed_official 87:085cde657901 3208 SDIO_CmdInitStructure.WaitForInterrupt = SDIO_WAIT_NO;
mbed_official 87:085cde657901 3209 SDIO_CmdInitStructure.CPSM = SDIO_CPSM_ENABLE;
mbed_official 87:085cde657901 3210 SDIO_SendCommand(hsd->Instance, &SDIO_CmdInitStructure);
mbed_official 87:085cde657901 3211
mbed_official 87:085cde657901 3212 while(!__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT))
mbed_official 87:085cde657901 3213 {
mbed_official 87:085cde657901 3214 }
mbed_official 87:085cde657901 3215
mbed_official 87:085cde657901 3216 if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CTIMEOUT))
mbed_official 87:085cde657901 3217 {
mbed_official 87:085cde657901 3218 errorState = SD_CMD_RSP_TIMEOUT;
mbed_official 87:085cde657901 3219
mbed_official 87:085cde657901 3220 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CTIMEOUT);
mbed_official 87:085cde657901 3221
mbed_official 87:085cde657901 3222 return errorState;
mbed_official 87:085cde657901 3223 }
mbed_official 87:085cde657901 3224 else if(__HAL_SD_SDIO_GET_FLAG(hsd, SDIO_FLAG_CCRCFAIL))
mbed_official 87:085cde657901 3225 {
mbed_official 87:085cde657901 3226 errorState = SD_CMD_CRC_FAIL;
mbed_official 87:085cde657901 3227
mbed_official 87:085cde657901 3228 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_FLAG_CCRCFAIL);
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 /* Check response received is of desired command */
mbed_official 87:085cde657901 3234 if((uint32_t)SDIO_GetCommandResponse(hsd->Instance) != SD_CMD_SEND_STATUS)
mbed_official 87:085cde657901 3235 {
mbed_official 87:085cde657901 3236 errorState = SD_ILLEGAL_CMD;
mbed_official 87:085cde657901 3237
mbed_official 87:085cde657901 3238 return errorState;
mbed_official 87:085cde657901 3239 }
mbed_official 87:085cde657901 3240
mbed_official 87:085cde657901 3241 /* Clear all the static flags */
mbed_official 87:085cde657901 3242 __HAL_SD_SDIO_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
mbed_official 87:085cde657901 3243
mbed_official 87:085cde657901 3244
mbed_official 87:085cde657901 3245 /* We have received response, retrieve it for analysis */
mbed_official 87:085cde657901 3246 responseR1 = SDIO_GetResponse(SDIO_RESP1);
mbed_official 87:085cde657901 3247
mbed_official 87:085cde657901 3248 /* Find out card status */
mbed_official 87:085cde657901 3249 *pStatus = (uint8_t)((responseR1 >> 9) & 0x0000000F);
mbed_official 87:085cde657901 3250
mbed_official 87:085cde657901 3251 if((responseR1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
mbed_official 87:085cde657901 3252 {
mbed_official 87:085cde657901 3253 return errorState;
mbed_official 87:085cde657901 3254 }
mbed_official 87:085cde657901 3255
mbed_official 87:085cde657901 3256 if((responseR1 & SD_OCR_ADDR_OUT_OF_RANGE) == SD_OCR_ADDR_OUT_OF_RANGE)
mbed_official 87:085cde657901 3257 {
mbed_official 87:085cde657901 3258 return(SD_ADDR_OUT_OF_RANGE);
mbed_official 87:085cde657901 3259 }
mbed_official 87:085cde657901 3260
mbed_official 87:085cde657901 3261 if((responseR1 & SD_OCR_ADDR_MISALIGNED) == SD_OCR_ADDR_MISALIGNED)
mbed_official 87:085cde657901 3262 {
mbed_official 87:085cde657901 3263 return(SD_ADDR_MISALIGNED);
mbed_official 87:085cde657901 3264 }
mbed_official 87:085cde657901 3265
mbed_official 87:085cde657901 3266 if((responseR1 & SD_OCR_BLOCK_LEN_ERR) == SD_OCR_BLOCK_LEN_ERR)
mbed_official 87:085cde657901 3267 {
mbed_official 87:085cde657901 3268 return(SD_BLOCK_LEN_ERR);
mbed_official 87:085cde657901 3269 }
mbed_official 87:085cde657901 3270
mbed_official 87:085cde657901 3271 if((responseR1 & SD_OCR_ERASE_SEQ_ERR) == SD_OCR_ERASE_SEQ_ERR)
mbed_official 87:085cde657901 3272 {
mbed_official 87:085cde657901 3273 return(SD_ERASE_SEQ_ERR);
mbed_official 87:085cde657901 3274 }
mbed_official 87:085cde657901 3275
mbed_official 87:085cde657901 3276 if((responseR1 & SD_OCR_BAD_ERASE_PARAM) == SD_OCR_BAD_ERASE_PARAM)
mbed_official 87:085cde657901 3277 {
mbed_official 87:085cde657901 3278 return(SD_BAD_ERASE_PARAM);
mbed_official 87:085cde657901 3279 }
mbed_official 87:085cde657901 3280
mbed_official 87:085cde657901 3281 if((responseR1 & SD_OCR_WRITE_PROT_VIOLATION) == SD_OCR_WRITE_PROT_VIOLATION)
mbed_official 87:085cde657901 3282 {
mbed_official 87:085cde657901 3283 return(SD_WRITE_PROT_VIOLATION);
mbed_official 87:085cde657901 3284 }
mbed_official 87:085cde657901 3285
mbed_official 87:085cde657901 3286 if((responseR1 & SD_OCR_LOCK_UNLOCK_FAILED) == SD_OCR_LOCK_UNLOCK_FAILED)
mbed_official 87:085cde657901 3287 {
mbed_official 87:085cde657901 3288 return(SD_LOCK_UNLOCK_FAILED);
mbed_official 87:085cde657901 3289 }
mbed_official 87:085cde657901 3290
mbed_official 87:085cde657901 3291 if((responseR1 & SD_OCR_COM_CRC_FAILED) == SD_OCR_COM_CRC_FAILED)
mbed_official 87:085cde657901 3292 {
mbed_official 87:085cde657901 3293 return(SD_COM_CRC_FAILED);
mbed_official 87:085cde657901 3294 }
mbed_official 87:085cde657901 3295
mbed_official 87:085cde657901 3296 if((responseR1 & SD_OCR_ILLEGAL_CMD) == SD_OCR_ILLEGAL_CMD)
mbed_official 87:085cde657901 3297 {
mbed_official 87:085cde657901 3298 return(SD_ILLEGAL_CMD);
mbed_official 87:085cde657901 3299 }
mbed_official 87:085cde657901 3300
mbed_official 87:085cde657901 3301 if((responseR1 & SD_OCR_CARD_ECC_FAILED) == SD_OCR_CARD_ECC_FAILED)
mbed_official 87:085cde657901 3302 {
mbed_official 87:085cde657901 3303 return(SD_CARD_ECC_FAILED);
mbed_official 87:085cde657901 3304 }
mbed_official 87:085cde657901 3305
mbed_official 87:085cde657901 3306 if((responseR1 & SD_OCR_CC_ERROR) == SD_OCR_CC_ERROR)
mbed_official 87:085cde657901 3307 {
mbed_official 87:085cde657901 3308 return(SD_CC_ERROR);
mbed_official 87:085cde657901 3309 }
mbed_official 87:085cde657901 3310
mbed_official 87:085cde657901 3311 if((responseR1 & SD_OCR_GENERAL_UNKNOWN_ERROR) == SD_OCR_GENERAL_UNKNOWN_ERROR)
mbed_official 87:085cde657901 3312 {
mbed_official 87:085cde657901 3313 return(SD_GENERAL_UNKNOWN_ERROR);
mbed_official 87:085cde657901 3314 }
mbed_official 87:085cde657901 3315
mbed_official 87:085cde657901 3316 if((responseR1 & SD_OCR_STREAM_READ_UNDERRUN) == SD_OCR_STREAM_READ_UNDERRUN)
mbed_official 87:085cde657901 3317 {
mbed_official 87:085cde657901 3318 return(SD_STREAM_READ_UNDERRUN);
mbed_official 87:085cde657901 3319 }
mbed_official 87:085cde657901 3320
mbed_official 87:085cde657901 3321 if((responseR1 & SD_OCR_STREAM_WRITE_OVERRUN) == SD_OCR_STREAM_WRITE_OVERRUN)
mbed_official 87:085cde657901 3322 {
mbed_official 87:085cde657901 3323 return(SD_STREAM_WRITE_OVERRUN);
mbed_official 87:085cde657901 3324 }
mbed_official 87:085cde657901 3325
mbed_official 87:085cde657901 3326 if((responseR1 & SD_OCR_CID_CSD_OVERWRIETE) == SD_OCR_CID_CSD_OVERWRIETE)
mbed_official 87:085cde657901 3327 {
mbed_official 87:085cde657901 3328 return(SD_CID_CSD_OVERWRITE);
mbed_official 87:085cde657901 3329 }
mbed_official 87:085cde657901 3330
mbed_official 87:085cde657901 3331 if((responseR1 & SD_OCR_WP_ERASE_SKIP) == SD_OCR_WP_ERASE_SKIP)
mbed_official 87:085cde657901 3332 {
mbed_official 87:085cde657901 3333 return(SD_WP_ERASE_SKIP);
mbed_official 87:085cde657901 3334 }
mbed_official 87:085cde657901 3335
mbed_official 87:085cde657901 3336 if((responseR1 & SD_OCR_CARD_ECC_DISABLED) == SD_OCR_CARD_ECC_DISABLED)
mbed_official 87:085cde657901 3337 {
mbed_official 87:085cde657901 3338 return(SD_CARD_ECC_DISABLED);
mbed_official 87:085cde657901 3339 }
mbed_official 87:085cde657901 3340
mbed_official 87:085cde657901 3341 if((responseR1 & SD_OCR_ERASE_RESET) == SD_OCR_ERASE_RESET)
mbed_official 87:085cde657901 3342 {
mbed_official 87:085cde657901 3343 return(SD_ERASE_RESET);
mbed_official 87:085cde657901 3344 }
mbed_official 87:085cde657901 3345
mbed_official 87:085cde657901 3346 if((responseR1 & SD_OCR_AKE_SEQ_ERROR) == SD_OCR_AKE_SEQ_ERROR)
mbed_official 87:085cde657901 3347 {
mbed_official 87:085cde657901 3348 return(SD_AKE_SEQ_ERROR);
mbed_official 87:085cde657901 3349 }
mbed_official 87:085cde657901 3350
mbed_official 87:085cde657901 3351 return errorState;
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 #endif /* HAL_SD_MODULE_ENABLED */
mbed_official 87:085cde657901 3359 /**
mbed_official 87:085cde657901 3360 * @}
mbed_official 87:085cde657901 3361 */
mbed_official 87:085cde657901 3362
mbed_official 87:085cde657901 3363 /**
mbed_official 87:085cde657901 3364 * @}
mbed_official 87:085cde657901 3365 */
mbed_official 87:085cde657901 3366
mbed_official 87:085cde657901 3367 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/