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@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Committer:: <>
Date:: Fri Sep 02 15:07:44 2016 +0100
Revision:: 144:ef7eb2e8f9f7

This updates the lib to the mbed lib v125

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@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning