mbed-F401 - mbed library with additional peripherals for ST F…

Users » dreschpe » Code » mbed-F401

Peter Drescher / mbed-F401

mbed library with additional peripherals for ST F401 board

Fork of mbed-src by mbed official

This mbed LIB has additional peripherals for ST F401 board

UART2 : PA_3 rx, PA_2 tx
UART3 : PC_7 rx, PC_6 tx
I2C2 : PB_3 SDA, PB_10 SCL
I2C3 : PB_4 SDA, PA_8 SCL

targets/cmsis/TARGET_STM/TARGET_NUCLEO_F401RE/stm32f4xx_hal_sd.c@106:ced8cbb51063, 2014-02-26 (annotated)

Committer:: mbed_official
Date:: Wed Feb 26 09:45:12 2014 +0000
Revision:: 106:ced8cbb51063
Parent:: 87:085cde657901

Synchronized with git revision 4222735eff5868389433f0e9271976b39c8115cd



Full URL: https://github.com/mbedmicro/mbed/commit/4222735eff5868389433f0e9271976b39c8115cd/



[NUCLEO_xxx] Update STM32CubeF4 driver V1.0.0 + update license

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	08 Mar 2014
Imports:	301
Forks:	0
Commits:	115
Dependents:	0
Dependencies:	0
Followers:	15
Issues:	1

targets/cmsis/TARGET_STM/TARGET_NUCLEO_F401RE/stm32f4xx_hal_sd.c@106:ced8cbb51063, 2014-02-26 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning