mbed-src - mbed library sources

Users » BigDotStu » Code » mbed-src

Stuart Northfield / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_sd.c@394:83f921546702, 2014-11-07 (annotated)

Committer:: mbed_official
Date:: Fri Nov 07 15:45:07 2014 +0000
Revision:: 394:83f921546702
Parent:: targets/cmsis/TARGET_STM/TARGET_NUCLEO_L152RE/stm32l1xx_hal_sd.c@354:e67efb2aab0e

Synchronized with git revision aab52cb7ec5a665869e507dd988bbfd55b7e087e

Full URL: https://github.com/mbedmicro/mbed/commit/aab52cb7ec5a665869e507dd988bbfd55b7e087e/

Tests: Fix cpputest testrunner

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	15 Nov 2014
Imports:	9
Forks:	0
Commits:	401
Dependents:	0
Dependencies:	0
Followers:	3

Developers

Stuart Northfield

Tony Engeham

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_sd.c@394:83f921546702, 2014-11-07 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Developers

Important Information for this Arm website

Access Warning