Statistics
| Branch: | Tag: | Revision:

amiro-blt / Target / Modules / PowerManagement_1-1 / Boot / lib / fatfs / mmc.c @ 367c0652

History | View | Annotate | Download (108 KB)

1 69661903 Thomas Schöpping
/****************************************************************************************
2
| Project Name: Application Development using the Olimex STM32-E407 board
3
|  Description: Disk I/O source file for FatFS configured for an MMC card on SDIO.
4
|    File Name: mmc.c
5
|        Notes: The SDIO interface was derived from the SDCARD example that comes with
6
|               the Standard Peripheral Library from STMicroelectronics as falls under
7
|               their copyright and license. By using this file you agree to:
8
|
9
|                   COPYRIGHT 2013 STMicroelectronics
10
|
11
|        Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
12
|        You may not use this file except in compliance with the License.
13
|        You may obtain a copy of the License at:
14
|   
15
|             http://www.st.com/software_license_agreement_liberty_v2
16
|   
17
|        Unless required by applicable law or agreed to in writing, software 
18
|        distributed under the License is distributed on an "AS IS" BASIS, 
19
|        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20
|        See the License for the specific language governing permissions and
21
|        limitations under the License.
22
|
23
|****************************************************************************************/
24
25
26
/****************************************************************************************
27
* Include files
28
****************************************************************************************/
29
#include <string.h> 
30
#include "diskio.h"
31
#include "stm32f4xx.h"
32
33
/****************************************************************************************
34
* Type definitions
35
****************************************************************************************/
36
/** 
37
  * @brief  SDIO specific error defines  
38
  */   
39
typedef enum
40
{
41
  SD_CMD_CRC_FAIL                    = (1), /*!< Command response received (but CRC check failed) */
42
  SD_DATA_CRC_FAIL                   = (2), /*!< Data bock sent/received (CRC check Failed) */
43
  SD_CMD_RSP_TIMEOUT                 = (3), /*!< Command response timeout */
44
  SD_DATA_TIMEOUT                    = (4), /*!< Data time out */
45
  SD_TX_UNDERRUN                     = (5), /*!< Transmit FIFO under-run */
46
  SD_RX_OVERRUN                      = (6), /*!< Receive FIFO over-run */
47
  SD_START_BIT_ERR                   = (7), /*!< Start bit not detected on all data signals in widE bus mode */
48
  SD_CMD_OUT_OF_RANGE                = (8), /*!< CMD's argument was out of range.*/
49
  SD_ADDR_MISALIGNED                 = (9), /*!< Misaligned address */
50
  SD_BLOCK_LEN_ERR                   = (10), /*!< Transferred block length is not allowed for the card or the number of transferred bytes does not match the block length */
51
  SD_ERASE_SEQ_ERR                   = (11), /*!< An error in the sequence of erase command occurs.*/
52
  SD_BAD_ERASE_PARAM                 = (12), /*!< An Invalid selection for erase groups */
53
  SD_WRITE_PROT_VIOLATION            = (13), /*!< Attempt to program a write protect block */
54
  SD_LOCK_UNLOCK_FAILED              = (14), /*!< Sequence or password error has been detected in unlock command or if there was an attempt to access a locked card */
55
  SD_COM_CRC_FAILED                  = (15), /*!< CRC check of the previous command failed */
56
  SD_ILLEGAL_CMD                     = (16), /*!< Command is not legal for the card state */
57
  SD_CARD_ECC_FAILED                 = (17), /*!< Card internal ECC was applied but failed to correct the data */
58
  SD_CC_ERROR                        = (18), /*!< Internal card controller error */
59
  SD_GENERAL_UNKNOWN_ERROR           = (19), /*!< General or Unknown error */
60
  SD_STREAM_READ_UNDERRUN            = (20), /*!< The card could not sustain data transfer in stream read operation. */
61
  SD_STREAM_WRITE_OVERRUN            = (21), /*!< The card could not sustain data programming in stream mode */
62
  SD_CID_CSD_OVERWRITE               = (22), /*!< CID/CSD overwrite error */
63
  SD_WP_ERASE_SKIP                   = (23), /*!< only partial address space was erased */
64
  SD_CARD_ECC_DISABLED               = (24), /*!< Command has been executed without using internal ECC */
65
  SD_ERASE_RESET                     = (25), /*!< Erase sequence was cleared before executing because an out of erase sequence command was received */
66
  SD_AKE_SEQ_ERROR                   = (26), /*!< Error in sequence of authentication. */
67
  SD_INVALID_VOLTRANGE               = (27),
68
  SD_ADDR_OUT_OF_RANGE               = (28),
69
  SD_SWITCH_ERROR                    = (29),
70
  SD_SDIO_DISABLED                   = (30),
71
  SD_SDIO_FUNCTION_BUSY              = (31),
72
  SD_SDIO_FUNCTION_FAILED            = (32),
73
  SD_SDIO_UNKNOWN_FUNCTION           = (33),
74
75
/** 
76
  * @brief  Standard error defines   
77
  */ 
78
  SD_INTERNAL_ERROR, 
79
  SD_NOT_CONFIGURED,
80
  SD_REQUEST_PENDING, 
81
  SD_REQUEST_NOT_APPLICABLE, 
82
  SD_INVALID_PARAMETER,  
83
  SD_UNSUPPORTED_FEATURE,  
84
  SD_UNSUPPORTED_HW,  
85
  SD_ERROR,  
86
  SD_OK = 0 
87
} SD_Error;
88
89
/** 
90
  * @brief  SDIO Transfer state  
91
  */   
92
typedef enum
93
{
94
  SD_TRANSFER_OK  = 0,
95
  SD_TRANSFER_BUSY = 1,
96
  SD_TRANSFER_ERROR
97
} SDTransferState;
98
99
/** 
100
  * @brief  SD Card States 
101
  */   
102
typedef enum
103
{
104
  SD_CARD_READY                  = ((uint32_t)0x00000001),
105
  SD_CARD_IDENTIFICATION         = ((uint32_t)0x00000002),
106
  SD_CARD_STANDBY                = ((uint32_t)0x00000003),
107
  SD_CARD_TRANSFER               = ((uint32_t)0x00000004),
108
  SD_CARD_SENDING                = ((uint32_t)0x00000005),
109
  SD_CARD_RECEIVING              = ((uint32_t)0x00000006),
110
  SD_CARD_PROGRAMMING            = ((uint32_t)0x00000007),
111
  SD_CARD_DISCONNECTED           = ((uint32_t)0x00000008),
112
  SD_CARD_ERROR                  = ((uint32_t)0x000000FF)
113
}SDCardState;
114
115
116
/** 
117
  * @brief  Card Specific Data: CSD Register   
118
  */ 
119
typedef struct
120
{
121
  __IO uint8_t  CSDStruct;            /*!< CSD structure */
122
  __IO uint8_t  SysSpecVersion;       /*!< System specification version */
123
  __IO uint8_t  Reserved1;            /*!< Reserved */
124
  __IO uint8_t  TAAC;                 /*!< Data read access-time 1 */
125
  __IO uint8_t  NSAC;                 /*!< Data read access-time 2 in CLK cycles */
126
  __IO uint8_t  MaxBusClkFrec;        /*!< Max. bus clock frequency */
127
  __IO uint16_t CardComdClasses;      /*!< Card command classes */
128
  __IO uint8_t  RdBlockLen;           /*!< Max. read data block length */
129
  __IO uint8_t  PartBlockRead;        /*!< Partial blocks for read allowed */
130
  __IO uint8_t  WrBlockMisalign;      /*!< Write block misalignment */
131
  __IO uint8_t  RdBlockMisalign;      /*!< Read block misalignment */
132
  __IO uint8_t  DSRImpl;              /*!< DSR implemented */
133
  __IO uint8_t  Reserved2;            /*!< Reserved */
134
  __IO uint32_t DeviceSize;           /*!< Device Size */
135
  __IO uint8_t  MaxRdCurrentVDDMin;   /*!< Max. read current @ VDD min */
136
  __IO uint8_t  MaxRdCurrentVDDMax;   /*!< Max. read current @ VDD max */
137
  __IO uint8_t  MaxWrCurrentVDDMin;   /*!< Max. write current @ VDD min */
138
  __IO uint8_t  MaxWrCurrentVDDMax;   /*!< Max. write current @ VDD max */
139
  __IO uint8_t  DeviceSizeMul;        /*!< Device size multiplier */
140
  __IO uint8_t  EraseGrSize;          /*!< Erase group size */
141
  __IO uint8_t  EraseGrMul;           /*!< Erase group size multiplier */
142
  __IO uint8_t  WrProtectGrSize;      /*!< Write protect group size */
143
  __IO uint8_t  WrProtectGrEnable;    /*!< Write protect group enable */
144
  __IO uint8_t  ManDeflECC;           /*!< Manufacturer default ECC */
145
  __IO uint8_t  WrSpeedFact;          /*!< Write speed factor */
146
  __IO uint8_t  MaxWrBlockLen;        /*!< Max. write data block length */
147
  __IO uint8_t  WriteBlockPaPartial;  /*!< Partial blocks for write allowed */
148
  __IO uint8_t  Reserved3;            /*!< Reserded */
149
  __IO uint8_t  ContentProtectAppli;  /*!< Content protection application */
150
  __IO uint8_t  FileFormatGrouop;     /*!< File format group */
151
  __IO uint8_t  CopyFlag;             /*!< Copy flag (OTP) */
152
  __IO uint8_t  PermWrProtect;        /*!< Permanent write protection */
153
  __IO uint8_t  TempWrProtect;        /*!< Temporary write protection */
154
  __IO uint8_t  FileFormat;           /*!< File Format */
155
  __IO uint8_t  ECC;                  /*!< ECC code */
156
  __IO uint8_t  CSD_CRC;              /*!< CSD CRC */
157
  __IO uint8_t  Reserved4;            /*!< always 1*/
158
} SD_CSD;
159
160
/** 
161
  * @brief  Card Identification Data: CID Register   
162
  */
163
typedef struct
164
{
165
  __IO uint8_t  ManufacturerID;       /*!< ManufacturerID */
166
  __IO uint16_t OEM_AppliID;          /*!< OEM/Application ID */
167
  __IO uint32_t ProdName1;            /*!< Product Name part1 */
168
  __IO uint8_t  ProdName2;            /*!< Product Name part2*/
169
  __IO uint8_t  ProdRev;              /*!< Product Revision */
170
  __IO uint32_t ProdSN;               /*!< Product Serial Number */
171
  __IO uint8_t  Reserved1;            /*!< Reserved1 */
172
  __IO uint16_t ManufactDate;         /*!< Manufacturing Date */
173
  __IO uint8_t  CID_CRC;              /*!< CID CRC */
174
  __IO uint8_t  Reserved2;            /*!< always 1 */
175
} SD_CID;
176
177
/** 
178
  * @brief SD Card Status 
179
  */
180
typedef struct
181
{
182
  __IO uint8_t DAT_BUS_WIDTH;
183
  __IO uint8_t SECURED_MODE;
184
  __IO uint16_t SD_CARD_TYPE;
185
  __IO uint32_t SIZE_OF_PROTECTED_AREA;
186
  __IO uint8_t SPEED_CLASS;
187
  __IO uint8_t PERFORMANCE_MOVE;
188
  __IO uint8_t AU_SIZE;
189
  __IO uint16_t ERASE_SIZE;
190
  __IO uint8_t ERASE_TIMEOUT;
191
  __IO uint8_t ERASE_OFFSET;
192
} SD_CardStatus;
193
194
195
/** 
196
  * @brief SD Card information 
197
  */
198
typedef struct
199
{
200
  SD_CSD SD_csd;
201
  SD_CID SD_cid;
202
  uint64_t CardCapacity;  /*!< Card Capacity */
203
  uint32_t CardBlockSize; /*!< Card Block Size */
204
  uint16_t RCA;
205
  uint8_t CardType;
206
} SD_CardInfo;
207
208
209
/****************************************************************************************
210
* Defines
211
****************************************************************************************/
212
/** 
213
  * @brief SDIO Commands  Index 
214
  */
215
#define SD_CMD_GO_IDLE_STATE                       ((uint8_t)0)
216
#define SD_CMD_SEND_OP_COND                        ((uint8_t)1)
217
#define SD_CMD_ALL_SEND_CID                        ((uint8_t)2)
218
#define SD_CMD_SET_REL_ADDR                        ((uint8_t)3) /*!< SDIO_SEND_REL_ADDR for SD Card */
219
#define SD_CMD_SET_DSR                             ((uint8_t)4)
220
#define SD_CMD_SDIO_SEN_OP_COND                    ((uint8_t)5)
221
#define SD_CMD_HS_SWITCH                           ((uint8_t)6)
222
#define SD_CMD_SEL_DESEL_CARD                      ((uint8_t)7)
223
#define SD_CMD_HS_SEND_EXT_CSD                     ((uint8_t)8)
224
#define SD_CMD_SEND_CSD                            ((uint8_t)9)
225
#define SD_CMD_SEND_CID                            ((uint8_t)10)
226
#define SD_CMD_READ_DAT_UNTIL_STOP                 ((uint8_t)11) /*!< SD Card doesn't support it */
227
#define SD_CMD_STOP_TRANSMISSION                   ((uint8_t)12)
228
#define SD_CMD_SEND_STATUS                         ((uint8_t)13)
229
#define SD_CMD_HS_BUSTEST_READ                     ((uint8_t)14)
230
#define SD_CMD_GO_INACTIVE_STATE                   ((uint8_t)15)
231
#define SD_CMD_SET_BLOCKLEN                        ((uint8_t)16)
232
#define SD_CMD_READ_SINGLE_BLOCK                   ((uint8_t)17)
233
#define SD_CMD_READ_MULT_BLOCK                     ((uint8_t)18)
234
#define SD_CMD_HS_BUSTEST_WRITE                    ((uint8_t)19)
235
#define SD_CMD_WRITE_DAT_UNTIL_STOP                ((uint8_t)20) /*!< SD Card doesn't support it */
236
#define SD_CMD_SET_BLOCK_COUNT                     ((uint8_t)23) /*!< SD Card doesn't support it */
237
#define SD_CMD_WRITE_SINGLE_BLOCK                  ((uint8_t)24)
238
#define SD_CMD_WRITE_MULT_BLOCK                    ((uint8_t)25)
239
#define SD_CMD_PROG_CID                            ((uint8_t)26) /*!< reserved for manufacturers */
240
#define SD_CMD_PROG_CSD                            ((uint8_t)27)
241
#define SD_CMD_SET_WRITE_PROT                      ((uint8_t)28)
242
#define SD_CMD_CLR_WRITE_PROT                      ((uint8_t)29)
243
#define SD_CMD_SEND_WRITE_PROT                     ((uint8_t)30)
244
#define SD_CMD_SD_ERASE_GRP_START                  ((uint8_t)32) /*!< To set the address of the first write
245
                                                                  block to be erased. (For SD card only) */
246
#define SD_CMD_SD_ERASE_GRP_END                    ((uint8_t)33) /*!< To set the address of the last write block of the
247
                                                                  continuous range to be erased. (For SD card only) */
248
#define SD_CMD_ERASE_GRP_START                     ((uint8_t)35) /*!< To set the address of the first write block to be erased.
249
                                                                  (For MMC card only spec 3.31) */
250
251
#define SD_CMD_ERASE_GRP_END                       ((uint8_t)36) /*!< To set the address of the last write block of the
252
                                                                  continuous range to be erased. (For MMC card only spec 3.31) */
253
254
#define SD_CMD_ERASE                               ((uint8_t)38)
255
#define SD_CMD_FAST_IO                             ((uint8_t)39) /*!< SD Card doesn't support it */
256
#define SD_CMD_GO_IRQ_STATE                        ((uint8_t)40) /*!< SD Card doesn't support it */
257
#define SD_CMD_LOCK_UNLOCK                         ((uint8_t)42)
258
#define SD_CMD_APP_CMD                             ((uint8_t)55)
259
#define SD_CMD_GEN_CMD                             ((uint8_t)56)
260
#define SD_CMD_NO_CMD                              ((uint8_t)64)
261
262
/** 
263
  * @brief Following commands are SD Card Specific commands.
264
  *        SDIO_APP_CMD should be sent before sending these commands. 
265
  */
266
#define SD_CMD_APP_SD_SET_BUSWIDTH                 ((uint8_t)6)  /*!< For SD Card only */
267
#define SD_CMD_SD_APP_STAUS                        ((uint8_t)13) /*!< For SD Card only */
268
#define SD_CMD_SD_APP_SEND_NUM_WRITE_BLOCKS        ((uint8_t)22) /*!< For SD Card only */
269
#define SD_CMD_SD_APP_OP_COND                      ((uint8_t)41) /*!< For SD Card only */
270
#define SD_CMD_SD_APP_SET_CLR_CARD_DETECT          ((uint8_t)42) /*!< For SD Card only */
271
#define SD_CMD_SD_APP_SEND_SCR                     ((uint8_t)51) /*!< For SD Card only */
272
#define SD_CMD_SDIO_RW_DIRECT                      ((uint8_t)52) /*!< For SD I/O Card only */
273
#define SD_CMD_SDIO_RW_EXTENDED                    ((uint8_t)53) /*!< For SD I/O Card only */
274
275
/** 
276
  * @brief Following commands are SD Card Specific security commands.
277
  *        SDIO_APP_CMD should be sent before sending these commands. 
278
  */
279
#define SD_CMD_SD_APP_GET_MKB                      ((uint8_t)43) /*!< For SD Card only */
280
#define SD_CMD_SD_APP_GET_MID                      ((uint8_t)44) /*!< For SD Card only */
281
#define SD_CMD_SD_APP_SET_CER_RN1                  ((uint8_t)45) /*!< For SD Card only */
282
#define SD_CMD_SD_APP_GET_CER_RN2                  ((uint8_t)46) /*!< For SD Card only */
283
#define SD_CMD_SD_APP_SET_CER_RES2                 ((uint8_t)47) /*!< For SD Card only */
284
#define SD_CMD_SD_APP_GET_CER_RES1                 ((uint8_t)48) /*!< For SD Card only */
285
#define SD_CMD_SD_APP_SECURE_READ_MULTIPLE_BLOCK   ((uint8_t)18) /*!< For SD Card only */
286
#define SD_CMD_SD_APP_SECURE_WRITE_MULTIPLE_BLOCK  ((uint8_t)25) /*!< For SD Card only */
287
#define SD_CMD_SD_APP_SECURE_ERASE                 ((uint8_t)38) /*!< For SD Card only */
288
#define SD_CMD_SD_APP_CHANGE_SECURE_AREA           ((uint8_t)49) /*!< For SD Card only */
289
#define SD_CMD_SD_APP_SECURE_WRITE_MKB             ((uint8_t)48) /*!< For SD Card only */
290
  
291
/* Uncomment the following line to select the SDIO Data transfer mode */  
292
#define SD_POLLING_MODE                            ((uint32_t)0x00000002)
293
    
294
#if defined (SD_POLLING_MODE)    
295
  /* do not use DMA mode if configured for polling */
296
  #if defined (SD_DMA_MODE)    
297
  #undef SD_DMA_MODE
298
  #endif
299
#else
300
  /* always use DMA mode if configured for interrupt mode */
301
  #define SD_DMA_MODE                              ((uint32_t)0x00000000)
302
#endif    
303
304
/**
305
  * @brief  SD detection on its memory slot
306
  */
307
#define SD_PRESENT                                 ((uint8_t)0x01)
308
#define SD_NOT_PRESENT                             ((uint8_t)0x00)
309
310
/** 
311
  * @brief Supported SD Memory Cards 
312
  */
313
#define SDIO_STD_CAPACITY_SD_CARD_V1_1             ((uint32_t)0x00000000)
314
#define SDIO_STD_CAPACITY_SD_CARD_V2_0             ((uint32_t)0x00000001)
315
#define SDIO_HIGH_CAPACITY_SD_CARD                 ((uint32_t)0x00000002)
316
#define SDIO_MULTIMEDIA_CARD                       ((uint32_t)0x00000003)
317
#define SDIO_SECURE_DIGITAL_IO_CARD                ((uint32_t)0x00000004)
318
#define SDIO_HIGH_SPEED_MULTIMEDIA_CARD            ((uint32_t)0x00000005)
319
#define SDIO_SECURE_DIGITAL_IO_COMBO_CARD          ((uint32_t)0x00000006)
320
#define SDIO_HIGH_CAPACITY_MMC_CARD                ((uint32_t)0x00000007)
321
322
/** 
323
  * @brief  SDIO Static flags, TimeOut, FIFO Address  
324
  */
325
#ifndef NULL
326
#define NULL  ((void*)0)
327
#endif
328
329
#define SDIO_STATIC_FLAGS               ((uint32_t)0x000005FF)
330
#define SDIO_CMD0TIMEOUT                ((uint32_t)0x00010000)
331
332
/** 
333
  * @brief  Mask for errors Card Status R1 (OCR Register) 
334
  */
335
#define SD_OCR_ADDR_OUT_OF_RANGE        ((uint32_t)0x80000000)
336
#define SD_OCR_ADDR_MISALIGNED          ((uint32_t)0x40000000)
337
#define SD_OCR_BLOCK_LEN_ERR            ((uint32_t)0x20000000)
338
#define SD_OCR_ERASE_SEQ_ERR            ((uint32_t)0x10000000)
339
#define SD_OCR_BAD_ERASE_PARAM          ((uint32_t)0x08000000)
340
#define SD_OCR_WRITE_PROT_VIOLATION     ((uint32_t)0x04000000)
341
#define SD_OCR_LOCK_UNLOCK_FAILED       ((uint32_t)0x01000000)
342
#define SD_OCR_COM_CRC_FAILED           ((uint32_t)0x00800000)
343
#define SD_OCR_ILLEGAL_CMD              ((uint32_t)0x00400000)
344
#define SD_OCR_CARD_ECC_FAILED          ((uint32_t)0x00200000)
345
#define SD_OCR_CC_ERROR                 ((uint32_t)0x00100000)
346
#define SD_OCR_GENERAL_UNKNOWN_ERROR    ((uint32_t)0x00080000)
347
#define SD_OCR_STREAM_READ_UNDERRUN     ((uint32_t)0x00040000)
348
#define SD_OCR_STREAM_WRITE_OVERRUN     ((uint32_t)0x00020000)
349
#define SD_OCR_CID_CSD_OVERWRIETE       ((uint32_t)0x00010000)
350
#define SD_OCR_WP_ERASE_SKIP            ((uint32_t)0x00008000)
351
#define SD_OCR_CARD_ECC_DISABLED        ((uint32_t)0x00004000)
352
#define SD_OCR_ERASE_RESET              ((uint32_t)0x00002000)
353
#define SD_OCR_AKE_SEQ_ERROR            ((uint32_t)0x00000008)
354
#define SD_OCR_ERRORBITS                ((uint32_t)0xFDFFE008)
355
356
/** 
357
  * @brief  Masks for R6 Response 
358
  */
359
#define SD_R6_GENERAL_UNKNOWN_ERROR     ((uint32_t)0x00002000)
360
#define SD_R6_ILLEGAL_CMD               ((uint32_t)0x00004000)
361
#define SD_R6_COM_CRC_FAILED            ((uint32_t)0x00008000)
362
363
#define SD_VOLTAGE_WINDOW_SD            ((uint32_t)0x80100000)
364
#define SD_HIGH_CAPACITY                ((uint32_t)0x40000000)
365
#define SD_STD_CAPACITY                 ((uint32_t)0x00000000)
366
#define SD_CHECK_PATTERN                ((uint32_t)0x000001AA)
367
368
#define SD_MAX_VOLT_TRIAL               ((uint32_t)0x0000FFFF)
369
#define SD_ALLZERO                      ((uint32_t)0x00000000)
370
371
#define SD_WIDE_BUS_SUPPORT             ((uint32_t)0x00040000)
372
#define SD_SINGLE_BUS_SUPPORT           ((uint32_t)0x00010000)
373
#define SD_CARD_LOCKED                  ((uint32_t)0x02000000)
374
375
376
#define SD_DATATIMEOUT                  ((uint32_t)0xFFFFFFFF)
377
#define SD_0TO7BITS                     ((uint32_t)0x000000FF)
378
#define SD_8TO15BITS                    ((uint32_t)0x0000FF00)
379
#define SD_16TO23BITS                   ((uint32_t)0x00FF0000)
380
#define SD_24TO31BITS                   ((uint32_t)0xFF000000)
381
#define SD_MAX_DATA_LENGTH              ((uint32_t)0x01FFFFFF)
382
383
#define SD_HALFFIFO                     ((uint32_t)0x00000008)
384
#define SD_HALFFIFOBYTES                ((uint32_t)0x00000020)
385
386
/** 
387
  * @brief  Command Class Supported 
388
  */
389
#define SD_CCCC_LOCK_UNLOCK             ((uint32_t)0x00000080)
390
#define SD_CCCC_WRITE_PROT              ((uint32_t)0x00000040)
391
#define SD_CCCC_ERASE                   ((uint32_t)0x00000020)
392
393
/** 
394
  * @brief  Following commands are SD Card Specific commands.
395
  *         SDIO_APP_CMD should be sent before sending these commands. 
396
  */
397
#define SDIO_SEND_IF_COND               ((uint32_t)0x00000008)
398
399
/**
400
  * @brief  SD FLASH SDIO Interface
401
  */
402
#define SD_DETECT_PIN                    GPIO_Pin_11                 /* PC.11 */
403
#define SD_DETECT_GPIO_PORT              GPIOC                       /* GPIOC */
404
#define SD_DETECT_GPIO_CLK               RCC_AHB1Periph_GPIOC
405
   
406
#define SDIO_FIFO_ADDRESS                ((uint32_t)0x40012C80)
407
/** 
408
  * @brief  SDIO Intialization Frequency (400KHz max)
409
  */
410
#define SDIO_INIT_CLK_DIV                ((uint8_t)0x76)
411
/** 
412
  * @brief  SDIO Data Transfer Frequency (25MHz max) 
413
  */
414
#define SDIO_TRANSFER_CLK_DIV            ((uint8_t)0x0) 
415
416
#define SD_SDIO_DMA                   DMA2
417
#define SD_SDIO_DMA_CLK               RCC_AHB1Periph_DMA2
418
 
419
#define SD_SDIO_DMA_STREAM            DMA2_Stream3
420
#define SD_SDIO_DMA_CHANNEL           DMA_Channel_4
421
#define SD_SDIO_DMA_FLAG_FEIF         DMA_FLAG_FEIF3
422
#define SD_SDIO_DMA_FLAG_DMEIF        DMA_FLAG_DMEIF3
423
#define SD_SDIO_DMA_FLAG_TEIF         DMA_FLAG_TEIF3
424
#define SD_SDIO_DMA_FLAG_HTIF         DMA_FLAG_HTIF3
425
#define SD_SDIO_DMA_FLAG_TCIF         DMA_FLAG_TCIF3 
426
#define SD_SDIO_DMA_IRQn              DMA2_Stream3_IRQn
427
#define SD_SDIO_DMA_IRQHANDLER        DMA2_Stream3_IRQHandler 
428
429
#define SD_BLOCKSIZE                   (512)
430
431
432
/****************************************************************************************
433
* Local data declarations
434
****************************************************************************************/
435
static uint32_t CardType =  SDIO_STD_CAPACITY_SD_CARD_V1_1;
436
static uint32_t CSD_Tab[4], CID_Tab[4], RCA = 0;
437
static uint8_t SDSTATUS_Tab[64];
438
static __IO uint32_t StopCondition = 0;
439
static __IO SD_Error TransferError = SD_OK;
440
static __IO uint32_t TransferEnd = 0, DMAEndOfTransfer = 1;
441
static SD_CardInfo SDCardInfo;
442
static SDIO_InitTypeDef SDIO_InitStructure;
443
static SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
444
static SDIO_DataInitTypeDef SDIO_DataInitStructure;
445
static volatile DSTATUS Stat = STA_NOINIT;    /* Disk status */
446
447
448
/****************************************************************************************
449
* Function prototypes
450
****************************************************************************************/
451
void SD_DeInit(void);
452
SD_Error SD_Init(void);
453
SDTransferState SD_GetStatus(void);
454
SDCardState SD_GetState(void);
455
uint8_t SD_Detect(void);
456
SD_Error SD_PowerON(void);
457
SD_Error SD_PowerOFF(void);
458
SD_Error SD_InitializeCards(void);
459
SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo);
460
SD_Error SD_GetCardStatus(SD_CardStatus *cardstatus);
461
SD_Error SD_EnableWideBusOperation(uint32_t WideMode);
462
SD_Error SD_SelectDeselect(uint64_t addr);
463
SD_Error SD_ReadBlock(uint8_t *readbuff, uint64_t ReadAddr, uint16_t BlockSize);
464
SD_Error SD_ReadMultiBlocks(uint8_t *readbuff, uint64_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks);
465
SD_Error SD_WriteBlock(uint8_t *writebuff, uint64_t WriteAddr, uint16_t BlockSize);
466
SD_Error SD_WriteMultiBlocks(uint8_t *writebuff, uint64_t WriteAddr, uint16_t BlockSize, uint32_t NumberOfBlocks);
467
SDTransferState SD_GetTransferState(void);
468
SD_Error SD_StopTransfer(void);
469
SD_Error SD_Erase(uint64_t startaddr, uint64_t endaddr);
470
SD_Error SD_SendStatus(uint32_t *pcardstatus);
471
SD_Error SD_SendSDStatus(uint32_t *psdstatus);
472
SD_Error SD_ProcessIRQSrc(void);
473
void SD_ProcessDMAIRQ(void);
474
SD_Error SD_WaitReadOperation(void);
475
SD_Error SD_WaitWriteOperation(void);
476
static SD_Error CmdError(void);
477
static SD_Error CmdResp1Error(uint8_t cmd);
478
static SD_Error CmdResp7Error(void);
479
static SD_Error CmdResp3Error(void);
480
static SD_Error CmdResp2Error(void);
481
static SD_Error CmdResp6Error(uint8_t cmd, uint16_t *prca);
482
static SD_Error SDEnWideBus(FunctionalState NewState);
483
static SD_Error IsCardProgramming(uint8_t *pstatus);
484
static SD_Error FindSCR(uint16_t rca, uint32_t *pscr);
485
static void SD_LowLevel_DeInit(void);
486
static void SD_LowLevel_Init(void); 
487
static void SD_LowLevel_DMA_TxConfig(uint32_t *BufferSRC, uint32_t BufferSize);
488
static void SD_LowLevel_DMA_RxConfig(uint32_t *BufferDST, uint32_t BufferSize);
489
490
491
/**
492
  * @brief  DeInitializes the SDIO interface.
493
  * @param  None
494
  * @retval None
495
  */
496
void SD_DeInit(void)
497
{ 
498
  SD_LowLevel_DeInit();
499
}
500
501
/**
502
  * @brief  Initializes the SD Card and put it into StandBy State (Ready for data 
503
  *         transfer).
504
  * @param  None
505
  * @retval SD_Error: SD Card Error code.
506
  */
507
SD_Error SD_Init(void)
508
{
509
  __IO SD_Error errorstatus = SD_OK;
510
  
511
  /* SDIO Peripheral Low Level Init */
512
   SD_LowLevel_Init();
513
  
514
  SDIO_DeInit();
515
516
  errorstatus = SD_PowerON();
517
518
  if (errorstatus != SD_OK)
519
  {
520
    /*!< CMD Response TimeOut (wait for CMDSENT flag) */
521
    return(errorstatus);
522
  }
523
524
  errorstatus = SD_InitializeCards();
525
526
  if (errorstatus != SD_OK)
527
  {
528
    /*!< CMD Response TimeOut (wait for CMDSENT flag) */
529
    return(errorstatus);
530
  }
531
532
  /*!< Configure the SDIO peripheral */
533
  /*!< SDIO_CK = SDIOCLK / (SDIO_TRANSFER_CLK_DIV + 2) */
534
  /*!< on STM32F4xx devices, SDIOCLK is fixed to 48MHz */
535
  SDIO_InitStructure.SDIO_ClockDiv = SDIO_TRANSFER_CLK_DIV;
536
  SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
537
  SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;
538
  SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;
539
  SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;
540
  SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;
541
  SDIO_Init(&SDIO_InitStructure);
542
543
  /*----------------- Read CSD/CID MSD registers ------------------*/
544
  errorstatus = SD_GetCardInfo(&SDCardInfo);
545
546
  if (errorstatus == SD_OK)
547
  {
548
    /*----------------- Select Card --------------------------------*/
549
    errorstatus = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
550
  }
551
552
  if (errorstatus == SD_OK)
553
  {
554
    errorstatus = SD_EnableWideBusOperation(SDIO_BusWide_4b);
555
  }  
556
557
  return(errorstatus);
558
}
559
560
/**
561
  * @brief  Gets the cuurent sd card data transfer status.
562
  * @param  None
563
  * @retval SDTransferState: Data Transfer state.
564
  *   This value can be: 
565
  *        - SD_TRANSFER_OK: No data transfer is acting
566
  *        - SD_TRANSFER_BUSY: Data transfer is acting
567
  */
568
SDTransferState SD_GetStatus(void)
569
{
570
  SDCardState cardstate =  SD_CARD_TRANSFER;
571
572
  cardstate = SD_GetState();
573
  
574
  if (cardstate == SD_CARD_TRANSFER)
575
  {
576
    return(SD_TRANSFER_OK);
577
  }
578
  else if(cardstate == SD_CARD_ERROR)
579
  {
580
    return (SD_TRANSFER_ERROR);
581
  }
582
  else
583
  {
584
    return(SD_TRANSFER_BUSY);
585
  }
586
}
587
588
/**
589
  * @brief  Returns the current card's state.
590
  * @param  None
591
  * @retval SDCardState: SD Card Error or SD Card Current State.
592
  */
593
SDCardState SD_GetState(void)
594
{
595
  uint32_t resp1 = 0;
596
  
597
  if(SD_Detect()== SD_PRESENT)
598
  {
599
    if (SD_SendStatus(&resp1) != SD_OK)
600
    {
601
      return SD_CARD_ERROR;
602
    }
603
    else
604
    {
605
      return (SDCardState)((resp1 >> 9) & 0x0F);
606
    }
607
  }
608
  else
609
  {
610
    return SD_CARD_ERROR;
611
  }
612
}
613
614
/**
615
 * @brief  Detect if SD card is correctly plugged in the memory slot.
616
 * @param  None
617
 * @retval Return if SD is detected or not
618
 */
619
uint8_t SD_Detect(void)
620
{
621
  __IO uint8_t status = SD_PRESENT;
622
623
  /*!< Check GPIO to detect SD */
624
        if (GPIO_ReadInputDataBit(SD_DETECT_GPIO_PORT, SD_DETECT_PIN) == Bit_RESET)
625
  {
626
    status = SD_NOT_PRESENT;
627
  }
628
  return status;
629
}
630
631
/**
632
  * @brief  Enquires cards about their operating voltage and configures 
633
  *   clock controls.
634
  * @param  None
635
  * @retval SD_Error: SD Card Error code.
636
  */
637
SD_Error SD_PowerON(void)
638
{
639
  __IO SD_Error errorstatus = SD_OK;
640
  uint32_t response = 0, count = 0, validvoltage = 0;
641
  uint32_t SDType = SD_STD_CAPACITY;
642
643
  /*!< Power ON Sequence -----------------------------------------------------*/
644
  /*!< Configure the SDIO peripheral */
645
  /*!< SDIO_CK = SDIOCLK / (SDIO_INIT_CLK_DIV + 2) */
646
  /*!< on STM32F4xx devices, SDIOCLK is fixed to 48MHz */
647
  /*!< SDIO_CK for initialization should not exceed 400 KHz */  
648
  SDIO_InitStructure.SDIO_ClockDiv = SDIO_INIT_CLK_DIV;
649
  SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
650
  SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;
651
  SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;
652
  SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;
653
  SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;
654
  SDIO_Init(&SDIO_InitStructure);
655
656
  /*!< Set Power State to ON */
657
  SDIO_SetPowerState(SDIO_PowerState_ON);
658
659
  /*!< Enable SDIO Clock */
660
  SDIO_ClockCmd(ENABLE);
661
662
  /*!< CMD0: GO_IDLE_STATE ---------------------------------------------------*/
663
  /*!< No CMD response required */
664
  SDIO_CmdInitStructure.SDIO_Argument = 0x0;
665
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_GO_IDLE_STATE;
666
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_No;
667
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
668
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
669
  SDIO_SendCommand(&SDIO_CmdInitStructure);
670
671
  errorstatus = CmdError();
672
673
  if (errorstatus != SD_OK)
674
  {
675
    /*!< CMD Response TimeOut (wait for CMDSENT flag) */
676
    return(errorstatus);
677
  }
678
679
  /*!< CMD8: SEND_IF_COND ----------------------------------------------------*/
680
  /*!< Send CMD8 to verify SD card interface operating condition */
681
  /*!< Argument: - [31:12]: Reserved (shall be set to '0')
682
               - [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
683
               - [7:0]: Check Pattern (recommended 0xAA) */
684
  /*!< CMD Response: R7 */
685
  SDIO_CmdInitStructure.SDIO_Argument = SD_CHECK_PATTERN;
686
  SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_IF_COND;
687
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
688
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
689
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
690
  SDIO_SendCommand(&SDIO_CmdInitStructure);
691
692
  errorstatus = CmdResp7Error();
693
694
  if (errorstatus == SD_OK)
695
  {
696
    CardType = SDIO_STD_CAPACITY_SD_CARD_V2_0; /*!< SD Card 2.0 */
697
    SDType = SD_HIGH_CAPACITY;
698
  }
699
  else
700
  {
701
    /*!< CMD55 */
702
    SDIO_CmdInitStructure.SDIO_Argument = 0x00;
703
    SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
704
    SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
705
    SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
706
    SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
707
    SDIO_SendCommand(&SDIO_CmdInitStructure);
708
    errorstatus = CmdResp1Error(SD_CMD_APP_CMD);
709
  }
710
  /*!< CMD55 */
711
  SDIO_CmdInitStructure.SDIO_Argument = 0x00;
712
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
713
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
714
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
715
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
716
  SDIO_SendCommand(&SDIO_CmdInitStructure);
717
  errorstatus = CmdResp1Error(SD_CMD_APP_CMD);
718
719
  /*!< If errorstatus is Command TimeOut, it is a MMC card */
720
  /*!< If errorstatus is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)
721
     or SD card 1.x */
722
  if (errorstatus == SD_OK)
723
  {
724
    /*!< SD CARD */
725
    /*!< Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
726
    while ((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
727
    {
728
729
      /*!< SEND CMD55 APP_CMD with RCA as 0 */
730
      SDIO_CmdInitStructure.SDIO_Argument = 0x00;
731
      SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
732
      SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
733
      SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
734
      SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
735
      SDIO_SendCommand(&SDIO_CmdInitStructure);
736
737
      errorstatus = CmdResp1Error(SD_CMD_APP_CMD);
738
739
      if (errorstatus != SD_OK)
740
      {
741
        return(errorstatus);
742
      }
743
      SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_SD | SDType;
744
      SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_OP_COND;
745
      SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
746
      SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
747
      SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
748
      SDIO_SendCommand(&SDIO_CmdInitStructure);
749
750
      errorstatus = CmdResp3Error();
751
      if (errorstatus != SD_OK)
752
      {
753
        return(errorstatus);
754
      }
755
756
      response = SDIO_GetResponse(SDIO_RESP1);
757
      validvoltage = (((response >> 31) == 1) ? 1 : 0);
758
      count++;
759
    }
760
    if (count >= SD_MAX_VOLT_TRIAL)
761
    {
762
      errorstatus = SD_INVALID_VOLTRANGE;
763
      return(errorstatus);
764
    }
765
766
    if (response &= SD_HIGH_CAPACITY)
767
    {
768
      CardType = SDIO_HIGH_CAPACITY_SD_CARD;
769
    }
770
771
  }/*!< else MMC Card */
772
773
  return(errorstatus);
774
}
775
776
/**
777
  * @brief  Turns the SDIO output signals off.
778
  * @param  None
779
  * @retval SD_Error: SD Card Error code.
780
  */
781
SD_Error SD_PowerOFF(void)
782
{
783
  SD_Error errorstatus = SD_OK;
784
785
  /*!< Set Power State to OFF */
786
  SDIO_SetPowerState(SDIO_PowerState_OFF);
787
788
  return(errorstatus);
789
}
790
791
/**
792
  * @brief  Intialises all cards or single card as the case may be Card(s) come 
793
  *         into standby state.
794
  * @param  None
795
  * @retval SD_Error: SD Card Error code.
796
  */
797
SD_Error SD_InitializeCards(void)
798
{
799
  SD_Error errorstatus = SD_OK;
800
  uint16_t rca = 0x01;
801
802
  if (SDIO_GetPowerState() == SDIO_PowerState_OFF)
803
  {
804
    errorstatus = SD_REQUEST_NOT_APPLICABLE;
805
    return(errorstatus);
806
  }
807
808
  if (SDIO_SECURE_DIGITAL_IO_CARD != CardType)
809
  {
810
    /*!< Send CMD2 ALL_SEND_CID */
811
    SDIO_CmdInitStructure.SDIO_Argument = 0x0;
812
    SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_ALL_SEND_CID;
813
    SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;
814
    SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
815
    SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
816
    SDIO_SendCommand(&SDIO_CmdInitStructure);
817
818
    errorstatus = CmdResp2Error();
819
820
    if (SD_OK != errorstatus)
821
    {
822
      return(errorstatus);
823
    }
824
825
    CID_Tab[0] = SDIO_GetResponse(SDIO_RESP1);
826
    CID_Tab[1] = SDIO_GetResponse(SDIO_RESP2);
827
    CID_Tab[2] = SDIO_GetResponse(SDIO_RESP3);
828
    CID_Tab[3] = SDIO_GetResponse(SDIO_RESP4);
829
  }
830
  if ((SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType) ||  (SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType) ||  (SDIO_SECURE_DIGITAL_IO_COMBO_CARD == CardType)
831
      ||  (SDIO_HIGH_CAPACITY_SD_CARD == CardType))
832
  {
833
    /*!< Send CMD3 SET_REL_ADDR with argument 0 */
834
    /*!< SD Card publishes its RCA. */
835
    SDIO_CmdInitStructure.SDIO_Argument = 0x00;
836
    SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR;
837
    SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
838
    SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
839
    SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
840
    SDIO_SendCommand(&SDIO_CmdInitStructure);
841
842
    errorstatus = CmdResp6Error(SD_CMD_SET_REL_ADDR, &rca);
843
844
    if (SD_OK != errorstatus)
845
    {
846
      return(errorstatus);
847
    }
848
  }
849
850
  if (SDIO_SECURE_DIGITAL_IO_CARD != CardType)
851
  {
852
    RCA = rca;
853
854
    /*!< Send CMD9 SEND_CSD with argument as card's RCA */
855
    SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)(rca << 16);
856
    SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_CSD;
857
    SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;
858
    SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
859
    SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
860
    SDIO_SendCommand(&SDIO_CmdInitStructure);
861
862
    errorstatus = CmdResp2Error();
863
864
    if (SD_OK != errorstatus)
865
    {
866
      return(errorstatus);
867
    }
868
869
    CSD_Tab[0] = SDIO_GetResponse(SDIO_RESP1);
870
    CSD_Tab[1] = SDIO_GetResponse(SDIO_RESP2);
871
    CSD_Tab[2] = SDIO_GetResponse(SDIO_RESP3);
872
    CSD_Tab[3] = SDIO_GetResponse(SDIO_RESP4);
873
  }
874
875
  errorstatus = SD_OK; /*!< All cards get intialized */
876
877
  return(errorstatus);
878
}
879
880
/**
881
  * @brief  Returns information about specific card.
882
  * @param  cardinfo: pointer to a SD_CardInfo structure that contains all SD card 
883
  *         information.
884
  * @retval SD_Error: SD Card Error code.
885
  */
886
SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo)
887
{
888
  SD_Error errorstatus = SD_OK;
889
  uint8_t tmp = 0;
890
891
  cardinfo->CardType = (uint8_t)CardType;
892
  cardinfo->RCA = (uint16_t)RCA;
893
894
  /*!< Byte 0 */
895
  tmp = (uint8_t)((CSD_Tab[0] & 0xFF000000) >> 24);
896
  cardinfo->SD_csd.CSDStruct = (tmp & 0xC0) >> 6;
897
  cardinfo->SD_csd.SysSpecVersion = (tmp & 0x3C) >> 2;
898
  cardinfo->SD_csd.Reserved1 = tmp & 0x03;
899
900
  /*!< Byte 1 */
901
  tmp = (uint8_t)((CSD_Tab[0] & 0x00FF0000) >> 16);
902
  cardinfo->SD_csd.TAAC = tmp;
903
904
  /*!< Byte 2 */
905
  tmp = (uint8_t)((CSD_Tab[0] & 0x0000FF00) >> 8);
906
  cardinfo->SD_csd.NSAC = tmp;
907
908
  /*!< Byte 3 */
909
  tmp = (uint8_t)(CSD_Tab[0] & 0x000000FF);
910
  cardinfo->SD_csd.MaxBusClkFrec = tmp;
911
912
  /*!< Byte 4 */
913
  tmp = (uint8_t)((CSD_Tab[1] & 0xFF000000) >> 24);
914
  cardinfo->SD_csd.CardComdClasses = tmp << 4;
915
916
  /*!< Byte 5 */
917
  tmp = (uint8_t)((CSD_Tab[1] & 0x00FF0000) >> 16);
918
  cardinfo->SD_csd.CardComdClasses |= (tmp & 0xF0) >> 4;
919
  cardinfo->SD_csd.RdBlockLen = tmp & 0x0F;
920
921
  /*!< Byte 6 */
922
  tmp = (uint8_t)((CSD_Tab[1] & 0x0000FF00) >> 8);
923
  cardinfo->SD_csd.PartBlockRead = (tmp & 0x80) >> 7;
924
  cardinfo->SD_csd.WrBlockMisalign = (tmp & 0x40) >> 6;
925
  cardinfo->SD_csd.RdBlockMisalign = (tmp & 0x20) >> 5;
926
  cardinfo->SD_csd.DSRImpl = (tmp & 0x10) >> 4;
927
  cardinfo->SD_csd.Reserved2 = 0; /*!< Reserved */
928
929
  if ((CardType == SDIO_STD_CAPACITY_SD_CARD_V1_1) || (CardType == SDIO_STD_CAPACITY_SD_CARD_V2_0))
930
  {
931
    cardinfo->SD_csd.DeviceSize = (tmp & 0x03) << 10;
932
933
    /*!< Byte 7 */
934
    tmp = (uint8_t)(CSD_Tab[1] & 0x000000FF);
935
    cardinfo->SD_csd.DeviceSize |= (tmp) << 2;
936
937
    /*!< Byte 8 */
938
    tmp = (uint8_t)((CSD_Tab[2] & 0xFF000000) >> 24);
939
    cardinfo->SD_csd.DeviceSize |= (tmp & 0xC0) >> 6;
940
941
    cardinfo->SD_csd.MaxRdCurrentVDDMin = (tmp & 0x38) >> 3;
942
    cardinfo->SD_csd.MaxRdCurrentVDDMax = (tmp & 0x07);
943
944
    /*!< Byte 9 */
945
    tmp = (uint8_t)((CSD_Tab[2] & 0x00FF0000) >> 16);
946
    cardinfo->SD_csd.MaxWrCurrentVDDMin = (tmp & 0xE0) >> 5;
947
    cardinfo->SD_csd.MaxWrCurrentVDDMax = (tmp & 0x1C) >> 2;
948
    cardinfo->SD_csd.DeviceSizeMul = (tmp & 0x03) << 1;
949
    /*!< Byte 10 */
950
    tmp = (uint8_t)((CSD_Tab[2] & 0x0000FF00) >> 8);
951
    cardinfo->SD_csd.DeviceSizeMul |= (tmp & 0x80) >> 7;
952
    
953
    cardinfo->CardCapacity = (cardinfo->SD_csd.DeviceSize + 1) ;
954
    cardinfo->CardCapacity *= (1 << (cardinfo->SD_csd.DeviceSizeMul + 2));
955
    cardinfo->CardBlockSize = 1 << (cardinfo->SD_csd.RdBlockLen);
956
    cardinfo->CardCapacity *= cardinfo->CardBlockSize;
957
  }
958
  else if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)
959
  {
960
    /*!< Byte 7 */
961
    tmp = (uint8_t)(CSD_Tab[1] & 0x000000FF);
962
    cardinfo->SD_csd.DeviceSize = (tmp & 0x3F) << 16;
963
964
    /*!< Byte 8 */
965
    tmp = (uint8_t)((CSD_Tab[2] & 0xFF000000) >> 24);
966
967
    cardinfo->SD_csd.DeviceSize |= (tmp << 8);
968
969
    /*!< Byte 9 */
970
    tmp = (uint8_t)((CSD_Tab[2] & 0x00FF0000) >> 16);
971
972
    cardinfo->SD_csd.DeviceSize |= (tmp);
973
974
    /*!< Byte 10 */
975
    tmp = (uint8_t)((CSD_Tab[2] & 0x0000FF00) >> 8);
976
    
977
    cardinfo->CardCapacity = ((uint64_t)cardinfo->SD_csd.DeviceSize + 1) * 512 * 1024;
978
    cardinfo->CardBlockSize = 512;    
979
  }
980
981
982
  cardinfo->SD_csd.EraseGrSize = (tmp & 0x40) >> 6;
983
  cardinfo->SD_csd.EraseGrMul = (tmp & 0x3F) << 1;
984
985
  /*!< Byte 11 */
986
  tmp = (uint8_t)(CSD_Tab[2] & 0x000000FF);
987
  cardinfo->SD_csd.EraseGrMul |= (tmp & 0x80) >> 7;
988
  cardinfo->SD_csd.WrProtectGrSize = (tmp & 0x7F);
989
990
  /*!< Byte 12 */
991
  tmp = (uint8_t)((CSD_Tab[3] & 0xFF000000) >> 24);
992
  cardinfo->SD_csd.WrProtectGrEnable = (tmp & 0x80) >> 7;
993
  cardinfo->SD_csd.ManDeflECC = (tmp & 0x60) >> 5;
994
  cardinfo->SD_csd.WrSpeedFact = (tmp & 0x1C) >> 2;
995
  cardinfo->SD_csd.MaxWrBlockLen = (tmp & 0x03) << 2;
996
997
  /*!< Byte 13 */
998
  tmp = (uint8_t)((CSD_Tab[3] & 0x00FF0000) >> 16);
999
  cardinfo->SD_csd.MaxWrBlockLen |= (tmp & 0xC0) >> 6;
1000
  cardinfo->SD_csd.WriteBlockPaPartial = (tmp & 0x20) >> 5;
1001
  cardinfo->SD_csd.Reserved3 = 0;
1002
  cardinfo->SD_csd.ContentProtectAppli = (tmp & 0x01);
1003
1004
  /*!< Byte 14 */
1005
  tmp = (uint8_t)((CSD_Tab[3] & 0x0000FF00) >> 8);
1006
  cardinfo->SD_csd.FileFormatGrouop = (tmp & 0x80) >> 7;
1007
  cardinfo->SD_csd.CopyFlag = (tmp & 0x40) >> 6;
1008
  cardinfo->SD_csd.PermWrProtect = (tmp & 0x20) >> 5;
1009
  cardinfo->SD_csd.TempWrProtect = (tmp & 0x10) >> 4;
1010
  cardinfo->SD_csd.FileFormat = (tmp & 0x0C) >> 2;
1011
  cardinfo->SD_csd.ECC = (tmp & 0x03);
1012
1013
  /*!< Byte 15 */
1014
  tmp = (uint8_t)(CSD_Tab[3] & 0x000000FF);
1015
  cardinfo->SD_csd.CSD_CRC = (tmp & 0xFE) >> 1;
1016
  cardinfo->SD_csd.Reserved4 = 1;
1017
1018
1019
  /*!< Byte 0 */
1020
  tmp = (uint8_t)((CID_Tab[0] & 0xFF000000) >> 24);
1021
  cardinfo->SD_cid.ManufacturerID = tmp;
1022
1023
  /*!< Byte 1 */
1024
  tmp = (uint8_t)((CID_Tab[0] & 0x00FF0000) >> 16);
1025
  cardinfo->SD_cid.OEM_AppliID = tmp << 8;
1026
1027
  /*!< Byte 2 */
1028
  tmp = (uint8_t)((CID_Tab[0] & 0x000000FF00) >> 8);
1029
  cardinfo->SD_cid.OEM_AppliID |= tmp;
1030
1031
  /*!< Byte 3 */
1032
  tmp = (uint8_t)(CID_Tab[0] & 0x000000FF);
1033
  cardinfo->SD_cid.ProdName1 = tmp << 24;
1034
1035
  /*!< Byte 4 */
1036
  tmp = (uint8_t)((CID_Tab[1] & 0xFF000000) >> 24);
1037
  cardinfo->SD_cid.ProdName1 |= tmp << 16;
1038
1039
  /*!< Byte 5 */
1040
  tmp = (uint8_t)((CID_Tab[1] & 0x00FF0000) >> 16);
1041
  cardinfo->SD_cid.ProdName1 |= tmp << 8;
1042
1043
  /*!< Byte 6 */
1044
  tmp = (uint8_t)((CID_Tab[1] & 0x0000FF00) >> 8);
1045
  cardinfo->SD_cid.ProdName1 |= tmp;
1046
1047
  /*!< Byte 7 */
1048
  tmp = (uint8_t)(CID_Tab[1] & 0x000000FF);
1049
  cardinfo->SD_cid.ProdName2 = tmp;
1050
1051
  /*!< Byte 8 */
1052
  tmp = (uint8_t)((CID_Tab[2] & 0xFF000000) >> 24);
1053
  cardinfo->SD_cid.ProdRev = tmp;
1054
1055
  /*!< Byte 9 */
1056
  tmp = (uint8_t)((CID_Tab[2] & 0x00FF0000) >> 16);
1057
  cardinfo->SD_cid.ProdSN = tmp << 24;
1058
1059
  /*!< Byte 10 */
1060
  tmp = (uint8_t)((CID_Tab[2] & 0x0000FF00) >> 8);
1061
  cardinfo->SD_cid.ProdSN |= tmp << 16;
1062
1063
  /*!< Byte 11 */
1064
  tmp = (uint8_t)(CID_Tab[2] & 0x000000FF);
1065
  cardinfo->SD_cid.ProdSN |= tmp << 8;
1066
1067
  /*!< Byte 12 */
1068
  tmp = (uint8_t)((CID_Tab[3] & 0xFF000000) >> 24);
1069
  cardinfo->SD_cid.ProdSN |= tmp;
1070
1071
  /*!< Byte 13 */
1072
  tmp = (uint8_t)((CID_Tab[3] & 0x00FF0000) >> 16);
1073
  cardinfo->SD_cid.Reserved1 |= (tmp & 0xF0) >> 4;
1074
  cardinfo->SD_cid.ManufactDate = (tmp & 0x0F) << 8;
1075
1076
  /*!< Byte 14 */
1077
  tmp = (uint8_t)((CID_Tab[3] & 0x0000FF00) >> 8);
1078
  cardinfo->SD_cid.ManufactDate |= tmp;
1079
1080
  /*!< Byte 15 */
1081
  tmp = (uint8_t)(CID_Tab[3] & 0x000000FF);
1082
  cardinfo->SD_cid.CID_CRC = (tmp & 0xFE) >> 1;
1083
  cardinfo->SD_cid.Reserved2 = 1;
1084
  
1085
  return(errorstatus);
1086
}
1087
1088
/**
1089
  * @brief  Enables wide bus opeartion for the requeseted card if supported by 
1090
  *         card.
1091
  * @param  WideMode: Specifies the SD card wide bus mode. 
1092
  *   This parameter can be one of the following values:
1093
  *     @arg SDIO_BusWide_8b: 8-bit data transfer (Only for MMC)
1094
  *     @arg SDIO_BusWide_4b: 4-bit data transfer
1095
  *     @arg SDIO_BusWide_1b: 1-bit data transfer
1096
  * @retval SD_Error: SD Card Error code.
1097
  */
1098
SD_Error SD_GetCardStatus(SD_CardStatus *cardstatus)
1099
{
1100
  SD_Error errorstatus = SD_OK;
1101
  uint8_t tmp = 0;
1102
1103
  errorstatus = SD_SendSDStatus((uint32_t *)SDSTATUS_Tab);
1104
1105
  if (errorstatus  != SD_OK)
1106
  {
1107
    return(errorstatus);
1108
  }
1109
1110
  /*!< Byte 0 */
1111
  tmp = (uint8_t)((SDSTATUS_Tab[0] & 0xC0) >> 6);
1112
  cardstatus->DAT_BUS_WIDTH = tmp;
1113
1114
  /*!< Byte 0 */
1115
  tmp = (uint8_t)((SDSTATUS_Tab[0] & 0x20) >> 5);
1116
  cardstatus->SECURED_MODE = tmp;
1117
1118
  /*!< Byte 2 */
1119
  tmp = (uint8_t)((SDSTATUS_Tab[2] & 0xFF));
1120
  cardstatus->SD_CARD_TYPE = tmp << 8;
1121
1122
  /*!< Byte 3 */
1123
  tmp = (uint8_t)((SDSTATUS_Tab[3] & 0xFF));
1124
  cardstatus->SD_CARD_TYPE |= tmp;
1125
1126
  /*!< Byte 4 */
1127
  tmp = (uint8_t)(SDSTATUS_Tab[4] & 0xFF);
1128
  cardstatus->SIZE_OF_PROTECTED_AREA = tmp << 24;
1129
1130
  /*!< Byte 5 */
1131
  tmp = (uint8_t)(SDSTATUS_Tab[5] & 0xFF);
1132
  cardstatus->SIZE_OF_PROTECTED_AREA |= tmp << 16;
1133
1134
  /*!< Byte 6 */
1135
  tmp = (uint8_t)(SDSTATUS_Tab[6] & 0xFF);
1136
  cardstatus->SIZE_OF_PROTECTED_AREA |= tmp << 8;
1137
1138
  /*!< Byte 7 */
1139
  tmp = (uint8_t)(SDSTATUS_Tab[7] & 0xFF);
1140
  cardstatus->SIZE_OF_PROTECTED_AREA |= tmp;
1141
1142
  /*!< Byte 8 */
1143
  tmp = (uint8_t)((SDSTATUS_Tab[8] & 0xFF));
1144
  cardstatus->SPEED_CLASS = tmp;
1145
1146
  /*!< Byte 9 */
1147
  tmp = (uint8_t)((SDSTATUS_Tab[9] & 0xFF));
1148
  cardstatus->PERFORMANCE_MOVE = tmp;
1149
1150
  /*!< Byte 10 */
1151
  tmp = (uint8_t)((SDSTATUS_Tab[10] & 0xF0) >> 4);
1152
  cardstatus->AU_SIZE = tmp;
1153
1154
  /*!< Byte 11 */
1155
  tmp = (uint8_t)(SDSTATUS_Tab[11] & 0xFF);
1156
  cardstatus->ERASE_SIZE = tmp << 8;
1157
1158
  /*!< Byte 12 */
1159
  tmp = (uint8_t)(SDSTATUS_Tab[12] & 0xFF);
1160
  cardstatus->ERASE_SIZE |= tmp;
1161
1162
  /*!< Byte 13 */
1163
  tmp = (uint8_t)((SDSTATUS_Tab[13] & 0xFC) >> 2);
1164
  cardstatus->ERASE_TIMEOUT = tmp;
1165
1166
  /*!< Byte 13 */
1167
  tmp = (uint8_t)((SDSTATUS_Tab[13] & 0x3));
1168
  cardstatus->ERASE_OFFSET = tmp;
1169
 
1170
  return(errorstatus);
1171
}
1172
1173
/**
1174
  * @brief  Enables wide bus opeartion for the requeseted card if supported by 
1175
  *         card.
1176
  * @param  WideMode: Specifies the SD card wide bus mode. 
1177
  *   This parameter can be one of the following values:
1178
  *     @arg SDIO_BusWide_8b: 8-bit data transfer (Only for MMC)
1179
  *     @arg SDIO_BusWide_4b: 4-bit data transfer
1180
  *     @arg SDIO_BusWide_1b: 1-bit data transfer
1181
  * @retval SD_Error: SD Card Error code.
1182
  */
1183
SD_Error SD_EnableWideBusOperation(uint32_t WideMode)
1184
{
1185
  SD_Error errorstatus = SD_OK;
1186
1187
  /*!< MMC Card doesn't support this feature */
1188
  if (SDIO_MULTIMEDIA_CARD == CardType)
1189
  {
1190
    errorstatus = SD_UNSUPPORTED_FEATURE;
1191
    return(errorstatus);
1192
  }
1193
  else if ((SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType) || (SDIO_HIGH_CAPACITY_SD_CARD == CardType))
1194
  {
1195
    if (SDIO_BusWide_8b == WideMode)
1196
    {
1197
      errorstatus = SD_UNSUPPORTED_FEATURE;
1198
      return(errorstatus);
1199
    }
1200
    else if (SDIO_BusWide_4b == WideMode)
1201
    {
1202
      errorstatus = SDEnWideBus(ENABLE);
1203
1204
      if (SD_OK == errorstatus)
1205
      {
1206
        /*!< Configure the SDIO peripheral */
1207
        SDIO_InitStructure.SDIO_ClockDiv = SDIO_TRANSFER_CLK_DIV; 
1208
        SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
1209
        SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;
1210
        SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;
1211
        SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_4b;
1212
        SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;
1213
        SDIO_Init(&SDIO_InitStructure);
1214
      }
1215
    }
1216
    else
1217
    {
1218
      errorstatus = SDEnWideBus(DISABLE);
1219
1220
      if (SD_OK == errorstatus)
1221
      {
1222
        /*!< Configure the SDIO peripheral */
1223
        SDIO_InitStructure.SDIO_ClockDiv = SDIO_TRANSFER_CLK_DIV; 
1224
        SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
1225
        SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;
1226
        SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;
1227
        SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;
1228
        SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;
1229
        SDIO_Init(&SDIO_InitStructure);
1230
      }
1231
    }
1232
  }
1233
1234
  return(errorstatus);
1235
}
1236
1237
/**
1238
  * @brief  Selects od Deselects the corresponding card.
1239
  * @param  addr: Address of the Card to be selected.
1240
  * @retval SD_Error: SD Card Error code.
1241
  */
1242
SD_Error SD_SelectDeselect(uint64_t addr)
1243
{
1244
  SD_Error errorstatus = SD_OK;
1245
1246
  /*!< Send CMD7 SDIO_SEL_DESEL_CARD */
1247
  SDIO_CmdInitStructure.SDIO_Argument =  (uint32_t)addr;
1248
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEL_DESEL_CARD;
1249
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1250
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1251
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1252
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1253
1254
  errorstatus = CmdResp1Error(SD_CMD_SEL_DESEL_CARD);
1255
1256
  return(errorstatus);
1257
}
1258
1259
/**
1260
  * @brief  Allows to read one block from a specified address in a card. The Data
1261
  *         transfer can be managed by DMA mode or Polling mode. 
1262
  * @note   This operation should be followed by two functions to check if the 
1263
  *         DMA Controller and SD Card status.
1264
  *          - SD_ReadWaitOperation(): this function insure that the DMA
1265
  *            controller has finished all data transfer.
1266
  *          - SD_GetStatus(): to check that the SD Card has finished the 
1267
  *            data transfer and it is ready for data.            
1268
  * @param  readbuff: pointer to the buffer that will contain the received data
1269
  * @param  ReadAddr: Address from where data are to be read.  
1270
  * @param  BlockSize: the SD card Data block size. The Block size should be 512.
1271
  * @retval SD_Error: SD Card Error code.
1272
  */
1273
SD_Error SD_ReadBlock(uint8_t *readbuff, uint64_t ReadAddr, uint16_t BlockSize)
1274
{
1275
  SD_Error errorstatus = SD_OK;
1276
#if defined (SD_POLLING_MODE) 
1277
  uint32_t count = 0, *tempbuff = (uint32_t *)readbuff;
1278
#endif
1279
1280
  TransferError = SD_OK;
1281
  TransferEnd = 0;
1282
  StopCondition = 0;
1283
1284
  SDIO->DCTRL = 0x0;
1285
1286
#if defined (SD_DMA_MODE)
1287
  SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_IT_RXOVERR | SDIO_IT_STBITERR, ENABLE);
1288
  SDIO_DMACmd(ENABLE);
1289
  SD_LowLevel_DMA_RxConfig((uint32_t *)readbuff, BlockSize);
1290
#endif
1291
1292
  if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)
1293
  {
1294
    BlockSize = 512;
1295
    ReadAddr /= 512;
1296
  }
1297
1298
  /* Set Block Size for Card */ 
1299
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) BlockSize;
1300
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
1301
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1302
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1303
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1304
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1305
1306
        uint32_t timeout = SDIO_CMD0TIMEOUT; /*!< 10000 */
1307
1308
        while ((timeout > 0) && (SDIO_GetFlagStatus(SDIO_FLAG_CMDSENT) == RESET))
1309
        {
1310
                timeout--;
1311
        }
1312
1313
  errorstatus = CmdResp1Error(SD_CMD_SET_BLOCKLEN);
1314
1315
  if (SD_OK != errorstatus)
1316
  {
1317
    return(errorstatus);
1318
  }
1319
1320
  SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
1321
  SDIO_DataInitStructure.SDIO_DataLength = BlockSize;
1322
  SDIO_DataInitStructure.SDIO_DataBlockSize = (uint32_t) 9 << 4;
1323
  SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;
1324
  SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
1325
  SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
1326
  SDIO_DataConfig(&SDIO_DataInitStructure);
1327
1328
  /*!< Send CMD17 READ_SINGLE_BLOCK */
1329
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)ReadAddr;
1330
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
1331
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1332
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1333
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1334
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1335
1336
  errorstatus = CmdResp1Error(SD_CMD_READ_SINGLE_BLOCK);
1337
1338
  if (errorstatus != SD_OK)
1339
  {
1340
    return(errorstatus);
1341
  }
1342
1343
#if defined (SD_POLLING_MODE)  
1344
  /*!< In case of single block transfer, no need of stop transfer at all.*/
1345
  /*!< Polling mode */
1346
  while (!(SDIO->STA &(SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR)))
1347
  {
1348
    if (SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET)
1349
    {
1350
      for (count = 0; count < 8; count++)
1351
      {
1352
        *(tempbuff + count) = SDIO_ReadData();
1353
      }
1354
      tempbuff += 8;
1355
    }
1356
  }
1357
1358
  if (SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)
1359
  {
1360
    SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);
1361
    errorstatus = SD_DATA_TIMEOUT;
1362
    return(errorstatus);
1363
  }
1364
  else if (SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)
1365
  {
1366
    SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);
1367
    errorstatus = SD_DATA_CRC_FAIL;
1368
    return(errorstatus);
1369
  }
1370
  else if (SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)
1371
  {
1372
    SDIO_ClearFlag(SDIO_FLAG_RXOVERR);
1373
    errorstatus = SD_RX_OVERRUN;
1374
    return(errorstatus);
1375
  }
1376
  else if (SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)
1377
  {
1378
    SDIO_ClearFlag(SDIO_FLAG_STBITERR);
1379
    errorstatus = SD_START_BIT_ERR;
1380
    return(errorstatus);
1381
  }
1382
  count = SD_DATATIMEOUT;
1383
  while ((SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET) && (count > 0))
1384
  {
1385
    *tempbuff = SDIO_ReadData();
1386
    tempbuff++;
1387
    count--;
1388
  }
1389
1390
  /*!< Clear all the static flags */
1391
  SDIO_ClearFlag(SDIO_STATIC_FLAGS);
1392
1393
#endif
1394
        DMAEndOfTransfer = 0;
1395
1396
  return(errorstatus);
1397
}
1398
1399
/**
1400
  * @brief  Allows to read blocks from a specified address  in a card.  The Data
1401
  *         transfer can be managed by DMA mode or Polling mode. 
1402
  * @note   This operation should be followed by two functions to check if the 
1403
  *         DMA Controller and SD Card status.
1404
  *          - SD_ReadWaitOperation(): this function insure that the DMA
1405
  *            controller has finished all data transfer.
1406
  *          - SD_GetStatus(): to check that the SD Card has finished the 
1407
  *            data transfer and it is ready for data.   
1408
  * @param  readbuff: pointer to the buffer that will contain the received data.
1409
  * @param  ReadAddr: Address from where data are to be read.
1410
  * @param  BlockSize: the SD card Data block size. The Block size should be 512.
1411
  * @param  NumberOfBlocks: number of blocks to be read.
1412
  * @retval SD_Error: SD Card Error code.
1413
  */
1414
SD_Error SD_ReadMultiBlocks(uint8_t *readbuff, uint64_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks)
1415
{
1416
  SD_Error errorstatus = SD_OK;
1417
  TransferError = SD_OK;
1418
  TransferEnd = 0;
1419
  StopCondition = 1;
1420
        
1421
  SDIO->DCTRL = 0x0;
1422
1423
  SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_IT_RXOVERR | SDIO_IT_STBITERR, ENABLE);
1424
  SD_LowLevel_DMA_RxConfig((uint32_t *)readbuff, (NumberOfBlocks * BlockSize));
1425
  SDIO_DMACmd(ENABLE);
1426
1427
  if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)
1428
  {
1429
    BlockSize = 512;
1430
    ReadAddr /= 512;
1431
  }
1432
1433
  /*!< Set Block Size for Card */
1434
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) BlockSize;
1435
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
1436
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1437
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1438
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1439
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1440
1441
        uint32_t timeout = SDIO_CMD0TIMEOUT; /*!< 10000 */
1442
1443
        while ((timeout > 0) && (SDIO_GetFlagStatus(SDIO_FLAG_CMDSENT) == RESET))
1444
        {
1445
                timeout--;
1446
        }
1447
1448
  errorstatus = CmdResp1Error(SD_CMD_SET_BLOCKLEN);
1449
1450
  if (SD_OK != errorstatus)
1451
  {
1452
    return(errorstatus);
1453
  }
1454
    
1455
  SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
1456
  SDIO_DataInitStructure.SDIO_DataLength = NumberOfBlocks * BlockSize;
1457
  SDIO_DataInitStructure.SDIO_DataBlockSize = (uint32_t) 9 << 4;
1458
  SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;
1459
  SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
1460
  SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
1461
  SDIO_DataConfig(&SDIO_DataInitStructure);
1462
1463
  /*!< Send CMD18 READ_MULT_BLOCK with argument data address */
1464
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)ReadAddr;
1465
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_MULT_BLOCK;
1466
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1467
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1468
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1469
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1470
1471
  errorstatus = CmdResp1Error(SD_CMD_READ_MULT_BLOCK);
1472
1473
  if (errorstatus != SD_OK)
1474
  {
1475
    return(errorstatus);
1476
  }
1477
1478
        DMAEndOfTransfer = 0;
1479
1480
  return(errorstatus);
1481
}
1482
1483
/**
1484
  * @brief  This function waits until the SDIO DMA data transfer is finished. 
1485
  *         This function should be called after SDIO_ReadMultiBlocks() function
1486
  *         to insure that all data sent by the card are already transferred by 
1487
  *         the DMA controller.
1488
  * @param  None.
1489
  * @retval SD_Error: SD Card Error code.
1490
  */
1491
SD_Error SD_WaitReadOperation(void)
1492
{
1493
  SD_Error errorstatus = SD_OK;
1494
  uint32_t timeout;
1495
1496
  timeout = SD_DATATIMEOUT;
1497
  
1498
  while ((DMAEndOfTransfer == 0x00) && (TransferEnd == 0) && (TransferError == SD_OK) && (timeout > 0))
1499
  {
1500
    timeout--;
1501
  }
1502
  
1503
  DMAEndOfTransfer = 0x00;
1504
1505
  timeout = SD_DATATIMEOUT;
1506
  
1507
  while(((SDIO->STA & SDIO_FLAG_RXACT)) && (timeout > 0))
1508
  {
1509
    timeout--;  
1510
  }
1511
1512
  if (StopCondition == 1)
1513
  {
1514
    errorstatus = SD_StopTransfer();
1515
    StopCondition = 0;
1516
  }
1517
  
1518
  if ((timeout == 0) && (errorstatus == SD_OK))
1519
  {
1520
    errorstatus = SD_DATA_TIMEOUT;
1521
  }
1522
  
1523
  /*!< Clear all the static flags */
1524
  SDIO_ClearFlag(SDIO_STATIC_FLAGS);
1525
1526
  if (TransferError != SD_OK)
1527
  {
1528
    return(TransferError);
1529
  }
1530
  else
1531
  {
1532
    return(errorstatus);  
1533
  }
1534
}
1535
1536
/**
1537
  * @brief  Allows to write one block starting from a specified address in a card.
1538
  *         The Data transfer can be managed by DMA mode or Polling mode.
1539
  * @note   This operation should be followed by two functions to check if the 
1540
  *         DMA Controller and SD Card status.
1541
  *          - SD_ReadWaitOperation(): this function insure that the DMA
1542
  *            controller has finished all data transfer.
1543
  *          - SD_GetStatus(): to check that the SD Card has finished the 
1544
  *            data transfer and it is ready for data.      
1545
  * @param  writebuff: pointer to the buffer that contain the data to be transferred.
1546
  * @param  WriteAddr: Address from where data are to be read.   
1547
  * @param  BlockSize: the SD card Data block size. The Block size should be 512.
1548
  * @retval SD_Error: SD Card Error code.
1549
  */
1550
SD_Error SD_WriteBlock(uint8_t *writebuff, uint64_t WriteAddr, uint16_t BlockSize)
1551
{
1552
  SD_Error errorstatus = SD_OK;
1553
1554
#if defined (SD_POLLING_MODE)
1555
  uint32_t bytestransferred = 0, count = 0, restwords = 0;
1556
  uint32_t *tempbuff = (uint32_t *)writebuff;
1557
#endif
1558
1559
  TransferError = SD_OK;
1560
  TransferEnd = 0;
1561
  StopCondition = 0;
1562
1563
  SDIO->DCTRL = 0x0;
1564
1565
#if defined (SD_DMA_MODE)
1566
  SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_IT_RXOVERR | SDIO_IT_STBITERR, ENABLE);
1567
  SD_LowLevel_DMA_TxConfig((uint32_t *)writebuff, BlockSize);
1568
  SDIO_DMACmd(ENABLE);
1569
#endif
1570
1571
  if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)
1572
  {
1573
    BlockSize = 512;
1574
    WriteAddr /= 512;
1575
  }
1576
1577
  /* Set Block Size for Card */ 
1578
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) BlockSize;
1579
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
1580
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1581
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1582
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1583
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1584
1585
  errorstatus = CmdResp1Error(SD_CMD_SET_BLOCKLEN);
1586
1587
  if (SD_OK != errorstatus)
1588
  {
1589
    return(errorstatus);
1590
  }
1591
1592
  /*!< Send CMD24 WRITE_SINGLE_BLOCK */
1593
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)WriteAddr;
1594
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
1595
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1596
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1597
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1598
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1599
1600
  errorstatus = CmdResp1Error(SD_CMD_WRITE_SINGLE_BLOCK);
1601
1602
  if (errorstatus != SD_OK)
1603
  {
1604
    return(errorstatus);
1605
  }
1606
1607
  SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
1608
  SDIO_DataInitStructure.SDIO_DataLength = BlockSize;
1609
  SDIO_DataInitStructure.SDIO_DataBlockSize = (uint32_t) 9 << 4;
1610
  SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToCard;
1611
  SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
1612
  SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
1613
  SDIO_DataConfig(&SDIO_DataInitStructure);
1614
1615
  /*!< In case of single data block transfer no need of stop command at all */
1616
#if defined (SD_POLLING_MODE) 
1617
  while (!(SDIO->STA & (SDIO_FLAG_DBCKEND | SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_STBITERR)))
1618
  {
1619
    if (SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET)
1620
    {
1621
      if ((512 - bytestransferred) < 32)
1622
      {
1623
        restwords = ((512 - bytestransferred) % 4 == 0) ? ((512 - bytestransferred) / 4) : (( 512 -  bytestransferred) / 4 + 1);
1624
        for (count = 0; count < restwords; count++, tempbuff++, bytestransferred += 4)
1625
        {
1626
          SDIO_WriteData(*tempbuff);
1627
        }
1628
      }
1629
      else
1630
      {
1631
        for (count = 0; count < 8; count++)
1632
        {
1633
          SDIO_WriteData(*(tempbuff + count));
1634
        }
1635
        tempbuff += 8;
1636
        bytestransferred += 32;
1637
      }
1638
    }
1639
  }
1640
  if (SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)
1641
  {
1642
    SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);
1643
    errorstatus = SD_DATA_TIMEOUT;
1644
    return(errorstatus);
1645
  }
1646
  else if (SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)
1647
  {
1648
    SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);
1649
    errorstatus = SD_DATA_CRC_FAIL;
1650
    return(errorstatus);
1651
  }
1652
  else if (SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET)
1653
  {
1654
    SDIO_ClearFlag(SDIO_FLAG_TXUNDERR);
1655
    errorstatus = SD_TX_UNDERRUN;
1656
    return(errorstatus);
1657
  }
1658
  else if (SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)
1659
  {
1660
    SDIO_ClearFlag(SDIO_FLAG_STBITERR);
1661
    errorstatus = SD_START_BIT_ERR;
1662
    return(errorstatus);
1663
  }
1664
  
1665
#endif
1666
  
1667
        DMAEndOfTransfer = 0;
1668
  return(errorstatus);
1669
}
1670
1671
/**
1672
  * @brief  Allows to write blocks starting from a specified address in a card.
1673
  *         The Data transfer can be managed by DMA mode only. 
1674
  * @note   This operation should be followed by two functions to check if the 
1675
  *         DMA Controller and SD Card status.
1676
  *          - SD_ReadWaitOperation(): this function insure that the DMA
1677
  *            controller has finished all data transfer.
1678
  *          - SD_GetStatus(): to check that the SD Card has finished the 
1679
  *            data transfer and it is ready for data.     
1680
  * @param  WriteAddr: Address from where data are to be read.
1681
  * @param  writebuff: pointer to the buffer that contain the data to be transferred.
1682
  * @param  BlockSize: the SD card Data block size. The Block size should be 512.
1683
  * @param  NumberOfBlocks: number of blocks to be written.
1684
  * @retval SD_Error: SD Card Error code.
1685
  */
1686
SD_Error SD_WriteMultiBlocks(uint8_t *writebuff, uint64_t WriteAddr, uint16_t BlockSize, uint32_t NumberOfBlocks)
1687
{
1688
  SD_Error errorstatus = SD_OK;
1689
1690
  TransferError = SD_OK;
1691
  TransferEnd = 0;
1692
  StopCondition = 1;
1693
  SDIO->DCTRL = 0x0;
1694
1695
  SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND | SDIO_IT_RXOVERR | SDIO_IT_STBITERR, ENABLE);
1696
  SD_LowLevel_DMA_TxConfig((uint32_t *)writebuff, (NumberOfBlocks * BlockSize));
1697
  SDIO_DMACmd(ENABLE);
1698
1699
  if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)
1700
  {
1701
    BlockSize = 512;
1702
    WriteAddr /= 512;
1703
  }
1704
1705
  /* Set Block Size for Card */ 
1706
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) BlockSize;
1707
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
1708
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1709
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1710
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1711
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1712
1713
  errorstatus = CmdResp1Error(SD_CMD_SET_BLOCKLEN);
1714
1715
  if (SD_OK != errorstatus)
1716
  {
1717
    return(errorstatus);
1718
  }
1719
  
1720
  /*!< To improve performance */
1721
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) (RCA << 16);
1722
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
1723
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1724
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1725
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1726
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1727
1728
1729
  errorstatus = CmdResp1Error(SD_CMD_APP_CMD);
1730
1731
  if (errorstatus != SD_OK)
1732
  {
1733
    return(errorstatus);
1734
  }
1735
  /*!< To improve performance */
1736
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)NumberOfBlocks;
1737
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCK_COUNT;
1738
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1739
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1740
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1741
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1742
1743
  errorstatus = CmdResp1Error(SD_CMD_SET_BLOCK_COUNT);
1744
1745
  if (errorstatus != SD_OK)
1746
  {
1747
    return(errorstatus);
1748
  }
1749
1750
1751
  /*!< Send CMD25 WRITE_MULT_BLOCK with argument data address */
1752
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)WriteAddr;
1753
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
1754
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1755
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1756
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1757
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1758
1759
  errorstatus = CmdResp1Error(SD_CMD_WRITE_MULT_BLOCK);
1760
1761
  if (SD_OK != errorstatus)
1762
  {
1763
    return(errorstatus);
1764
  }
1765
1766
  SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
1767
  SDIO_DataInitStructure.SDIO_DataLength = NumberOfBlocks * BlockSize;
1768
  SDIO_DataInitStructure.SDIO_DataBlockSize = (uint32_t) 9 << 4;
1769
  SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToCard;
1770
  SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
1771
  SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
1772
  SDIO_DataConfig(&SDIO_DataInitStructure);
1773
1774
        DMAEndOfTransfer = 0;
1775
  return(errorstatus);
1776
}
1777
1778
/**
1779
  * @brief  This function waits until the SDIO DMA data transfer is finished. 
1780
  *         This function should be called after SDIO_WriteBlock() and
1781
  *         SDIO_WriteMultiBlocks() function to insure that all data sent by the 
1782
  *         card are already transferred by the DMA controller.        
1783
  * @param  None.
1784
  * @retval SD_Error: SD Card Error code.
1785
  */
1786
SD_Error SD_WaitWriteOperation(void)
1787
{
1788
  SD_Error errorstatus = SD_OK;
1789
  uint32_t timeout;
1790
1791
  timeout = SD_DATATIMEOUT;
1792
  
1793
        while ((DMAEndOfTransfer == 0x00) && (TransferEnd == 0) && (TransferError == SD_OK) && (timeout > 0))
1794
        {
1795
                if (DMA_GetITStatus(DMA2_Stream3, DMA_IT_TCIF3) == 1)
1796
                {
1797
                        DMAEndOfTransfer = 1;
1798
                        /// clear the interrupt bits
1799
                        DMA_ClearITPendingBit(DMA2_Stream3, DMA_IT_TCIF3);
1800
                }
1801
                timeout--;
1802
        }
1803
1804
        timeout = SD_DATATIMEOUT;
1805
1806
        while((SDIO->DCOUNT != 0) && (timeout > 0))
1807
        {
1808
                timeout--;
1809
        }
1810
1811
  if (StopCondition == 1)
1812
  {
1813
    errorstatus = SD_StopTransfer();
1814
    StopCondition = 0;
1815
  }
1816
  
1817
  if ((timeout == 0) && (errorstatus == SD_OK))
1818
  {
1819
    errorstatus = SD_DATA_TIMEOUT;
1820
  }
1821
  
1822
  /*!< Clear all the static flags */
1823
  SDIO_ClearFlag(SDIO_STATIC_FLAGS);
1824
  
1825
  if (TransferError != SD_OK)
1826
  {
1827
    return(TransferError);
1828
  }
1829
  else
1830
  {
1831
    return(errorstatus);
1832
  }
1833
}
1834
1835
/**
1836
  * @brief  Gets the cuurent data transfer state.
1837
  * @param  None
1838
  * @retval SDTransferState: Data Transfer state.
1839
  *   This value can be: 
1840
  *        - SD_TRANSFER_OK: No data transfer is acting
1841
  *        - SD_TRANSFER_BUSY: Data transfer is acting
1842
  */
1843
SDTransferState SD_GetTransferState(void)
1844
{
1845
  if (SDIO->STA & (SDIO_FLAG_TXACT | SDIO_FLAG_RXACT))
1846
  {
1847
    return(SD_TRANSFER_BUSY);
1848
  }
1849
  else
1850
  {
1851
    return(SD_TRANSFER_OK);
1852
  }
1853
}
1854
1855
/**
1856
  * @brief  Aborts an ongoing data transfer.
1857
  * @param  None
1858
  * @retval SD_Error: SD Card Error code.
1859
  */
1860
SD_Error SD_StopTransfer(void)
1861
{
1862
  SD_Error errorstatus = SD_OK;
1863
1864
  /*!< Send CMD12 STOP_TRANSMISSION  */
1865
  SDIO_CmdInitStructure.SDIO_Argument = 0x0;
1866
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
1867
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1868
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1869
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1870
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1871
1872
  errorstatus = CmdResp1Error(SD_CMD_STOP_TRANSMISSION);
1873
1874
  return(errorstatus);
1875
}
1876
1877
/**
1878
  * @brief  Allows to erase memory area specified for the given card.
1879
  * @param  startaddr: the start address.
1880
  * @param  endaddr: the end address.
1881
  * @retval SD_Error: SD Card Error code.
1882
  */
1883
SD_Error SD_Erase(uint64_t startaddr, uint64_t endaddr)
1884
{
1885
  SD_Error errorstatus = SD_OK;
1886
  uint32_t delay = 0;
1887
  __IO uint32_t maxdelay = 0;
1888
  uint8_t cardstate = 0;
1889
1890
  /*!< Check if the card coomnd class supports erase command */
1891
  if (((CSD_Tab[1] >> 20) & SD_CCCC_ERASE) == 0)
1892
  {
1893
    errorstatus = SD_REQUEST_NOT_APPLICABLE;
1894
    return(errorstatus);
1895
  }
1896
1897
  maxdelay = 120000 / ((SDIO->CLKCR & 0xFF) + 2);
1898
1899
  if (SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED)
1900
  {
1901
    errorstatus = SD_LOCK_UNLOCK_FAILED;
1902
    return(errorstatus);
1903
  }
1904
1905
  if (CardType == SDIO_HIGH_CAPACITY_SD_CARD)
1906
  {
1907
    startaddr /= 512;
1908
    endaddr /= 512;
1909
  }
1910
  
1911
  /*!< According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
1912
  if ((SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType) || (SDIO_HIGH_CAPACITY_SD_CARD == CardType))
1913
  {
1914
    /*!< Send CMD32 SD_ERASE_GRP_START with argument as addr  */
1915
    SDIO_CmdInitStructure.SDIO_Argument =(uint32_t)startaddr;
1916
    SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_ERASE_GRP_START;
1917
    SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1918
    SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1919
    SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1920
    SDIO_SendCommand(&SDIO_CmdInitStructure);
1921
1922
    errorstatus = CmdResp1Error(SD_CMD_SD_ERASE_GRP_START);
1923
    if (errorstatus != SD_OK)
1924
    {
1925
      return(errorstatus);
1926
    }
1927
1928
    /*!< Send CMD33 SD_ERASE_GRP_END with argument as addr  */
1929
    SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)endaddr;
1930
    SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_ERASE_GRP_END;
1931
    SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1932
    SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1933
    SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1934
    SDIO_SendCommand(&SDIO_CmdInitStructure);
1935
1936
    errorstatus = CmdResp1Error(SD_CMD_SD_ERASE_GRP_END);
1937
    if (errorstatus != SD_OK)
1938
    {
1939
      return(errorstatus);
1940
    }
1941
  }
1942
1943
  /*!< Send CMD38 ERASE */
1944
  SDIO_CmdInitStructure.SDIO_Argument = 0;
1945
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_ERASE;
1946
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1947
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1948
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1949
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1950
1951
  errorstatus = CmdResp1Error(SD_CMD_ERASE);
1952
1953
  if (errorstatus != SD_OK)
1954
  {
1955
    return(errorstatus);
1956
  }
1957
1958
  for (delay = 0; delay < maxdelay; delay++)
1959
  {}
1960
1961
  /*!< Wait till the card is in programming state */
1962
  errorstatus = IsCardProgramming(&cardstate);
1963
  delay = SD_DATATIMEOUT;
1964
  while ((delay > 0) && (errorstatus == SD_OK) && ((SD_CARD_PROGRAMMING == cardstate) || (SD_CARD_RECEIVING == cardstate)))
1965
  {
1966
    errorstatus = IsCardProgramming(&cardstate);
1967
    delay--;
1968
  }
1969
1970
  return(errorstatus);
1971
}
1972
1973
/**
1974
  * @brief  Returns the current card's status.
1975
  * @param  pcardstatus: pointer to the buffer that will contain the SD card 
1976
  *         status (Card Status register).
1977
  * @retval SD_Error: SD Card Error code.
1978
  */
1979
SD_Error SD_SendStatus(uint32_t *pcardstatus)
1980
{
1981
  SD_Error errorstatus = SD_OK;
1982
1983
  if (pcardstatus == NULL)
1984
  {
1985
    errorstatus = SD_INVALID_PARAMETER;
1986
    return(errorstatus);
1987
  }
1988
1989
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
1990
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
1991
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
1992
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
1993
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
1994
  SDIO_SendCommand(&SDIO_CmdInitStructure);
1995
1996
  errorstatus = CmdResp1Error(SD_CMD_SEND_STATUS);
1997
1998
  if (errorstatus != SD_OK)
1999
  {
2000
    return(errorstatus);
2001
  }
2002
2003
  *pcardstatus = SDIO_GetResponse(SDIO_RESP1);
2004
2005
  return(errorstatus);
2006
}
2007
2008
/**
2009
  * @brief  Returns the current SD card's status.
2010
  * @param  psdstatus: pointer to the buffer that will contain the SD card status 
2011
  *         (SD Status register).
2012
  * @retval SD_Error: SD Card Error code.
2013
  */
2014
SD_Error SD_SendSDStatus(uint32_t *psdstatus)
2015
{
2016
  SD_Error errorstatus = SD_OK;
2017
  uint32_t count = 0;
2018
2019
  if (SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED)
2020
  {
2021
    errorstatus = SD_LOCK_UNLOCK_FAILED;
2022
    return(errorstatus);
2023
  }
2024
2025
  /*!< Set block size for card if it is not equal to current block size for card. */
2026
  SDIO_CmdInitStructure.SDIO_Argument = 64;
2027
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
2028
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
2029
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
2030
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
2031
  SDIO_SendCommand(&SDIO_CmdInitStructure);
2032
2033
  errorstatus = CmdResp1Error(SD_CMD_SET_BLOCKLEN);
2034
2035
  if (errorstatus != SD_OK)
2036
  {
2037
    return(errorstatus);
2038
  }
2039
2040
  /*!< CMD55 */
2041
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
2042
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
2043
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
2044
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
2045
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
2046
  SDIO_SendCommand(&SDIO_CmdInitStructure);
2047
  errorstatus = CmdResp1Error(SD_CMD_APP_CMD);
2048
2049
  if (errorstatus != SD_OK)
2050
  {
2051
    return(errorstatus);
2052
  }
2053
2054
  SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
2055
  SDIO_DataInitStructure.SDIO_DataLength = 64;
2056
  SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_64b;
2057
  SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;
2058
  SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
2059
  SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
2060
  SDIO_DataConfig(&SDIO_DataInitStructure);
2061
2062
  /*!< Send ACMD13 SD_APP_STAUS  with argument as card's RCA.*/
2063
  SDIO_CmdInitStructure.SDIO_Argument = 0;
2064
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_STAUS;
2065
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
2066
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
2067
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
2068
  SDIO_SendCommand(&SDIO_CmdInitStructure);
2069
  errorstatus = CmdResp1Error(SD_CMD_SD_APP_STAUS);
2070
2071
  if (errorstatus != SD_OK)
2072
  {
2073
    return(errorstatus);
2074
  }
2075
2076
  while (!(SDIO->STA &(SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR)))
2077
  {
2078
    if (SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET)
2079
    {
2080
      for (count = 0; count < 8; count++)
2081
      {
2082
        *(psdstatus + count) = SDIO_ReadData();
2083
      }
2084
      psdstatus += 8;
2085
    }
2086
  }
2087
2088
  if (SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)
2089
  {
2090
    SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);
2091
    errorstatus = SD_DATA_TIMEOUT;
2092
    return(errorstatus);
2093
  }
2094
  else if (SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)
2095
  {
2096
    SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);
2097
    errorstatus = SD_DATA_CRC_FAIL;
2098
    return(errorstatus);
2099
  }
2100
  else if (SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)
2101
  {
2102
    SDIO_ClearFlag(SDIO_FLAG_RXOVERR);
2103
    errorstatus = SD_RX_OVERRUN;
2104
    return(errorstatus);
2105
  }
2106
  else if (SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)
2107
  {
2108
    SDIO_ClearFlag(SDIO_FLAG_STBITERR);
2109
    errorstatus = SD_START_BIT_ERR;
2110
    return(errorstatus);
2111
  }
2112
2113
  count = SD_DATATIMEOUT;
2114
  while ((SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET) && (count > 0))
2115
  {
2116
    *psdstatus = SDIO_ReadData();
2117
    psdstatus++;
2118
    count--;
2119
  }
2120
  /*!< Clear all the static status flags*/
2121
  SDIO_ClearFlag(SDIO_STATIC_FLAGS);
2122
2123
  return(errorstatus);
2124
}
2125
2126
/**
2127
  * @brief  Allows to process all the interrupts that are high.
2128
  * @param  None
2129
  * @retval SD_Error: SD Card Error code.
2130
  */
2131
SD_Error SD_ProcessIRQSrc(void)
2132
{ 
2133
  if (SDIO_GetITStatus(SDIO_IT_DATAEND) != RESET)
2134
  {
2135
    TransferError = SD_OK;
2136
    SDIO_ClearITPendingBit(SDIO_IT_DATAEND);
2137
    TransferEnd = 1;
2138
  }  
2139
  else if (SDIO_GetITStatus(SDIO_IT_DCRCFAIL) != RESET)
2140
  {
2141
    SDIO_ClearITPendingBit(SDIO_IT_DCRCFAIL);
2142
    TransferError = SD_DATA_CRC_FAIL;
2143
  }
2144
  else if (SDIO_GetITStatus(SDIO_IT_DTIMEOUT) != RESET)
2145
  {
2146
    SDIO_ClearITPendingBit(SDIO_IT_DTIMEOUT);
2147
    TransferError = SD_DATA_TIMEOUT;
2148
  }
2149
  else if (SDIO_GetITStatus(SDIO_IT_RXOVERR) != RESET)
2150
  {
2151
    SDIO_ClearITPendingBit(SDIO_IT_RXOVERR);
2152
    TransferError = SD_RX_OVERRUN;
2153
  }
2154
  else if (SDIO_GetITStatus(SDIO_IT_TXUNDERR) != RESET)
2155
  {
2156
    SDIO_ClearITPendingBit(SDIO_IT_TXUNDERR);
2157
    TransferError = SD_TX_UNDERRUN;
2158
  }
2159
  else if (SDIO_GetITStatus(SDIO_IT_STBITERR) != RESET)
2160
  {
2161
    SDIO_ClearITPendingBit(SDIO_IT_STBITERR);
2162
    TransferError = SD_START_BIT_ERR;
2163
  }
2164
2165
  SDIO_ITConfig(SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_DATAEND |
2166
                SDIO_IT_TXFIFOHE | SDIO_IT_RXFIFOHF | SDIO_IT_TXUNDERR |
2167
                SDIO_IT_RXOVERR | SDIO_IT_STBITERR, DISABLE);
2168
  return(TransferError);
2169
}
2170
2171
/**
2172
  * @brief  This function waits until the SDIO DMA data transfer is finished. 
2173
  * @param  None.
2174
  * @retval None.
2175
  */
2176
void SD_ProcessDMAIRQ(void)
2177
{
2178
  if(DMA2->LISR & SD_SDIO_DMA_FLAG_TCIF)
2179
  {
2180
    DMAEndOfTransfer = 0x01;
2181
    DMA_ClearFlag(SD_SDIO_DMA_STREAM, SD_SDIO_DMA_FLAG_TCIF|SD_SDIO_DMA_FLAG_FEIF);
2182
  }
2183
}
2184
2185
/**
2186
  * @brief  Checks for error conditions for CMD0.
2187
  * @param  None
2188
  * @retval SD_Error: SD Card Error code.
2189
  */
2190
static SD_Error CmdError(void)
2191
{
2192
  SD_Error errorstatus = SD_OK;
2193
  uint32_t timeout;
2194
2195
  timeout = SDIO_CMD0TIMEOUT; /*!< 10000 */
2196
2197
  while ((timeout > 0) && (SDIO_GetFlagStatus(SDIO_FLAG_CMDSENT) == RESET))
2198
  {
2199
    timeout--;
2200
  }
2201
2202
  if (timeout == 0)
2203
  {
2204
    errorstatus = SD_CMD_RSP_TIMEOUT;
2205
    return(errorstatus);
2206
  }
2207
2208
  /*!< Clear all the static flags */
2209
  SDIO_ClearFlag(SDIO_STATIC_FLAGS);
2210
2211
  return(errorstatus);
2212
}
2213
2214
/**
2215
  * @brief  Checks for error conditions for R7 response.
2216
  * @param  None
2217
  * @retval SD_Error: SD Card Error code.
2218
  */
2219
static SD_Error CmdResp7Error(void)
2220
{
2221
  SD_Error errorstatus = SD_OK;
2222
  uint32_t status;
2223
  uint32_t timeout = SDIO_CMD0TIMEOUT;
2224
2225
  status = SDIO->STA;
2226
2227
  while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) && (timeout > 0))
2228
  {
2229
    timeout--;
2230
    status = SDIO->STA;
2231
  }
2232
2233
  if ((timeout == 0) || (status & SDIO_FLAG_CTIMEOUT))
2234
  {
2235
    /*!< Card is not V2.0 complient or card does not support the set voltage range */
2236
    errorstatus = SD_CMD_RSP_TIMEOUT;
2237
    SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
2238
    return(errorstatus);
2239
  }
2240
2241
  if (status & SDIO_FLAG_CMDREND)
2242
  {
2243
    /*!< Card is SD V2.0 compliant */
2244
    errorstatus = SD_OK;
2245
    SDIO_ClearFlag(SDIO_FLAG_CMDREND);
2246
    return(errorstatus);
2247
  }
2248
  return(errorstatus);
2249
}
2250
2251
/**
2252
  * @brief  Checks for error conditions for R1 response.
2253
  * @param  cmd: The sent command index.
2254
  * @retval SD_Error: SD Card Error code.
2255
  */
2256
static SD_Error CmdResp1Error(uint8_t cmd)
2257
{
2258
  SD_Error errorstatus = SD_OK;
2259
  uint32_t status;
2260
  uint32_t response_r1;
2261
2262
  status = SDIO->STA;
2263
2264
  while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)))
2265
  {
2266
    status = SDIO->STA;
2267
  }
2268
2269
  if (status & SDIO_FLAG_CTIMEOUT)
2270
  {
2271
    errorstatus = SD_CMD_RSP_TIMEOUT;
2272
    SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
2273
    return(errorstatus);
2274
  }
2275
  else if (status & SDIO_FLAG_CCRCFAIL)
2276
  {
2277
    errorstatus = SD_CMD_CRC_FAIL;
2278
    SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);
2279
    return(errorstatus);
2280
  }
2281
2282
  /*!< Check response received is of desired command */
2283
  if (SDIO_GetCommandResponse() != cmd)
2284
  {
2285
    errorstatus = SD_ILLEGAL_CMD;
2286
    return(errorstatus);
2287
  }
2288
2289
  /*!< Clear all the static flags */
2290
  SDIO_ClearFlag(SDIO_STATIC_FLAGS);
2291
2292
  /*!< We have received response, retrieve it for analysis  */
2293
  response_r1 = SDIO_GetResponse(SDIO_RESP1);
2294
2295
  if ((response_r1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
2296
  {
2297
    return(errorstatus);
2298
  }
2299
2300
  if (response_r1 & SD_OCR_ADDR_OUT_OF_RANGE)
2301
  {
2302
    return(SD_ADDR_OUT_OF_RANGE);
2303
  }
2304
2305
  if (response_r1 & SD_OCR_ADDR_MISALIGNED)
2306
  {
2307
    return(SD_ADDR_MISALIGNED);
2308
  }
2309
2310
  if (response_r1 & SD_OCR_BLOCK_LEN_ERR)
2311
  {
2312
    return(SD_BLOCK_LEN_ERR);
2313
  }
2314
2315
  if (response_r1 & SD_OCR_ERASE_SEQ_ERR)
2316
  {
2317
    return(SD_ERASE_SEQ_ERR);
2318
  }
2319
2320
  if (response_r1 & SD_OCR_BAD_ERASE_PARAM)
2321
  {
2322
    return(SD_BAD_ERASE_PARAM);
2323
  }
2324
2325
  if (response_r1 & SD_OCR_WRITE_PROT_VIOLATION)
2326
  {
2327
    return(SD_WRITE_PROT_VIOLATION);
2328
  }
2329
2330
  if (response_r1 & SD_OCR_LOCK_UNLOCK_FAILED)
2331
  {
2332
    return(SD_LOCK_UNLOCK_FAILED);
2333
  }
2334
2335
  if (response_r1 & SD_OCR_COM_CRC_FAILED)
2336
  {
2337
    return(SD_COM_CRC_FAILED);
2338
  }
2339
2340
  if (response_r1 & SD_OCR_ILLEGAL_CMD)
2341
  {
2342
    return(SD_ILLEGAL_CMD);
2343
  }
2344
2345
  if (response_r1 & SD_OCR_CARD_ECC_FAILED)
2346
  {
2347
    return(SD_CARD_ECC_FAILED);
2348
  }
2349
2350
  if (response_r1 & SD_OCR_CC_ERROR)
2351
  {
2352
    return(SD_CC_ERROR);
2353
  }
2354
2355
  if (response_r1 & SD_OCR_GENERAL_UNKNOWN_ERROR)
2356
  {
2357
    return(SD_GENERAL_UNKNOWN_ERROR);
2358
  }
2359
2360
  if (response_r1 & SD_OCR_STREAM_READ_UNDERRUN)
2361
  {
2362
    return(SD_STREAM_READ_UNDERRUN);
2363
  }
2364
2365
  if (response_r1 & SD_OCR_STREAM_WRITE_OVERRUN)
2366
  {
2367
    return(SD_STREAM_WRITE_OVERRUN);
2368
  }
2369
2370
  if (response_r1 & SD_OCR_CID_CSD_OVERWRIETE)
2371
  {
2372
    return(SD_CID_CSD_OVERWRITE);
2373
  }
2374
2375
  if (response_r1 & SD_OCR_WP_ERASE_SKIP)
2376
  {
2377
    return(SD_WP_ERASE_SKIP);
2378
  }
2379
2380
  if (response_r1 & SD_OCR_CARD_ECC_DISABLED)
2381
  {
2382
    return(SD_CARD_ECC_DISABLED);
2383
  }
2384
2385
  if (response_r1 & SD_OCR_ERASE_RESET)
2386
  {
2387
    return(SD_ERASE_RESET);
2388
  }
2389
2390
  if (response_r1 & SD_OCR_AKE_SEQ_ERROR)
2391
  {
2392
    return(SD_AKE_SEQ_ERROR);
2393
  }
2394
  return(errorstatus);
2395
}
2396
2397
/**
2398
  * @brief  Checks for error conditions for R3 (OCR) response.
2399
  * @param  None
2400
  * @retval SD_Error: SD Card Error code.
2401
  */
2402
static SD_Error CmdResp3Error(void)
2403
{
2404
  SD_Error errorstatus = SD_OK;
2405
  uint32_t status;
2406
2407
  status = SDIO->STA;
2408
2409
  while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)))
2410
  {
2411
    status = SDIO->STA;
2412
  }
2413
2414
  if (status & SDIO_FLAG_CTIMEOUT)
2415
  {
2416
    errorstatus = SD_CMD_RSP_TIMEOUT;
2417
    SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
2418
    return(errorstatus);
2419
  }
2420
  /*!< Clear all the static flags */
2421
  SDIO_ClearFlag(SDIO_STATIC_FLAGS);
2422
  return(errorstatus);
2423
}
2424
2425
/**
2426
  * @brief  Checks for error conditions for R2 (CID or CSD) response.
2427
  * @param  None
2428
  * @retval SD_Error: SD Card Error code.
2429
  */
2430
static SD_Error CmdResp2Error(void)
2431
{
2432
  SD_Error errorstatus = SD_OK;
2433
  uint32_t status;
2434
2435
  status = SDIO->STA;
2436
2437
  while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CTIMEOUT | SDIO_FLAG_CMDREND)))
2438
  {
2439
    status = SDIO->STA;
2440
  }
2441
2442
  if (status & SDIO_FLAG_CTIMEOUT)
2443
  {
2444
    errorstatus = SD_CMD_RSP_TIMEOUT;
2445
    SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
2446
    return(errorstatus);
2447
  }
2448
  else if (status & SDIO_FLAG_CCRCFAIL)
2449
  {
2450
    errorstatus = SD_CMD_CRC_FAIL;
2451
    SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);
2452
    return(errorstatus);
2453
  }
2454
2455
  /*!< Clear all the static flags */
2456
  SDIO_ClearFlag(SDIO_STATIC_FLAGS);
2457
2458
  return(errorstatus);
2459
}
2460
2461
/**
2462
  * @brief  Checks for error conditions for R6 (RCA) response.
2463
  * @param  cmd: The sent command index.
2464
  * @param  prca: pointer to the variable that will contain the SD card relative 
2465
  *         address RCA. 
2466
  * @retval SD_Error: SD Card Error code.
2467
  */
2468
static SD_Error CmdResp6Error(uint8_t cmd, uint16_t *prca)
2469
{
2470
  SD_Error errorstatus = SD_OK;
2471
  uint32_t status;
2472
  uint32_t response_r1;
2473
2474
  status = SDIO->STA;
2475
2476
  while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CTIMEOUT | SDIO_FLAG_CMDREND)))
2477
  {
2478
    status = SDIO->STA;
2479
  }
2480
2481
  if (status & SDIO_FLAG_CTIMEOUT)
2482
  {
2483
    errorstatus = SD_CMD_RSP_TIMEOUT;
2484
    SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
2485
    return(errorstatus);
2486
  }
2487
  else if (status & SDIO_FLAG_CCRCFAIL)
2488
  {
2489
    errorstatus = SD_CMD_CRC_FAIL;
2490
    SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);
2491
    return(errorstatus);
2492
  }
2493
2494
  /*!< Check response received is of desired command */
2495
  if (SDIO_GetCommandResponse() != cmd)
2496
  {
2497
    errorstatus = SD_ILLEGAL_CMD;
2498
    return(errorstatus);
2499
  }
2500
2501
  /*!< Clear all the static flags */
2502
  SDIO_ClearFlag(SDIO_STATIC_FLAGS);
2503
2504
  /*!< We have received response, retrieve it.  */
2505
  response_r1 = SDIO_GetResponse(SDIO_RESP1);
2506
2507
  if (SD_ALLZERO == (response_r1 & (SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD | SD_R6_COM_CRC_FAILED)))
2508
  {
2509
    *prca = (uint16_t) (response_r1 >> 16);
2510
    return(errorstatus);
2511
  }
2512
2513
  if (response_r1 & SD_R6_GENERAL_UNKNOWN_ERROR)
2514
  {
2515
    return(SD_GENERAL_UNKNOWN_ERROR);
2516
  }
2517
2518
  if (response_r1 & SD_R6_ILLEGAL_CMD)
2519
  {
2520
    return(SD_ILLEGAL_CMD);
2521
  }
2522
2523
  if (response_r1 & SD_R6_COM_CRC_FAILED)
2524
  {
2525
    return(SD_COM_CRC_FAILED);
2526
  }
2527
2528
  return(errorstatus);
2529
}
2530
2531
/**
2532
  * @brief  Enables or disables the SDIO wide bus mode.
2533
  * @param  NewState: new state of the SDIO wide bus mode.
2534
  *   This parameter can be: ENABLE or DISABLE.
2535
  * @retval SD_Error: SD Card Error code.
2536
  */
2537
static SD_Error SDEnWideBus(FunctionalState NewState)
2538
{
2539
  SD_Error errorstatus = SD_OK;
2540
2541
  uint32_t scr[2] = {0, 0};
2542
2543
  if (SDIO_GetResponse(SDIO_RESP1) & SD_CARD_LOCKED)
2544
  {
2545
    errorstatus = SD_LOCK_UNLOCK_FAILED;
2546
    return(errorstatus);
2547
  }
2548
2549
  /*!< Get SCR Register */
2550
  errorstatus = FindSCR(RCA, scr);
2551
2552
  if (errorstatus != SD_OK)
2553
  {
2554
    return(errorstatus);
2555
  }
2556
2557
  /*!< If wide bus operation to be enabled */
2558
  if (NewState == ENABLE)
2559
  {
2560
    /*!< If requested card supports wide bus operation */
2561
    if ((scr[1] & SD_WIDE_BUS_SUPPORT) != SD_ALLZERO)
2562
    {
2563
      /*!< Send CMD55 APP_CMD with argument as card's RCA.*/
2564
      SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
2565
      SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
2566
      SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
2567
      SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
2568
      SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
2569
      SDIO_SendCommand(&SDIO_CmdInitStructure);
2570
2571
      errorstatus = CmdResp1Error(SD_CMD_APP_CMD);
2572
2573
      if (errorstatus != SD_OK)
2574
      {
2575
        return(errorstatus);
2576
      }
2577
2578
      /*!< Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
2579
      SDIO_CmdInitStructure.SDIO_Argument = 0x2;
2580
      SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
2581
      SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
2582
      SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
2583
      SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
2584
      SDIO_SendCommand(&SDIO_CmdInitStructure);
2585
2586
      errorstatus = CmdResp1Error(SD_CMD_APP_SD_SET_BUSWIDTH);
2587
2588
      if (errorstatus != SD_OK)
2589
      {
2590
        return(errorstatus);
2591
      }
2592
      return(errorstatus);
2593
    }
2594
    else
2595
    {
2596
      errorstatus = SD_REQUEST_NOT_APPLICABLE;
2597
      return(errorstatus);
2598
    }
2599
  }   /*!< If wide bus operation to be disabled */
2600
  else
2601
  {
2602
    /*!< If requested card supports 1 bit mode operation */
2603
    if ((scr[1] & SD_SINGLE_BUS_SUPPORT) != SD_ALLZERO)
2604
    {
2605
      /*!< Send CMD55 APP_CMD with argument as card's RCA.*/
2606
      SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
2607
      SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
2608
      SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
2609
      SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
2610
      SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
2611
      SDIO_SendCommand(&SDIO_CmdInitStructure);
2612
2613
2614
      errorstatus = CmdResp1Error(SD_CMD_APP_CMD);
2615
2616
      if (errorstatus != SD_OK)
2617
      {
2618
        return(errorstatus);
2619
      }
2620
2621
      /*!< Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
2622
      SDIO_CmdInitStructure.SDIO_Argument = 0x00;
2623
      SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
2624
      SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
2625
      SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
2626
      SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
2627
      SDIO_SendCommand(&SDIO_CmdInitStructure);
2628
2629
      errorstatus = CmdResp1Error(SD_CMD_APP_SD_SET_BUSWIDTH);
2630
2631
      if (errorstatus != SD_OK)
2632
      {
2633
        return(errorstatus);
2634
      }
2635
2636
      return(errorstatus);
2637
    }
2638
    else
2639
    {
2640
      errorstatus = SD_REQUEST_NOT_APPLICABLE;
2641
      return(errorstatus);
2642
    }
2643
  }
2644
}
2645
2646
/**
2647
  * @brief  Checks if the SD card is in programming state.
2648
  * @param  pstatus: pointer to the variable that will contain the SD card state.
2649
  * @retval SD_Error: SD Card Error code.
2650
  */
2651
static SD_Error IsCardProgramming(uint8_t *pstatus)
2652
{
2653
  SD_Error errorstatus = SD_OK;
2654
  __IO uint32_t respR1 = 0, status = 0;
2655
2656
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
2657
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
2658
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
2659
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
2660
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
2661
  SDIO_SendCommand(&SDIO_CmdInitStructure);
2662
2663
  status = SDIO->STA;
2664
  while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)))
2665
  {
2666
    status = SDIO->STA;
2667
  }
2668
2669
  if (status & SDIO_FLAG_CTIMEOUT)
2670
  {
2671
    errorstatus = SD_CMD_RSP_TIMEOUT;
2672
    SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
2673
    return(errorstatus);
2674
  }
2675
  else if (status & SDIO_FLAG_CCRCFAIL)
2676
  {
2677
    errorstatus = SD_CMD_CRC_FAIL;
2678
    SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);
2679
    return(errorstatus);
2680
  }
2681
2682
  status = (uint32_t)SDIO_GetCommandResponse();
2683
2684
  /*!< Check response received is of desired command */
2685
  if (status != SD_CMD_SEND_STATUS)
2686
  {
2687
    errorstatus = SD_ILLEGAL_CMD;
2688
    return(errorstatus);
2689
  }
2690
2691
  /*!< Clear all the static flags */
2692
  SDIO_ClearFlag(SDIO_STATIC_FLAGS);
2693
2694
2695
  /*!< We have received response, retrieve it for analysis  */
2696
  respR1 = SDIO_GetResponse(SDIO_RESP1);
2697
2698
  /*!< Find out card status */
2699
  *pstatus = (uint8_t) ((respR1 >> 9) & 0x0000000F);
2700
2701
  if ((respR1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
2702
  {
2703
    return(errorstatus);
2704
  }
2705
2706
  if (respR1 & SD_OCR_ADDR_OUT_OF_RANGE)
2707
  {
2708
    return(SD_ADDR_OUT_OF_RANGE);
2709
  }
2710
2711
  if (respR1 & SD_OCR_ADDR_MISALIGNED)
2712
  {
2713
    return(SD_ADDR_MISALIGNED);
2714
  }
2715
2716
  if (respR1 & SD_OCR_BLOCK_LEN_ERR)
2717
  {
2718
    return(SD_BLOCK_LEN_ERR);
2719
  }
2720
2721
  if (respR1 & SD_OCR_ERASE_SEQ_ERR)
2722
  {
2723
    return(SD_ERASE_SEQ_ERR);
2724
  }
2725
2726
  if (respR1 & SD_OCR_BAD_ERASE_PARAM)
2727
  {
2728
    return(SD_BAD_ERASE_PARAM);
2729
  }
2730
2731
  if (respR1 & SD_OCR_WRITE_PROT_VIOLATION)
2732
  {
2733
    return(SD_WRITE_PROT_VIOLATION);
2734
  }
2735
2736
  if (respR1 & SD_OCR_LOCK_UNLOCK_FAILED)
2737
  {
2738
    return(SD_LOCK_UNLOCK_FAILED);
2739
  }
2740
2741
  if (respR1 & SD_OCR_COM_CRC_FAILED)
2742
  {
2743
    return(SD_COM_CRC_FAILED);
2744
  }
2745
2746
  if (respR1 & SD_OCR_ILLEGAL_CMD)
2747
  {
2748
    return(SD_ILLEGAL_CMD);
2749
  }
2750
2751
  if (respR1 & SD_OCR_CARD_ECC_FAILED)
2752
  {
2753
    return(SD_CARD_ECC_FAILED);
2754
  }
2755
2756
  if (respR1 & SD_OCR_CC_ERROR)
2757
  {
2758
    return(SD_CC_ERROR);
2759
  }
2760
2761
  if (respR1 & SD_OCR_GENERAL_UNKNOWN_ERROR)
2762
  {
2763
    return(SD_GENERAL_UNKNOWN_ERROR);
2764
  }
2765
2766
  if (respR1 & SD_OCR_STREAM_READ_UNDERRUN)
2767
  {
2768
    return(SD_STREAM_READ_UNDERRUN);
2769
  }
2770
2771
  if (respR1 & SD_OCR_STREAM_WRITE_OVERRUN)
2772
  {
2773
    return(SD_STREAM_WRITE_OVERRUN);
2774
  }
2775
2776
  if (respR1 & SD_OCR_CID_CSD_OVERWRIETE)
2777
  {
2778
    return(SD_CID_CSD_OVERWRITE);
2779
  }
2780
2781
  if (respR1 & SD_OCR_WP_ERASE_SKIP)
2782
  {
2783
    return(SD_WP_ERASE_SKIP);
2784
  }
2785
2786
  if (respR1 & SD_OCR_CARD_ECC_DISABLED)
2787
  {
2788
    return(SD_CARD_ECC_DISABLED);
2789
  }
2790
2791
  if (respR1 & SD_OCR_ERASE_RESET)
2792
  {
2793
    return(SD_ERASE_RESET);
2794
  }
2795
2796
  if (respR1 & SD_OCR_AKE_SEQ_ERROR)
2797
  {
2798
    return(SD_AKE_SEQ_ERROR);
2799
  }
2800
2801
  return(errorstatus);
2802
}
2803
2804
/**
2805
  * @brief  Find the SD card SCR register value.
2806
  * @param  rca: selected card address.
2807
  * @param  pscr: pointer to the buffer that will contain the SCR value.
2808
  * @retval SD_Error: SD Card Error code.
2809
  */
2810
static SD_Error FindSCR(uint16_t rca, uint32_t *pscr)
2811
{
2812
  uint32_t index = 0;
2813
  SD_Error errorstatus = SD_OK;
2814
  uint32_t tempscr[2] = {0, 0};
2815
2816
  /*!< Set Block Size To 8 Bytes */
2817
  /*!< Send CMD55 APP_CMD with argument as card's RCA */
2818
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)8;
2819
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
2820
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
2821
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
2822
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
2823
  SDIO_SendCommand(&SDIO_CmdInitStructure);
2824
2825
  errorstatus = CmdResp1Error(SD_CMD_SET_BLOCKLEN);
2826
2827
  if (errorstatus != SD_OK)
2828
  {
2829
    return(errorstatus);
2830
  }
2831
2832
  /*!< Send CMD55 APP_CMD with argument as card's RCA */
2833
  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
2834
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
2835
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
2836
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
2837
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
2838
  SDIO_SendCommand(&SDIO_CmdInitStructure);
2839
2840
  errorstatus = CmdResp1Error(SD_CMD_APP_CMD);
2841
2842
  if (errorstatus != SD_OK)
2843
  {
2844
    return(errorstatus);
2845
  }
2846
  SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
2847
  SDIO_DataInitStructure.SDIO_DataLength = 8;
2848
  SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_8b;
2849
  SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;
2850
  SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
2851
  SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
2852
  SDIO_DataConfig(&SDIO_DataInitStructure);
2853
2854
2855
  /*!< Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
2856
  SDIO_CmdInitStructure.SDIO_Argument = 0x0;
2857
  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_SEND_SCR;
2858
  SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
2859
  SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
2860
  SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
2861
  SDIO_SendCommand(&SDIO_CmdInitStructure);
2862
2863
  errorstatus = CmdResp1Error(SD_CMD_SD_APP_SEND_SCR);
2864
2865
  if (errorstatus != SD_OK)
2866
  {
2867
    return(errorstatus);
2868
  }
2869
2870
  while (!(SDIO->STA & (SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND | SDIO_FLAG_STBITERR)))
2871
  {
2872
    if (SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET)
2873
    {
2874
      *(tempscr + index) = SDIO_ReadData();
2875
      index++;
2876
    }
2877
  }
2878
2879
  if (SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)
2880
  {
2881
    SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);
2882
    errorstatus = SD_DATA_TIMEOUT;
2883
    return(errorstatus);
2884
  }
2885
  else if (SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)
2886
  {
2887
    SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);
2888
    errorstatus = SD_DATA_CRC_FAIL;
2889
    return(errorstatus);
2890
  }
2891
  else if (SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)
2892
  {
2893
    SDIO_ClearFlag(SDIO_FLAG_RXOVERR);
2894
    errorstatus = SD_RX_OVERRUN;
2895
    return(errorstatus);
2896
  }
2897
  else if (SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)
2898
  {
2899
    SDIO_ClearFlag(SDIO_FLAG_STBITERR);
2900
    errorstatus = SD_START_BIT_ERR;
2901
    return(errorstatus);
2902
  }
2903
2904
  /*!< Clear all the static flags */
2905
  SDIO_ClearFlag(SDIO_STATIC_FLAGS);
2906
2907
  *(pscr + 1) = ((tempscr[0] & SD_0TO7BITS) << 24) | ((tempscr[0] & SD_8TO15BITS) << 8) | ((tempscr[0] & SD_16TO23BITS) >> 8) | ((tempscr[0] & SD_24TO31BITS) >> 24);
2908
2909
  *(pscr) = ((tempscr[1] & SD_0TO7BITS) << 24) | ((tempscr[1] & SD_8TO15BITS) << 8) | ((tempscr[1] & SD_16TO23BITS) >> 8) | ((tempscr[1] & SD_24TO31BITS) >> 24);
2910
2911
  return(errorstatus);
2912
}
2913
2914
/**
2915
  * @brief  DeInitializes the SDIO interface.
2916
  * @param  None
2917
  * @retval None
2918
  */
2919
static void SD_LowLevel_DeInit(void)
2920
{
2921
  GPIO_InitTypeDef  GPIO_InitStructure;
2922
  
2923
  /*!< Disable SDIO Clock */
2924
  SDIO_ClockCmd(DISABLE);
2925
  
2926
  /*!< Set Power State to OFF */
2927
  SDIO_SetPowerState(SDIO_PowerState_OFF);
2928
2929
  /*!< DeInitializes the SDIO peripheral */
2930
  SDIO_DeInit();
2931
  
2932
  /* Disable the SDIO APB2 Clock */
2933
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SDIO, DISABLE);
2934
2935
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource8, GPIO_AF_MCO);
2936
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource9, GPIO_AF_MCO);
2937
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_MCO);
2938
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_MCO);
2939
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_MCO);
2940
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource2, GPIO_AF_MCO);
2941
2942
  /* Configure PC.08, PC.09, PC.10, PC.11 pins: D0, D1, D2, D3 pins */
2943
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11;
2944
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
2945
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
2946
  GPIO_Init(GPIOC, &GPIO_InitStructure);
2947
2948
  /* Configure PD.02 CMD line */
2949
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
2950
  GPIO_Init(GPIOD, &GPIO_InitStructure);
2951
2952
  /* Configure PC.12 pin: CLK pin */
2953
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
2954
  GPIO_Init(GPIOC, &GPIO_InitStructure);
2955
}
2956
2957
/**
2958
  * @brief  Initializes the SD Card and put it into StandBy State (Ready for 
2959
  *         data transfer).
2960
  * @param  None
2961
  * @retval None
2962
  */
2963
static void SD_LowLevel_Init(void)
2964
{
2965
  GPIO_InitTypeDef  GPIO_InitStructure;
2966
#if !defined (SD_POLLING_MODE)
2967
        NVIC_InitTypeDef NVIC_InitStructure;
2968
#endif
2969
2970
  /* GPIOC and GPIOD Periph clock enable */
2971
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD | SD_DETECT_GPIO_CLK, ENABLE);
2972
2973
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource8, GPIO_AF_SDIO);
2974
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource9, GPIO_AF_SDIO);
2975
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_SDIO);
2976
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_SDIO);
2977
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_SDIO);
2978
  GPIO_PinAFConfig(GPIOD, GPIO_PinSource2, GPIO_AF_SDIO);
2979
2980
  /* Configure PC.08, PC.09, PC.10, PC.11 pins: D0, D1, D2, D3 pins */
2981
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11;
2982
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_25MHz;
2983
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
2984
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
2985
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
2986
  GPIO_Init(GPIOC, &GPIO_InitStructure);
2987
2988
  /* Configure PD.02 CMD line */
2989
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
2990
  GPIO_Init(GPIOD, &GPIO_InitStructure);
2991
2992
  /* Configure PC.12 pin: CLK pin */
2993
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
2994
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
2995
  GPIO_Init(GPIOC, &GPIO_InitStructure);
2996
  
2997
  /*!< Configure SD_SPI_DETECT_PIN pin: SD Card detect pin */
2998
  GPIO_InitStructure.GPIO_Pin = SD_DETECT_PIN;
2999
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
3000
        GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
3001
  GPIO_Init(SD_DETECT_GPIO_PORT, &GPIO_InitStructure);
3002
3003
  /* Enable the SDIO APB2 Clock */
3004
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SDIO, ENABLE);
3005
3006
  /* Enable the DMA2 Clock */
3007
  RCC_AHB1PeriphClockCmd(SD_SDIO_DMA_CLK, ENABLE);
3008
3009
#if !defined (SD_POLLING_MODE)
3010
        /* SDIO Interrupt ENABLE */
3011
        NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn;
3012
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
3013
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
3014
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
3015
        NVIC_Init(&NVIC_InitStructure);
3016
3017
        /* DMA2 STREAMx Interrupt ENABLE */
3018
        NVIC_InitStructure.NVIC_IRQChannel = SD_SDIO_DMA_IRQn;
3019
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
3020
        NVIC_Init(&NVIC_InitStructure);
3021
#endif
3022
}
3023
3024
/**
3025
  * @brief  Configures the DMA2 Channel4 for SDIO Tx request.
3026
  * @param  BufferSRC: pointer to the source buffer
3027
  * @param  BufferSize: buffer size
3028
  * @retval None
3029
  */
3030
static void SD_LowLevel_DMA_TxConfig(uint32_t *BufferSRC, uint32_t BufferSize)
3031
{
3032
  DMA_InitTypeDef SDDMA_InitStructure;
3033
3034
  DMA_ClearFlag(SD_SDIO_DMA_STREAM, SD_SDIO_DMA_FLAG_FEIF | SD_SDIO_DMA_FLAG_DMEIF | SD_SDIO_DMA_FLAG_TEIF | SD_SDIO_DMA_FLAG_HTIF | SD_SDIO_DMA_FLAG_TCIF);
3035
3036
  /* DMA2 Stream3  or Stream6 disable */
3037
  DMA_Cmd(SD_SDIO_DMA_STREAM, DISABLE);
3038
3039
  /* DMA2 Stream3  or Stream6 Config */
3040
  DMA_DeInit(SD_SDIO_DMA_STREAM);
3041
3042
  SDDMA_InitStructure.DMA_Channel = SD_SDIO_DMA_CHANNEL;
3043
  SDDMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SDIO_FIFO_ADDRESS;
3044
  SDDMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)BufferSRC;
3045
  SDDMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
3046
  SDDMA_InitStructure.DMA_BufferSize = BufferSize;
3047
  SDDMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
3048
  SDDMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
3049
  SDDMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
3050
  SDDMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
3051
  SDDMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
3052
  SDDMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
3053
  SDDMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
3054
  SDDMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
3055
  SDDMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_INC4;
3056
  SDDMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_INC4;
3057
  DMA_Init(SD_SDIO_DMA_STREAM, &SDDMA_InitStructure);
3058
  DMA_ITConfig(SD_SDIO_DMA_STREAM, DMA_IT_TC, ENABLE);
3059
  DMA_FlowControllerConfig(SD_SDIO_DMA_STREAM, DMA_FlowCtrl_Peripheral);
3060
3061
  /* DMA2 Stream3  or Stream6 enable */
3062
  DMA_Cmd(SD_SDIO_DMA_STREAM, ENABLE);
3063
}
3064
3065
/**
3066
  * @brief  Configures the DMA2 Channel4 for SDIO Rx request.
3067
  * @param  BufferDST: pointer to the destination buffer
3068
  * @param  BufferSize: buffer size
3069
  * @retval None
3070
  */
3071
static void SD_LowLevel_DMA_RxConfig(uint32_t *BufferDST, uint32_t BufferSize)
3072
{
3073
  DMA_InitTypeDef SDDMA_InitStructure;
3074
3075
  DMA_ClearFlag(SD_SDIO_DMA_STREAM, SD_SDIO_DMA_FLAG_FEIF | SD_SDIO_DMA_FLAG_DMEIF | SD_SDIO_DMA_FLAG_TEIF | SD_SDIO_DMA_FLAG_HTIF | SD_SDIO_DMA_FLAG_TCIF);
3076
3077
  /* DMA2 Stream3  or Stream6 disable */
3078
  DMA_Cmd(SD_SDIO_DMA_STREAM, DISABLE);
3079
3080
  /* DMA2 Stream3 or Stream6 Config */
3081
  DMA_DeInit(SD_SDIO_DMA_STREAM);
3082
3083
  SDDMA_InitStructure.DMA_Channel = SD_SDIO_DMA_CHANNEL;
3084
  SDDMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SDIO_FIFO_ADDRESS;
3085
  SDDMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)BufferDST;
3086
  SDDMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
3087
  SDDMA_InitStructure.DMA_BufferSize = BufferSize;
3088
  SDDMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
3089
  SDDMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
3090
  SDDMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
3091
  SDDMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
3092
  SDDMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
3093
  SDDMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
3094
  SDDMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
3095
  SDDMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
3096
  SDDMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_INC4;
3097
  SDDMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_INC4;
3098
  DMA_Init(SD_SDIO_DMA_STREAM, &SDDMA_InitStructure);
3099
  DMA_ITConfig(SD_SDIO_DMA_STREAM, DMA_IT_TC, ENABLE);
3100
  DMA_FlowControllerConfig(SD_SDIO_DMA_STREAM, DMA_FlowCtrl_Peripheral);
3101
3102
  /* DMA2 Stream3 or Stream6 enable */
3103
  DMA_Cmd(SD_SDIO_DMA_STREAM, ENABLE);
3104
}
3105
3106
   
3107
/**
3108
  * @brief  This function handles SDIO global interrupt request.
3109
  * @param  None
3110
  * @retval None
3111
  */
3112
void SDIO_IRQHandler(void)
3113
{
3114
#if !defined (SD_POLLING_MODE) 
3115
  /* Process All SDIO Interrupt Sources */
3116
  SD_ProcessIRQSrc();
3117
#endif  
3118
}
3119
3120
/**
3121
  * @brief  This function handles DMA2 Stream3 or DMA2 Stream6 global interrupts
3122
  *         requests.
3123
  * @param  None
3124
  * @retval None
3125
  */
3126
void SD_SDIO_DMA_IRQHANDLER(void)
3127
{
3128
#if !defined (SD_POLLING_MODE) 
3129
  /* Process DMA2 Stream3 or DMA2 Stream6 Interrupt Sources */
3130
  SD_ProcessDMAIRQ();
3131
#endif
3132
}
3133
3134
/*!
3135
 * \brief initializes the sd card
3136
 * \param the disk number
3137
 * \return disk status
3138
 */
3139
DSTATUS disk_initialize (BYTE drv)
3140
{
3141
        SD_Error result = SD_Init();
3142
        if (result == SD_OK) {
3143
                SD_CardInfo card;
3144
                Stat &= ~STA_NOINIT;        /* Clear STA_NOINIT */
3145
                SD_GetCardInfo(&card);
3146
                return RES_OK;
3147
        } else {
3148
                Stat = STA_NOINIT;        /* Set STA_NOINIT */
3149
                return RES_NOTRDY;
3150
        }
3151
}
3152
3153
/*!
3154
 * \brief get the sd cards Status
3155
 * \param the disk number
3156
 * \return disk status
3157
 * \note Supports only single drive
3158
 */
3159
DSTATUS disk_status (BYTE drv)
3160
{
3161
        Stat = STA_NOINIT;
3162
3163
        if ((drv == 0) && (SD_GetStatus() == 0))
3164
        {
3165
                Stat &= ~STA_NOINIT;
3166
        }
3167
3168
        return Stat;
3169
}
3170
3171
/*!
3172
 * \brief reads multiple sectors from the sd Card
3173
 * \param drv: disk number
3174
 * \param buff: pointer to the data buffer to store read data
3175
 * \param sector: start sector number (LBA)
3176
 * \param count: sector count
3177
 */
3178
DRESULT disk_read (BYTE drv, BYTE *buff, DWORD sector, BYTE count)
3179
{
3180
        DWORD scratch [SD_BLOCKSIZE / 4]; /* Alignment ensured, need enough stack */
3181
        SD_Error sdstatus = SD_OK;
3182
3183
        if (drv != 0)
3184
        {
3185
                return RES_ERROR;
3186
        }
3187
  
3188
#if defined (SD_POLLING_MODE)
3189
  while (count--)
3190
  {
3191
    sdstatus = SD_ReadBlock((BYTE *)scratch, (uint32_t )((sector + count) * SD_BLOCKSIZE), SD_BLOCKSIZE);
3192
    if (sdstatus != SD_OK)
3193
    {
3194
      return RES_ERROR;
3195
    }
3196
    
3197
                while(SD_GetStatus() == SD_TRANSFER_BUSY);
3198
3199
    memcpy (&buff[count * SD_BLOCKSIZE], scratch, SD_BLOCKSIZE);
3200
3201
    if (count == 0)
3202
    {
3203
      return RES_OK;
3204
    }
3205
  }
3206
#else
3207
        if ((DWORD)buff & 3) /* DMA Alignment issue, do single up to aligned buffer */
3208
        {
3209
                while (count--)
3210
                {
3211
                        sdstatus = SD_ReadBlock((BYTE *)scratch, (uint32_t )((sector + count) * SD_BLOCKSIZE), SD_BLOCKSIZE);
3212
      if (sdstatus != SD_OK)
3213
      {
3214
        return RES_ERROR;
3215
      }
3216
3217
                        /* Check if the Transfer is finished */
3218
                        sdstatus = SD_WaitReadOperation();
3219
3220
                        while(SD_GetStatus() == SD_TRANSFER_BUSY);
3221
3222
                        memcpy (&buff[count * SD_BLOCKSIZE], scratch, SD_BLOCKSIZE);
3223
3224
                        if ((sdstatus == SD_OK) && (count == 0))
3225
                        {
3226
                                return RES_OK;
3227
                        }
3228
                        else if (sdstatus != SD_OK)
3229
                        {
3230
                                return RES_ERROR;
3231
                        }
3232
3233
                }
3234
        }
3235
        else
3236
        {
3237
                sdstatus = SD_ReadMultiBlocks((BYTE *)buff, (uint32_t )(sector * SD_BLOCKSIZE), SD_BLOCKSIZE, count);
3238
    if (sdstatus != SD_OK)
3239
    {
3240
      return RES_ERROR;
3241
    }
3242
3243
                /* Check if the Transfer is finished */
3244
                sdstatus =  SD_WaitReadOperation();
3245
3246
                while(SD_GetStatus() == SD_TRANSFER_BUSY);
3247
3248
                if (sdstatus == SD_OK)
3249
                {
3250
                        return RES_OK;
3251
                }
3252
        }
3253
#endif /* defined (SD_POLLING_MODE) */  
3254
3255
        return RES_ERROR;
3256
}
3257
3258
/*!
3259
 * \brief write multiple sectors to the sd Card
3260
 * \param drv: Physical drive nmuber (0)
3261
 * \param buff: Pointer to the data to be written
3262
 * \param sector: Start sector number (LBA)
3263
 * \param count: Sector count (1..255)
3264
 * \note this function needs DMA access and is disabled if _READONLY is set
3265
 */
3266
#if        _READONLY == 0
3267
DRESULT disk_write(BYTE drv, const BYTE *buff, DWORD sector, BYTE count)
3268
{
3269
        DWORD scratch [SD_BLOCKSIZE / 4]; /* Alignment ensured, need enough stack */
3270
        SD_Error sdstatus = SD_OK;
3271
  
3272
        if (drv != 0)
3273
        {
3274
                return RES_ERROR;
3275
        }
3276
3277
#if defined (SD_POLLING_MODE)
3278
  while (count--)
3279
  {
3280
    memcpy (scratch, &buff[count * SD_BLOCKSIZE], SD_BLOCKSIZE);
3281
3282
    sdstatus = SD_WriteBlock((BYTE *)scratch, (uint32_t )((sector + count) * SD_BLOCKSIZE), SD_BLOCKSIZE);
3283
    
3284
    /* note that the SD_TX_UNDERRUN is sometimes triggered when the SDIO is configured
3285
     * for polling mode (SD_POLLING_MODE), but testing shows, the block was correctly
3286
     * written so no need to flag this event as an error. note that when running in
3287
     * interrupt driven mode, the SD_TX_UNDERRUN interrupt is not used, which explains
3288
     * why it only happens in polling mode.
3289
     */
3290
    if ( (sdstatus != SD_OK) && (sdstatus != SD_TX_UNDERRUN) )
3291
    {
3292
      return RES_ERROR;
3293
    }
3294
3295
    while(SD_GetStatus() == SD_TRANSFER_BUSY);
3296
3297
    if (count == 0)
3298
    {
3299
      return RES_OK;
3300
    }
3301
  }
3302
#else
3303
  if ((DWORD)buff & 3) /* DMA Alignment issue, do single up to aligned buffer */
3304
  {
3305
    while (count--)
3306
    {
3307
      memcpy (scratch, &buff[count * SD_BLOCKSIZE], SD_BLOCKSIZE);
3308
      sdstatus = SD_WriteBlock((BYTE *)scratch, (uint32_t )((sector + count) * SD_BLOCKSIZE), SD_BLOCKSIZE);
3309
      if (sdstatus != SD_OK)
3310
      {
3311
        return RES_ERROR;
3312
      }
3313
3314
      /* Check if the Transfer is finished */
3315
      sdstatus = SD_WaitWriteOperation();
3316
3317
      while(SD_GetStatus() == SD_TRANSFER_BUSY);
3318
3319
      if ((sdstatus == SD_OK) && (count == 0))
3320
      {
3321
        return RES_OK;
3322
      }
3323
      else if (sdstatus != SD_OK)
3324
      {
3325
        return RES_ERROR;
3326
      }
3327
    }
3328
  }
3329
  else
3330
  {
3331
    sdstatus = SD_WriteMultiBlocks((BYTE *)buff, (uint32_t )(sector * SD_BLOCKSIZE), SD_BLOCKSIZE, count);
3332
    if (sdstatus != SD_OK)
3333
    {
3334
      return RES_ERROR;
3335
    }
3336
3337
    /* Check if the Transfer is finished */
3338
    sdstatus = SD_WaitWriteOperation();
3339
3340
    while(SD_GetStatus() == SD_TRANSFER_BUSY);
3341
3342
    if (sdstatus == SD_OK)
3343
    {
3344
      return RES_OK;
3345
    }
3346
  }
3347
#endif  
3348
3349
  return RES_ERROR;
3350
}
3351
#endif
3352
3353
/*!
3354
 * \brief ioctl implementation
3355
 * \param drv: Physical drive nmuber (0)
3356
 * \param ctrl: Control code
3357
 * \param buff: Buffer to send/receive control data
3358
 * \return operation result
3359
 * \note some ioctl's are not implemented because there is no need for them
3360
 *      or the API's differes
3361
 */
3362
DRESULT disk_ioctl(BYTE drv, BYTE ctrl, void *buff)
3363
{
3364
        DRESULT res;
3365
        SD_CardInfo SDCardInfo;
3366
3367
        res = RES_ERROR;
3368
3369
        if (Stat & STA_NOINIT) return RES_NOTRDY;
3370
3371
        switch (ctrl) {
3372
                case CTRL_SYNC :                /* Make sure that no pending write process */
3373
                        res = RES_OK;
3374
                        break;
3375
3376
                case GET_SECTOR_COUNT :        /* Get number of sectors on the disk (DWORD) */
3377
                        if(drv == 0)
3378
                        {
3379
                                SD_GetCardInfo(&SDCardInfo);
3380
                                *(DWORD*)buff = SDCardInfo.CardCapacity / SD_BLOCKSIZE;
3381
                        }
3382
                        res = RES_OK;
3383
                        break;
3384
3385
                case GET_SECTOR_SIZE :        /* Get R/W sector size (WORD) */
3386
                        *(WORD*)buff = SD_BLOCKSIZE;
3387
                        res = RES_OK;
3388
                        break;
3389
3390
                case GET_BLOCK_SIZE :        /* Get erase block size in unit of sector (DWORD) */
3391
                        if(drv == 0)
3392
                                *(DWORD*)buff = 32;
3393
                        res = RES_OK;
3394
                        break;
3395
3396
                default:
3397
                        res = RES_PARERR;
3398
        }
3399
        return res;
3400
}
3401
3402
/*!
3403
 * \brief user provided timer function for FatFs module
3404
 */
3405
DWORD get_fattime(void)
3406
{
3407
  /* No RTC supprt. Return a fixed value 2013/5/10 0:00:00 */
3408
  return    ((DWORD)(2013 - 1980) << 25)  /* Y */
3409
      | ((DWORD)5  << 21)       /* M */
3410
      | ((DWORD)10 << 16)       /* D */
3411
      | ((DWORD)0  << 11)       /* H */
3412
      | ((DWORD)0  << 5)        /* M */
3413
      | ((DWORD)0  >> 1);       /* S */
3414
}
3415
3416
/********************************* end of mmc.c ****************************************/
3417