mbed-dev | Mbed

Users » fwndz » Code » mbed-dev

targets/cmsis/TARGET_STM/TARGET_STM32F1/stm32f1xx_hal_sd.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

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

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

Repository toolbox

Repository details

Type:	Library
Created:	21 Dec 2016
Imports:	1
Forks:	0
Commits:	154
Dependents:	0
Dependencies:	0
Followers:	1

Important changes to repositories hosted on mbed.com

targets/cmsis/TARGET_STM/TARGET_STM32F1/stm32f1xx_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

Important changes to repositories hosted on mbed.com

targets/cmsis/TARGET_STM/TARGET_STM32F1/stm32f1xx_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