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_STM32L4/stm32l4xx_hal_sd.c@610:813dcc80987e, 2015-08-14 (annotated)

Committer:
mbed_official
Date:
Fri Aug 14 13:15:17 2015 +0100
Revision:
610:813dcc80987e
Synchronized with git revision 6d84db41c6833e0b9b024741eb0616a5f62d5599



Full URL: https://github.com/mbedmicro/mbed/commit/6d84db41c6833e0b9b024741eb0616a5f62d5599/



DISCO_F746NG - Improvements

Who changed what in which revision?

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