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_STM32L1/stm32l1xx_hal_sd.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
394:83f921546702 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



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



Initial version of drivers for SAMR21

Who changed what in which revision?

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