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