mbed-dev - added prescaler for 16 bit pwm in LPC1347 target

Users » JojoS » Code » mbed-dev

added prescaler for 16 bit pwm in LPC1347 target

targets/cmsis/TARGET_STM/TARGET_STM32F2/stm32f2xx_hal_sd.c@147:ba84b7dc41a7, 2016-09-10 (annotated)

Committer:: JojoS
Date:: Sat Sep 10 15:32:04 2016 +0000
Revision:: 147:ba84b7dc41a7
Parent:: 144:ef7eb2e8f9f7

added prescaler for 16 bit timers (solution as in LPC11xx), default prescaler 31 for max 28 ms period time

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	10 Sep 2016
Imports:	1
Forks:	0
Commits:	148
Dependents:	0
Dependencies:	0
Followers:	1

targets/cmsis/TARGET_STM/TARGET_STM32F2/stm32f2xx_hal_sd.c@147:ba84b7dc41a7, 2016-09-10 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning