1 /******************************************************************************
2 ** File Name: card_sdio.c
5 ** Copyright: 2004 Spreadtrum, Incoporated. All Rights Reserved.
6 ** Description: This file describe operation of SD host.
7 ******************************************************************************
9 ******************************************************************************
11 ** ------------------------------------------------------------------------- *
12 ** DATE NAME DESCRIPTION
13 ** 09/17/2007 Jason.wu Create.
14 ******************************************************************************/
16 /**---------------------------------------------------------------------------*
18 **---------------------------------------------------------------------------*/
20 #include "asm/arch/sci_types.h"
21 #include "asm/arch/os_api.h"
22 #include "card_sdio.h"
23 #include "sdio_card_pal.h"
25 #include "sdua_config.h"
28 #define CARD_SDIO_HIGHSPEED_SUPPORT
30 //#define CARD_SDIO_PRINT(x)
31 #define CARD_SDIO_PRINT(x) SCI_TRACE_LOW x
32 #define CARD_SDIO_ASSERT SCI_ASSERT
33 #define DEFAULT_CARD_BLOCKLEN 512
34 #define CARD_CMD_MAX_TIME 5000
36 typedef enum CARD_VERTION_E_TAG
40 CARD_SD_V2_0_STANDARD,
43 CARD_MMC_441_STANDARD,
48 /*****************************************************************************/
49 // The struct of Card IDentification (CID) register of MMC. please refer to <Multi media card System Specification version 3.31>
50 /*****************************************************************************/
51 typedef struct CARD_MMC_CID_STRUCT_TAG
53 uint8 MID; // 8 bit Manufacturer ID
54 uint16 OID; // 16 bit OEM/Application ID
55 uint8 PNM[6]; // 48 bit Product name
56 uint8 PRV; // 8 bit Product revision
57 uint32 PSN; // 32 bit Product serial number
58 uint8 MDT; // 8bit Manufacturing date
59 // uint8 CRC; // 8 bit
60 // uint8 lastBit; // 1 bit :always 1
63 /*****************************************************************************/
64 // The struct of Card-Specific Data register of MMC. please refer to <Multi media card System Specification version 3.31>
65 /*****************************************************************************/
66 typedef struct CARD_MMC_CSD_STRUCT_TAG
69 uint8 CSD_STRUCTURE; // 2 bit
70 uint8 SPEC_VERS; // 4 bit
71 uint8 reserved1; // 2 bit
74 uint8 TRAN_SPEED; // 8 bit
76 uint8 READ_BL_LEN; // 4 bit
77 uint8 READ_BL_PARTIAL; // 1 bit
78 uint8 WRITE_BLK_MISALIGN; // 1 bit
79 uint8 READ_BLK_MISALIGN; // 1 bit
80 uint8 DSR_IMP; // 1 bit
81 uint8 reserved2; // 2 bit
82 uint16 C_SIZE; //12 bit
83 uint8 VDD_R_CURR_MIN; // 3 bit
84 uint8 VDD_R_CURR_MAX; // 3 bit
85 uint8 VDD_W_CURR_MIN; // 3 bit
86 uint8 VDD_W_CURR_MAX; // 3 bit
87 uint8 C_SIZE_MULT; // 3 bit
88 uint8 ERASE_GRP_SIZE; // 5 bit
89 uint8 ERASE_GRP_MULT; // 5 bit
90 uint8 WP_GRP_SIZE; // 5 bit
91 uint8 WP_GRP_ENABLE; // 1 bit
92 uint8 DEFAULT_ECC; // 2 bit
93 uint8 R2W_FACTOR; // 3 bit
94 uint8 WRITE_BL_LEN; // 4 bit
95 uint8 WRITE_BL_PARTIAL; // 1 bit
96 uint8 reserved3; // 4 bit
97 uint8 CONTENT_PROT_APP; // 1 bit
99 uint8 FILE_FORMAT_GRP; // 1 bit
101 uint8 PERM_WRITE_PROTECT; // 1 bit
102 uint8 TMP_WRITE_PROTECT; // 1 bit
103 uint8 FILE_FORMAT; // 2 bit
105 // uint8 CRC; // 7 bit
106 // uint8 LastBit; // 1 bit: always 1
109 /*****************************************************************************/
110 // The struct of Card IDentification (CID) register of SD. please refer to <SD Specifications Part 1 Physical Layer Specification Version 2.00>
111 /*****************************************************************************/
112 typedef struct CARD_SD_CID_STRUCT_TAG
115 uint16 OID; // 16 bit
116 uint8 PNM[5]; // 40 bit
118 uint32 PSN; // 32 bit
120 // uint8 CRC; // 1 bit
121 // uint8 lastBit; // 1 bit :always 1
124 /*****************************************************************************/
125 // The struct of Card-Specific Data register of SD. please refer to <SD Specifications Part 1 Physical Layer Specification Version 2.00>
126 /*****************************************************************************/
127 typedef struct CARD_SD_CSD10_STRUCT_TAG
130 uint8 CSD_STRUCTURE; // 2 bit
131 uint8 reserved1; // 6 bit
134 uint8 TRAN_SPEED; // 8 bit
136 uint8 READ_BL_LEN; // 4 bit
137 uint8 READ_BL_PARTIAL; // 1 bit
138 uint8 WRITE_BLK_MISALIGN; // 1 bit
139 uint8 READ_BLK_MISALIGN; // 1 bit
140 uint8 DSR_IMP; // 1 bit
142 uint8 reserved2; // 2 bit
143 uint16 C_SIZE; //12 bit
144 uint8 VDD_R_CURR_MIN; // 3 bit
145 uint8 VDD_R_CURR_MAX; // 3 bit
146 uint8 VDD_W_CURR_MIN; // 3 bit
147 uint8 VDD_W_CURR_MAX; // 3 bit
148 uint8 C_SIZE_MULT; // 3 bit
150 uint8 ERASE_BLK_EN; // 1 bit
151 uint8 SECTOR_SIZE; // 7 bit
152 uint8 WP_GRP_SIZE; // 7 bit
153 uint8 WP_GRP_ENABLE; // 1 bit
154 uint8 reserved3; // 2 bit
156 uint8 R2W_FACTOR; // 3 bit
157 uint8 WRITE_BL_LEN; // 4 bit
158 uint8 WRITE_BL_PARTIAL; // 1 bit
159 uint8 reserved4; // 5 bit
161 uint8 FILE_FORMAT_GRP; // 1 bit
163 uint8 PERM_WRITE_PROTECT; // 1 bit
164 uint8 TMP_WRITE_PROTECT; // 1 bit
165 uint8 FILE_FORMAT; // 2 bit
166 uint8 reserved5; // 2 bit
167 // uint8 CRC; // 7 bit
168 // uint8 LastBit; // 1 bit: always 1
171 /*****************************************************************************/
172 // The struct of Card-Specific Data register of SD. please refer to <SD Specifications Part 1 Physical Layer Specification Version 2.00>
173 /*****************************************************************************/
174 typedef struct CARD_SD_CSD20_STRUCT_TAG
177 uint8 CSD_STRUCTURE; // 2 bit
178 uint8 reserved1; // 6 bit
181 uint8 TRAN_SPEED; // 8 bit
183 uint8 READ_BL_LEN; // 4 bit
184 uint8 READ_BL_PARTIAL; // 1 bit
185 uint8 WRITE_BLK_MISALIGN; // 1 bit
186 uint8 READ_BLK_MISALIGN; // 1 bit
187 uint8 DSR_IMP; // 1 bit
189 uint8 reserved2; // 6 bit
190 uint32 C_SIZE; //22 bit
191 uint8 reserved3; // 1 bit
193 uint8 ERASE_BLK_EN; // 1 bit
194 uint8 SECTOR_SIZE; // 7 bit
195 uint8 WP_GRP_SIZE; // 7 bit
196 uint8 WP_GRP_ENABLE; // 1 bit
197 uint8 reserved4; // 2 bit
199 uint8 R2W_FACTOR; // 3 bit
200 uint8 WRITE_BL_LEN; // 4 bit
201 uint8 WRITE_BL_PARTIAL; // 1 bit
202 uint8 reserved5; // 5 bit
204 uint8 FILE_FORMAT_GRP; // 1 bit
206 uint8 PERM_WRITE_PROTECT; // 1 bit
207 uint8 TMP_WRITE_PROTECT; // 1 bit
208 uint8 FILE_FORMAT; // 2 bit
209 uint8 reserved6; // 2 bit
210 // uint8 CRC; // 7 bit
211 // uint8 LastBit; // 1 bit: always 1
214 typedef union CARD_CSD_STRUCT_TAG
216 CARD_SD_CSD10_T SD_CSD10;
217 CARD_SD_CSD20_T SD_CSD20;
218 CARD_MMC_CSD_T MMC_CSD;
221 typedef union CARD_CID_STRUCT_TAG
223 CARD_SD_CID_T SD_CID;
224 CARD_MMC_CID_T MMC_CID;
227 typedef enum CARD_BUS_WIDTH_TAG
234 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET 3
235 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_MASK 0x38
236 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_NONE (0<<PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET)
237 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT1 (1<<PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET)
238 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT2 (2<<PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET)
239 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_USER (7<<PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET)
241 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_OFFSET 00
242 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_MASK 0x07
243 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_USER 0
244 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_BOOT1 1
245 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_BOOT2 2
246 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_RPMB 3
247 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_GENERAL_P1 4
248 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_GENERAL_P2 5
249 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_GENERAL_P3 6
250 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_GENERAL_P4 7
252 #define EXT_CSD_CARD_WIDTH_1_BIT 0
253 #define EXT_CSD_CARD_WIDTH_4_BIT 1
254 #define EXT_CSD_CARD_WIDTH_8_BIT 2
256 #define EXT_CSD_PARTITION_CFG_INDEX 179
257 #define EXT_CSD_BUS_WIDTH_INDEX 183
259 #define CMD6_BIT_MODE_OFFSET_ACCESS 24
260 #define CMD6_BIT_MODE_MASK_ACCESS 0x03000000
261 #define CMD6_BIT_MODE_OFFSET_INDEX 16
262 #define CMD6_BIT_MODE_MASK_INDEX 0x00FF0000
263 #define CMD6_BIT_MODE_OFFSET_VALUE 8
264 #define CMD6_BIT_MODE_MASK_VALUE 0x0000FF00
265 #define CMD6_BIT_MODE_OFFSET_CMD_SET 0
266 #define CMD6_BIT_MODE_MASK_CMD_SET 0x00000003
268 #define CMD6_ACCESS_MODE_COMMAND_SET (0<<CMD6_BIT_MODE_OFFSET_ACCESS)
269 #define CMD6_ACCESS_MODE_SET_BITS (1<<CMD6_BIT_MODE_OFFSET_ACCESS)
270 #define CMD6_ACCESS_MODE_CLEAR_BITS (2<<CMD6_BIT_MODE_OFFSET_ACCESS)
271 #define CMD6_ACCESS_MODE_WRITE_BYTE (3<<CMD6_BIT_MODE_OFFSET_ACCESS)
273 #define CMD6_CMD_SET_OLD (0<<CMD6_BIT_MODE_OFFSET_CMD_SET)
274 #define CMD6_CMD_SET (1<<CMD6_BIT_MODE_OFFSET_CMD_SET)
277 * CSD field definitions
280 #define CSD_STRUCT_VER_1_0 0 /* Valid for system specification 1.0 - 1.2 */
281 #define CSD_STRUCT_VER_1_1 1 /* Valid for system specification 1.4 - 2.2 */
282 #define CSD_STRUCT_VER_1_2 2 /* Valid for system specification 3.1 - 3.2 - 3.31 - 4.0 - 4.1 */
283 #define CSD_STRUCT_EXT_CSD 3 /* Version is coded in CSD_STRUCTURE in EXT_CSD */
285 #define CSD_SPEC_VER_0 0 /* Implements system specification 1.0 - 1.2 */
286 #define CSD_SPEC_VER_1 1 /* Implements system specification 1.4 */
287 #define CSD_SPEC_VER_2 2 /* Implements system specification 2.0 - 2.2 */
288 #define CSD_SPEC_VER_3 3 /* Implements system specification 3.1 - 3.2 - 3.31 */
289 #define CSD_SPEC_VER_4 4 /* Implements system specification 4.0 - 4.1 */
295 #define EXT_CSD_BUS_WIDTH_INDEX 183 /* R/W */
296 #define EXT_CSD_HS_TIMING_INDEX 185 /* R/W */
297 #define EXT_CSD_CARD_TYPE_INDEX 196 /* RO */
298 #define EXT_CSD_SEC_CNT_INDEX 212 /* RO, 4 bytes */
299 #define EXT_CSD_PARTITION_CFG_INDEX 179
304 #define EXT_CSD_CMD_SET_NORMAL (1<<0)
305 #define EXT_CSD_CMD_SET_SECURE (1<<1)
306 #define EXT_CSD_CMD_SET_CPSECURE (1<<2)
308 #define EXT_CSD_CARD_TYPE_26 (1<<0) /* Card can run at 26MHz */
309 #define EXT_CSD_CARD_TYPE_52 (1<<1) /* Card can run at 52MHz */
311 #define EXT_CSD_BUS_WIDTH_1 0 /* Card is in 1 bit mode */
312 #define EXT_CSD_BUS_WIDTH_4 1 /* Card is in 4 bit mode */
313 #define EXT_CSD_BUS_WIDTH_8 2 /* Card is in 8 bit mode */
316 * MMC_SWITCH access modes
319 #define MMC_SWITCH_MODE_CMD_SET 0x00 /* Change the command set */
320 #define MMC_SWITCH_MODE_SET_BITS 0x01 /* Set bits which are 1 in value */
321 #define MMC_SWITCH_MODE_CLEAR_BITS 0x02 /* Clear bits which are 1 in value */
322 #define MMC_SWITCH_MODE_WRITE_BYTE 0x03 /* Set target to value */
325 typedef struct CARD_PORT_TAG
329 SDIO_CARD_PAL_HANDLE sdioPalHd;
331 CARD_VERTION_E vertion;
333 CARD_BUS_WIDTH_E bus_width;
341 uint32 Rpmb_Capacity;
342 uint32 Boot1_Capacity;
343 uint32 Boot2_Capacity;
344 CARD_EMMC_PARTITION_TPYE Cur_Partition;
348 BOOLEAN ifSupportHighSpeed;
351 BOOLEAN ifEnterHighSpeed;
354 __align(32) uint8 s_extcsdbuf[512];
355 __align(32) uint8 s_sendbuf[512];
356 __align(32) uint8 s_receivebuf1[512];
357 __align(32) uint8 s_receivebuf2[512];
359 CARD_SDIO_HANDLE emmc_handle = NULL;
362 LOCAL CARD_PORT_T cardPort[CARD_SDIO_SLOT_MAX] = {0};
364 extern int LDO_Init(void);
365 extern void SDIO_Card_Pal_SetType(SDIO_CARD_PAL_HANDLE handle, SDIO_CARD_PAL_TYPE_E sdio_type);
367 //-----------------------------------------------------------------------------------
368 // To judge whether the handle is valid
369 //-----------------------------------------------------------------------------------
370 LOCAL BOOLEAN _IsCardHandleValid(CARD_SDIO_HANDLE cardHandle)
374 for(i = 0; i < CARD_SDIO_SLOT_MAX; i++)
376 if(cardHandle == &cardPort[i])
378 if(TRUE == cardHandle->open_flag)
393 /*****************************************************************************/
394 // Description: Get Card operation handle,after we get the handle ,we can get next operation way of card
397 // slotNo: slot number
402 /*****************************************************************************/
403 PUBLIC CARD_SDIO_HANDLE CARD_SDIO_Open(CARD_SDIO_SLOT_NO slotNo)
405 CARD_SDIO_ASSERT(slotNo < CARD_SDIO_SLOT_MAX); /*assert verified*/
407 if(TRUE == cardPort[slotNo].open_flag)
412 cardPort[slotNo].open_flag = TRUE;
413 cardPort[slotNo].sdioPalHd = SDIO_Card_Pal_Open((SDIO_CARD_PAL_SLOT_E)slotNo);
414 cardPort[slotNo].BlockLen = 0;
415 cardPort[slotNo].RCA = 0x1000 | slotNo;
416 cardPort[slotNo].bus_width = CARD_WIDTH_1_BIT;
418 return &cardPort[slotNo];
421 /*****************************************************************************/
422 // Description: close operation handle of card. afer we free it ,other application can operate on this card
425 // cardHandle: the handle returned by CARD_SDIO_Open
429 /*****************************************************************************/
430 PUBLIC void CARD_SDIO_Close(CARD_SDIO_HANDLE cardHandle)
432 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
434 SDIO_Card_Pal_Close(cardHandle->sdioPalHd);
435 cardHandle->open_flag = FALSE;
438 PUBLIC void CARD_SDIO_PwrCtl(CARD_SDIO_HANDLE cardHandle,BOOLEAN switchCtl)
440 if(TRUE == switchCtl)
442 SDIO_Card_Pal_Pwr(cardHandle->sdioPalHd,SDIO_CARD_PAL_ON);
444 else if(FALSE == switchCtl)
446 SDIO_Card_Pal_Pwr(cardHandle->sdioPalHd,SDIO_CARD_PAL_OFF);
450 CARD_SDIO_ASSERT(0); /*assert verified*/
454 //-----------------------------------------------------------------------------------
455 // Analyze SD CID buffer
456 //-----------------------------------------------------------------------------------
457 LOCAL void _SD_CID_Analyze(uint8* CIDbuf,CARD_SD_CID_T *CID)
462 CID->MID = CIDbuf[0];
466 CID->OID = tmp16 + CIDbuf[2];
468 CID->PNM[0] = CIDbuf[3];
469 CID->PNM[1] = CIDbuf[4];
470 CID->PNM[2] = CIDbuf[5];
471 CID->PNM[3] = CIDbuf[6];
472 CID->PNM[4] = CIDbuf[7];
474 CID->PRV = CIDbuf[8];
485 tmp16 = CIDbuf[13]&0x0F;
487 CID->MDT = tmp16 + CIDbuf[14];
489 // CID->CRC = ((CIDbuf[15]&0xFE)>>1);
490 // CID->lastBit = (CIDbuf[15]&0x01);
493 //-----------------------------------------------------------------------------------
494 // Analyze MMC CID buffer
495 //-----------------------------------------------------------------------------------
496 LOCAL void _MMC_CID_Analyze(uint8* CIDbuf,CARD_MMC_CID_T *CID)
501 CID->MID = CIDbuf[0];
505 CID->OID = tmp16 + CIDbuf[2];
507 CID->PNM[0] = CIDbuf[3];
508 CID->PNM[1] = CIDbuf[4];
509 CID->PNM[2] = CIDbuf[5];
510 CID->PNM[3] = CIDbuf[6];
511 CID->PNM[4] = CIDbuf[7];
512 CID->PNM[5] = CIDbuf[8];
514 CID->PRV = CIDbuf[9];
525 CID->MDT = CIDbuf[14];
527 // CID->CRC = ((CIDbuf[15]&0xFE)>>1);
528 // CID->lastBit = (CIDbuf[15]&0x01);
532 //-----------------------------------------------------------------------------------
533 // Analyze SD CSD buffer
535 // Expand SD CSD1.x to CSD struct member
537 //-----------------------------------------------------------------------------------
538 LOCAL void _SD_CSD10_Analyze(uint8* CSDbuf,CARD_SD_CSD10_T *CSD)
544 tmp8 = CSDbuf[0]&0xC0; //0b11000000
545 CSD->CSD_STRUCTURE = tmp8>>6; // 2 bit
547 tmp8 = CSDbuf[0]&0x3F;//0b00111111;
548 CSD->reserved1 = tmp8; // 6 bit
551 CSD->TAAC = tmp8; // 8 bit
554 CSD->NSAC = tmp8; // 8 bit
557 CSD->TRAN_SPEED = tmp8; // 8 bit
561 tmp8 = CSDbuf[5]&0xF0;//0b11110000;
564 CSD->CCC = tmp16; //12 bit
566 tmp8 = CSDbuf[5]&0x0F;//0b00001111;
567 CSD->READ_BL_LEN = tmp8; // 4 bit
569 tmp8 = CSDbuf[6]&0x80;//0b10000000;
570 CSD->READ_BL_PARTIAL = tmp8>>7; // 1 bit
572 tmp8 = CSDbuf[6]&0x40;//0b01000000;
573 CSD->WRITE_BLK_MISALIGN = tmp8>>6; // 1 bit
575 tmp8 = CSDbuf[6]&0x20;//0b00100000;
576 CSD->READ_BLK_MISALIGN = tmp8>>5; // 1 bit
578 tmp8 = CSDbuf[6]&0x10;//0b00010000;
579 CSD->DSR_IMP = tmp8>>4; // 1 bit
581 tmp8 = CSDbuf[6]&0x0C;//0b00001100;
582 CSD->reserved2 = tmp8>>2; // 2 bit
584 tmp16 = CSDbuf[6]&0x03;//0b00000011;
588 tmp8 = CSDbuf[8]&0xC0;//0b11000000;
590 tmp16 = tmp16 + tmp8;
591 CSD->C_SIZE = tmp16; //12 bit
593 tmp8 = CSDbuf[8]&0x38;//0b00111000;
594 CSD->VDD_R_CURR_MIN = tmp8>>3; // 3 bit
596 tmp8 = CSDbuf[8]&0x07;//0b00000111;
597 CSD->VDD_R_CURR_MAX = tmp8; // 3 bit
599 tmp8 = CSDbuf[9]&0xE0;//0b11100000;
600 CSD->VDD_W_CURR_MIN = tmp8>>5; // 3 bit
602 tmp8 = CSDbuf[9]&0x1C;//0b00011100;
603 CSD->VDD_W_CURR_MAX = tmp8>>2; // 3 bit
605 tmp8 = CSDbuf[9]&0x03;//0b00000011;
607 tmp8 = tmp8 + ((CSDbuf[10]&0x80/*0b10000000*/)>>7);
608 CSD->C_SIZE_MULT = tmp8; // 3 bit
610 tmp8 = CSDbuf[10]&0x40;//0b01000000;
611 CSD->ERASE_BLK_EN = tmp8>>6; // 1 bit
613 tmp8 = CSDbuf[10]&0x3F;//0b00111111;
615 tmp8 = tmp8 + ((CSDbuf[11]&0x80/*0b10000000*/)>>7);
616 CSD->SECTOR_SIZE = tmp8; // 7 bit
618 tmp8 = CSDbuf[11]&0x7F;//0b01111111;
619 CSD->WP_GRP_SIZE = tmp8; // 7 bit
621 tmp8 = CSDbuf[12]&0x80;//0b10000000;
622 CSD->WP_GRP_ENABLE = tmp8>>7; // 1 bit
624 tmp8 = CSDbuf[12]&0x60;//0b01100000;
625 CSD->reserved3 = tmp8>>5; // 2 bit
627 tmp8 = CSDbuf[12]&0x1C;//0b00011100;
628 CSD->R2W_FACTOR = tmp8>>2; // 3 bit
630 tmp8 = CSDbuf[12]&0x03;//0b00000011;
632 tmp8 = tmp8 + ((CSDbuf[13]&0xC0/*0b11000000*/)>>6);
633 CSD->WRITE_BL_LEN = tmp8; // 4 bit
635 tmp8 = CSDbuf[13]&0x20;//0b00100000;
636 CSD->WRITE_BL_PARTIAL = tmp8>>5; // 1 bit
638 tmp8 = CSDbuf[13]&0x1F;//0b00011111;
639 CSD->reserved4 = tmp8; // 5 bit
641 tmp8 = CSDbuf[14]&0x80;//0b10000000;
642 CSD->FILE_FORMAT_GRP = tmp8>>7; // 1 bit
644 tmp8 = CSDbuf[14]&0x40;//0b01000000;
645 CSD->COPY = tmp8>>6; // 1 bit
647 tmp8 = CSDbuf[14]&0x20;//0b00100000;
648 CSD->PERM_WRITE_PROTECT = tmp8>>5; // 1 bit
650 tmp8 = CSDbuf[14]&0x10;//0b00010000;
651 CSD->TMP_WRITE_PROTECT = tmp8>>4; // 1 bit
653 tmp8 = CSDbuf[14]&0x0C;//0b00001100;
654 CSD->FILE_FORMAT = tmp8>>2; // 2 bit
655 tmp8 = CSDbuf[14]&0x03;//0b00000011;
656 CSD->reserved5 = tmp8; // 2 bit
658 // tmp8 = CSDbuf[15]&0xFE;//0b11111110;
659 // CSD->CRC = tmp8>>1; // 7 bit
661 // tmp8 = CSDbuf[15]&0x01;//0b00000001;
662 // CSD->LastBit = tmp8; // 1 bit: always 1
666 //-----------------------------------------------------------------------------------
667 // Analyze SD CSD buffer
669 // Expand SD CSD2.0 to CSD struct member
671 //-----------------------------------------------------------------------------------
672 LOCAL void _SD_CSD20_Analyze(uint8* CSDbuf,CARD_SD_CSD20_T *CSD)
679 tmp8 = CSDbuf[0]&0xC0; //0b11000000
680 CSD->CSD_STRUCTURE = tmp8>>6; // 2 bit
682 tmp8 = CSDbuf[0]&0x3F;//0b00111111;
683 CSD->reserved1 = tmp8; // 6 bit
686 CSD->TAAC = tmp8; // 8 bit
689 CSD->NSAC = tmp8; // 8 bit
692 CSD->TRAN_SPEED = tmp8; // 8 bit
696 tmp8 = CSDbuf[5]&0xF0;//0b11110000;
699 CSD->CCC = tmp16; //12 bit
701 tmp8 = CSDbuf[5]&0x0F;//0b00001111;
702 CSD->READ_BL_LEN = tmp8; // 4 bit
704 tmp8 = CSDbuf[6]&0x80;//0b10000000;
705 CSD->READ_BL_PARTIAL = tmp8>>7; // 1 bit
707 tmp8 = CSDbuf[6]&0x40;//0b01000000;
708 CSD->WRITE_BLK_MISALIGN = tmp8>>6; // 1 bit
710 tmp8 = CSDbuf[6]&0x20;//0b00100000;
711 CSD->READ_BLK_MISALIGN = tmp8>>5; // 1 bit
713 tmp8 = CSDbuf[6]&0x10;//0b00010000;
714 CSD->DSR_IMP = tmp8>>4; // 1 bit
716 tmp8 = CSDbuf[6]&0x0F;//0b00001111;
718 tmp8 += ((CSDbuf[7]&0xC0/*0b11000000*/)>>6);
719 CSD->reserved2 = tmp8; // 6 bit
721 tmp32 = CSDbuf[7]&0x3F;//0b00111111
726 CSD->C_SIZE = tmp32; // 22 bit
728 tmp8 = CSDbuf[10]&0x80;//0b10000000
730 CSD->reserved3 = tmp8;
732 tmp8 = CSDbuf[10]&0x40;//0b01000000;
733 CSD->ERASE_BLK_EN = tmp8>>6; // 1 bit
735 tmp8 = CSDbuf[10]&0x3F;//0b00111111;
737 tmp8 = tmp8 + ((CSDbuf[11]&0x80/*0b10000000*/)>>7);
738 CSD->SECTOR_SIZE = tmp8; // 7 bit
740 tmp8 = CSDbuf[11]&0x7F;//0b01111111;
741 CSD->WP_GRP_SIZE = tmp8; // 7 bit
743 tmp8 = CSDbuf[12]&0x80;//0b10000000;
744 CSD->WP_GRP_ENABLE = tmp8>>7; // 1 bit
746 tmp8 = CSDbuf[12]&0x60;//0b01100000;
747 CSD->reserved4 = tmp8>>5; // 2 bit
749 tmp8 = CSDbuf[12]&0x1C;//0b00011100;
750 CSD->R2W_FACTOR = tmp8>>2; // 3 bit
752 tmp8 = CSDbuf[12]&0x03;//0b00000011;
754 tmp8 = tmp8 + ((CSDbuf[13]&0xC0/*0b11000000*/)>>6);
755 CSD->WRITE_BL_LEN = tmp8; // 4 bit
757 tmp8 = CSDbuf[13]&0x20;//0b00100000;
758 CSD->WRITE_BL_PARTIAL = tmp8>>5; // 1 bit
760 tmp8 = CSDbuf[13]&0x1F;//0b00011111;
761 CSD->reserved5 = tmp8; // 5 bit
763 tmp8 = CSDbuf[14]&0x80;//0b10000000;
764 CSD->FILE_FORMAT_GRP = tmp8>>7; // 1 bit
766 tmp8 = CSDbuf[14]&0x40;//0b01000000;
767 CSD->COPY = tmp8>>6; // 1 bit
769 tmp8 = CSDbuf[14]&0x20;//0b00100000;
770 CSD->PERM_WRITE_PROTECT = tmp8>>5; // 1 bit
772 tmp8 = CSDbuf[14]&0x10;//0b00010000;
773 CSD->TMP_WRITE_PROTECT = tmp8>>4; // 1 bit
775 tmp8 = CSDbuf[14]&0x0C;//0b00001100;
776 CSD->FILE_FORMAT = tmp8>>2; // 2 bit
777 tmp8 = CSDbuf[14]&0x03;//0b00000011;
778 CSD->reserved6 = tmp8; // 2 bit
780 // tmp8 = CSDbuf[15]&0xFE;//0b11111110;
781 // CSD->CRC = tmp8>>1; // 7 bit
783 // tmp8 = CSDbuf[15]&0x01;//0b00000001;
784 // CSD->LastBit = tmp8; // 1 bit: always 1
787 //-----------------------------------------------------------------------------------
788 // Analyze MMC CSD buffer
790 // Expand MMC CSD to CSD struct member
792 //-----------------------------------------------------------------------------------
793 LOCAL void _MMC_CSD_Analyze(uint8* CSDbuf,CARD_MMC_CSD_T *CSD)
799 tmp8 = CSDbuf[0]&0xC0; //0b11000000
800 CSD->CSD_STRUCTURE = tmp8>>6; // 2 bit
802 tmp8 = CSDbuf[0]&0x3C;//0b00111100;
803 CSD->SPEC_VERS = tmp8>>2; // 4 bit
805 tmp8 = CSDbuf[0]&0x03;//0b00000011;
806 CSD->reserved1 = tmp8; // 2 bit
809 CSD->TAAC = tmp8; // 8 bit
812 CSD->NSAC = tmp8; // 8 bit
815 CSD->TRAN_SPEED = tmp8; // 8 bit
819 tmp8 = CSDbuf[5]&0xF0;//0b11110000;
822 CSD->CCC = tmp16; //12 bit
824 tmp8 = CSDbuf[5]&0x0F;//0b00001111;
825 CSD->READ_BL_LEN = tmp8; // 4 bit
827 tmp8 = CSDbuf[6]&0x80;//0b10000000;
828 CSD->READ_BL_PARTIAL = tmp8>>7; // 1 bit
830 tmp8 = CSDbuf[6]&0x40;//0b01000000;
831 CSD->WRITE_BLK_MISALIGN = tmp8>>6; // 1 bit
833 tmp8 = CSDbuf[6]&0x20;//0b00100000;
834 CSD->READ_BLK_MISALIGN = tmp8>>5; // 1 bit
836 tmp8 = CSDbuf[6]&0x10;//0b00010000;
837 CSD->DSR_IMP = tmp8>>4; // 1 bit
839 tmp8 = CSDbuf[6]&0x0C;//0b00001100;
840 CSD->reserved2 = tmp8>>2; // 2 bit
842 tmp16 = CSDbuf[6]&0x03;//0b00000011;
846 tmp8 = CSDbuf[8]&0xC0;//0b11000000;
848 tmp16 = tmp16 + tmp8;
849 CSD->C_SIZE = tmp16; //12 bit
851 tmp8 = CSDbuf[8]&0x38;//0b00111000;
852 CSD->VDD_R_CURR_MIN = tmp8>>3; // 3 bit
854 tmp8 = CSDbuf[8]&0x07;//0b00000111;
855 CSD->VDD_R_CURR_MAX = tmp8; // 3 bit
857 tmp8 = CSDbuf[9]&0xE0;//0b11100000;
858 CSD->VDD_W_CURR_MIN = tmp8>>5; // 3 bit
860 tmp8 = CSDbuf[9]&0x1C;//0b00011100;
861 CSD->VDD_W_CURR_MAX = tmp8>>2; // 3 bit
863 tmp8 = CSDbuf[9]&0x03;//0b00000011;
865 tmp8 = tmp8 + ((CSDbuf[10]&0x80/*0b10000000*/)>>7);
866 CSD->C_SIZE_MULT = tmp8; // 3 bit
868 tmp8 = CSDbuf[10]&0x7C;//0b01111100;
869 CSD->ERASE_GRP_SIZE = tmp8>>2; // 5 bit
871 tmp8 = CSDbuf[10]&0x03;//0b00000011;
873 tmp8 = tmp8 + ((CSDbuf[11]&0xE0/*0b11100000*/)>>5);
874 CSD->ERASE_GRP_MULT = tmp8; // 5 bit
876 tmp8 = CSDbuf[11]&0x1F;//0b00011111;
877 CSD->WP_GRP_SIZE = tmp8; // 5 bit
879 tmp8 = CSDbuf[12]&0x80;//0b10000000;
880 CSD->WP_GRP_ENABLE = tmp8>>7; // 1 bit
882 tmp8 = CSDbuf[12]&0x60;//0b01100000;
883 CSD->DEFAULT_ECC = tmp8>>5; // 2 bit
885 tmp8 = CSDbuf[12]&0x1C;//0b00011100;
886 CSD->R2W_FACTOR = tmp8>>2; // 3 bit
888 tmp8 = CSDbuf[12]&0x03;//0b00000011;
890 tmp8 = tmp8 + ((CSDbuf[13]&0xC0/*0b11000000*/)>>6);
891 CSD->WRITE_BL_LEN = tmp8; // 4 bit
893 tmp8 = CSDbuf[13]&0x20;//0b00100000;
894 CSD->WRITE_BL_PARTIAL = tmp8>>5; // 1 bit
896 tmp8 = CSDbuf[13]&0x1E;//0b00011110;
897 CSD->reserved3 = tmp8>>1; // 4 bit
899 tmp8 = CSDbuf[13]&0x01;//0b00000001;
900 CSD->CONTENT_PROT_APP = tmp8; // 1 bit
902 tmp8 = CSDbuf[14]&0x80;//0b10000000;
903 CSD->FILE_FORMAT_GRP = tmp8>>7; // 1 bit
905 tmp8 = CSDbuf[14]&0x40;//0b01000000;
906 CSD->COPY = tmp8>>6; // 1 bit
908 tmp8 = CSDbuf[14]&0x20;//0b00100000;
909 CSD->PERM_WRITE_PROTECT = tmp8>>5; // 1 bit
911 tmp8 = CSDbuf[14]&0x10;//0b00010000;
912 CSD->TMP_WRITE_PROTECT = tmp8>>4; // 1 bit
914 tmp8 = CSDbuf[14]&0x0C;//0b00001100;
915 CSD->FILE_FORMAT = tmp8>>2; // 2 bit
916 tmp8 = CSDbuf[14]&0x03;//0b00000011;
917 CSD->ECC = tmp8; // 2 bit
919 // tmp8 = CSDbuf[15]&0xFE;//0b11111110;
920 // CSD->CRC = tmp8>>1; // 7 bit
922 // tmp8 = CSDbuf[15]&0x01;//0b00000001;
923 // CSD->LastBit = tmp8; // 1 bit: always 1
928 /*****************************************************************************/
929 // Description: Read CSD register and analyze it
932 // cardHandle: the handle returned by CARD_SDIO_Open
933 // CSD: CSD data will be stored in this place
938 /*****************************************************************************/
939 LOCAL BOOLEAN CARD_SDIO_ReadCSD(CARD_SDIO_HANDLE cardHandle,CARD_CSD_T* CSD)
942 uint16 RCA = cardHandle->RCA;
945 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
949 argument = argument<<16;
952 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD9_SEND_CSD,argument,NULL,rspBuf))
957 CARD_SDIO_PRINT(("SD20 %x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",rspBuf[0],rspBuf[1],rspBuf[2],rspBuf[3],rspBuf[4],rspBuf[5],rspBuf[6],rspBuf[7],rspBuf[8],rspBuf[9],rspBuf[10],rspBuf[11],rspBuf[12],rspBuf[13],rspBuf[14]));
959 if((CARD_MMC_441_STANDARD == cardHandle->vertion)||(CARD_MMC_441_HIGHCAP == cardHandle->vertion))
961 _MMC_CSD_Analyze(rspBuf,&(CSD->MMC_CSD));
962 cardHandle->CCC = CSD->MMC_CSD.CCC;
963 cardHandle->CCC &= (~((1<<10)|(1<<11))); // for MMC mode This two classes is reserved
965 CARD_SDIO_PRINT(("CARD_MMC_331:"));
966 CARD_SDIO_PRINT(("CSD_STRUCTURE\t\t = 0x%x",CSD->MMC_CSD.CSD_STRUCTURE));
967 CARD_SDIO_PRINT(("SPEC_VERS\t\t = 0x%x",CSD->MMC_CSD.SPEC_VERS));
968 CARD_SDIO_PRINT(("reserved1\t\t = 0x%x",CSD->MMC_CSD.reserved1));
969 CARD_SDIO_PRINT(("TAAC\t\t\t = 0x%x",CSD->MMC_CSD.TAAC));
970 CARD_SDIO_PRINT(("NSAC\t\t\t = 0x%x",CSD->MMC_CSD.NSAC));
971 CARD_SDIO_PRINT(("TRAN_SPEED\t\t = 0x%x",CSD->MMC_CSD.TRAN_SPEED));
972 CARD_SDIO_PRINT(("CCC\t\t\t = 0x%x",CSD->MMC_CSD.CCC));
973 CARD_SDIO_PRINT(("READ_BL_LEN\t\t = 0x%x",CSD->MMC_CSD.READ_BL_LEN));
974 CARD_SDIO_PRINT(("READ_BL_PARTIAL\t\t = 0x%x",CSD->MMC_CSD.READ_BL_PARTIAL));
975 CARD_SDIO_PRINT(("WRITE_BLK_MISALIGN\t = 0x%x",CSD->MMC_CSD.WRITE_BLK_MISALIGN));
976 CARD_SDIO_PRINT(("READ_BLK_MISALIGN\t = 0x%x",CSD->MMC_CSD.READ_BLK_MISALIGN));
977 CARD_SDIO_PRINT(("DSR_IMP\t\t\t = 0x%x",CSD->MMC_CSD.DSR_IMP));
978 CARD_SDIO_PRINT(("reserved2\t\t = 0x%x",CSD->MMC_CSD.reserved2));
979 CARD_SDIO_PRINT(("C_SIZE\t\t\t = 0x%x",CSD->MMC_CSD.C_SIZE));
980 CARD_SDIO_PRINT(("VDD_R_CURR_MIN\t\t = 0x%x",CSD->MMC_CSD.VDD_R_CURR_MIN));
981 CARD_SDIO_PRINT(("VDD_R_CURR_MAX\t\t = 0x%x",CSD->MMC_CSD.VDD_R_CURR_MAX));
982 CARD_SDIO_PRINT(("VDD_W_CURR_MIN\t\t = 0x%x",CSD->MMC_CSD.VDD_W_CURR_MIN));
983 CARD_SDIO_PRINT(("VDD_W_CURR_MAX\t\t = 0x%x",CSD->MMC_CSD.VDD_W_CURR_MAX));
984 CARD_SDIO_PRINT(("C_SIZE_MULT\t\t = 0x%x",CSD->MMC_CSD.C_SIZE_MULT));
985 CARD_SDIO_PRINT(("ERASE_GRP_SIZE\t\t = 0x%x",CSD->MMC_CSD.ERASE_GRP_SIZE));
986 CARD_SDIO_PRINT(("ERASE_GRP_MULT\t\t = 0x%x",CSD->MMC_CSD.ERASE_GRP_MULT));
987 CARD_SDIO_PRINT(("WP_GRP_SIZE\t\t = 0x%x",CSD->MMC_CSD.WP_GRP_SIZE));
988 CARD_SDIO_PRINT(("WP_GRP_ENABLE\t\t = 0x%x",CSD->MMC_CSD.WP_GRP_ENABLE));
989 CARD_SDIO_PRINT(("DEFAULT_ECC\t\t = 0x%x",CSD->MMC_CSD.DEFAULT_ECC));
990 CARD_SDIO_PRINT(("R2W_FACTOR\t\t = 0x%x",CSD->MMC_CSD.R2W_FACTOR));
991 CARD_SDIO_PRINT(("WRITE_BL_LEN\t\t = 0x%x",CSD->MMC_CSD.WRITE_BL_LEN));
992 CARD_SDIO_PRINT(("WRITE_BL_PARTIAL\t = 0x%x",CSD->MMC_CSD.WRITE_BL_PARTIAL));
993 CARD_SDIO_PRINT(("reserved3\t\t = 0x%x",CSD->MMC_CSD.reserved3));
994 CARD_SDIO_PRINT(("CONTENT_PROT_APP\t = 0x%x",CSD->MMC_CSD.CONTENT_PROT_APP));
995 CARD_SDIO_PRINT(("----RW bit---"));
996 CARD_SDIO_PRINT(("FILE_FORMAT_GRP\t\t = 0x%x",CSD->MMC_CSD.FILE_FORMAT_GRP));
997 CARD_SDIO_PRINT(("COPY\t\t\t = 0x%x",CSD->MMC_CSD.COPY));
998 CARD_SDIO_PRINT(("PERM_WRITE_PROTECT\t = 0x%x",CSD->MMC_CSD.PERM_WRITE_PROTECT));
999 CARD_SDIO_PRINT(("TMP_WRITE_PROTECT\t = 0x%x",CSD->MMC_CSD.TMP_WRITE_PROTECT));
1000 CARD_SDIO_PRINT(("FILE_FORMAT\t\t = 0x%x",CSD->MMC_CSD.FILE_FORMAT));
1001 CARD_SDIO_PRINT(("ECC\t\t\t = 0x%x",CSD->MMC_CSD.ECC));
1002 // CARD_SDIO_PRINT(("CRC\t\t\t = 0x%x",CSD->MMC_CSD.CRC));
1003 // CARD_SDIO_PRINT(("LastBit\t\t\t = 0x%x",CSD->MMC_CSD.LastBit));
1008 CARD_SDIO_ASSERT(0); /*assert verified*/
1013 #if defined CONFIG_SC8830 || defined(CONFIG_SC9630)
1014 PUBLIC BOOLEAN SDCARD_SDIO_ReadCSD(CARD_SDIO_HANDLE cardHandle, CARD_CSD_T *CSD)
1017 uint16 RCA = cardHandle->RCA;
1018 uint32 argument = 0;
1020 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));
1021 cardHandle->CCC = 0;
1024 argument = argument << 16;
1027 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_CMD9_SEND_CSD, argument, NULL, rspBuf))
1032 CARD_SDIO_PRINT(("SD20 %x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x", rspBuf[0], rspBuf[1], rspBuf[2], rspBuf[3], rspBuf[4], rspBuf[5], rspBuf[6], rspBuf[7], rspBuf[8], rspBuf[9], rspBuf[10], rspBuf[11], rspBuf[12], rspBuf[13], rspBuf[14]));
1034 if(CARD_SD_V2_0_HIGHCAP == cardHandle->vertion)
1036 _SD_CSD20_Analyze(rspBuf, &(CSD->SD_CSD20));
1037 cardHandle->CCC = CSD->SD_CSD20.CCC;
1039 CARD_SDIO_PRINT(("CARD_SD_V2_0_HIGHCAP:"));
1040 CARD_SDIO_PRINT(("CSD_STRUCTURE = %x", CSD->SD_CSD20.CSD_STRUCTURE));
1041 CARD_SDIO_PRINT(("reserved1= %x", CSD->SD_CSD20.reserved1));
1042 CARD_SDIO_PRINT(("TAAC= %x", CSD->SD_CSD20.TAAC));
1043 CARD_SDIO_PRINT(("NSAC= %x", CSD->SD_CSD20.NSAC));
1044 CARD_SDIO_PRINT(("TRAN_SPEED= %x", CSD->SD_CSD20.TRAN_SPEED));
1045 CARD_SDIO_PRINT(("CCC= %x", CSD->SD_CSD20.CCC));
1046 CARD_SDIO_PRINT(("READ_BL_LEN= %x", CSD->SD_CSD20.READ_BL_LEN));
1047 CARD_SDIO_PRINT(("READ_BL_PARTIAL= %x", CSD->SD_CSD20.READ_BL_PARTIAL));
1048 CARD_SDIO_PRINT(("WRITE_BLK_MISALIGN= %x", CSD->SD_CSD20.WRITE_BLK_MISALIGN));
1049 CARD_SDIO_PRINT(("READ_BLK_MISALIGN= %x", CSD->SD_CSD20.READ_BLK_MISALIGN));
1050 CARD_SDIO_PRINT(("DSR_IMP= %x", CSD->SD_CSD20.DSR_IMP));
1052 CARD_SDIO_PRINT(("reserved2= %x", CSD->SD_CSD20.reserved2));
1053 CARD_SDIO_PRINT(("C_SIZE= %x", CSD->SD_CSD20.C_SIZE));
1054 CARD_SDIO_PRINT(("reserved3= %x", CSD->SD_CSD20.reserved3));
1056 CARD_SDIO_PRINT(("ERASE_BLK_EN= %x", CSD->SD_CSD20.ERASE_BLK_EN));
1057 CARD_SDIO_PRINT(("SECTOR_SIZE= %x", CSD->SD_CSD20.SECTOR_SIZE));
1058 CARD_SDIO_PRINT(("WP_GRP_SIZE= %x", CSD->SD_CSD20.WP_GRP_SIZE));
1059 CARD_SDIO_PRINT(("WP_GRP_ENABLE= %x", CSD->SD_CSD20.WP_GRP_ENABLE));
1060 CARD_SDIO_PRINT(("reserved4= %x", CSD->SD_CSD20.reserved4));
1062 CARD_SDIO_PRINT(("R2W_FACTOR= %x", CSD->SD_CSD20.R2W_FACTOR));
1063 CARD_SDIO_PRINT(("WRITE_BL_LEN= %x", CSD->SD_CSD20.WRITE_BL_LEN));
1064 CARD_SDIO_PRINT(("WRITE_BL_PARTIAL= %x", CSD->SD_CSD20.WRITE_BL_PARTIAL));
1065 CARD_SDIO_PRINT(("reserved5= %x", CSD->SD_CSD20.reserved5));
1067 CARD_SDIO_PRINT(("FILE_FORMAT_GRP= %x", CSD->SD_CSD20.FILE_FORMAT_GRP));
1068 CARD_SDIO_PRINT(("COPY= %x", CSD->SD_CSD20.COPY));
1069 CARD_SDIO_PRINT(("PERM_WRITE_PROTECT= %x", CSD->SD_CSD20.PERM_WRITE_PROTECT));
1070 CARD_SDIO_PRINT(("TMP_WRITE_PROTECT= %x", CSD->SD_CSD20.TMP_WRITE_PROTECT));
1071 CARD_SDIO_PRINT(("FILE_FORMAT= %x", CSD->SD_CSD20.FILE_FORMAT));
1072 CARD_SDIO_PRINT(("reserved6= %x", CSD->SD_CSD20.reserved6));
1073 // CARD_SDIO_PRINT(("CRC= %x",CSD->SD_CSD20.CRC));
1074 // CARD_SDIO_PRINT(("LastBit= %x",CSD->SD_CSD20.LastBit));
1077 (CARD_SD_V2_0_STANDARD == cardHandle->vertion)
1078 || (CARD_SD_V1_X == cardHandle->vertion)
1081 _SD_CSD10_Analyze(rspBuf, &(CSD->SD_CSD10));
1082 cardHandle->CCC = CSD->SD_CSD10.CCC;
1084 CARD_SDIO_PRINT(("CARD_SD_V2_0_STANDARD||CARD_SD_V1_X:"));
1085 CARD_SDIO_PRINT(("CSD_STRUCTURE = %x", CSD->SD_CSD10.CSD_STRUCTURE));
1086 CARD_SDIO_PRINT(("reserved1= %x", CSD->SD_CSD10.reserved1));
1087 CARD_SDIO_PRINT(("TAAC= %x", CSD->SD_CSD10.TAAC));
1088 CARD_SDIO_PRINT(("NSAC= %x", CSD->SD_CSD10.NSAC));
1089 CARD_SDIO_PRINT(("TRAN_SPEED= %x", CSD->SD_CSD10.TRAN_SPEED));
1090 CARD_SDIO_PRINT(("CCC= %x", CSD->SD_CSD10.CCC));
1091 CARD_SDIO_PRINT(("READ_BL_LEN= %x", CSD->SD_CSD10.READ_BL_LEN));
1092 CARD_SDIO_PRINT(("READ_BL_PARTIAL= %x", CSD->SD_CSD10.READ_BL_PARTIAL));
1093 CARD_SDIO_PRINT(("WRITE_BLK_MISALIGN= %x", CSD->SD_CSD10.WRITE_BLK_MISALIGN));
1094 CARD_SDIO_PRINT(("READ_BLK_MISALIGN= %x", CSD->SD_CSD10.READ_BLK_MISALIGN));
1095 CARD_SDIO_PRINT(("DSR_IMP= %x", CSD->SD_CSD10.DSR_IMP));
1097 CARD_SDIO_PRINT(("reserved2= %x", CSD->SD_CSD10.reserved2));
1098 CARD_SDIO_PRINT(("C_SIZE= %x", CSD->SD_CSD10.C_SIZE));
1099 CARD_SDIO_PRINT(("VDD_R_CURR_MIN = %x", CSD->SD_CSD10.VDD_R_CURR_MIN));
1100 CARD_SDIO_PRINT(("VDD_R_CURR_MAX = %x", CSD->SD_CSD10.VDD_R_CURR_MAX));
1101 CARD_SDIO_PRINT(("VDD_W_CURR_MIN = %x", CSD->SD_CSD10.VDD_W_CURR_MIN));
1102 CARD_SDIO_PRINT(("VDD_W_CURR_MAX = %x", CSD->SD_CSD10.VDD_W_CURR_MAX));
1103 CARD_SDIO_PRINT(("C_SIZE_MULT = %x", CSD->SD_CSD10.C_SIZE_MULT));
1105 CARD_SDIO_PRINT(("ERASE_BLK_EN= %x", CSD->SD_CSD10.ERASE_BLK_EN));
1106 CARD_SDIO_PRINT(("SECTOR_SIZE= %x", CSD->SD_CSD10.SECTOR_SIZE));
1107 CARD_SDIO_PRINT(("WP_GRP_SIZE= %x", CSD->SD_CSD10.WP_GRP_SIZE));
1108 CARD_SDIO_PRINT(("WP_GRP_ENABLE= %x", CSD->SD_CSD10.WP_GRP_ENABLE));
1109 CARD_SDIO_PRINT(("reserved3= %x", CSD->SD_CSD10.reserved3));
1111 CARD_SDIO_PRINT(("R2W_FACTOR= %x", CSD->SD_CSD10.R2W_FACTOR));
1112 CARD_SDIO_PRINT(("WRITE_BL_LEN= %x", CSD->SD_CSD10.WRITE_BL_LEN));
1113 CARD_SDIO_PRINT(("WRITE_BL_PARTIAL= %x", CSD->SD_CSD10.WRITE_BL_PARTIAL));
1114 CARD_SDIO_PRINT(("reserved4= %x", CSD->SD_CSD10.reserved4));
1116 CARD_SDIO_PRINT(("FILE_FORMAT_GRP= %x", CSD->SD_CSD10.FILE_FORMAT_GRP));
1117 CARD_SDIO_PRINT(("COPY= %x", CSD->SD_CSD10.COPY));
1118 CARD_SDIO_PRINT(("PERM_WRITE_PROTECT= %x", CSD->SD_CSD10.PERM_WRITE_PROTECT));
1119 CARD_SDIO_PRINT(("TMP_WRITE_PROTECT= %x", CSD->SD_CSD10.TMP_WRITE_PROTECT));
1120 CARD_SDIO_PRINT(("FILE_FORMAT= %x", CSD->SD_CSD10.FILE_FORMAT));
1121 CARD_SDIO_PRINT(("reserved5= %x", CSD->SD_CSD10.reserved5));
1122 // CARD_SDIO_PRINT(("CRC= %x",CSD->SD_CSD10.CRC));
1123 // CARD_SDIO_PRINT(("LastBit= %x",CSD->SD_CSD10.LastBit));
1125 else if(CARD_MMC_331 == cardHandle->vertion)
1127 _MMC_CSD_Analyze(rspBuf, &(CSD->MMC_CSD));
1128 cardHandle->CCC = CSD->MMC_CSD.CCC;
1129 cardHandle->CCC &= (~((1 << 10) | (1 << 11))); // for MMC mode This two classes is reserved
1131 CARD_SDIO_PRINT(("CARD_MMC_331:"));
1132 CARD_SDIO_PRINT(("CSD_STRUCTURE\t\t = 0x%x", CSD->MMC_CSD.CSD_STRUCTURE));
1133 CARD_SDIO_PRINT(("SPEC_VERS\t\t = 0x%x", CSD->MMC_CSD.SPEC_VERS));
1134 CARD_SDIO_PRINT(("reserved1\t\t = 0x%x", CSD->MMC_CSD.reserved1));
1135 CARD_SDIO_PRINT(("TAAC\t\t\t = 0x%x", CSD->MMC_CSD.TAAC));
1136 CARD_SDIO_PRINT(("NSAC\t\t\t = 0x%x", CSD->MMC_CSD.NSAC));
1137 CARD_SDIO_PRINT(("TRAN_SPEED\t\t = 0x%x", CSD->MMC_CSD.TRAN_SPEED));
1138 CARD_SDIO_PRINT(("CCC\t\t\t = 0x%x", CSD->MMC_CSD.CCC));
1139 CARD_SDIO_PRINT(("READ_BL_LEN\t\t = 0x%x", CSD->MMC_CSD.READ_BL_LEN));
1140 CARD_SDIO_PRINT(("READ_BL_PARTIAL\t\t = 0x%x", CSD->MMC_CSD.READ_BL_PARTIAL));
1141 CARD_SDIO_PRINT(("WRITE_BLK_MISALIGN\t = 0x%x", CSD->MMC_CSD.WRITE_BLK_MISALIGN));
1142 CARD_SDIO_PRINT(("READ_BLK_MISALIGN\t = 0x%x", CSD->MMC_CSD.READ_BLK_MISALIGN));
1143 CARD_SDIO_PRINT(("DSR_IMP\t\t\t = 0x%x", CSD->MMC_CSD.DSR_IMP));
1144 CARD_SDIO_PRINT(("reserved2\t\t = 0x%x", CSD->MMC_CSD.reserved2));
1145 CARD_SDIO_PRINT(("C_SIZE\t\t\t = 0x%x", CSD->MMC_CSD.C_SIZE));
1146 CARD_SDIO_PRINT(("VDD_R_CURR_MIN\t\t = 0x%x", CSD->MMC_CSD.VDD_R_CURR_MIN));
1147 CARD_SDIO_PRINT(("VDD_R_CURR_MAX\t\t = 0x%x", CSD->MMC_CSD.VDD_R_CURR_MAX));
1148 CARD_SDIO_PRINT(("VDD_W_CURR_MIN\t\t = 0x%x", CSD->MMC_CSD.VDD_W_CURR_MIN));
1149 CARD_SDIO_PRINT(("VDD_W_CURR_MAX\t\t = 0x%x", CSD->MMC_CSD.VDD_W_CURR_MAX));
1150 CARD_SDIO_PRINT(("C_SIZE_MULT\t\t = 0x%x", CSD->MMC_CSD.C_SIZE_MULT));
1151 CARD_SDIO_PRINT(("ERASE_GRP_SIZE\t\t = 0x%x", CSD->MMC_CSD.ERASE_GRP_SIZE));
1152 CARD_SDIO_PRINT(("ERASE_GRP_MULT\t\t = 0x%x", CSD->MMC_CSD.ERASE_GRP_MULT));
1153 CARD_SDIO_PRINT(("WP_GRP_SIZE\t\t = 0x%x", CSD->MMC_CSD.WP_GRP_SIZE));
1154 CARD_SDIO_PRINT(("WP_GRP_ENABLE\t\t = 0x%x", CSD->MMC_CSD.WP_GRP_ENABLE));
1155 CARD_SDIO_PRINT(("DEFAULT_ECC\t\t = 0x%x", CSD->MMC_CSD.DEFAULT_ECC));
1156 CARD_SDIO_PRINT(("R2W_FACTOR\t\t = 0x%x", CSD->MMC_CSD.R2W_FACTOR));
1157 CARD_SDIO_PRINT(("WRITE_BL_LEN\t\t = 0x%x", CSD->MMC_CSD.WRITE_BL_LEN));
1158 CARD_SDIO_PRINT(("WRITE_BL_PARTIAL\t = 0x%x", CSD->MMC_CSD.WRITE_BL_PARTIAL));
1159 CARD_SDIO_PRINT(("reserved3\t\t = 0x%x", CSD->MMC_CSD.reserved3));
1160 CARD_SDIO_PRINT(("CONTENT_PROT_APP\t = 0x%x", CSD->MMC_CSD.CONTENT_PROT_APP));
1161 CARD_SDIO_PRINT(("----RW bit---"));
1162 CARD_SDIO_PRINT(("FILE_FORMAT_GRP\t\t = 0x%x", CSD->MMC_CSD.FILE_FORMAT_GRP));
1163 CARD_SDIO_PRINT(("COPY\t\t\t = 0x%x", CSD->MMC_CSD.COPY));
1164 CARD_SDIO_PRINT(("PERM_WRITE_PROTECT\t = 0x%x", CSD->MMC_CSD.PERM_WRITE_PROTECT));
1165 CARD_SDIO_PRINT(("TMP_WRITE_PROTECT\t = 0x%x", CSD->MMC_CSD.TMP_WRITE_PROTECT));
1166 CARD_SDIO_PRINT(("FILE_FORMAT\t\t = 0x%x", CSD->MMC_CSD.FILE_FORMAT));
1167 CARD_SDIO_PRINT(("ECC\t\t\t = 0x%x", CSD->MMC_CSD.ECC));
1168 // CARD_SDIO_PRINT(("CRC\t\t\t = 0x%x",CSD->MMC_CSD.CRC));
1169 // CARD_SDIO_PRINT(("LastBit\t\t\t = 0x%x",CSD->MMC_CSD.LastBit));
1174 CARD_SDIO_ASSERT(0);
1181 /*****************************************************************************/
1182 // Description: Read EXT CSD register and analyze it
1185 // cardHandle: the handle returned by CARD_SDIO_Open
1186 // CSD: CSD data will be stored in this place
1191 /*****************************************************************************/
1192 LOCAL BOOLEAN CARD_SDIO_ReadExtCSD(CARD_SDIO_HANDLE cardHandle)
1196 uint32 argument = 0;
1197 CARD_DATA_PARAM_T data;
1199 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
1200 cardHandle->CCC = 0;
1204 data.databuf = s_extcsdbuf;
1205 data.direction = SDIO_DMA_IN;
1206 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD8_SEND_IF_COND,argument,&data,rspBuf))
1215 #define CID_BYTE_SIZE 16
1216 unsigned char g_regCID[CID_BYTE_SIZE];
1218 unsigned char *get_global_cid(void)
1223 /*****************************************************************************/
1224 // Description: Read CID register and analyze it
1227 // cardHandle: the handle returned by CARD_SDIO_Open
1228 // CID: CID data will be stored in this place
1233 /*****************************************************************************/
1234 uint8 CARD_SDIO_ReadCID(CARD_SDIO_HANDLE cardHandle,CARD_CID_T* CID)
1238 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
1240 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD2_ALL_SEND_CID,0,NULL,rspBuf))
1245 if(CARD_MMC_441_STANDARD == cardHandle->vertion)
1247 _MMC_CID_Analyze(rspBuf,&CID->MMC_CID);
1248 CARD_SDIO_PRINT(("-----MMC CID value---\r\n"));
1249 CARD_SDIO_PRINT(("MID\t\t = 0x%x\r\n",CID->MMC_CID.MID));
1250 CARD_SDIO_PRINT(("OID\t\t = 0x%x\r\n",CID->MMC_CID.OID));
1251 CARD_SDIO_PRINT(("PNM\t\t = %c,%c,%c,%c,%c,%c\r\n",CID->MMC_CID.PNM[0],CID->MMC_CID.PNM[1],CID->MMC_CID.PNM[2],CID->MMC_CID.PNM[3],CID->MMC_CID.PNM[4],CID->MMC_CID.PNM[5]));
1252 CARD_SDIO_PRINT(("PRV\t\t = 0x%x\r\n",CID->MMC_CID.PRV));
1253 CARD_SDIO_PRINT(("PSN\t\t = 0x%x\r\n",CID->MMC_CID.PSN));
1254 CARD_SDIO_PRINT(("MDT\t\t = 0x%x\r\n",CID->MMC_CID.MDT));
1256 memcpy(g_regCID, rspBuf, CID_BYTE_SIZE);
1260 CARD_SDIO_ASSERT(0); /*assert verified*/
1266 /*****************************************************************************/
1267 // Description: Set relate address to card ,this address is used to select card
1270 // cardHandle: the handle returned by CARD_SDIO_Open
1271 // RCA: new relative address
1276 /*****************************************************************************/
1277 LOCAL BOOLEAN CARD_SDIO_SetRCA(CARD_SDIO_HANDLE cardHandle,uint16 RCA)
1280 uint32 argument = 0;
1282 if(CARD_MMC_331 != cardHandle->vertion)
1284 // only MMC card can set RCA
1289 argument = argument<<16;
1291 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
1293 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD3_SET_RELATIVE_ADDR,argument,NULL,rspBuf))
1302 /*****************************************************************************/
1303 // Description: Get relate address from card ,this address is used to select card
1306 // cardHandle: the handle returned by CARD_SDIO_Open
1307 // RCA: relative address will stored in this place
1312 /*****************************************************************************/
1313 LOCAL BOOLEAN CARD_SDIO_ReadRCA(CARD_SDIO_HANDLE cardHandle,uint16*RCA)
1317 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
1320 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD3_SEND_RELATIVE_ADDR,1<<16,NULL,rspBuf))
1328 #if defined( CONFIG_SC8830 ) || defined(CONFIG_SC9630)
1329 LOCAL BOOLEAN SDCARD_SDIO_ReadRCA(CARD_SDIO_HANDLE cardHandle,uint16*RCA)
1334 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
1337 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD3_SEND_RELATIVE_ADDR,1<<16,NULL,rspBuf))
1343 tmpRCA = tmpRCA << 8;
1344 tmpRCA |= rspBuf[1];
1353 //-----------------------------------------------------------------------------------
1354 // Before operate card ,we must active card first,this function is used to active card
1355 //-----------------------------------------------------------------------------------
1356 LOCAL BOOLEAN _SelectCard(CARD_SDIO_HANDLE cardHandle)
1359 uint16 RCA = cardHandle->RCA;
1360 uint32 argument = 0;
1363 argument = argument<<16;
1365 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD7_SELECT_DESELECT_CARD,argument,NULL,rspBuf))
1373 LOCAL BOOLEAN MMC_SWITCH(CARD_SDIO_HANDLE cardHandle, uint8 index, uint8 value)
1376 uint32 argument = 0;
1378 argument = CMD6_ACCESS_MODE_WRITE_BYTE | CMD6_CMD_SET;
1379 argument |= index<<CMD6_BIT_MODE_OFFSET_INDEX;
1380 argument |= value<<CMD6_BIT_MODE_OFFSET_VALUE;
1383 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD6_SET_EXT_CSD,argument,NULL,rspBuf))
1391 BOOLEAN CARD_SDIO_Select_CurPartition(CARD_SDIO_HANDLE cardHandle, CARD_EMMC_PARTITION_TPYE cardPartiton)
1394 uint16 RCA = cardHandle->RCA;
1395 uint32 argument = 0;
1397 argument = CMD6_ACCESS_MODE_WRITE_BYTE | ( EXT_CSD_PARTITION_CFG_INDEX<<CMD6_BIT_MODE_OFFSET_INDEX & CMD6_BIT_MODE_MASK_INDEX) | CMD6_CMD_SET;
1399 switch(cardPartiton)
1401 case PARTITION_USER:
1402 argument |= (PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT1 |PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_USER)<<CMD6_BIT_MODE_OFFSET_VALUE;
1405 case PARTITION_BOOT1:
1406 argument |= (PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT1 |PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_BOOT1)<<CMD6_BIT_MODE_OFFSET_VALUE;
1409 case PARTITION_BOOT2:
1410 argument |= (PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT1 |PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_BOOT2)<<CMD6_BIT_MODE_OFFSET_VALUE;
1413 case PARTITION_RPMB:
1414 case PARTITION_GENERAL_P1:
1415 case PARTITION_GENERAL_P2:
1416 case PARTITION_GENERAL_P3:
1417 case PARTITION_GENERAL_P4:
1418 CARD_SDIO_ASSERT(0); //if want to support RPMB or GENERAL Partiton, need add code
1421 CARD_SDIO_ASSERT(0); /*assert verified*/
1426 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD6_SET_EXT_CSD,argument,NULL,rspBuf))
1431 cardHandle->Cur_Partition = cardPartiton;
1436 //-----------------------------------------------------------------------------------
1437 // Set data bus width of card
1438 //-----------------------------------------------------------------------------------
1439 LOCAL BOOLEAN _SetBusWidth(CARD_SDIO_HANDLE cardHandle,CARD_BUS_WIDTH_E width)
1442 uint16 RCA = cardHandle->RCA;
1443 uint32 argument = 0;
1445 argument = CMD6_ACCESS_MODE_WRITE_BYTE | ( EXT_CSD_BUS_WIDTH_INDEX<<CMD6_BIT_MODE_OFFSET_INDEX & CMD6_BIT_MODE_MASK_INDEX) ;
1449 case CARD_WIDTH_1_BIT:
1451 argument |= EXT_CSD_CARD_WIDTH_1_BIT<<CMD6_BIT_MODE_OFFSET_VALUE;
1455 case CARD_WIDTH_4_BIT:
1457 argument |=EXT_CSD_CARD_WIDTH_4_BIT<<CMD6_BIT_MODE_OFFSET_VALUE;
1460 case CARD_WIDTH_8_BIT:
1462 argument |=EXT_CSD_CARD_WIDTH_8_BIT<<CMD6_BIT_MODE_OFFSET_VALUE;
1468 CARD_SDIO_ASSERT(0); /*assert verified*/
1472 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD6_SET_EXT_CSD,argument,NULL,rspBuf))
1479 case CARD_WIDTH_1_BIT:
1481 SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd,SDIO_CARD_PAL_1_BIT);
1485 case CARD_WIDTH_4_BIT:
1487 SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd,SDIO_CARD_PAL_4_BIT);
1490 #if defined (CONFIG_SC8825) || defined(CONFIG_SC7710G2) || defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
1491 case CARD_WIDTH_8_BIT:
1493 SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd,SDIO_CARD_PAL_8_BIT);
1499 CARD_SDIO_ASSERT(0); /*assert verified*/
1503 cardHandle->bus_width = width;
1508 /*****************************************************************************/
1509 // Description: Set block length of card. the data will be transmited in block unit
1512 // cardHandle: the handle returned by CARD_SDIO_Open
1513 // length: block length
1518 /*****************************************************************************/
1519 PUBLIC BOOLEAN CARD_SDIO_SetBlockLength(CARD_SDIO_HANDLE cardHandle,uint32 length)
1523 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
1525 if((CARD_SD_V2_0_HIGHCAP == cardHandle->vertion)&&(512 != length))
1527 CARD_SDIO_PRINT(("SD20 Block Length of SD V2.0 High capacity is fixed to 512,you cannot set to value 0x%x\r\n",length));
1530 if(length == cardHandle->BlockLen)
1534 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD16_SET_BLOCKLEN,length,NULL,rspBuf))
1539 cardHandle->BlockLen = length;
1554 uint16 grp6Supported;
1555 uint16 grp5Supported;
1556 uint16 grp4Supported;
1557 uint16 grp3Supported;
1558 uint16 grp2Supported;
1559 uint16 grp1Supported;
1561 uint8 grp6SwitchResult;
1562 uint8 grp5SwitchResult;
1563 uint8 grp4SwitchResult;
1564 uint8 grp3SwitchResult;
1565 uint8 grp2SwitchResult;
1566 uint8 grp1SwitchResult;
1570 uint16 grp6BusyStatus;
1571 uint16 grp5BusyStatus;
1572 uint16 grp4BusyStatus;
1573 uint16 grp3BusyStatus;
1574 uint16 grp2BusyStatus;
1575 uint16 grp1BusyStatus;
1577 }CARD_CMD6_STATUS_T;
1580 LOCAL void _CMD6_Response_Analyze(uint8* resBuf,CARD_CMD6_STATUS_T* cmdStatus)
1582 cmdStatus->currentVal = ((resBuf[0]<<8)|(resBuf[1]));
1583 cmdStatus->grp6Supported = ((resBuf[2]<<8)|(resBuf[3]));
1584 cmdStatus->grp5Supported = ((resBuf[4]<<8)|(resBuf[5]));
1585 cmdStatus->grp4Supported = ((resBuf[6]<<8)|(resBuf[7]));
1586 cmdStatus->grp3Supported = ((resBuf[8]<<8)|(resBuf[9]));
1587 cmdStatus->grp2Supported = ((resBuf[10]<<8)|(resBuf[11]));
1588 cmdStatus->grp1Supported = ((resBuf[12]<<8)|(resBuf[13]));
1590 cmdStatus->grp6SwitchResult = ((resBuf[14]&0xF0)>>4);
1591 cmdStatus->grp5SwitchResult = (resBuf[14]&0x0F);
1592 cmdStatus->grp4SwitchResult = ((resBuf[15]&0xF0)>>4);
1593 cmdStatus->grp3SwitchResult = (resBuf[15]&0x0F);
1594 cmdStatus->grp2SwitchResult = ((resBuf[16]&0xF0)>>4);
1595 cmdStatus->grp1SwitchResult = (resBuf[16]&0x0F);
1597 cmdStatus->version = resBuf[17];
1599 cmdStatus->grp6BusyStatus = ((resBuf[18]<<8)|(resBuf[19]));
1600 cmdStatus->grp5BusyStatus = ((resBuf[20]<<8)|(resBuf[21]));
1601 cmdStatus->grp4BusyStatus = ((resBuf[22]<<8)|(resBuf[23]));
1602 cmdStatus->grp3BusyStatus = ((resBuf[24]<<8)|(resBuf[25]));
1603 cmdStatus->grp2BusyStatus = ((resBuf[26]<<8)|(resBuf[27]));
1604 cmdStatus->grp1BusyStatus = ((resBuf[28]<<8)|(resBuf[29]));
1606 CARD_SDIO_PRINT(("currentVal = 0x%x",cmdStatus->currentVal));
1608 CARD_SDIO_PRINT(("grp6Supported = 0x%x",cmdStatus->grp6Supported));
1609 CARD_SDIO_PRINT(("grp5Supported = 0x%x",cmdStatus->grp5Supported));
1610 CARD_SDIO_PRINT(("grp4Supported = 0x%x",cmdStatus->grp4Supported));
1611 CARD_SDIO_PRINT(("grp3Supported = 0x%x",cmdStatus->grp3Supported));
1612 CARD_SDIO_PRINT(("grp2Supported = 0x%x",cmdStatus->grp2Supported));
1613 CARD_SDIO_PRINT(("grp1Supported = 0x%x",cmdStatus->grp1Supported));
1615 CARD_SDIO_PRINT(("grp6SwitchResult = 0x%x",cmdStatus->grp6SwitchResult));
1616 CARD_SDIO_PRINT(("grp5SwitchResult = 0x%x",cmdStatus->grp5SwitchResult));
1617 CARD_SDIO_PRINT(("grp4SwitchResult = 0x%x",cmdStatus->grp4SwitchResult));
1618 CARD_SDIO_PRINT(("grp3SwitchResult = 0x%x",cmdStatus->grp3SwitchResult));
1619 CARD_SDIO_PRINT(("grp2SwitchResult = 0x%x",cmdStatus->grp2SwitchResult));
1620 CARD_SDIO_PRINT(("grp1SwitchResult = 0x%x",cmdStatus->grp1SwitchResult));
1622 CARD_SDIO_PRINT(("status version = 0x%x",cmdStatus->version));
1624 CARD_SDIO_PRINT(("grp6BusyStatus = 0x%x",cmdStatus->grp6BusyStatus));
1625 CARD_SDIO_PRINT(("grp5BusyStatus = 0x%x",cmdStatus->grp5BusyStatus));
1626 CARD_SDIO_PRINT(("grp4BusyStatus = 0x%x",cmdStatus->grp4BusyStatus));
1627 CARD_SDIO_PRINT(("grp3BusyStatus = 0x%x",cmdStatus->grp3BusyStatus));
1628 CARD_SDIO_PRINT(("grp2BusyStatus = 0x%x",cmdStatus->grp2BusyStatus));
1629 CARD_SDIO_PRINT(("grp1BusyStatus = 0x%x",cmdStatus->grp1BusyStatus));
1635 #define SECTOR_MODE 0x40000000
1636 #define BYTE_MODE 0x00000000
1638 PUBLIC BOOLEAN CARD_SDIO_InitCard(CARD_SDIO_HANDLE cardHandle, CARD_SPEED_MODE speedmode)
1641 uint32 pre_tick, cur_tick;
1643 CARD_BUS_WIDTH_E busWidth = CARD_WIDTH_1_BIT;
1645 BOOLEAN vertion_flag; //TRUE: SD2.0 FALSE: SD1.x
1646 SDIO_CARD_PAL_ERROR_E errCode;
1648 uint8 extcsd_Part_Config;
1650 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
1652 // CARD_SDIO_PwrCtl(cardHandle,TRUE);
1653 cardHandle->bus_width = CARD_WIDTH_1_BIT;
1654 cardHandle->BlockLen = 0;
1655 cardHandle->vertion = CARD_V_UNKONWN;
1656 cardHandle->Cur_Partition = PARTITION_MAX;
1658 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD0_GO_IDLE_STATE,0,NULL,rspBuf))
1662 //Now the card is in Idle State
1663 if(CARD_V_UNKONWN== cardHandle->vertion)
1665 pre_tick = SCI_GetTickCount(); /*set start tick value*/
1668 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD1_SEND_OP_COND,0x00FF8000 | SECTOR_MODE,NULL,rspBuf))
1673 if(0 != (rspBuf[0]&BIT_7))
1675 cardHandle->vertion = CARD_MMC_441_STANDARD;
1679 cur_tick = SCI_GetTickCount();
1680 if(CARD_CMD_MAX_TIME < (cur_tick - pre_tick))
1682 /*cmd time out, return false*/
1687 while(1); /*lint !e506*/
1690 // Now SD is in Ready State
1691 if(1 != CARD_SDIO_ReadCID(cardHandle,&g_CID))
1695 // Now SD is in Identification State
1696 if(FALSE == CARD_SDIO_ReadRCA(cardHandle,&RCA))
1700 cardHandle->RCA = 1;
1701 if(FALSE == CARD_SDIO_ReadCSD(cardHandle,&CSD))
1705 if(!(CARD_MMC_441_STANDARD == cardHandle->vertion))
1709 if(0xFFF != CSD.MMC_CSD.C_SIZE)
1711 cardHandle->GrpSize = (CSD.MMC_CSD.ERASE_GRP_SIZE+1)*(CSD.MMC_CSD.ERASE_GRP_MULT+1)*(1 << CSD.MMC_CSD.WRITE_BL_LEN);
1712 cardHandle->Nac_Max = (uint32)((((CSD.MMC_CSD.TAAC*cardHandle->ClockRate) + (100*CSD.MMC_CSD.NSAC))*10) / 8);
1713 cardHandle->Capacity = (CSD.MMC_CSD.C_SIZE+1) <<(CSD.MMC_CSD.C_SIZE_MULT+2 + CSD.MMC_CSD.READ_BL_LEN - 9); //unit is 512 byte
1718 cardHandle->vertion = CARD_MMC_441_HIGHCAP;
1721 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1726 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD7_SELECT_DESELECT_CARD, 1<<16,NULL,rspBuf))
1730 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1735 //get card Capacity and RPMB Capacity
1736 //(void)memset(s_extcsdbuf, 0x0, 512);
1737 CARD_SDIO_ReadExtCSD(cardHandle);
1738 if(CARD_MMC_441_HIGHCAP == cardHandle->vertion)
1740 cardHandle->Capacity = (((uint32)s_extcsdbuf[215])<<24)+ (((uint32)s_extcsdbuf[214])<<16)+ (((uint32)s_extcsdbuf[213])<<8)+ ((uint32)s_extcsdbuf[212]); //unit is 512 byte
1742 extcsd_Part_Config = s_extcsdbuf[179];
1743 cardHandle->Rpmb_Capacity = s_extcsdbuf[168]*256; //128/512 ==256 ,unit is 512 byte
1744 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1749 //get Boot1 Capacity
1750 CARD_SDIO_Select_CurPartition(cardHandle, PARTITION_BOOT1);
1751 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1755 CARD_SDIO_ReadExtCSD(cardHandle);
1756 extcsd_Part_Config = s_extcsdbuf[179];
1757 cardHandle->Boot1_Capacity = s_extcsdbuf[226]*256; //128/512 ==256 ,unit is 512 byte
1758 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1763 //get Boot2 Capacity
1764 CARD_SDIO_Select_CurPartition(cardHandle, PARTITION_BOOT2);
1765 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1769 CARD_SDIO_ReadExtCSD(cardHandle);
1770 extcsd_Part_Config = s_extcsdbuf[179];
1771 cardHandle->Boot2_Capacity = s_extcsdbuf[226]*256; //128/512 ==256 ,unit is 512 byte
1772 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1777 MMC_SWITCH(cardHandle, EXT_CSD_HS_TIMING_INDEX, 1);
1778 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1782 #if defined (CONFIG_SC8825) || defined(CONFIG_SC7710G2) ||defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
1783 SDIO_Card_Pal_DisSdClk(cardHandle->sdioPalHd);
1784 SDIO_Card_Pal_SetSpeedMode(cardHandle->sdioPalHd, EMMC_SPEED_SDR25);
1785 #if defined(CONFIG_FPGA)
1786 SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd, SDIO_CARD_PAL_2MHz);
1788 SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd, SDIO_CARD_PAL_50MHz);
1791 SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd,SDIO_CARD_PAL_25MHz);
1793 #if defined (CONFIG_SC8825) || defined(CONFIG_SC7710G2) || defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
1794 busWidth = CARD_WIDTH_8_BIT;
1796 busWidth = CARD_WIDTH_4_BIT;
1798 if(FALSE == _SetBusWidth(cardHandle,busWidth))
1802 if(FALSE == CARD_SDIO_SetBlockLength(cardHandle,DEFAULT_CARD_BLOCKLEN))
1809 for(i=0; i<512; i++)
1810 s_sendbuf[i] = 0x1f;
1811 CARD_SDIO_WriteSingleBlock(cardHandle, 0, (uint8*)s_sendbuf);
1812 for(i=0; i<512; i++)
1813 s_sendbuf[i] = 0x5a;
1814 CARD_SDIO_WriteSingleBlock(cardHandle, 1, (uint8*)s_sendbuf);
1817 CARD_SDIO_ReadSingleBlock(cardHandle, 0, (uint8*)s_receivebuf1);
1818 CARD_SDIO_ReadSingleBlock(cardHandle, 1, (uint8*)s_receivebuf2);
1820 (void)memset((uint8*)0x2000000, 0x0, 0x100000);
1821 (void)memset((uint8*)0x3000000, 0x0, 0x100000);
1822 CARD_SDIO_WriteMultiBlock(cardHandle, 0, 50, (uint8*)0x2000000);
1824 CARD_SDIO_ReadMultiBlock(cardHandle, 0, 50, (uint8*)0x3000000);
1827 uint32 argument = 0;
1828 argument = CMD6_ACCESS_MODE_WRITE_BYTE | ( 162<<CMD6_BIT_MODE_OFFSET_INDEX & CMD6_BIT_MODE_MASK_INDEX) | CMD6_CMD_SET |(1<<8);
1829 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD6_SET_EXT_CSD,argument,NULL,rspBuf))
1833 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1839 CARD_SDIO_Select_CurPartition(cardHandle, PARTITION_BOOT2);
1841 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1846 CARD_SDIO_ReadSingleBlock(cardHandle, 0, (uint8*)s_receivebuf1);
1847 CARD_SDIO_ReadSingleBlock(cardHandle, 1, (uint8*)s_receivebuf2);
1857 #if defined CONFIG_SC8830 || defined(CONFIG_SC9630)
1859 PUBLIC BOOLEAN SDSetBusWidth(CARD_SDIO_HANDLE cardHandle, CARD_BUS_WIDTH_E width)
1862 uint16 RCA = cardHandle->RCA;
1863 uint32 argument = 0;
1866 if(width == cardHandle->bus_width)
1872 argument = argument << 16;
1873 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_CMD55_APP_CMD, argument, NULL, rspBuf))
1880 case CARD_WIDTH_1_BIT:
1886 case CARD_WIDTH_4_BIT:
1894 CARD_SDIO_ASSERT(0);
1898 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_ACMD6_SET_BUS_WIDTH, argument, NULL, rspBuf))
1905 case CARD_WIDTH_1_BIT:
1907 SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd, SDIO_CARD_PAL_1_BIT);
1911 case CARD_WIDTH_4_BIT:
1913 SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd, SDIO_CARD_PAL_4_BIT);
1919 CARD_SDIO_ASSERT(0);
1923 cardHandle->bus_width = width;
1928 uint8 CARD_SDIO_getCID(unsigned int *uid)
1930 uid[0] = g_CID.MMC_CID.MID << 24 | g_CID.MMC_CID.OID & 0xff << 16 | (g_CID.MMC_CID.OID >> 8) & 0xff << 8 | g_CID.MMC_CID.PNM[0];
1931 uid[1] = g_CID.MMC_CID.PNM[1] << 24 | g_CID.MMC_CID.PNM[2] << 16 | g_CID.MMC_CID.PNM[3] << 8 | g_CID.MMC_CID.PNM[4];
1932 uid[2] = g_CID.MMC_CID.PRV << 24 | g_CID.MMC_CID.PSN & 0xff << 16 | (g_CID.MMC_CID.PSN >> 8) & 0xff << 8 | (g_CID.MMC_CID.PSN >> 16) & 0xff;
1933 uid[3] = (g_CID.MMC_CID.PSN >> 24) & 0xff << 24 | g_CID.MMC_CID.MDT & 0xff << 16 | (g_CID.MMC_CID.MDT >> 8) & 0xff << 8 | 1;
1938 /*****************************************************************************/
1939 // Description: Initialize card, change card from idle state to standy by state ,and get some information from card
1942 // cardHandle: the handle returned by CARD_SDIO_Open
1947 /*****************************************************************************/
1948 PUBLIC BOOLEAN SDCARD_SDIO_InitCard(CARD_SDIO_HANDLE cardHandle, CARD_SPEED_MODE speedmode)
1951 uint32 pre_tick, cur_tick,temp;
1953 CARD_BUS_WIDTH_E busWidth = CARD_WIDTH_1_BIT;
1955 BOOLEAN vertion_flag; //TRUE: SD2.0 FALSE: SD1.x
1956 SDIO_CARD_PAL_ERROR_E errCode;
1958 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
1960 cardHandle->bus_width = CARD_WIDTH_1_BIT;
1961 cardHandle->BlockLen = 0;
1962 cardHandle->vertion = CARD_V_UNKONWN;
1963 #if defined(CONFIG_SC8830)
1964 #include <asm/arch/pinmap.h>
1965 temp = (*(volatile unsigned int *)((SPRD_PIN_PHYS+REG_PIN_SD0_D3)));
1966 *((volatile unsigned int *)(SPRD_PIN_PHYS+REG_PIN_SD0_D3)) = BIT_PIN_NULL|BITS_PIN_DS(1)|BITS_PIN_AF(3)|BIT_PIN_SLP_NUL|BIT_PIN_SLP_Z;
1968 sprd_gpio_request(NULL, 100);
1969 sprd_gpio_direction_output(NULL, 100, 1);
1970 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD0_GO_IDLE_STATE,0,NULL,rspBuf))
1975 *((volatile unsigned int *)(SPRD_PIN_PHYS+REG_PIN_SD0_D3)) = temp;
1978 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD0_GO_IDLE_STATE,0,NULL,rspBuf))
1983 //Now the card is in Idle State
1984 vertion_flag = TRUE;
1985 pre_tick = SCI_GetTickCount();
1986 cur_tick = pre_tick;
1989 if(CARD_CMD_MAX_TIME < (cur_tick - pre_tick))
1993 errCode = SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD8_SEND_IF_COND,0x000001AA,NULL,rspBuf);
1994 if(SDIO_CARD_PAL_ERR_NONE != errCode)
1996 if(0 != (errCode&SDIO_CARD_PAL_ERR_CMD_TIMEOUT)) //lint !e655
1998 //SD2.0 not support current voltage or it is SD1.x
1999 vertion_flag = FALSE;
2004 cur_tick = SCI_GetTickCount();
2008 CARD_SDIO_PRINT(("SD20 %x,%x,%x,%x\r\n",rspBuf[0],rspBuf[1],rspBuf[2],rspBuf[3]));
2009 if((0xAA == rspBuf[3])&&(0x00 == rspBuf[2]))
2011 //SD2.0 not support current voltage
2012 CARD_SDIO_ASSERT(0); /*assert verified*/
2013 return FALSE; /*lint !e527*/
2015 cur_tick = SCI_GetTickCount();
2017 while(0xAA != rspBuf[3]); /*lint !e644 */
2019 CARD_SDIO_PRINT(("SD20 vertion_flag = %x\r\n",vertion_flag));
2021 pre_tick = SCI_GetTickCount(); /*set start tick value*/
2022 if(FALSE == vertion_flag)
2026 errCode = SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD55_APP_CMD,0,NULL,rspBuf);
2027 if(SDIO_CARD_PAL_ERR_NONE != errCode)
2029 if(0 != (errCode&SDIO_CARD_PAL_ERR_CMD_TIMEOUT)) //lint !e655
2031 //not SD1.x maybe it is MMC
2040 errCode = SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD41_SD_SEND_OP_COND,0x00FF8000,NULL,rspBuf);
2041 if(SDIO_CARD_PAL_ERR_NONE != errCode)
2043 if(0 != (errCode&SDIO_CARD_PAL_ERR_CMD_TIMEOUT)) //lint !e655
2045 //not SD1.x maybe it is MMC
2054 CARD_SDIO_PRINT(("SD20 %x,%x,%x,%x\r\n",rspBuf[0],rspBuf[1],rspBuf[2],rspBuf[3]));
2055 if(0 != (rspBuf[0]&BIT_7))
2057 cardHandle->vertion = CARD_SD_V1_X;
2061 cur_tick = SCI_GetTickCount();
2062 if(CARD_CMD_MAX_TIME < (cur_tick - pre_tick))
2064 /*cmd time out, return false*/
2068 while(1); /*lint !e506*/
2071 if(CARD_V_UNKONWN== cardHandle->vertion)
2073 pre_tick = SCI_GetTickCount(); /*set start tick value*/
2077 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD1_SEND_OP_COND,0x00FF8000,NULL,rspBuf))
2081 if(0 != (rspBuf[0]&BIT_7))
2083 cardHandle->vertion = CARD_MMC_331;
2087 cur_tick = SCI_GetTickCount();
2088 if(CARD_CMD_MAX_TIME < (cur_tick - pre_tick))
2090 /*cmd time out, return false*/
2094 while(1); /*lint !e506*/
2103 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD55_APP_CMD,0,NULL,rspBuf))
2108 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD41_SD_SEND_OP_COND,0x40FF8000,NULL,rspBuf))
2113 CARD_SDIO_PRINT(("SD20 %x,%x,%x,%x\r\n",rspBuf[0],rspBuf[1],rspBuf[2],rspBuf[3]));
2114 if(0 != (rspBuf[0]&BIT_7))
2116 if(0 != (rspBuf[0]&BIT_6))
2118 cardHandle->vertion = CARD_SD_V2_0_HIGHCAP;
2122 cardHandle->vertion = CARD_SD_V2_0_STANDARD;
2127 cur_tick = SCI_GetTickCount();
2128 if(CARD_CMD_MAX_TIME < (cur_tick - pre_tick))
2130 /*cmd time out, return false*/
2134 while(1); /*lint !e506*/
2137 if(CARD_V_UNKONWN == cardHandle->vertion)
2142 // Now SD is in Ready State
2143 if(FALSE == CARD_SDIO_ReadCID(cardHandle,&g_CID))
2147 // Now SD is in Identification State
2149 if(CARD_MMC_331 == cardHandle->vertion)
2151 if(FALSE == CARD_SDIO_SetRCA(cardHandle,cardHandle->RCA))
2157 // only SD card can Read RCA
2158 (CARD_SD_V1_X == cardHandle->vertion)
2159 ||(CARD_SD_V2_0_STANDARD == cardHandle->vertion)
2160 ||(CARD_SD_V2_0_HIGHCAP == cardHandle->vertion)
2163 if(FALSE == SDCARD_SDIO_ReadRCA(cardHandle,&RCA))
2165 printf("SDCARD_SDIO_ReadRCA failed!\r\n");
2168 cardHandle->RCA = RCA;
2172 CARD_SDIO_ASSERT(0); /*assert verified*/
2173 return FALSE; /*lint !e527*/
2176 // Now SD is in Stand-by State
2178 CARD_SDIO_PRINT(("SD20 type is %x",cardHandle->vertion));
2180 if(FALSE == SDCARD_SDIO_ReadCSD(cardHandle,&CSD))
2182 printf("read csd failed!\r\n");
2187 (((CARD_SD_V1_X == cardHandle->vertion)||(CARD_SD_V2_0_STANDARD== cardHandle->vertion))&&(0 == CSD.SD_CSD10.CSD_STRUCTURE))
2188 ||((CARD_SD_V2_0_HIGHCAP== cardHandle->vertion)&&(1 == CSD.SD_CSD20.CSD_STRUCTURE))
2189 ||((CARD_MMC_331 == cardHandle->vertion))
2192 printf("unkown sd type0!\r\n");
2195 if((CARD_SD_V1_X == cardHandle->vertion)||(CARD_SD_V2_0_STANDARD== cardHandle->vertion))
2197 cardHandle->Nac_Max = (uint32)((CSD.SD_CSD10.TAAC*cardHandle->ClockRate) + (100*CSD.SD_CSD10.NSAC));
2198 cardHandle->Capacity = (CSD.SD_CSD10.C_SIZE+1) <<(CSD.SD_CSD10.C_SIZE_MULT+2 + CSD.SD_CSD10.READ_BL_LEN-9); //unit is 512byte
2200 else if(CARD_SD_V2_0_HIGHCAP== cardHandle->vertion)
2202 cardHandle->Nac_Max = (uint32)((CSD.SD_CSD20.TAAC*cardHandle->ClockRate) + (100*CSD.SD_CSD20.NSAC));
2203 cardHandle->Capacity = (CSD.SD_CSD20.C_SIZE+1)<<10; // (CSD.SD_CSD20.C_SIZE+1)*1024 unit is 512byte
2205 else if(CARD_MMC_331 == cardHandle->vertion)
2207 cardHandle->GrpSize = (CSD.MMC_CSD.ERASE_GRP_SIZE+1)*(CSD.MMC_CSD.ERASE_GRP_MULT+1)*(1 << CSD.MMC_CSD.WRITE_BL_LEN);
2208 cardHandle->Nac_Max = (uint32)((((CSD.MMC_CSD.TAAC*cardHandle->ClockRate) + (100*CSD.MMC_CSD.NSAC))*10) / 8);
2209 cardHandle->Capacity = (CSD.MMC_CSD.C_SIZE+1) <<(CSD.MMC_CSD.C_SIZE_MULT+2 + CSD.MMC_CSD.READ_BL_LEN - 9); //unit is 512 byte
2214 CARD_SDIO_ASSERT(0); /*assert verified*/
2215 printf("unkown sd type1!\r\n");
2216 return FALSE; /*lint !e527*/
2219 SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd,SDIO_CARD_PAL_50MHz);
2220 //SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd,SDIO_CARD_PAL_25MHz);
2222 if(FALSE == _SelectCard(cardHandle))
2224 printf("select card failed!\r\n");
2228 if(FALSE == SDSetBusWidth(cardHandle,CARD_WIDTH_4_BIT))
2230 printf("set bus width failed!\r\n");
2234 if(FALSE == CARD_SDIO_SetBlockLength( cardHandle,DEFAULT_CARD_BLOCKLEN))
2236 printf("set block length failed!\r\n");
2244 //-----------------------------------------------------------------------------------
2245 // Inquire Card whethe ready for data
2246 //-----------------------------------------------------------------------------------
2247 LOCAL BOOLEAN _IsCardReady(CARD_SDIO_HANDLE cardHandle)
2249 uint32 pre_tick = 0, cur_tick = 0;
2250 uint8 rspBuf[16] = {0};
2251 uint16 RCA = cardHandle->RCA;
2252 uint32 argument = 0;
2255 argument = argument<<16;
2256 pre_tick = SCI_GetTickCount(); /*set start tick value*/
2260 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS,argument,NULL,rspBuf))
2265 // CARD_SDIO_PRINT(("SD20 %x,%x,%x,%x",rspBuf[0],rspBuf[1],rspBuf[2],rspBuf[3]));
2267 if(0 != (rspBuf[2]&BIT_0))
2272 cur_tick = SCI_GetTickCount();
2273 if(CARD_CMD_MAX_TIME < (cur_tick - pre_tick))
2275 /*cmd time out, return false*/
2276 CARD_SDIO_PRINT(("[Card_sdio] _IsCardReady timeout !"));
2280 while(1); /*lint !e506*/
2284 /*****************************************************************************/
2285 // Description: Read single block data from card , unit is block
2288 // cardHandle: the handle returned by CARD_SDIO_Open
2289 // BlockId: block number that you want to read
2290 // buf : that data read from card will be stored in this place
2295 /*****************************************************************************/
2296 PUBLIC BOOLEAN CARD_SDIO_ReadSingleBlock(CARD_EMMC_PARTITION_TPYE cardPartiton, CARD_SDIO_HANDLE cardHandle,uint32 BlockId,uint8* buf)
2299 uint32 address = 0xFFFFFFFF;
2300 CARD_DATA_PARAM_T data;
2302 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
2304 if((CARD_MMC_441_STANDARD == cardHandle->vertion))
2306 address = BlockId*cardHandle->BlockLen;
2308 else if(CARD_MMC_441_HIGHCAP== cardHandle->vertion)
2314 CARD_SDIO_ASSERT(0); /*assert verified*/
2317 if(FALSE == _IsCardReady(cardHandle))
2322 data.blkLen = cardHandle->BlockLen;
2325 data.direction = SDIO_DMA_IN;
2326 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD17_READ_SINGLE_BLOCK,address,&data,rspBuf))
2335 /*****************************************************************************/
2336 // Description: Read multi block data from card , unit is block
2339 // cardHandle: the handle returned by CARD_SDIO_Open
2340 // startBlock: start block number that you want to read
2341 // num: the number of block you want to read
2342 // buf : that data read from card will be stored in this place
2347 /*****************************************************************************/
2348 PUBLIC BOOLEAN CARD_SDIO_ReadMultiBlock(CARD_EMMC_PARTITION_TPYE cardPartiton, CARD_SDIO_HANDLE cardHandle,uint32 startBlock,uint32 num,uint8* buf)
2351 uint32 address = 0xFFFFFFFF;
2352 CARD_DATA_PARAM_T data;
2353 uint32 argument = 0;
2354 CARD_DATA_PARAM_T *dataParam = NULL;
2356 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
2358 if((CARD_MMC_441_STANDARD == cardHandle->vertion))
2360 address = startBlock*cardHandle->BlockLen;
2363 else if(CARD_MMC_441_HIGHCAP== cardHandle->vertion)
2365 address = startBlock;
2369 CARD_SDIO_ASSERT(0); /*assert verified*/
2372 if(FALSE == _IsCardReady(cardHandle))
2377 data.blkLen = cardHandle->BlockLen;
2380 data.direction = SDIO_DMA_IN;
2381 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD18_READ_MULTIPLE_BLOCK,address,&data,rspBuf))
2383 SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD12_STOP_TRANSMISSION,argument,dataParam,rspBuf);
2386 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD12_STOP_TRANSMISSION,argument,dataParam,rspBuf))
2394 /*****************************************************************************/
2395 // Description: Wrtie single block data to card , unit is block
2398 // cardHandle: the handle returned by CARD_SDIO_Open
2399 // BlockId: block number that you want to write
2400 // buf : that data to be writen to card is stored in this place
2405 /*****************************************************************************/
2406 PUBLIC BOOLEAN CARD_SDIO_WriteSingleBlock(CARD_EMMC_PARTITION_TPYE cardPartiton, CARD_SDIO_HANDLE cardHandle,uint32 BlockId,uint8* buf)
2409 uint32 address = 0xFFFFFFFF;
2410 CARD_DATA_PARAM_T data;
2412 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
2414 if((CARD_MMC_441_STANDARD == cardHandle->vertion))
2416 address = BlockId*cardHandle->BlockLen;
2419 else if(CARD_MMC_441_HIGHCAP== cardHandle->vertion)
2425 CARD_SDIO_ASSERT(0); /*assert verified*/
2428 if(FALSE == _IsCardReady(cardHandle))
2433 data.blkLen = cardHandle->BlockLen;
2436 data.direction = SDIO_DMA_OUT;
2437 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD24_WRITE_BLOCK,address,&data,rspBuf))
2446 /*****************************************************************************/
2447 // Description: Wrtie multi block data to card , unit is block
2450 // cardHandle: the handle returned by CARD_SDIO_Open
2451 // startBlock: start block number that you want to write
2452 // num: the number of block you want to write
2453 // buf : the data to be writen to card is stored in this place
2458 /*****************************************************************************/
2459 PUBLIC BOOLEAN CARD_SDIO_WriteMultiBlock(CARD_EMMC_PARTITION_TPYE cardPartiton, CARD_SDIO_HANDLE cardHandle,uint32 startBlock,uint32 num,uint8* buf)
2462 uint32 address = 0xFFFFFFFF;
2463 CARD_DATA_PARAM_T data;
2464 uint32 argument = 0;
2465 CARD_DATA_PARAM_T *dataParam = NULL;
2467 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
2469 if((CARD_MMC_441_STANDARD == cardHandle->vertion))
2471 address = startBlock*cardHandle->BlockLen;
2474 else if(CARD_MMC_441_HIGHCAP== cardHandle->vertion)
2476 address = startBlock;
2480 CARD_SDIO_ASSERT(0); /*assert verified*/
2483 if(FALSE == _IsCardReady(cardHandle))
2488 data.blkLen = cardHandle->BlockLen;
2491 data.direction = SDIO_DMA_OUT;
2492 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD25_WRITE_MULTIPLE_BLOCK,address,&data,rspBuf))
2494 SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD12_STOP_TRANSMISSION,argument,dataParam,rspBuf);
2497 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD12_STOP_TRANSMISSION,argument,dataParam,rspBuf))
2507 //-----------------------------------------------------------------------------------
2508 // Set SD20 erase start address
2509 //-----------------------------------------------------------------------------------
2510 LOCAL BOOLEAN _SD20_SetEraseStart(CARD_SDIO_HANDLE cardHandle,uint32 startBlock)
2514 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD32_ERASE_WR_BLK_START,startBlock,NULL,rspBuf))
2522 //-----------------------------------------------------------------------------------
2523 // Set SD20 erase end address
2524 //-----------------------------------------------------------------------------------
2525 LOCAL BOOLEAN _SD20_SetEraseEnd(CARD_SDIO_HANDLE cardHandle,uint32 endBlock)
2529 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD33_ERASE_WR_BLK_END,endBlock,NULL,rspBuf))
2537 //-----------------------------------------------------------------------------------
2538 // Set MMC441 erase start address
2539 //-----------------------------------------------------------------------------------
2540 LOCAL BOOLEAN _MMC441_SetEraseStart(CARD_SDIO_HANDLE cardHandle,uint32 startBlock)
2544 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD35_ERASE_GROUP_START,startBlock,NULL,rspBuf))
2552 //-----------------------------------------------------------------------------------
2553 // Set MMC441erase end address
2554 //-----------------------------------------------------------------------------------
2555 LOCAL BOOLEAN _MMC441_SetEraseEnd(CARD_SDIO_HANDLE cardHandle,uint32 endBlock)
2559 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD36_ERASE_GROUP_END,endBlock,NULL,rspBuf))
2566 /*****************************************************************************/
2567 // Description: erase card
2570 // cardHandle: the handle returned by CARD_SDIO_Open
2571 // startBlock: start block number that you want to erase
2572 // endBlock : end block number that you want to erase
2577 /*****************************************************************************/
2578 PUBLIC BOOLEAN CARD_SDIO_Erase(CARD_SDIO_HANDLE cardHandle,uint32 startBlock,uint32 endBlock)
2581 uint32 startAddress = 0xFFFFFFFF, endAddress = 0xFFFFFFFF;
2583 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
2585 if((CARD_SD_V2_0_STANDARD == cardHandle->vertion)
2586 ||(CARD_SD_V1_X == cardHandle->vertion)
2587 || (CARD_MMC_441_STANDARD == cardHandle->vertion))
2589 startAddress = startBlock*cardHandle->BlockLen;
2590 endAddress = endBlock*cardHandle->BlockLen;
2592 else if((CARD_MMC_441_HIGHCAP== cardHandle->vertion) || (CARD_SD_V2_0_HIGHCAP== cardHandle->vertion))
2594 startAddress = startBlock;
2595 endAddress = endBlock;
2597 else if(CARD_MMC_331 == cardHandle->vertion)
2603 CARD_SDIO_ASSERT(0); /*assert verified*/
2606 if((CARD_MMC_441_HIGHCAP== cardHandle->vertion) || (CARD_MMC_441_STANDARD == cardHandle->vertion))
2608 //set MMC441start group Id
2609 if(FALSE == _MMC441_SetEraseStart( cardHandle,startAddress))
2613 //set MMC441 end group Id
2614 if(FALSE == _MMC441_SetEraseEnd( cardHandle,endAddress))
2621 //set SD20 start group Id
2622 if(FALSE == _SD20_SetEraseStart( cardHandle,startAddress))
2626 //set SD20 end group Id
2627 if(FALSE == _SD20_SetEraseEnd( cardHandle,endAddress))
2632 //send erase command
2633 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD38_ERASE,0,NULL,rspBuf))
2642 /*****************************************************************************/
2643 // Description: Get total block number of card ,block length is fix to 512 byte
2646 // cardHandle: the handle returned by CARD_SDIO_Open
2648 // uint32 value : total block num
2650 /*****************************************************************************/
2651 PUBLIC uint32 CARD_SDIO_GetCapacity(CARD_SDIO_HANDLE cardHandle)
2653 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
2655 return cardHandle->Capacity;
2658 /*****************************************************************************/
2659 /*****************************************************************************/
2660 PUBLIC uint32 CARD_SDIO_BOOT_Enable(CARD_SDIO_HANDLE cardHandle)
2665 PUBLIC BOOLEAN Emmc_Init()
2669 #if defined (CONFIG_TIGER) || defined (CONFIG_SC7710G2) || defined (CONFIG_SC8830) || defined(CONFIG_SC9630)
2670 emmc_handle = CARD_SDIO_Open(CARD_SDIO_SLOT_7);
2672 emmc_handle = CARD_SDIO_Open(CARD_SDIO_SLOT_1);
2674 //CARD_SDIO_PwrCtl(emmc_handle, FALSE);
2675 CARD_SDIO_PwrCtl(emmc_handle, TRUE);
2676 ret = CARD_SDIO_InitCard(emmc_handle, HIGH_SPEED_MODE);
2681 #if defined CONFIG_SC8830 || defined(CONFIG_SC9630)
2682 LOCAL CARD_SDIO_HANDLE sdcard_handle = NULL;
2684 LOCAL BOOLEAN SDCARD_SDIO_WriteMultiBlock(CARD_SDIO_HANDLE cardHandle,uint32 startBlock,uint32 num,uint8* buf)
2687 uint32 address = 0xFFFFFFFF;
2688 CARD_DATA_PARAM_T data;
2689 uint32 argument = 0;
2690 CARD_DATA_PARAM_T *dataParam = NULL;
2692 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle)); /*assert verified*/
2694 if((CARD_SD_V2_0_STANDARD == cardHandle->vertion) || (CARD_SD_V1_X == cardHandle->vertion) || (CARD_MMC_331 == cardHandle->vertion))
2696 address = startBlock * cardHandle->BlockLen;
2698 else if(CARD_SD_V2_0_HIGHCAP == cardHandle->vertion)
2700 address = startBlock;
2704 CARD_SDIO_ASSERT(0);
2707 data.blkLen = cardHandle->BlockLen;
2712 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_CMD24_WRITE_BLOCK, address, &data, rspBuf))
2719 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD25_WRITE_MULTIPLE_BLOCK,address,&data,rspBuf))
2721 SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD12_STOP_TRANSMISSION,argument,dataParam,rspBuf);
2724 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD12_STOP_TRANSMISSION,argument,dataParam,rspBuf))
2732 PUBLIC BOOLEAN SDCARD_Write(uint32 startBlcok, uint32 blkCnt, uint8* buf)
2734 return SDCARD_SDIO_WriteMultiBlock(sdcard_handle, startBlcok, blkCnt, buf);
2737 LOCAL BOOLEAN SDCARD_SDIO_ReadMultiBlock(CARD_SDIO_HANDLE cardHandle, uint32 startBlock, uint32 num, uint8 *buf)
2739 uint8 rspBuf[16] = {0};
2741 CARD_DATA_PARAM_T data = {0};
2743 CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));
2745 if((CARD_SD_V2_0_STANDARD == cardHandle->vertion) || (CARD_SD_V1_X == cardHandle->vertion) || (CARD_MMC_331 == cardHandle->vertion))
2747 address = startBlock * cardHandle->BlockLen;
2749 else if(CARD_SD_V2_0_HIGHCAP == cardHandle->vertion)
2751 address = startBlock;
2755 CARD_SDIO_ASSERT(0);
2758 data.blkLen = cardHandle->BlockLen;
2763 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_CMD17_READ_SINGLE_BLOCK, address, &data, rspBuf))
2770 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_CMD18_READ_MULTIPLE_BLOCK_AUT12, address, &data, rspBuf))
2778 PUBLIC BOOLEAN SDCARD_Read(uint32 startBlcok, uint32 blkCnt, uint8* buf)
2780 return SDCARD_SDIO_ReadMultiBlock(sdcard_handle, startBlcok, blkCnt, buf);
2783 PUBLIC BOOLEAN SDCARD_Init()
2787 sdcard_handle = CARD_SDIO_Open(CARD_SDIO_SLOT_6);
2789 SDIO_Card_Pal_SetType(sdcard_handle->sdioPalHd, SDIO_CARD_PAL_TYPE_SD);
2790 CARD_SDIO_PwrCtl(sdcard_handle, FALSE);
2791 CARD_SDIO_PwrCtl(sdcard_handle, TRUE);
2792 return SDCARD_SDIO_InitCard(sdcard_handle, HIGH_SPEED_MODE);
2797 PUBLIC BOOLEAN SDCARD_PowerOn()
2799 sdcard_handle = CARD_SDIO_Open(CARD_SDIO_SLOT_6);
2800 SDIO_Card_Pal_SetType(sdcard_handle->sdioPalHd, SDIO_CARD_PAL_TYPE_SD);
2801 CARD_SDIO_PwrCtl(sdcard_handle, FALSE);
2802 CARD_SDIO_PwrCtl(sdcard_handle, TRUE);
2806 PUBLIC BOOLEAN Emmc_Write(CARD_EMMC_PARTITION_TPYE cardPartiton, uint32 startBlock,uint32 num,uint8* buf)
2810 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2814 if(emmc_handle->Cur_Partition != cardPartiton){
2815 CARD_SDIO_Select_CurPartition(emmc_handle,cardPartiton);
2817 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2823 ret = CARD_SDIO_WriteSingleBlock(cardPartiton,emmc_handle, startBlock, buf);
2825 ret = CARD_SDIO_WriteMultiBlock(cardPartiton,emmc_handle, startBlock, num, buf);
2831 PUBLIC BOOLEAN Emmc_Read(CARD_EMMC_PARTITION_TPYE cardPartiton, uint32 startBlock,uint32 num,uint8* buf)
2836 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2840 if(emmc_handle->Cur_Partition != cardPartiton){
2841 CARD_SDIO_Select_CurPartition(emmc_handle,cardPartiton);
2843 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2850 ret = CARD_SDIO_ReadSingleBlock(cardPartiton,emmc_handle, startBlock, buf);
2852 ret = CARD_SDIO_ReadMultiBlock(cardPartiton,emmc_handle, startBlock, num, buf);
2858 PUBLIC BOOLEAN Emmc_Erase(CARD_EMMC_PARTITION_TPYE cardPartiton, uint32 startBlock,uint32 num)
2862 uint32 endBlock = startBlock +num -1;
2864 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2868 if(emmc_handle->Cur_Partition != cardPartiton){
2869 CARD_SDIO_Select_CurPartition(emmc_handle,cardPartiton);
2871 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2878 ret = CARD_SDIO_Erase(emmc_handle,startBlock, endBlock);
2880 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2889 PUBLIC uint32 Emmc_GetCapacity(CARD_EMMC_PARTITION_TPYE cardPartiton)
2891 switch(cardPartiton)
2893 case PARTITION_USER:
2894 return emmc_handle->Capacity;
2896 case PARTITION_BOOT1:
2897 return emmc_handle->Boot1_Capacity;
2899 case PARTITION_BOOT2:
2900 return emmc_handle->Boot2_Capacity;
2907 PUBLIC void Emmc_DisSdClk()
2909 SDIO_Card_Pal_DisSdClk(emmc_handle->sdioPalHd);