drivers/mmc/card_sdio.c

   1 /******************************************************************************
   2  ** File Name:      card_sdio.c
   3  ** Author:         Jason.wu
   4  ** DATE:           09/17/2007
   5  ** Copyright:      2004 Spreadtrum, Incoporated. All Rights Reserved.
   6  ** Description:    This file describe operation of SD host.
   7  ******************************************************************************
   8
   9  ******************************************************************************
  10  **                        Edit History                                       *
  11  ** ------------------------------------------------------------------------- *
  12  ** DATE           NAME             DESCRIPTION
  13  ** 09/17/2007     Jason.wu        Create.
  14  ******************************************************************************/
  15
  16 /**---------------------------------------------------------------------------*
  17  **                         Dependencies                                      *
  18  **---------------------------------------------------------------------------*/
  19
  20 #include <common.h>
  21 #include <asm/arch/gpio.h>
  22 #include "asm/arch/sci_types.h"
  23 #include "asm/arch/os_api.h"
  24 #include "card_sdio.h"
  25 #include "sdio_card_pal.h"
  26 #ifdef MBBMS_SUPPORT
  27 #include "sdua_config.h"
  28 #endif
  29 #if defined(CONFIG_SC8830)
  30 #include <asm/arch/pinmap.h>
  31 #endif
  32
  33 #ifndef __maybe_unused
  34 #define __maybe_unused          __attribute__((unused))
  35 #endif
  36
  37 #define CARD_SDIO_HIGHSPEED_SUPPORT
  38
  39 //#define CARD_SDIO_PRINT(x)
  40 #define CARD_SDIO_PRINT(x) SCI_TRACE_LOW x
  41 #define CARD_SDIO_ASSERT SCI_ASSERT
  42 #define DEFAULT_CARD_BLOCKLEN 512
  43 #define CARD_CMD_MAX_TIME 5000
  44
  45 typedef enum CARD_VERTION_E_TAG
  46 {
  47         CARD_V_UNKONWN,
  48         CARD_SD_V1_X,
  49         CARD_SD_V2_0_STANDARD,
  50         CARD_SD_V2_0_HIGHCAP,
  51         CARD_MMC_331,
  52         CARD_MMC_441_STANDARD,
  53         CARD_MMC_441_HIGHCAP
  54 }CARD_VERTION_E;
  55
  56
  57 /*****************************************************************************/
  58 //      The struct of Card IDentification (CID) register of MMC. please refer to <Multi media card System Specification version 3.31>
  59 /*****************************************************************************/
  60 typedef struct CARD_MMC_CID_STRUCT_TAG
  61 {
  62         uint8 MID;      // 8 bit        Manufacturer ID
  63         uint16 OID;     // 16 bit       OEM/Application ID
  64         uint8 PNM[6];   // 48 bit       Product name
  65         uint8 PRV;      // 8 bit        Product revision
  66         uint32 PSN;     // 32 bit       Product serial number
  67         uint8 MDT;      // 8bit Manufacturing date
  68 //      uint8 CRC;      // 8 bit
  69 //      uint8 lastBit;  // 1 bit :always 1
  70 }CARD_MMC_CID_T;
  71
  72 /*****************************************************************************/
  73 // The struct of Card-Specific Data register of MMC. please refer to <Multi media card System Specification version 3.31>
  74 /*****************************************************************************/
  75 typedef struct CARD_MMC_CSD_STRUCT_TAG
  76 {
  77 //R
  78         uint8 CSD_STRUCTURE;    // 2 bit
  79         uint8 SPEC_VERS;                        // 4 bit
  80         uint8 reserved1;                        // 2 bit
  81         uint8 TAAC;                             // 8 bit
  82         uint8 NSAC;                             // 8 bit
  83         uint8 TRAN_SPEED;               // 8 bit
  84         uint16 CCC;                             //12 bit
  85         uint8 READ_BL_LEN;              // 4 bit
  86         uint8 READ_BL_PARTIAL;  // 1 bit
  87         uint8 WRITE_BLK_MISALIGN;       // 1 bit
  88         uint8 READ_BLK_MISALIGN;        // 1 bit
  89         uint8 DSR_IMP;                  // 1 bit
  90         uint8 reserved2;                        // 2 bit
  91         uint16 C_SIZE;                  //12 bit
  92         uint8 VDD_R_CURR_MIN;   // 3 bit
  93         uint8 VDD_R_CURR_MAX;   // 3 bit
  94         uint8 VDD_W_CURR_MIN;   // 3 bit
  95         uint8 VDD_W_CURR_MAX;   // 3 bit
  96         uint8 C_SIZE_MULT;              // 3 bit
  97         uint8 ERASE_GRP_SIZE;   // 5 bit
  98         uint8 ERASE_GRP_MULT;   // 5 bit
  99         uint8 WP_GRP_SIZE;              // 5 bit
 100         uint8 WP_GRP_ENABLE;    // 1 bit
 101         uint8 DEFAULT_ECC;              // 2 bit
 102         uint8 R2W_FACTOR;               // 3 bit
 103         uint8 WRITE_BL_LEN;             // 4 bit
 104         uint8 WRITE_BL_PARTIAL; // 1 bit
 105         uint8 reserved3;                        // 4 bit
 106         uint8 CONTENT_PROT_APP; // 1 bit
 107 //RW
 108         uint8 FILE_FORMAT_GRP;  // 1 bit
 109         uint8 COPY;                             // 1 bit
 110         uint8 PERM_WRITE_PROTECT;       // 1 bit
 111         uint8 TMP_WRITE_PROTECT;        // 1 bit
 112         uint8 FILE_FORMAT;              // 2 bit
 113         uint8 ECC;                              // 2 bit
 114 //      uint8 CRC;                              // 7 bit
 115 //      uint8 LastBit;                          // 1 bit: always 1
 116 }CARD_MMC_CSD_T;
 117
 118 /*****************************************************************************/
 119 //      The struct of Card IDentification (CID) register of SD. please refer to <SD Specifications Part 1 Physical Layer Specification Version 2.00>
 120 /*****************************************************************************/
 121 typedef struct CARD_SD_CID_STRUCT_TAG
 122 {
 123         uint8 MID;      // 8 bit
 124         uint16 OID;     // 16 bit
 125         uint8 PNM[5];   // 40 bit
 126         uint8 PRV;      // 8 bit
 127         uint32 PSN;     // 32 bit
 128         uint16 MDT;     // 12bit
 129 //      uint8 CRC;      // 1 bit
 130 //      uint8 lastBit;  // 1 bit :always 1
 131 }CARD_SD_CID_T;
 132
 133 /*****************************************************************************/
 134 // The struct of Card-Specific Data register of SD. please refer to <SD Specifications Part 1 Physical Layer Specification Version 2.00>
 135 /*****************************************************************************/
 136 typedef struct CARD_SD_CSD10_STRUCT_TAG
 137 {
 138 //R
 139         uint8 CSD_STRUCTURE;    // 2 bit
 140         uint8 reserved1;                        // 6 bit
 141         uint8 TAAC;                             // 8 bit
 142         uint8 NSAC;                             // 8 bit
 143         uint8 TRAN_SPEED;               // 8 bit
 144         uint16 CCC;                             //12 bit
 145         uint8 READ_BL_LEN;              // 4 bit
 146         uint8 READ_BL_PARTIAL;  // 1 bit
 147         uint8 WRITE_BLK_MISALIGN;       // 1 bit
 148         uint8 READ_BLK_MISALIGN;        // 1 bit
 149         uint8 DSR_IMP;                  // 1 bit
 150
 151         uint8 reserved2;                        // 2 bit
 152         uint16 C_SIZE;                  //12 bit
 153         uint8 VDD_R_CURR_MIN;   // 3 bit
 154         uint8 VDD_R_CURR_MAX;   // 3 bit
 155         uint8 VDD_W_CURR_MIN;   // 3 bit
 156         uint8 VDD_W_CURR_MAX;   // 3 bit
 157         uint8 C_SIZE_MULT;              // 3 bit
 158
 159         uint8 ERASE_BLK_EN;             // 1 bit
 160         uint8 SECTOR_SIZE;              // 7 bit
 161         uint8 WP_GRP_SIZE;              // 7 bit
 162         uint8 WP_GRP_ENABLE;    // 1 bit
 163         uint8 reserved3;                // 2 bit
 164
 165         uint8 R2W_FACTOR;               // 3 bit
 166         uint8 WRITE_BL_LEN;             // 4 bit
 167         uint8 WRITE_BL_PARTIAL; // 1 bit
 168         uint8 reserved4;                        // 5 bit
 169 //RW
 170         uint8 FILE_FORMAT_GRP;  // 1 bit
 171         uint8 COPY;                             // 1 bit
 172         uint8 PERM_WRITE_PROTECT;       // 1 bit
 173         uint8 TMP_WRITE_PROTECT;        // 1 bit
 174         uint8 FILE_FORMAT;              // 2 bit
 175         uint8 reserved5;                        // 2 bit
 176 //      uint8 CRC;                              // 7 bit
 177 //      uint8 LastBit;                          // 1 bit: always 1
 178 }CARD_SD_CSD10_T;
 179
 180 /*****************************************************************************/
 181 // The struct of Card-Specific Data register of SD. please refer to <SD Specifications Part 1 Physical Layer Specification Version 2.00>
 182 /*****************************************************************************/
 183 typedef struct CARD_SD_CSD20_STRUCT_TAG
 184 {
 185 //R
 186         uint8 CSD_STRUCTURE;    // 2 bit
 187         uint8 reserved1;                        // 6 bit
 188         uint8 TAAC;                             // 8 bit
 189         uint8 NSAC;                             // 8 bit
 190         uint8 TRAN_SPEED;               // 8 bit
 191         uint16 CCC;                             //12 bit
 192         uint8 READ_BL_LEN;              // 4 bit
 193         uint8 READ_BL_PARTIAL;  // 1 bit
 194         uint8 WRITE_BLK_MISALIGN;       // 1 bit
 195         uint8 READ_BLK_MISALIGN;        // 1 bit
 196         uint8 DSR_IMP;                  // 1 bit
 197
 198         uint8 reserved2;                        // 6 bit
 199         uint32 C_SIZE;                  //22 bit
 200         uint8 reserved3;                        // 1 bit
 201
 202         uint8 ERASE_BLK_EN;             // 1 bit
 203         uint8 SECTOR_SIZE;              // 7 bit
 204         uint8 WP_GRP_SIZE;              // 7 bit
 205         uint8 WP_GRP_ENABLE;    // 1 bit
 206         uint8 reserved4;                // 2 bit
 207
 208         uint8 R2W_FACTOR;               // 3 bit
 209         uint8 WRITE_BL_LEN;             // 4 bit
 210         uint8 WRITE_BL_PARTIAL; // 1 bit
 211         uint8 reserved5;                        // 5 bit
 212 //RW
 213         uint8 FILE_FORMAT_GRP;  // 1 bit
 214         uint8 COPY;                             // 1 bit
 215         uint8 PERM_WRITE_PROTECT;       // 1 bit
 216         uint8 TMP_WRITE_PROTECT;        // 1 bit
 217         uint8 FILE_FORMAT;              // 2 bit
 218         uint8 reserved6;                        // 2 bit
 219 //      uint8 CRC;                              // 7 bit
 220 //      uint8 LastBit;                          // 1 bit: always 1
 221 }CARD_SD_CSD20_T;
 222
 223 typedef union CARD_CSD_STRUCT_TAG
 224 {
 225         CARD_SD_CSD10_T SD_CSD10;
 226         CARD_SD_CSD20_T SD_CSD20;
 227         CARD_MMC_CSD_T MMC_CSD;
 228 }CARD_CSD_T;
 229
 230 typedef union CARD_CID_STRUCT_TAG
 231 {
 232         CARD_SD_CID_T SD_CID;
 233         CARD_MMC_CID_T MMC_CID;
 234 }CARD_CID_T;
 235 /*lint -save -e749*/
 236 typedef enum CARD_BUS_WIDTH_TAG
 237 {
 238         CARD_WIDTH_1_BIT,
 239         CARD_WIDTH_4_BIT,
 240         CARD_WIDTH_8_BIT
 241 }CARD_BUS_WIDTH_E;
 242
 243 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET   3
 244 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_MASK   0x38
 245 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_NONE   (0<<PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET)
 246 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT1   (1<<PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET)
 247 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT2   (2<<PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET)
 248 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_USER   (7<<PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET)
 249
 250 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_OFFSET  00
 251 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_MASK   0x07
 252 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_USER      0
 253 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_BOOT1     1
 254 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_BOOT2     2
 255 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_RPMB      3
 256 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_GENERAL_P1        4
 257 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_GENERAL_P2        5
 258 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_GENERAL_P3        6
 259 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_GENERAL_P4        7
 260
 261 #define EXT_CSD_CARD_WIDTH_1_BIT                0
 262 #define EXT_CSD_CARD_WIDTH_4_BIT                1
 263 #define EXT_CSD_CARD_WIDTH_8_BIT                2
 264
 265 #define EXT_CSD_PARTITION_CFG_INDEX     179
 266 #define EXT_CSD_BUS_WIDTH_INDEX         183
 267
 268 #define CMD6_BIT_MODE_OFFSET_ACCESS     24
 269 #define CMD6_BIT_MODE_MASK_ACCESS       0x03000000
 270 #define CMD6_BIT_MODE_OFFSET_INDEX              16
 271 #define CMD6_BIT_MODE_MASK_INDEX        0x00FF0000
 272 #define CMD6_BIT_MODE_OFFSET_VALUE              8
 273 #define CMD6_BIT_MODE_MASK_VALUE        0x0000FF00
 274 #define CMD6_BIT_MODE_OFFSET_CMD_SET    0
 275 #define CMD6_BIT_MODE_MASK_CMD_SET      0x00000003
 276
 277 #define CMD6_ACCESS_MODE_COMMAND_SET    (0<<CMD6_BIT_MODE_OFFSET_ACCESS)
 278 #define CMD6_ACCESS_MODE_SET_BITS       (1<<CMD6_BIT_MODE_OFFSET_ACCESS)
 279 #define CMD6_ACCESS_MODE_CLEAR_BITS     (2<<CMD6_BIT_MODE_OFFSET_ACCESS)
 280 #define CMD6_ACCESS_MODE_WRITE_BYTE     (3<<CMD6_BIT_MODE_OFFSET_ACCESS)
 281
 282 #define CMD6_CMD_SET_OLD        (0<<CMD6_BIT_MODE_OFFSET_CMD_SET)
 283 #define CMD6_CMD_SET            (1<<CMD6_BIT_MODE_OFFSET_CMD_SET)
 284
 285 /*
 286  * CSD field definitions
 287  */
 288
 289 #define CSD_STRUCT_VER_1_0  0           /* Valid for system specification 1.0 - 1.2 */
 290 #define CSD_STRUCT_VER_1_1  1           /* Valid for system specification 1.4 - 2.2 */
 291 #define CSD_STRUCT_VER_1_2  2           /* Valid for system specification 3.1 - 3.2 - 3.31 - 4.0 - 4.1 */
 292 #define CSD_STRUCT_EXT_CSD  3           /* Version is coded in CSD_STRUCTURE in EXT_CSD */
 293
 294 #define CSD_SPEC_VER_0      0           /* Implements system specification 1.0 - 1.2 */
 295 #define CSD_SPEC_VER_1      1           /* Implements system specification 1.4 */
 296 #define CSD_SPEC_VER_2      2           /* Implements system specification 2.0 - 2.2 */
 297 #define CSD_SPEC_VER_3      3           /* Implements system specification 3.1 - 3.2 - 3.31 */
 298 #define CSD_SPEC_VER_4      4           /* Implements system specification 4.0 - 4.1 */
 299
 300 /*
 301  * EXT_CSD fields
 302  */
 303
 304 #define EXT_CSD_BUS_WIDTH_INDEX 183     /* R/W */
 305 #define EXT_CSD_HS_TIMING_INDEX 185     /* R/W */
 306 #define EXT_CSD_CARD_TYPE_INDEX 196     /* RO */
 307 #define EXT_CSD_SEC_CNT_INDEX   212     /* RO, 4 bytes */
 308 #define EXT_CSD_PARTITION_CFG_INDEX     179
 309 /*
 310  *
 311  */
 312
 313 #define EXT_CSD_CMD_SET_NORMAL          (1<<0)
 314 #define EXT_CSD_CMD_SET_SECURE          (1<<1)
 315 #define EXT_CSD_CMD_SET_CPSECURE        (1<<2)
 316
 317 #define EXT_CSD_CARD_TYPE_26    (1<<0)  /* Card can run at 26MHz */
 318 #define EXT_CSD_CARD_TYPE_52    (1<<1)  /* Card can run at 52MHz */
 319
 320 #define EXT_CSD_BUS_WIDTH_1     0       /* Card is in 1 bit mode */
 321 #define EXT_CSD_BUS_WIDTH_4     1       /* Card is in 4 bit mode */
 322 #define EXT_CSD_BUS_WIDTH_8     2       /* Card is in 8 bit mode */
 323
 324 /*
 325  * MMC_SWITCH access modes
 326  */
 327
 328 #define MMC_SWITCH_MODE_CMD_SET 0x00    /* Change the command set */
 329 #define MMC_SWITCH_MODE_SET_BITS        0x01    /* Set bits which are 1 in value */
 330 #define MMC_SWITCH_MODE_CLEAR_BITS      0x02    /* Clear bits which are 1 in value */
 331 #define MMC_SWITCH_MODE_WRITE_BYTE      0x03    /* Set target to value */
 332
 333
 334 typedef struct CARD_PORT_TAG
 335 {
 336         BOOLEAN open_flag;
 337
 338         SDIO_CARD_PAL_HANDLE sdioPalHd;
 339
 340         CARD_VERTION_E vertion;
 341         uint16 RCA;
 342         CARD_BUS_WIDTH_E bus_width;
 343
 344         uint32 ClockRate;
 345         uint32 BlockLen;
 346
 347         uint32 Nac_Max;
 348         uint32 GrpSize;
 349         uint32 Capacity;
 350         uint32 Rpmb_Capacity;
 351         uint32 Boot1_Capacity;
 352         uint32 Boot2_Capacity;
 353         CARD_EMMC_PARTITION_TPYE Cur_Partition;
 354
 355         uint16  CCC;
 356         BOOLEAN ifSupportEC;
 357         BOOLEAN ifSupportHighSpeed;
 358
 359         BOOLEAN ifEnterEC;
 360         BOOLEAN ifEnterHighSpeed;
 361 }CARD_PORT_T;
 362
 363 __align(32) uint8 s_extcsdbuf[512];
 364 __align(32) uint8 s_sendbuf[512];
 365 __align(32) uint8 s_receivebuf1[512];
 366 __align(32) uint8 s_receivebuf2[512];
 367
 368 CARD_SDIO_HANDLE  emmc_handle = NULL;
 369 CARD_CID_T g_CID;
 370
 371 LOCAL CARD_PORT_T cardPort[CARD_SDIO_SLOT_MAX] = {0};
 372
 373 extern int LDO_Init(void);
 374 extern  void  SDIO_Card_Pal_SetType(SDIO_CARD_PAL_HANDLE handle, SDIO_CARD_PAL_TYPE_E sdio_type);
 375 extern int sprd_gpio_request(struct gpio_chip *chip, unsigned offset);
 376 extern int sprd_gpio_direction_output(struct gpio_chip *chip, unsigned offset, int value);
 377
 378 //-----------------------------------------------------------------------------------
 379 //      To judge whether the handle is valid
 380 //-----------------------------------------------------------------------------------
 381 LOCAL BOOLEAN __maybe_unused _IsCardHandleValid(CARD_SDIO_HANDLE cardHandle)
 382 {
 383         uint32 i;
 384
 385         for(i = 0; i < CARD_SDIO_SLOT_MAX; i++)
 386         {
 387                 if(cardHandle == &cardPort[i])
 388                 {
 389                         if(TRUE == cardHandle->open_flag)
 390                         {
 391                                 return TRUE;
 392                         }
 393                         else
 394                         {
 395                                 return FALSE;
 396                         }
 397                 }
 398         }
 399         return FALSE;
 400
 401 }
 402
 403
 404 /*****************************************************************************/
 405 //  Description:  Get Card operation handle,after we get the handle ,we can get next operation way of card
 406 //  Author: Jason.wu
 407 //  Param
 408 //              slotNo: slot number
 409 //  Return:
 410 //              Not zero: success
 411 //              zero : fail
 412 //  Note:
 413 /*****************************************************************************/
 414 PUBLIC CARD_SDIO_HANDLE CARD_SDIO_Open(CARD_SDIO_SLOT_NO slotNo)
 415 {
 416         CARD_SDIO_ASSERT(slotNo < CARD_SDIO_SLOT_MAX);  /*assert verified*/
 417
 418         if(TRUE == cardPort[slotNo].open_flag)
 419         {
 420                 return NULL;
 421         }
 422
 423         cardPort[slotNo].open_flag = TRUE;
 424         cardPort[slotNo].sdioPalHd = SDIO_Card_Pal_Open((SDIO_CARD_PAL_SLOT_E)slotNo);
 425         cardPort[slotNo].BlockLen = 0;
 426         cardPort[slotNo].RCA = 0x1000 | slotNo;
 427         cardPort[slotNo].bus_width = CARD_WIDTH_1_BIT;
 428
 429         return &cardPort[slotNo];
 430 }
 431
 432 /*****************************************************************************/
 433 //  Description:  close operation handle of card. afer we free it ,other application can operate on this card
 434 //  Author: Jason.wu
 435 //  Param
 436 //              cardHandle: the handle returned by CARD_SDIO_Open
 437 //  Return:
 438 //              NONE
 439 //  Note:
 440 /*****************************************************************************/
 441 PUBLIC void CARD_SDIO_Close(CARD_SDIO_HANDLE cardHandle)
 442 {
 443         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
 444
 445         SDIO_Card_Pal_Close(cardHandle->sdioPalHd);
 446         cardHandle->open_flag = FALSE;
 447 }
 448
 449 PUBLIC void CARD_SDIO_PwrCtl(CARD_SDIO_HANDLE cardHandle,BOOLEAN switchCtl)
 450 {
 451         if(TRUE == switchCtl)
 452         {
 453                 SDIO_Card_Pal_Pwr(cardHandle->sdioPalHd,SDIO_CARD_PAL_ON);
 454         }
 455         else if(FALSE == switchCtl)
 456         {
 457                 SDIO_Card_Pal_Pwr(cardHandle->sdioPalHd,SDIO_CARD_PAL_OFF);
 458         }
 459         else
 460         {
 461                 CARD_SDIO_ASSERT(0);    /*assert verified*/
 462         }
 463 }
 464
 465 //-----------------------------------------------------------------------------------
 466 //      Analyze SD CID buffer
 467 //-----------------------------------------------------------------------------------
 468 LOCAL void __maybe_unused _SD_CID_Analyze(uint8* CIDbuf,CARD_SD_CID_T *CID)
 469 {
 470         uint16 tmp16;
 471         uint32 tmp32;
 472
 473         CID->MID = CIDbuf[0];
 474
 475         tmp16 = CIDbuf[1];
 476         tmp16 = tmp16<<8;
 477         CID->OID = tmp16 + CIDbuf[2];
 478
 479         CID->PNM[0] = CIDbuf[3];
 480         CID->PNM[1] = CIDbuf[4];
 481         CID->PNM[2] = CIDbuf[5];
 482         CID->PNM[3] = CIDbuf[6];
 483         CID->PNM[4] = CIDbuf[7];
 484
 485         CID->PRV = CIDbuf[8];
 486
 487         tmp32 = CIDbuf[9];
 488         tmp32 = tmp32<<8;
 489         tmp32 += CIDbuf[10];
 490         tmp32 = tmp32<<8;
 491         tmp32 += CIDbuf[11];
 492         tmp32 = tmp32<<8;
 493         tmp32 += CIDbuf[12];
 494         CID->PSN = tmp32;
 495
 496         tmp16 = CIDbuf[13]&0x0F;
 497         tmp16 = tmp16<<8;
 498         CID->MDT = tmp16 + CIDbuf[14];
 499
 500 //      CID->CRC = ((CIDbuf[15]&0xFE)>>1);
 501 //      CID->lastBit = (CIDbuf[15]&0x01);
 502 }
 503
 504 //-----------------------------------------------------------------------------------
 505 //      Analyze MMC CID buffer
 506 //-----------------------------------------------------------------------------------
 507 LOCAL void _MMC_CID_Analyze(uint8* CIDbuf,CARD_MMC_CID_T *CID)
 508 {
 509         uint16 tmp16;
 510         uint32 tmp32;
 511
 512         CID->MID = CIDbuf[0];
 513
 514         tmp16 = CIDbuf[1];
 515         tmp16 = tmp16<<8;
 516         CID->OID = tmp16 + CIDbuf[2];
 517
 518         CID->PNM[0] = CIDbuf[3];
 519         CID->PNM[1] = CIDbuf[4];
 520         CID->PNM[2] = CIDbuf[5];
 521         CID->PNM[3] = CIDbuf[6];
 522         CID->PNM[4] = CIDbuf[7];
 523         CID->PNM[5] = CIDbuf[8];
 524
 525         CID->PRV = CIDbuf[9];
 526
 527         tmp32 = CIDbuf[10];
 528         tmp32 = tmp32<<8;
 529         tmp32 += CIDbuf[11];
 530         tmp32 = tmp32<<8;
 531         tmp32 += CIDbuf[12];
 532         tmp32 = tmp32<<8;
 533         tmp32 += CIDbuf[13];
 534         CID->PSN = tmp32;
 535
 536         CID->MDT = CIDbuf[14];
 537
 538 //      CID->CRC = ((CIDbuf[15]&0xFE)>>1);
 539 //      CID->lastBit = (CIDbuf[15]&0x01);
 540 }
 541
 542
 543 //-----------------------------------------------------------------------------------
 544 //      Analyze SD CSD buffer
 545 //
 546 //      Expand SD CSD1.x to CSD struct member
 547 //
 548 //-----------------------------------------------------------------------------------
 549 LOCAL void _SD_CSD10_Analyze(uint8* CSDbuf,CARD_SD_CSD10_T *CSD)
 550 {
 551         uint8 tmp8;
 552         uint16 tmp16;
 553
 554 //R
 555         tmp8 = CSDbuf[0]&0xC0; //0b11000000
 556         CSD->CSD_STRUCTURE = tmp8>>6;   // 2 bit
 557
 558         tmp8 = CSDbuf[0]&0x3F;//0b00111111;
 559         CSD->reserved1 = tmp8;                  // 6 bit
 560
 561         tmp8 = CSDbuf[1];
 562         CSD->TAAC = tmp8;                       // 8 bit
 563
 564         tmp8 = CSDbuf[2];
 565         CSD->NSAC = tmp8;                       // 8 bit
 566
 567         tmp8 = CSDbuf[3];
 568         CSD->TRAN_SPEED = tmp8;         // 8 bit
 569
 570         tmp16 = CSDbuf[4];
 571         tmp16 = tmp16<<4;
 572         tmp8 = CSDbuf[5]&0xF0;//0b11110000;
 573         tmp8 = tmp8>>4;
 574         tmp16 += tmp8;
 575         CSD->CCC = tmp16;                       //12 bit
 576
 577         tmp8 = CSDbuf[5]&0x0F;//0b00001111;
 578         CSD->READ_BL_LEN = tmp8;                // 4 bit
 579
 580         tmp8 = CSDbuf[6]&0x80;//0b10000000;
 581         CSD->READ_BL_PARTIAL = tmp8>>7;         // 1 bit
 582
 583         tmp8 = CSDbuf[6]&0x40;//0b01000000;
 584         CSD->WRITE_BLK_MISALIGN = tmp8>>6;      // 1 bit
 585
 586         tmp8 = CSDbuf[6]&0x20;//0b00100000;
 587         CSD->READ_BLK_MISALIGN = tmp8>>5;       // 1 bit
 588
 589         tmp8 = CSDbuf[6]&0x10;//0b00010000;
 590         CSD->DSR_IMP = tmp8>>4;                 // 1 bit
 591
 592         tmp8 = CSDbuf[6]&0x0C;//0b00001100;
 593         CSD->reserved2 = tmp8>>2;                       // 2 bit
 594
 595         tmp16 = CSDbuf[6]&0x03;//0b00000011;
 596         tmp16 = tmp16<<8;
 597         tmp16 += CSDbuf[7];
 598         tmp16 = tmp16<<2;
 599         tmp8 = CSDbuf[8]&0xC0;//0b11000000;
 600         tmp8 = tmp8>>6;
 601         tmp16 = tmp16 + tmp8;
 602         CSD->C_SIZE = tmp16;                            //12 bit
 603
 604         tmp8 = CSDbuf[8]&0x38;//0b00111000;
 605         CSD->VDD_R_CURR_MIN = tmp8>>3;  // 3 bit
 606
 607         tmp8 = CSDbuf[8]&0x07;//0b00000111;
 608         CSD->VDD_R_CURR_MAX = tmp8;             // 3 bit
 609
 610         tmp8 = CSDbuf[9]&0xE0;//0b11100000;
 611         CSD->VDD_W_CURR_MIN = tmp8>>5;  // 3 bit
 612
 613         tmp8 = CSDbuf[9]&0x1C;//0b00011100;
 614         CSD->VDD_W_CURR_MAX = tmp8>>2;  // 3 bit
 615
 616         tmp8 = CSDbuf[9]&0x03;//0b00000011;
 617         tmp8 = tmp8<<1;
 618         tmp8 = tmp8 + ((CSDbuf[10]&0x80/*0b10000000*/)>>7);
 619         CSD->C_SIZE_MULT = tmp8;                        // 3 bit
 620 //--
 621         tmp8 = CSDbuf[10]&0x40;//0b01000000;
 622         CSD->ERASE_BLK_EN = tmp8>>6;    // 1 bit
 623
 624         tmp8 = CSDbuf[10]&0x3F;//0b00111111;
 625         tmp8 = tmp8<<1;
 626         tmp8 = tmp8 + ((CSDbuf[11]&0x80/*0b10000000*/)>>7);
 627         CSD->SECTOR_SIZE = tmp8;                // 7 bit
 628
 629         tmp8 = CSDbuf[11]&0x7F;//0b01111111;
 630         CSD->WP_GRP_SIZE = tmp8;                        // 7 bit
 631 //--
 632         tmp8 = CSDbuf[12]&0x80;//0b10000000;
 633         CSD->WP_GRP_ENABLE = tmp8>>7;   // 1 bit
 634
 635         tmp8 = CSDbuf[12]&0x60;//0b01100000;
 636         CSD->reserved3 = tmp8>>5;               // 2 bit
 637
 638         tmp8 = CSDbuf[12]&0x1C;//0b00011100;
 639         CSD->R2W_FACTOR = tmp8>>2;              // 3 bit
 640
 641         tmp8 = CSDbuf[12]&0x03;//0b00000011;
 642         tmp8 = tmp8<<2;
 643         tmp8 = tmp8 + ((CSDbuf[13]&0xC0/*0b11000000*/)>>6);
 644         CSD->WRITE_BL_LEN = tmp8;               // 4 bit
 645
 646         tmp8 = CSDbuf[13]&0x20;//0b00100000;
 647         CSD->WRITE_BL_PARTIAL = tmp8>>5;        // 1 bit
 648
 649         tmp8 = CSDbuf[13]&0x1F;//0b00011111;
 650         CSD->reserved4 = tmp8;                  // 5 bit
 651 //RW
 652         tmp8 = CSDbuf[14]&0x80;//0b10000000;
 653         CSD->FILE_FORMAT_GRP = tmp8>>7; // 1 bit
 654
 655         tmp8 = CSDbuf[14]&0x40;//0b01000000;
 656         CSD->COPY = tmp8>>6;                            // 1 bit
 657
 658         tmp8 = CSDbuf[14]&0x20;//0b00100000;
 659         CSD->PERM_WRITE_PROTECT = tmp8>>5;      // 1 bit
 660
 661         tmp8 = CSDbuf[14]&0x10;//0b00010000;
 662         CSD->TMP_WRITE_PROTECT = tmp8>>4;       // 1 bit
 663
 664         tmp8 = CSDbuf[14]&0x0C;//0b00001100;
 665         CSD->FILE_FORMAT = tmp8>>2;             // 2 bit
 666         tmp8 = CSDbuf[14]&0x03;//0b00000011;
 667         CSD->reserved5 = tmp8;                                  // 2 bit
 668
 669 //      tmp8 = CSDbuf[15]&0xFE;//0b11111110;
 670 //      CSD->CRC = tmp8>>1;                             // 7 bit
 671
 672 //      tmp8 = CSDbuf[15]&0x01;//0b00000001;
 673 //      CSD->LastBit = tmp8;                            // 1 bit: always 1
 674 }
 675
 676
 677 //-----------------------------------------------------------------------------------
 678 //      Analyze SD CSD buffer
 679 //
 680 //      Expand SD CSD2.0 to CSD struct member
 681 //
 682 //-----------------------------------------------------------------------------------
 683 LOCAL void _SD_CSD20_Analyze(uint8* CSDbuf,CARD_SD_CSD20_T *CSD)
 684 {
 685         uint8 tmp8;
 686         uint16 tmp16;
 687         uint32 tmp32;
 688
 689 //R
 690         tmp8 = CSDbuf[0]&0xC0; //0b11000000
 691         CSD->CSD_STRUCTURE = tmp8>>6;   // 2 bit
 692
 693         tmp8 = CSDbuf[0]&0x3F;//0b00111111;
 694         CSD->reserved1 = tmp8;                  // 6 bit
 695
 696         tmp8 = CSDbuf[1];
 697         CSD->TAAC = tmp8;                       // 8 bit
 698
 699         tmp8 = CSDbuf[2];
 700         CSD->NSAC = tmp8;                       // 8 bit
 701
 702         tmp8 = CSDbuf[3];
 703         CSD->TRAN_SPEED = tmp8;         // 8 bit
 704
 705         tmp16 = CSDbuf[4];
 706         tmp16 = tmp16<<4;
 707         tmp8 = CSDbuf[5]&0xF0;//0b11110000;
 708         tmp8 = tmp8>>4;
 709         tmp16 += tmp8;
 710         CSD->CCC = tmp16;                       //12 bit
 711
 712         tmp8 = CSDbuf[5]&0x0F;//0b00001111;
 713         CSD->READ_BL_LEN = tmp8;                // 4 bit
 714
 715         tmp8 = CSDbuf[6]&0x80;//0b10000000;
 716         CSD->READ_BL_PARTIAL = tmp8>>7;         // 1 bit
 717
 718         tmp8 = CSDbuf[6]&0x40;//0b01000000;
 719         CSD->WRITE_BLK_MISALIGN = tmp8>>6;      // 1 bit
 720
 721         tmp8 = CSDbuf[6]&0x20;//0b00100000;
 722         CSD->READ_BLK_MISALIGN = tmp8>>5;       // 1 bit
 723
 724         tmp8 = CSDbuf[6]&0x10;//0b00010000;
 725         CSD->DSR_IMP = tmp8>>4;                 // 1 bit
 726 //--
 727         tmp8 = CSDbuf[6]&0x0F;//0b00001111;
 728         tmp8 = tmp8<<2;
 729         tmp8 += ((CSDbuf[7]&0xC0/*0b11000000*/)>>6);
 730         CSD->reserved2 = tmp8;                          // 6 bit
 731
 732         tmp32 = CSDbuf[7]&0x3F;//0b00111111
 733         tmp32 = tmp32<<8;
 734         tmp32 += CSDbuf[8];
 735         tmp32 = tmp32<<8;
 736         tmp32 += CSDbuf[9];
 737         CSD->C_SIZE = tmp32;                            // 22 bit
 738
 739         tmp8 = CSDbuf[10]&0x80;//0b10000000
 740         tmp8 = tmp8>>7;
 741         CSD->reserved3 = tmp8;
 742 //--
 743         tmp8 = CSDbuf[10]&0x40;//0b01000000;
 744         CSD->ERASE_BLK_EN = tmp8>>6;    // 1 bit
 745
 746         tmp8 = CSDbuf[10]&0x3F;//0b00111111;
 747         tmp8 = tmp8<<1;
 748         tmp8 = tmp8 + ((CSDbuf[11]&0x80/*0b10000000*/)>>7);
 749         CSD->SECTOR_SIZE = tmp8;                // 7 bit
 750
 751         tmp8 = CSDbuf[11]&0x7F;//0b01111111;
 752         CSD->WP_GRP_SIZE = tmp8;                        // 7 bit
 753 //--
 754         tmp8 = CSDbuf[12]&0x80;//0b10000000;
 755         CSD->WP_GRP_ENABLE = tmp8>>7;   // 1 bit
 756
 757         tmp8 = CSDbuf[12]&0x60;//0b01100000;
 758         CSD->reserved4 = tmp8>>5;               // 2 bit
 759
 760         tmp8 = CSDbuf[12]&0x1C;//0b00011100;
 761         CSD->R2W_FACTOR = tmp8>>2;              // 3 bit
 762
 763         tmp8 = CSDbuf[12]&0x03;//0b00000011;
 764         tmp8 = tmp8<<2;
 765         tmp8 = tmp8 + ((CSDbuf[13]&0xC0/*0b11000000*/)>>6);
 766         CSD->WRITE_BL_LEN = tmp8;               // 4 bit
 767
 768         tmp8 = CSDbuf[13]&0x20;//0b00100000;
 769         CSD->WRITE_BL_PARTIAL = tmp8>>5;        // 1 bit
 770
 771         tmp8 = CSDbuf[13]&0x1F;//0b00011111;
 772         CSD->reserved5 = tmp8;                  // 5 bit
 773 //RW
 774         tmp8 = CSDbuf[14]&0x80;//0b10000000;
 775         CSD->FILE_FORMAT_GRP = tmp8>>7; // 1 bit
 776
 777         tmp8 = CSDbuf[14]&0x40;//0b01000000;
 778         CSD->COPY = tmp8>>6;                            // 1 bit
 779
 780         tmp8 = CSDbuf[14]&0x20;//0b00100000;
 781         CSD->PERM_WRITE_PROTECT = tmp8>>5;      // 1 bit
 782
 783         tmp8 = CSDbuf[14]&0x10;//0b00010000;
 784         CSD->TMP_WRITE_PROTECT = tmp8>>4;       // 1 bit
 785
 786         tmp8 = CSDbuf[14]&0x0C;//0b00001100;
 787         CSD->FILE_FORMAT = tmp8>>2;             // 2 bit
 788         tmp8 = CSDbuf[14]&0x03;//0b00000011;
 789         CSD->reserved6 = tmp8;                                  // 2 bit
 790
 791 //      tmp8 = CSDbuf[15]&0xFE;//0b11111110;
 792 //      CSD->CRC = tmp8>>1;                             // 7 bit
 793
 794 //      tmp8 = CSDbuf[15]&0x01;//0b00000001;
 795 //      CSD->LastBit = tmp8;                            // 1 bit: always 1
 796 }
 797
 798 //-----------------------------------------------------------------------------------
 799 //      Analyze MMC CSD buffer
 800 //
 801 //      Expand MMC CSD to CSD struct member
 802 //
 803 //-----------------------------------------------------------------------------------
 804 LOCAL void _MMC_CSD_Analyze(uint8* CSDbuf,CARD_MMC_CSD_T *CSD)
 805 {
 806         uint8 tmp8;
 807         uint16 tmp16;
 808
 809 //R
 810         tmp8 = CSDbuf[0]&0xC0; //0b11000000
 811         CSD->CSD_STRUCTURE = tmp8>>6;   // 2 bit
 812
 813         tmp8 = CSDbuf[0]&0x3C;//0b00111100;
 814         CSD->SPEC_VERS = tmp8>>2;       // 4 bit
 815
 816         tmp8 = CSDbuf[0]&0x03;//0b00000011;
 817         CSD->reserved1 = tmp8;                  // 2 bit
 818
 819         tmp8 = CSDbuf[1];
 820         CSD->TAAC = tmp8;                       // 8 bit
 821
 822         tmp8 = CSDbuf[2];
 823         CSD->NSAC = tmp8;                       // 8 bit
 824
 825         tmp8 = CSDbuf[3];
 826         CSD->TRAN_SPEED = tmp8;         // 8 bit
 827
 828         tmp16 = CSDbuf[4];
 829         tmp16 = tmp16<<4;
 830         tmp8 = CSDbuf[5]&0xF0;//0b11110000;
 831         tmp8 = tmp8>>4;
 832         tmp16 += tmp8;
 833         CSD->CCC = tmp16;                       //12 bit
 834
 835         tmp8 = CSDbuf[5]&0x0F;//0b00001111;
 836         CSD->READ_BL_LEN = tmp8;                // 4 bit
 837
 838         tmp8 = CSDbuf[6]&0x80;//0b10000000;
 839         CSD->READ_BL_PARTIAL = tmp8>>7;         // 1 bit
 840
 841         tmp8 = CSDbuf[6]&0x40;//0b01000000;
 842         CSD->WRITE_BLK_MISALIGN = tmp8>>6;      // 1 bit
 843
 844         tmp8 = CSDbuf[6]&0x20;//0b00100000;
 845         CSD->READ_BLK_MISALIGN = tmp8>>5;       // 1 bit
 846
 847         tmp8 = CSDbuf[6]&0x10;//0b00010000;
 848         CSD->DSR_IMP = tmp8>>4;                 // 1 bit
 849
 850         tmp8 = CSDbuf[6]&0x0C;//0b00001100;
 851         CSD->reserved2 = tmp8>>2;                       // 2 bit
 852
 853         tmp16 = CSDbuf[6]&0x03;//0b00000011;
 854         tmp16 = tmp16<<8;
 855         tmp16 += CSDbuf[7];
 856         tmp16 = tmp16<<2;
 857         tmp8 = CSDbuf[8]&0xC0;//0b11000000;
 858         tmp8 = tmp8>>6;
 859         tmp16 = tmp16 + tmp8;
 860         CSD->C_SIZE = tmp16;                            //12 bit
 861
 862         tmp8 = CSDbuf[8]&0x38;//0b00111000;
 863         CSD->VDD_R_CURR_MIN = tmp8>>3;  // 3 bit
 864
 865         tmp8 = CSDbuf[8]&0x07;//0b00000111;
 866         CSD->VDD_R_CURR_MAX = tmp8;             // 3 bit
 867
 868         tmp8 = CSDbuf[9]&0xE0;//0b11100000;
 869         CSD->VDD_W_CURR_MIN = tmp8>>5;  // 3 bit
 870
 871         tmp8 = CSDbuf[9]&0x1C;//0b00011100;
 872         CSD->VDD_W_CURR_MAX = tmp8>>2;  // 3 bit
 873
 874         tmp8 = CSDbuf[9]&0x03;//0b00000011;
 875         tmp8 = tmp8<<1;
 876         tmp8 = tmp8 + ((CSDbuf[10]&0x80/*0b10000000*/)>>7);
 877         CSD->C_SIZE_MULT = tmp8;                        // 3 bit
 878
 879         tmp8 = CSDbuf[10]&0x7C;//0b01111100;
 880         CSD->ERASE_GRP_SIZE = tmp8>>2;  // 5 bit
 881
 882         tmp8 = CSDbuf[10]&0x03;//0b00000011;
 883         tmp8 = tmp8<<3;
 884         tmp8 = tmp8 + ((CSDbuf[11]&0xE0/*0b11100000*/)>>5);
 885         CSD->ERASE_GRP_MULT = tmp8;             // 5 bit
 886
 887         tmp8 = CSDbuf[11]&0x1F;//0b00011111;
 888         CSD->WP_GRP_SIZE = tmp8;                        // 5 bit
 889
 890         tmp8 = CSDbuf[12]&0x80;//0b10000000;
 891         CSD->WP_GRP_ENABLE = tmp8>>7;   // 1 bit
 892
 893         tmp8 = CSDbuf[12]&0x60;//0b01100000;
 894         CSD->DEFAULT_ECC = tmp8>>5;             // 2 bit
 895
 896         tmp8 = CSDbuf[12]&0x1C;//0b00011100;
 897         CSD->R2W_FACTOR = tmp8>>2;              // 3 bit
 898
 899         tmp8 = CSDbuf[12]&0x03;//0b00000011;
 900         tmp8 = tmp8<<2;
 901         tmp8 = tmp8 + ((CSDbuf[13]&0xC0/*0b11000000*/)>>6);
 902         CSD->WRITE_BL_LEN = tmp8;               // 4 bit
 903
 904         tmp8 = CSDbuf[13]&0x20;//0b00100000;
 905         CSD->WRITE_BL_PARTIAL = tmp8>>5;        // 1 bit
 906
 907         tmp8 = CSDbuf[13]&0x1E;//0b00011110;
 908         CSD->reserved3 = tmp8>>1;                       // 4 bit
 909
 910         tmp8 = CSDbuf[13]&0x01;//0b00000001;
 911         CSD->CONTENT_PROT_APP = tmp8;   // 1 bit
 912 //RW
 913         tmp8 = CSDbuf[14]&0x80;//0b10000000;
 914         CSD->FILE_FORMAT_GRP = tmp8>>7; // 1 bit
 915
 916         tmp8 = CSDbuf[14]&0x40;//0b01000000;
 917         CSD->COPY = tmp8>>6;                            // 1 bit
 918
 919         tmp8 = CSDbuf[14]&0x20;//0b00100000;
 920         CSD->PERM_WRITE_PROTECT = tmp8>>5;      // 1 bit
 921
 922         tmp8 = CSDbuf[14]&0x10;//0b00010000;
 923         CSD->TMP_WRITE_PROTECT = tmp8>>4;       // 1 bit
 924
 925         tmp8 = CSDbuf[14]&0x0C;//0b00001100;
 926         CSD->FILE_FORMAT = tmp8>>2;             // 2 bit
 927         tmp8 = CSDbuf[14]&0x03;//0b00000011;
 928         CSD->ECC = tmp8;                                        // 2 bit
 929
 930 //      tmp8 = CSDbuf[15]&0xFE;//0b11111110;
 931 //      CSD->CRC = tmp8>>1;                             // 7 bit
 932
 933 //      tmp8 = CSDbuf[15]&0x01;//0b00000001;
 934 //      CSD->LastBit = tmp8;                            // 1 bit: always 1
 935 }
 936
 937
 938
 939 /*****************************************************************************/
 940 //  Description:  Read CSD register and analyze it
 941 //  Author: Jason.wu
 942 //  Param
 943 //              cardHandle: the handle returned by CARD_SDIO_Open
 944 //              CSD: CSD data will be stored in this place
 945 //  Return:
 946 //              TRUE: success
 947 //              FALSE: fail
 948 //  Note:
 949 /*****************************************************************************/
 950 LOCAL BOOLEAN CARD_SDIO_ReadCSD(CARD_SDIO_HANDLE cardHandle,CARD_CSD_T* CSD)
 951 {
 952         uint8 rspBuf[16];
 953         uint16 RCA = cardHandle->RCA;
 954         uint32 argument = 0;
 955
 956         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
 957         cardHandle->CCC = 0;
 958
 959         argument = RCA;
 960         argument = argument<<16;
 961
 962
 963         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD9_SEND_CSD,argument,NULL,rspBuf))
 964         {
 965                 return FALSE;
 966         }
 967 //--
 968         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]));
 969
 970  if((CARD_MMC_441_STANDARD == cardHandle->vertion)||(CARD_MMC_441_HIGHCAP == cardHandle->vertion))
 971         {
 972                 _MMC_CSD_Analyze(rspBuf,&(CSD->MMC_CSD));
 973                 cardHandle->CCC = CSD->MMC_CSD.CCC;
 974                 cardHandle->CCC &= (~((1<<10)|(1<<11)));        // for MMC mode This two classes is reserved
 975
 976                 CARD_SDIO_PRINT(("CARD_MMC_331:"));
 977                 CARD_SDIO_PRINT(("CSD_STRUCTURE\t\t  = 0x%x",CSD->MMC_CSD.CSD_STRUCTURE));
 978                 CARD_SDIO_PRINT(("SPEC_VERS\t\t  = 0x%x",CSD->MMC_CSD.SPEC_VERS));
 979                 CARD_SDIO_PRINT(("reserved1\t\t  = 0x%x",CSD->MMC_CSD.reserved1));
 980                 CARD_SDIO_PRINT(("TAAC\t\t\t  = 0x%x",CSD->MMC_CSD.TAAC));
 981                 CARD_SDIO_PRINT(("NSAC\t\t\t  = 0x%x",CSD->MMC_CSD.NSAC));
 982                 CARD_SDIO_PRINT(("TRAN_SPEED\t\t  = 0x%x",CSD->MMC_CSD.TRAN_SPEED));
 983                 CARD_SDIO_PRINT(("CCC\t\t\t  = 0x%x",CSD->MMC_CSD.CCC));
 984                 CARD_SDIO_PRINT(("READ_BL_LEN\t\t  = 0x%x",CSD->MMC_CSD.READ_BL_LEN));
 985                 CARD_SDIO_PRINT(("READ_BL_PARTIAL\t\t  = 0x%x",CSD->MMC_CSD.READ_BL_PARTIAL));
 986                 CARD_SDIO_PRINT(("WRITE_BLK_MISALIGN\t  = 0x%x",CSD->MMC_CSD.WRITE_BLK_MISALIGN));
 987                 CARD_SDIO_PRINT(("READ_BLK_MISALIGN\t  = 0x%x",CSD->MMC_CSD.READ_BLK_MISALIGN));
 988                 CARD_SDIO_PRINT(("DSR_IMP\t\t\t  = 0x%x",CSD->MMC_CSD.DSR_IMP));
 989                 CARD_SDIO_PRINT(("reserved2\t\t  = 0x%x",CSD->MMC_CSD.reserved2));
 990                 CARD_SDIO_PRINT(("C_SIZE\t\t\t  = 0x%x",CSD->MMC_CSD.C_SIZE));
 991                 CARD_SDIO_PRINT(("VDD_R_CURR_MIN\t\t  = 0x%x",CSD->MMC_CSD.VDD_R_CURR_MIN));
 992                 CARD_SDIO_PRINT(("VDD_R_CURR_MAX\t\t  = 0x%x",CSD->MMC_CSD.VDD_R_CURR_MAX));
 993                 CARD_SDIO_PRINT(("VDD_W_CURR_MIN\t\t  = 0x%x",CSD->MMC_CSD.VDD_W_CURR_MIN));
 994                 CARD_SDIO_PRINT(("VDD_W_CURR_MAX\t\t  = 0x%x",CSD->MMC_CSD.VDD_W_CURR_MAX));
 995                 CARD_SDIO_PRINT(("C_SIZE_MULT\t\t  = 0x%x",CSD->MMC_CSD.C_SIZE_MULT));
 996                 CARD_SDIO_PRINT(("ERASE_GRP_SIZE\t\t  = 0x%x",CSD->MMC_CSD.ERASE_GRP_SIZE));
 997                 CARD_SDIO_PRINT(("ERASE_GRP_MULT\t\t  = 0x%x",CSD->MMC_CSD.ERASE_GRP_MULT));
 998                 CARD_SDIO_PRINT(("WP_GRP_SIZE\t\t  = 0x%x",CSD->MMC_CSD.WP_GRP_SIZE));
 999                 CARD_SDIO_PRINT(("WP_GRP_ENABLE\t\t  = 0x%x",CSD->MMC_CSD.WP_GRP_ENABLE));
1000                 CARD_SDIO_PRINT(("DEFAULT_ECC\t\t  = 0x%x",CSD->MMC_CSD.DEFAULT_ECC));
1001                 CARD_SDIO_PRINT(("R2W_FACTOR\t\t  = 0x%x",CSD->MMC_CSD.R2W_FACTOR));
1002                 CARD_SDIO_PRINT(("WRITE_BL_LEN\t\t  = 0x%x",CSD->MMC_CSD.WRITE_BL_LEN));
1003                 CARD_SDIO_PRINT(("WRITE_BL_PARTIAL\t  = 0x%x",CSD->MMC_CSD.WRITE_BL_PARTIAL));
1004                 CARD_SDIO_PRINT(("reserved3\t\t  = 0x%x",CSD->MMC_CSD.reserved3));
1005                 CARD_SDIO_PRINT(("CONTENT_PROT_APP\t  = 0x%x",CSD->MMC_CSD.CONTENT_PROT_APP));
1006                 CARD_SDIO_PRINT(("----RW bit---"));
1007                 CARD_SDIO_PRINT(("FILE_FORMAT_GRP\t\t  = 0x%x",CSD->MMC_CSD.FILE_FORMAT_GRP));
1008                 CARD_SDIO_PRINT(("COPY\t\t\t  = 0x%x",CSD->MMC_CSD.COPY));
1009                 CARD_SDIO_PRINT(("PERM_WRITE_PROTECT\t  = 0x%x",CSD->MMC_CSD.PERM_WRITE_PROTECT));
1010                 CARD_SDIO_PRINT(("TMP_WRITE_PROTECT\t  = 0x%x",CSD->MMC_CSD.TMP_WRITE_PROTECT));
1011                 CARD_SDIO_PRINT(("FILE_FORMAT\t\t  = 0x%x",CSD->MMC_CSD.FILE_FORMAT));
1012                 CARD_SDIO_PRINT(("ECC\t\t\t  = 0x%x",CSD->MMC_CSD.ECC));
1013 //              CARD_SDIO_PRINT(("CRC\t\t\t  = 0x%x",CSD->MMC_CSD.CRC));
1014 //              CARD_SDIO_PRINT(("LastBit\t\t\t  = 0x%x",CSD->MMC_CSD.LastBit));
1015
1016         }
1017         else
1018         {
1019                 CARD_SDIO_ASSERT(0);    /*assert verified*/
1020         }
1021
1022         return TRUE;
1023 }
1024 #if defined CONFIG_SC8830 || defined(CONFIG_SC9630)
1025 PUBLIC BOOLEAN SDCARD_SDIO_ReadCSD(CARD_SDIO_HANDLE cardHandle, CARD_CSD_T *CSD)
1026 {
1027     uint8 rspBuf[16];
1028     uint16 RCA = cardHandle->RCA;
1029     uint32 argument = 0;
1030
1031     CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));
1032     cardHandle->CCC = 0;
1033
1034     argument = RCA;
1035     argument = argument << 16;
1036
1037
1038     if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_CMD9_SEND_CSD, argument, NULL, rspBuf))
1039     {
1040         return FALSE;
1041     }
1042     //--
1043     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]));
1044
1045     if(CARD_SD_V2_0_HIGHCAP == cardHandle->vertion)
1046     {
1047         _SD_CSD20_Analyze(rspBuf, &(CSD->SD_CSD20));
1048         cardHandle->CCC = CSD->SD_CSD20.CCC;
1049
1050         CARD_SDIO_PRINT(("CARD_SD_V2_0_HIGHCAP:"));
1051         CARD_SDIO_PRINT(("CSD_STRUCTURE = %x", CSD->SD_CSD20.CSD_STRUCTURE));
1052         CARD_SDIO_PRINT(("reserved1= %x", CSD->SD_CSD20.reserved1));
1053         CARD_SDIO_PRINT(("TAAC= %x", CSD->SD_CSD20.TAAC));
1054         CARD_SDIO_PRINT(("NSAC= %x", CSD->SD_CSD20.NSAC));
1055         CARD_SDIO_PRINT(("TRAN_SPEED= %x", CSD->SD_CSD20.TRAN_SPEED));
1056         CARD_SDIO_PRINT(("CCC= %x", CSD->SD_CSD20.CCC));
1057         CARD_SDIO_PRINT(("READ_BL_LEN= %x", CSD->SD_CSD20.READ_BL_LEN));
1058         CARD_SDIO_PRINT(("READ_BL_PARTIAL= %x", CSD->SD_CSD20.READ_BL_PARTIAL));
1059         CARD_SDIO_PRINT(("WRITE_BLK_MISALIGN= %x", CSD->SD_CSD20.WRITE_BLK_MISALIGN));
1060         CARD_SDIO_PRINT(("READ_BLK_MISALIGN= %x", CSD->SD_CSD20.READ_BLK_MISALIGN));
1061         CARD_SDIO_PRINT(("DSR_IMP= %x", CSD->SD_CSD20.DSR_IMP));
1062
1063         CARD_SDIO_PRINT(("reserved2= %x", CSD->SD_CSD20.reserved2));
1064         CARD_SDIO_PRINT(("C_SIZE= %x", CSD->SD_CSD20.C_SIZE));
1065         CARD_SDIO_PRINT(("reserved3= %x", CSD->SD_CSD20.reserved3));
1066
1067         CARD_SDIO_PRINT(("ERASE_BLK_EN= %x", CSD->SD_CSD20.ERASE_BLK_EN));
1068         CARD_SDIO_PRINT(("SECTOR_SIZE= %x", CSD->SD_CSD20.SECTOR_SIZE));
1069         CARD_SDIO_PRINT(("WP_GRP_SIZE= %x", CSD->SD_CSD20.WP_GRP_SIZE));
1070         CARD_SDIO_PRINT(("WP_GRP_ENABLE= %x", CSD->SD_CSD20.WP_GRP_ENABLE));
1071         CARD_SDIO_PRINT(("reserved4= %x", CSD->SD_CSD20.reserved4));
1072
1073         CARD_SDIO_PRINT(("R2W_FACTOR= %x", CSD->SD_CSD20.R2W_FACTOR));
1074         CARD_SDIO_PRINT(("WRITE_BL_LEN= %x", CSD->SD_CSD20.WRITE_BL_LEN));
1075         CARD_SDIO_PRINT(("WRITE_BL_PARTIAL= %x", CSD->SD_CSD20.WRITE_BL_PARTIAL));
1076         CARD_SDIO_PRINT(("reserved5= %x", CSD->SD_CSD20.reserved5));
1077
1078         CARD_SDIO_PRINT(("FILE_FORMAT_GRP= %x", CSD->SD_CSD20.FILE_FORMAT_GRP));
1079         CARD_SDIO_PRINT(("COPY= %x", CSD->SD_CSD20.COPY));
1080         CARD_SDIO_PRINT(("PERM_WRITE_PROTECT= %x", CSD->SD_CSD20.PERM_WRITE_PROTECT));
1081         CARD_SDIO_PRINT(("TMP_WRITE_PROTECT= %x", CSD->SD_CSD20.TMP_WRITE_PROTECT));
1082         CARD_SDIO_PRINT(("FILE_FORMAT= %x", CSD->SD_CSD20.FILE_FORMAT));
1083         CARD_SDIO_PRINT(("reserved6= %x", CSD->SD_CSD20.reserved6));
1084         //      CARD_SDIO_PRINT(("CRC= %x",CSD->SD_CSD20.CRC));
1085         //      CARD_SDIO_PRINT(("LastBit= %x",CSD->SD_CSD20.LastBit));
1086     }
1087     else if(
1088         (CARD_SD_V2_0_STANDARD == cardHandle->vertion)
1089         || (CARD_SD_V1_X == cardHandle->vertion)
1090     )
1091     {
1092         _SD_CSD10_Analyze(rspBuf, &(CSD->SD_CSD10));
1093         cardHandle->CCC = CSD->SD_CSD10.CCC;
1094
1095         CARD_SDIO_PRINT(("CARD_SD_V2_0_STANDARD||CARD_SD_V1_X:"));
1096         CARD_SDIO_PRINT(("CSD_STRUCTURE = %x", CSD->SD_CSD10.CSD_STRUCTURE));
1097         CARD_SDIO_PRINT(("reserved1= %x", CSD->SD_CSD10.reserved1));
1098         CARD_SDIO_PRINT(("TAAC= %x", CSD->SD_CSD10.TAAC));
1099         CARD_SDIO_PRINT(("NSAC= %x", CSD->SD_CSD10.NSAC));
1100         CARD_SDIO_PRINT(("TRAN_SPEED= %x", CSD->SD_CSD10.TRAN_SPEED));
1101         CARD_SDIO_PRINT(("CCC= %x", CSD->SD_CSD10.CCC));
1102         CARD_SDIO_PRINT(("READ_BL_LEN= %x", CSD->SD_CSD10.READ_BL_LEN));
1103         CARD_SDIO_PRINT(("READ_BL_PARTIAL= %x", CSD->SD_CSD10.READ_BL_PARTIAL));
1104         CARD_SDIO_PRINT(("WRITE_BLK_MISALIGN= %x", CSD->SD_CSD10.WRITE_BLK_MISALIGN));
1105         CARD_SDIO_PRINT(("READ_BLK_MISALIGN= %x", CSD->SD_CSD10.READ_BLK_MISALIGN));
1106         CARD_SDIO_PRINT(("DSR_IMP= %x", CSD->SD_CSD10.DSR_IMP));
1107
1108         CARD_SDIO_PRINT(("reserved2= %x", CSD->SD_CSD10.reserved2));
1109         CARD_SDIO_PRINT(("C_SIZE= %x", CSD->SD_CSD10.C_SIZE));
1110         CARD_SDIO_PRINT(("VDD_R_CURR_MIN = %x", CSD->SD_CSD10.VDD_R_CURR_MIN));
1111         CARD_SDIO_PRINT(("VDD_R_CURR_MAX = %x", CSD->SD_CSD10.VDD_R_CURR_MAX));
1112         CARD_SDIO_PRINT(("VDD_W_CURR_MIN = %x", CSD->SD_CSD10.VDD_W_CURR_MIN));
1113         CARD_SDIO_PRINT(("VDD_W_CURR_MAX = %x", CSD->SD_CSD10.VDD_W_CURR_MAX));
1114         CARD_SDIO_PRINT(("C_SIZE_MULT = %x", CSD->SD_CSD10.C_SIZE_MULT));
1115
1116         CARD_SDIO_PRINT(("ERASE_BLK_EN= %x", CSD->SD_CSD10.ERASE_BLK_EN));
1117         CARD_SDIO_PRINT(("SECTOR_SIZE= %x", CSD->SD_CSD10.SECTOR_SIZE));
1118         CARD_SDIO_PRINT(("WP_GRP_SIZE= %x", CSD->SD_CSD10.WP_GRP_SIZE));
1119         CARD_SDIO_PRINT(("WP_GRP_ENABLE= %x", CSD->SD_CSD10.WP_GRP_ENABLE));
1120         CARD_SDIO_PRINT(("reserved3= %x", CSD->SD_CSD10.reserved3));
1121
1122         CARD_SDIO_PRINT(("R2W_FACTOR= %x", CSD->SD_CSD10.R2W_FACTOR));
1123         CARD_SDIO_PRINT(("WRITE_BL_LEN= %x", CSD->SD_CSD10.WRITE_BL_LEN));
1124         CARD_SDIO_PRINT(("WRITE_BL_PARTIAL= %x", CSD->SD_CSD10.WRITE_BL_PARTIAL));
1125         CARD_SDIO_PRINT(("reserved4= %x", CSD->SD_CSD10.reserved4));
1126
1127         CARD_SDIO_PRINT(("FILE_FORMAT_GRP= %x", CSD->SD_CSD10.FILE_FORMAT_GRP));
1128         CARD_SDIO_PRINT(("COPY= %x", CSD->SD_CSD10.COPY));
1129         CARD_SDIO_PRINT(("PERM_WRITE_PROTECT= %x", CSD->SD_CSD10.PERM_WRITE_PROTECT));
1130         CARD_SDIO_PRINT(("TMP_WRITE_PROTECT= %x", CSD->SD_CSD10.TMP_WRITE_PROTECT));
1131         CARD_SDIO_PRINT(("FILE_FORMAT= %x", CSD->SD_CSD10.FILE_FORMAT));
1132         CARD_SDIO_PRINT(("reserved5= %x", CSD->SD_CSD10.reserved5));
1133         //      CARD_SDIO_PRINT(("CRC= %x",CSD->SD_CSD10.CRC));
1134         //      CARD_SDIO_PRINT(("LastBit= %x",CSD->SD_CSD10.LastBit));
1135     }
1136     else if(CARD_MMC_331 == cardHandle->vertion)
1137     {
1138         _MMC_CSD_Analyze(rspBuf, &(CSD->MMC_CSD));
1139         cardHandle->CCC = CSD->MMC_CSD.CCC;
1140         cardHandle->CCC &= (~((1 << 10) | (1 << 11)));  // for MMC mode This two classes is reserved
1141
1142         CARD_SDIO_PRINT(("CARD_MMC_331:"));
1143         CARD_SDIO_PRINT(("CSD_STRUCTURE\t\t  = 0x%x", CSD->MMC_CSD.CSD_STRUCTURE));
1144         CARD_SDIO_PRINT(("SPEC_VERS\t\t  = 0x%x", CSD->MMC_CSD.SPEC_VERS));
1145         CARD_SDIO_PRINT(("reserved1\t\t  = 0x%x", CSD->MMC_CSD.reserved1));
1146         CARD_SDIO_PRINT(("TAAC\t\t\t  = 0x%x", CSD->MMC_CSD.TAAC));
1147         CARD_SDIO_PRINT(("NSAC\t\t\t  = 0x%x", CSD->MMC_CSD.NSAC));
1148         CARD_SDIO_PRINT(("TRAN_SPEED\t\t  = 0x%x", CSD->MMC_CSD.TRAN_SPEED));
1149         CARD_SDIO_PRINT(("CCC\t\t\t  = 0x%x", CSD->MMC_CSD.CCC));
1150         CARD_SDIO_PRINT(("READ_BL_LEN\t\t  = 0x%x", CSD->MMC_CSD.READ_BL_LEN));
1151         CARD_SDIO_PRINT(("READ_BL_PARTIAL\t\t  = 0x%x", CSD->MMC_CSD.READ_BL_PARTIAL));
1152         CARD_SDIO_PRINT(("WRITE_BLK_MISALIGN\t  = 0x%x", CSD->MMC_CSD.WRITE_BLK_MISALIGN));
1153         CARD_SDIO_PRINT(("READ_BLK_MISALIGN\t  = 0x%x", CSD->MMC_CSD.READ_BLK_MISALIGN));
1154         CARD_SDIO_PRINT(("DSR_IMP\t\t\t  = 0x%x", CSD->MMC_CSD.DSR_IMP));
1155         CARD_SDIO_PRINT(("reserved2\t\t  = 0x%x", CSD->MMC_CSD.reserved2));
1156         CARD_SDIO_PRINT(("C_SIZE\t\t\t  = 0x%x", CSD->MMC_CSD.C_SIZE));
1157         CARD_SDIO_PRINT(("VDD_R_CURR_MIN\t\t  = 0x%x", CSD->MMC_CSD.VDD_R_CURR_MIN));
1158         CARD_SDIO_PRINT(("VDD_R_CURR_MAX\t\t  = 0x%x", CSD->MMC_CSD.VDD_R_CURR_MAX));
1159         CARD_SDIO_PRINT(("VDD_W_CURR_MIN\t\t  = 0x%x", CSD->MMC_CSD.VDD_W_CURR_MIN));
1160         CARD_SDIO_PRINT(("VDD_W_CURR_MAX\t\t  = 0x%x", CSD->MMC_CSD.VDD_W_CURR_MAX));
1161         CARD_SDIO_PRINT(("C_SIZE_MULT\t\t  = 0x%x", CSD->MMC_CSD.C_SIZE_MULT));
1162         CARD_SDIO_PRINT(("ERASE_GRP_SIZE\t\t  = 0x%x", CSD->MMC_CSD.ERASE_GRP_SIZE));
1163         CARD_SDIO_PRINT(("ERASE_GRP_MULT\t\t  = 0x%x", CSD->MMC_CSD.ERASE_GRP_MULT));
1164         CARD_SDIO_PRINT(("WP_GRP_SIZE\t\t  = 0x%x", CSD->MMC_CSD.WP_GRP_SIZE));
1165         CARD_SDIO_PRINT(("WP_GRP_ENABLE\t\t  = 0x%x", CSD->MMC_CSD.WP_GRP_ENABLE));
1166         CARD_SDIO_PRINT(("DEFAULT_ECC\t\t  = 0x%x", CSD->MMC_CSD.DEFAULT_ECC));
1167         CARD_SDIO_PRINT(("R2W_FACTOR\t\t  = 0x%x", CSD->MMC_CSD.R2W_FACTOR));
1168         CARD_SDIO_PRINT(("WRITE_BL_LEN\t\t  = 0x%x", CSD->MMC_CSD.WRITE_BL_LEN));
1169         CARD_SDIO_PRINT(("WRITE_BL_PARTIAL\t  = 0x%x", CSD->MMC_CSD.WRITE_BL_PARTIAL));
1170         CARD_SDIO_PRINT(("reserved3\t\t  = 0x%x", CSD->MMC_CSD.reserved3));
1171         CARD_SDIO_PRINT(("CONTENT_PROT_APP\t  = 0x%x", CSD->MMC_CSD.CONTENT_PROT_APP));
1172         CARD_SDIO_PRINT(("----RW bit---"));
1173         CARD_SDIO_PRINT(("FILE_FORMAT_GRP\t\t  = 0x%x", CSD->MMC_CSD.FILE_FORMAT_GRP));
1174         CARD_SDIO_PRINT(("COPY\t\t\t  = 0x%x", CSD->MMC_CSD.COPY));
1175         CARD_SDIO_PRINT(("PERM_WRITE_PROTECT\t  = 0x%x", CSD->MMC_CSD.PERM_WRITE_PROTECT));
1176         CARD_SDIO_PRINT(("TMP_WRITE_PROTECT\t  = 0x%x", CSD->MMC_CSD.TMP_WRITE_PROTECT));
1177         CARD_SDIO_PRINT(("FILE_FORMAT\t\t  = 0x%x", CSD->MMC_CSD.FILE_FORMAT));
1178         CARD_SDIO_PRINT(("ECC\t\t\t  = 0x%x", CSD->MMC_CSD.ECC));
1179         //              CARD_SDIO_PRINT(("CRC\t\t\t  = 0x%x",CSD->MMC_CSD.CRC));
1180         //              CARD_SDIO_PRINT(("LastBit\t\t\t  = 0x%x",CSD->MMC_CSD.LastBit));
1181
1182     }
1183     else
1184     {
1185         CARD_SDIO_ASSERT(0);
1186     }
1187
1188
1189     return TRUE;
1190 }
1191 #endif
1192 /*****************************************************************************/
1193 //  Description:  Read EXT CSD register and analyze it
1194 //  Author: Jason.wu
1195 //  Param
1196 //              cardHandle: the handle returned by CARD_SDIO_Open
1197 //              CSD: CSD data will be stored in this place
1198 //  Return:
1199 //              TRUE: success
1200 //              FALSE: fail
1201 //  Note:
1202 /*****************************************************************************/
1203 LOCAL BOOLEAN CARD_SDIO_ReadExtCSD(CARD_SDIO_HANDLE cardHandle)
1204 {
1205           uint8 rspBuf[16];
1206
1207         uint32 argument = 0;
1208          CARD_DATA_PARAM_T data;
1209
1210         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1211         cardHandle->CCC = 0;
1212
1213          data.blkLen = 512;
1214         data.blkNum = 1;
1215         data.databuf = s_extcsdbuf;
1216         data.direction = SDIO_DMA_IN;
1217         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD8_SEND_IF_COND,argument,&data,rspBuf))
1218         {
1219                 return FALSE;
1220         }
1221
1222         return TRUE;
1223 }
1224
1225
1226 #define CID_BYTE_SIZE   16
1227 unsigned char g_regCID[CID_BYTE_SIZE];
1228
1229 unsigned char *get_global_cid(void)
1230 {
1231         return g_regCID;
1232 }
1233
1234 /*****************************************************************************/
1235 //  Description:  Read CID register and analyze it
1236 //  Author: Jason.wu
1237 //  Param
1238 //              cardHandle: the handle returned by CARD_SDIO_Open
1239 //              CID: CID data will be stored in this place
1240 //  Return:
1241 //              TRUE: success
1242 //              FALSE: fail
1243 //  Note:
1244 /*****************************************************************************/
1245 uint8 CARD_SDIO_ReadCID(CARD_SDIO_HANDLE cardHandle,CARD_CID_T* CID)
1246 {
1247         uint8 rspBuf[16];
1248
1249         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1250
1251         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD2_ALL_SEND_CID,0,NULL,rspBuf))
1252         {
1253                 return 0;
1254         }
1255
1256         if(CARD_MMC_441_STANDARD == cardHandle->vertion)
1257         {
1258                 _MMC_CID_Analyze(rspBuf,&CID->MMC_CID);
1259                 CARD_SDIO_PRINT(("-----MMC CID value---\r\n"));
1260                 CARD_SDIO_PRINT(("MID\t\t = 0x%x\r\n",CID->MMC_CID.MID));
1261                 CARD_SDIO_PRINT(("OID\t\t = 0x%x\r\n",CID->MMC_CID.OID));
1262                 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]));
1263                 CARD_SDIO_PRINT(("PRV\t\t = 0x%x\r\n",CID->MMC_CID.PRV));
1264                 CARD_SDIO_PRINT(("PSN\t\t = 0x%x\r\n",CID->MMC_CID.PSN));
1265                 CARD_SDIO_PRINT(("MDT\t\t = 0x%x\r\n",CID->MMC_CID.MDT));
1266
1267                 memcpy(g_regCID, rspBuf, CID_BYTE_SIZE);
1268         }
1269         else
1270         {
1271                 CARD_SDIO_ASSERT(0);    /*assert verified*/
1272         }
1273
1274         return 1;
1275 }
1276
1277 /*****************************************************************************/
1278 //  Description:  Set relate address to card ,this address is used to select card
1279 //  Author: Jason.wu
1280 //  Param
1281 //              cardHandle: the handle returned by CARD_SDIO_Open
1282 //              RCA: new relative address
1283 //  Return:
1284 //              TRUE: success
1285 //              FALSE: fail
1286 //  Note:
1287 /*****************************************************************************/
1288 LOCAL BOOLEAN CARD_SDIO_SetRCA(CARD_SDIO_HANDLE cardHandle,uint16 RCA)
1289 {
1290         uint8 rspBuf[16];
1291         uint32 argument = 0;
1292
1293         if(CARD_MMC_331 != cardHandle->vertion)
1294         {
1295         // only MMC card can set RCA
1296                 return FALSE;
1297         }
1298
1299         argument = RCA;
1300         argument = argument<<16;
1301
1302         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1303
1304         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD3_SET_RELATIVE_ADDR,argument,NULL,rspBuf))
1305         {
1306                 return FALSE;
1307         }
1308
1309         return TRUE;
1310
1311 }
1312
1313 /*****************************************************************************/
1314 //  Description:  Get relate address from card ,this address is used to select card
1315 //  Author: Jason.wu
1316 //  Param
1317 //              cardHandle: the handle returned by CARD_SDIO_Open
1318 //              RCA: relative address will stored in this place
1319 //  Return:
1320 //              TRUE: success
1321 //              FALSE: fail
1322 //  Note:
1323 /*****************************************************************************/
1324 LOCAL BOOLEAN CARD_SDIO_ReadRCA(CARD_SDIO_HANDLE cardHandle,uint16*RCA)
1325 {
1326         uint8 rspBuf[16];
1327
1328         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1329
1330
1331         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD3_SEND_RELATIVE_ADDR,1<<16,NULL,rspBuf))
1332         {
1333                 return FALSE;
1334         }
1335
1336         *RCA = 1;
1337         return TRUE;
1338 }
1339 #if defined( CONFIG_SC8830 ) || defined(CONFIG_SC9630)
1340 LOCAL BOOLEAN SDCARD_SDIO_ReadRCA(CARD_SDIO_HANDLE cardHandle,uint16*RCA)
1341 {
1342         uint8  rspBuf[16];
1343         uint16 tmpRCA;
1344
1345         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1346
1347
1348         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD3_SEND_RELATIVE_ADDR,1<<16,NULL,rspBuf))
1349         {
1350                 return FALSE;
1351         }
1352     tmpRCA = 0;
1353     tmpRCA = rspBuf[0];
1354     tmpRCA = tmpRCA << 8;
1355     tmpRCA |= rspBuf[1];
1356
1357     *RCA = tmpRCA;
1358
1359         return TRUE;
1360 }
1361 #endif
1362
1363
1364 //-----------------------------------------------------------------------------------
1365 //      Before operate card ,we must active card first,this function is used to active card
1366 //-----------------------------------------------------------------------------------
1367 LOCAL BOOLEAN _SelectCard(CARD_SDIO_HANDLE cardHandle)
1368 {
1369         uint8 rspBuf[16];
1370         uint16 RCA = cardHandle->RCA;
1371         uint32 argument = 0;
1372
1373         argument = RCA;
1374         argument = argument<<16;
1375
1376         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD7_SELECT_DESELECT_CARD,argument,NULL,rspBuf))
1377         {
1378                 return FALSE;
1379         }
1380
1381         return TRUE;
1382 }
1383
1384 LOCAL BOOLEAN MMC_SWITCH(CARD_SDIO_HANDLE cardHandle, uint8 index, uint8 value)
1385 {
1386         uint8 rspBuf[16];
1387         uint32 argument = 0;
1388
1389         argument = CMD6_ACCESS_MODE_WRITE_BYTE | CMD6_CMD_SET;
1390         argument |= index<<CMD6_BIT_MODE_OFFSET_INDEX;
1391         argument |= value<<CMD6_BIT_MODE_OFFSET_VALUE;
1392
1393
1394         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD6_SET_EXT_CSD,argument,NULL,rspBuf))
1395         {
1396                 return FALSE;
1397         }
1398
1399         return TRUE;
1400 }
1401
1402 BOOLEAN CARD_SDIO_Select_CurPartition(CARD_SDIO_HANDLE cardHandle, CARD_EMMC_PARTITION_TPYE cardPartiton)
1403 {
1404         uint8 rspBuf[16];
1405         uint32 argument = 0;
1406
1407         argument = CMD6_ACCESS_MODE_WRITE_BYTE | ( EXT_CSD_PARTITION_CFG_INDEX<<CMD6_BIT_MODE_OFFSET_INDEX & CMD6_BIT_MODE_MASK_INDEX) | CMD6_CMD_SET;
1408
1409         switch(cardPartiton)
1410         {
1411                 case PARTITION_USER:
1412                         argument |= (PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT1 |PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_USER)<<CMD6_BIT_MODE_OFFSET_VALUE;
1413                         break;
1414
1415                 case PARTITION_BOOT1:
1416                         argument |= (PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT1 |PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_BOOT1)<<CMD6_BIT_MODE_OFFSET_VALUE;
1417                         break;
1418
1419                 case PARTITION_BOOT2:
1420                         argument |= (PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT1 |PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_BOOT2)<<CMD6_BIT_MODE_OFFSET_VALUE;
1421                         break;
1422
1423                 case PARTITION_RPMB:
1424                 case PARTITION_GENERAL_P1:
1425                 case PARTITION_GENERAL_P2:
1426                 case PARTITION_GENERAL_P3:
1427                 case PARTITION_GENERAL_P4:
1428                         CARD_SDIO_ASSERT(0);    //if want to support RPMB or GENERAL Partiton, need add code
1429                         break;
1430                 default:
1431                         CARD_SDIO_ASSERT(0);    /*assert verified*/
1432                         break;
1433
1434         }
1435
1436         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD6_SET_EXT_CSD,argument,NULL,rspBuf))
1437         {
1438                 return FALSE;
1439         }
1440
1441         cardHandle->Cur_Partition = cardPartiton;
1442         return TRUE;
1443
1444 }
1445
1446 //-----------------------------------------------------------------------------------
1447 //      Set data bus width of card
1448 //-----------------------------------------------------------------------------------
1449 LOCAL BOOLEAN _SetBusWidth(CARD_SDIO_HANDLE cardHandle,CARD_BUS_WIDTH_E width)
1450 {
1451         uint8 rspBuf[16];
1452         uint32 argument = 0;
1453
1454         argument = CMD6_ACCESS_MODE_WRITE_BYTE | ( EXT_CSD_BUS_WIDTH_INDEX<<CMD6_BIT_MODE_OFFSET_INDEX & CMD6_BIT_MODE_MASK_INDEX) ;
1455
1456         switch(width)
1457         {
1458                 case CARD_WIDTH_1_BIT:
1459                 {
1460                         argument |= EXT_CSD_CARD_WIDTH_1_BIT<<CMD6_BIT_MODE_OFFSET_VALUE;
1461                 }
1462                 break;
1463
1464                 case CARD_WIDTH_4_BIT:
1465                 {
1466                         argument |=EXT_CSD_CARD_WIDTH_4_BIT<<CMD6_BIT_MODE_OFFSET_VALUE;
1467                 }
1468                 break;
1469                 case CARD_WIDTH_8_BIT:
1470                 {
1471                         argument |=EXT_CSD_CARD_WIDTH_8_BIT<<CMD6_BIT_MODE_OFFSET_VALUE;
1472                 }
1473                 break;
1474
1475                 default:
1476                 {
1477                         CARD_SDIO_ASSERT(0);    /*assert verified*/
1478                 }
1479                 break;
1480         }
1481         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD6_SET_EXT_CSD,argument,NULL,rspBuf))
1482         {
1483                 return FALSE;
1484         }
1485
1486         switch(width)
1487         {
1488                 case CARD_WIDTH_1_BIT:
1489                 {
1490                         SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd,SDIO_CARD_PAL_1_BIT);
1491                 }
1492                 break;
1493
1494                 case CARD_WIDTH_4_BIT:
1495                 {
1496                         SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd,SDIO_CARD_PAL_4_BIT);
1497                 }
1498                 break;
1499 #if defined (CONFIG_SC8825) || defined(CONFIG_SC7710G2) || defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
1500                 case CARD_WIDTH_8_BIT:
1501                 {
1502                         SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd,SDIO_CARD_PAL_8_BIT);
1503                 }
1504                 break;
1505 #endif
1506                 default:
1507                 {
1508                         CARD_SDIO_ASSERT(0);    /*assert verified*/
1509                 }
1510                 break;
1511         }
1512         cardHandle->bus_width = width;
1513
1514         return TRUE;
1515 }
1516
1517 /*****************************************************************************/
1518 //  Description:  Set block length of card.  the data will be transmited in block unit
1519 //  Author: Jason.wu
1520 //  Param
1521 //              cardHandle: the handle returned by CARD_SDIO_Open
1522 //              length: block length
1523 //  Return:
1524 //              TRUE: success
1525 //              FALSE: fail
1526 //  Note:
1527 /*****************************************************************************/
1528 PUBLIC BOOLEAN CARD_SDIO_SetBlockLength(CARD_SDIO_HANDLE cardHandle,uint32 length)
1529 {
1530         uint8 rspBuf[16];
1531
1532         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1533
1534         if((CARD_SD_V2_0_HIGHCAP == cardHandle->vertion)&&(512 != length))
1535         {
1536                 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));
1537                 return FALSE;
1538         }
1539         if(length == cardHandle->BlockLen)
1540         {
1541                 return TRUE;
1542         }
1543         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD16_SET_BLOCKLEN,length,NULL,rspBuf))
1544         {
1545                 return FALSE;
1546         }
1547
1548         cardHandle->BlockLen = length;
1549
1550         return TRUE;
1551 }
1552
1553
1554
1555 /*
1556
1557 */
1558
1559
1560 typedef struct
1561 {
1562         uint16  currentVal;
1563         uint16  grp6Supported;
1564         uint16  grp5Supported;
1565         uint16  grp4Supported;
1566         uint16  grp3Supported;
1567         uint16  grp2Supported;
1568         uint16  grp1Supported;
1569
1570         uint8   grp6SwitchResult;
1571         uint8   grp5SwitchResult;
1572         uint8   grp4SwitchResult;
1573         uint8   grp3SwitchResult;
1574         uint8   grp2SwitchResult;
1575         uint8   grp1SwitchResult;
1576
1577         uint8   version;
1578
1579         uint16  grp6BusyStatus;
1580         uint16  grp5BusyStatus;
1581         uint16  grp4BusyStatus;
1582         uint16  grp3BusyStatus;
1583         uint16  grp2BusyStatus;
1584         uint16  grp1BusyStatus;
1585
1586 }CARD_CMD6_STATUS_T;
1587
1588
1589 LOCAL void __maybe_unused _CMD6_Response_Analyze(uint8* resBuf,CARD_CMD6_STATUS_T* cmdStatus)
1590 {
1591         cmdStatus->currentVal           = ((resBuf[0]<<8)|(resBuf[1]));
1592         cmdStatus->grp6Supported        = ((resBuf[2]<<8)|(resBuf[3]));
1593         cmdStatus->grp5Supported        = ((resBuf[4]<<8)|(resBuf[5]));
1594         cmdStatus->grp4Supported        = ((resBuf[6]<<8)|(resBuf[7]));
1595         cmdStatus->grp3Supported        = ((resBuf[8]<<8)|(resBuf[9]));
1596         cmdStatus->grp2Supported        = ((resBuf[10]<<8)|(resBuf[11]));
1597         cmdStatus->grp1Supported        = ((resBuf[12]<<8)|(resBuf[13]));
1598
1599         cmdStatus->grp6SwitchResult     = ((resBuf[14]&0xF0)>>4);
1600         cmdStatus->grp5SwitchResult     = (resBuf[14]&0x0F);
1601         cmdStatus->grp4SwitchResult     = ((resBuf[15]&0xF0)>>4);
1602         cmdStatus->grp3SwitchResult     = (resBuf[15]&0x0F);
1603         cmdStatus->grp2SwitchResult     = ((resBuf[16]&0xF0)>>4);
1604         cmdStatus->grp1SwitchResult     = (resBuf[16]&0x0F);
1605
1606         cmdStatus->version              = resBuf[17];
1607
1608         cmdStatus->grp6BusyStatus       = ((resBuf[18]<<8)|(resBuf[19]));
1609         cmdStatus->grp5BusyStatus       = ((resBuf[20]<<8)|(resBuf[21]));
1610         cmdStatus->grp4BusyStatus       = ((resBuf[22]<<8)|(resBuf[23]));
1611         cmdStatus->grp3BusyStatus       = ((resBuf[24]<<8)|(resBuf[25]));
1612         cmdStatus->grp2BusyStatus       = ((resBuf[26]<<8)|(resBuf[27]));
1613         cmdStatus->grp1BusyStatus       = ((resBuf[28]<<8)|(resBuf[29]));
1614
1615         CARD_SDIO_PRINT(("currentVal = 0x%x",cmdStatus->currentVal));
1616
1617         CARD_SDIO_PRINT(("grp6Supported = 0x%x",cmdStatus->grp6Supported));
1618         CARD_SDIO_PRINT(("grp5Supported = 0x%x",cmdStatus->grp5Supported));
1619         CARD_SDIO_PRINT(("grp4Supported = 0x%x",cmdStatus->grp4Supported));
1620         CARD_SDIO_PRINT(("grp3Supported = 0x%x",cmdStatus->grp3Supported));
1621         CARD_SDIO_PRINT(("grp2Supported = 0x%x",cmdStatus->grp2Supported));
1622         CARD_SDIO_PRINT(("grp1Supported = 0x%x",cmdStatus->grp1Supported));
1623
1624         CARD_SDIO_PRINT(("grp6SwitchResult = 0x%x",cmdStatus->grp6SwitchResult));
1625         CARD_SDIO_PRINT(("grp5SwitchResult = 0x%x",cmdStatus->grp5SwitchResult));
1626         CARD_SDIO_PRINT(("grp4SwitchResult = 0x%x",cmdStatus->grp4SwitchResult));
1627         CARD_SDIO_PRINT(("grp3SwitchResult = 0x%x",cmdStatus->grp3SwitchResult));
1628         CARD_SDIO_PRINT(("grp2SwitchResult = 0x%x",cmdStatus->grp2SwitchResult));
1629         CARD_SDIO_PRINT(("grp1SwitchResult = 0x%x",cmdStatus->grp1SwitchResult));
1630
1631         CARD_SDIO_PRINT(("status version = 0x%x",cmdStatus->version));
1632
1633         CARD_SDIO_PRINT(("grp6BusyStatus = 0x%x",cmdStatus->grp6BusyStatus));
1634         CARD_SDIO_PRINT(("grp5BusyStatus = 0x%x",cmdStatus->grp5BusyStatus));
1635         CARD_SDIO_PRINT(("grp4BusyStatus = 0x%x",cmdStatus->grp4BusyStatus));
1636         CARD_SDIO_PRINT(("grp3BusyStatus = 0x%x",cmdStatus->grp3BusyStatus));
1637         CARD_SDIO_PRINT(("grp2BusyStatus = 0x%x",cmdStatus->grp2BusyStatus));
1638         CARD_SDIO_PRINT(("grp1BusyStatus = 0x%x",cmdStatus->grp1BusyStatus));
1639
1640         return;
1641 }
1642
1643
1644 #define SECTOR_MODE 0x40000000
1645 #define BYTE_MODE   0x00000000
1646
1647 PUBLIC BOOLEAN CARD_SDIO_InitCard(CARD_SDIO_HANDLE cardHandle, CARD_SPEED_MODE speedmode)
1648 {
1649         uint8 rspBuf[16];
1650         uint32 pre_tick, cur_tick;
1651         CARD_CSD_T CSD;
1652         CARD_BUS_WIDTH_E busWidth = CARD_WIDTH_1_BIT;
1653         uint16 RCA;
1654
1655         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1656
1657 //      CARD_SDIO_PwrCtl(cardHandle,TRUE);
1658         cardHandle->bus_width = CARD_WIDTH_1_BIT;
1659         cardHandle->BlockLen = 0;
1660         cardHandle->vertion = CARD_V_UNKONWN;
1661         cardHandle->Cur_Partition =  PARTITION_MAX;
1662
1663         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD0_GO_IDLE_STATE,0,NULL,rspBuf))
1664         {
1665                 return FALSE;
1666         }
1667 //Now the card is in Idle State
1668     if(CARD_V_UNKONWN== cardHandle->vertion)
1669     {
1670            pre_tick = SCI_GetTickCount(); /*set start tick value*/
1671         do
1672         {
1673                 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD1_SEND_OP_COND,0x00FF8000 | SECTOR_MODE,NULL,rspBuf))
1674                 {
1675                         //return FALSE;
1676                 }
1677                   //break;
1678                 if(0 != (rspBuf[0]&BIT_7))
1679                 {
1680                         cardHandle->vertion = CARD_MMC_441_STANDARD;
1681                         break;
1682                 }
1683
1684                 cur_tick = SCI_GetTickCount();
1685                 if(CARD_CMD_MAX_TIME <  (cur_tick - pre_tick))
1686                 {
1687                         /*cmd time out, return false*/
1688                         return FALSE;
1689                 }
1690
1691         }
1692         while(1); /*lint !e506*/
1693     }
1694
1695 // Now SD is in Ready State
1696     if(1 != CARD_SDIO_ReadCID(cardHandle,&g_CID))
1697         {
1698                 return FALSE;
1699         }
1700 // Now SD is in Identification State
1701     if(FALSE == CARD_SDIO_ReadRCA(cardHandle,&RCA))
1702     {
1703         return FALSE;
1704     }
1705     cardHandle->RCA = 1;
1706     if(FALSE == CARD_SDIO_ReadCSD(cardHandle,&CSD))
1707         {
1708                 return FALSE;
1709         }
1710      if(!(CARD_MMC_441_STANDARD == cardHandle->vertion))
1711         {
1712                 return FALSE;
1713         }
1714         if(0xFFF != CSD.MMC_CSD.C_SIZE)
1715         {
1716                 cardHandle->GrpSize = (CSD.MMC_CSD.ERASE_GRP_SIZE+1)*(CSD.MMC_CSD.ERASE_GRP_MULT+1)*(1 << CSD.MMC_CSD.WRITE_BL_LEN);
1717                 cardHandle->Nac_Max = (uint32)((((CSD.MMC_CSD.TAAC*cardHandle->ClockRate) + (100*CSD.MMC_CSD.NSAC))*10) / 8);
1718                 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
1719
1720         }
1721         else
1722         {
1723                 cardHandle->vertion = CARD_MMC_441_HIGHCAP;
1724         }
1725
1726         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1727         {
1728                 return FALSE;
1729         }
1730
1731         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD7_SELECT_DESELECT_CARD,  1<<16,NULL,rspBuf))
1732            {
1733                    return FALSE;
1734            }
1735          if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1736         {
1737                 return FALSE;
1738         }
1739
1740        //get card  Capacity and RPMB Capacity
1741        //(void)memset(s_extcsdbuf, 0x0, 512);
1742        CARD_SDIO_ReadExtCSD(cardHandle);
1743       if(CARD_MMC_441_HIGHCAP == cardHandle->vertion)
1744         {
1745         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
1746         }
1747         cardHandle->Rpmb_Capacity = s_extcsdbuf[168]*256; //128/512 ==256 ,unit is 512 byte
1748         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1749         {
1750                 return FALSE;
1751         }
1752
1753         //get Boot1 Capacity
1754         CARD_SDIO_Select_CurPartition(cardHandle, PARTITION_BOOT1);
1755         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1756                   {
1757                           return FALSE;
1758                   }
1759         CARD_SDIO_ReadExtCSD(cardHandle);
1760         cardHandle->Boot1_Capacity = s_extcsdbuf[226]*256; //128/512 ==256 ,unit is 512 byte
1761          if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1762          {
1763                  return FALSE;
1764          }
1765
1766          //get Boot2 Capacity
1767         CARD_SDIO_Select_CurPartition(cardHandle, PARTITION_BOOT2);
1768         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1769         {
1770                 return FALSE;
1771          }
1772         CARD_SDIO_ReadExtCSD(cardHandle);
1773         cardHandle->Boot2_Capacity = s_extcsdbuf[226]*256; //128/512 ==256 ,unit is 512 byte
1774         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1775         {
1776                 return FALSE;
1777         }
1778
1779         MMC_SWITCH(cardHandle, EXT_CSD_HS_TIMING_INDEX, 1);
1780         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1781         {
1782                 return FALSE;
1783         }
1784 #if defined (CONFIG_SC8825) || defined(CONFIG_SC7710G2) ||defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
1785         SDIO_Card_Pal_DisSdClk(cardHandle->sdioPalHd);
1786         SDIO_Card_Pal_SetSpeedMode(cardHandle->sdioPalHd, EMMC_SPEED_SDR25);
1787 #if defined(CONFIG_FPGA)
1788         SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd, SDIO_CARD_PAL_2MHz);
1789 #else
1790         SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd, SDIO_CARD_PAL_50MHz);
1791 #endif
1792 #else
1793         SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd,SDIO_CARD_PAL_25MHz);
1794 #endif
1795 #if defined (CONFIG_SC8825) || defined(CONFIG_SC7710G2) || defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
1796         busWidth = CARD_WIDTH_8_BIT;
1797 #else
1798         busWidth = CARD_WIDTH_4_BIT;
1799 #endif
1800         if(FALSE == _SetBusWidth(cardHandle,busWidth))
1801         {
1802                 return FALSE;
1803         }
1804         if(FALSE == CARD_SDIO_SetBlockLength(cardHandle,DEFAULT_CARD_BLOCKLEN))
1805         {
1806                 return FALSE;
1807         }
1808
1809     #if 0
1810         uint16 i, j;
1811         for(i=0; i<512; i++)
1812                 s_sendbuf[i] = 0x1f;
1813         CARD_SDIO_WriteSingleBlock(cardHandle, 0, (uint8*)s_sendbuf);
1814         for(i=0; i<512; i++)
1815                 s_sendbuf[i] = 0x5a;
1816         CARD_SDIO_WriteSingleBlock(cardHandle, 1, (uint8*)s_sendbuf);
1817 #endif
1818          /*
1819         CARD_SDIO_ReadSingleBlock(cardHandle, 0, (uint8*)s_receivebuf1);
1820         CARD_SDIO_ReadSingleBlock(cardHandle, 1, (uint8*)s_receivebuf2);
1821
1822         (void)memset((uint8*)0x2000000, 0x0, 0x100000);
1823         (void)memset((uint8*)0x3000000, 0x0, 0x100000);
1824          CARD_SDIO_WriteMultiBlock(cardHandle, 0, 50, (uint8*)0x2000000);
1825
1826          CARD_SDIO_ReadMultiBlock(cardHandle, 0, 50, (uint8*)0x3000000);
1827
1828         {
1829             uint32 argument = 0;
1830             argument = CMD6_ACCESS_MODE_WRITE_BYTE | ( 162<<CMD6_BIT_MODE_OFFSET_INDEX & CMD6_BIT_MODE_MASK_INDEX) | CMD6_CMD_SET |(1<<8);
1831             if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD6_SET_EXT_CSD,argument,NULL,rspBuf))
1832             {
1833                 return FALSE;
1834             }
1835             if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1836             {
1837                 return FALSE;
1838             }
1839         }
1840
1841          CARD_SDIO_Select_CurPartition(cardHandle, PARTITION_BOOT2);
1842
1843          if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1844          {
1845                  return FALSE;
1846          }
1847
1848           CARD_SDIO_ReadSingleBlock(cardHandle, 0, (uint8*)s_receivebuf1);
1849          CARD_SDIO_ReadSingleBlock(cardHandle, 1, (uint8*)s_receivebuf2);
1850
1851        */
1852
1853 //---
1854         return TRUE;
1855
1856 }
1857
1858
1859 #if defined CONFIG_SC8830 || defined(CONFIG_SC9630)
1860
1861 PUBLIC BOOLEAN SDSetBusWidth(CARD_SDIO_HANDLE cardHandle, CARD_BUS_WIDTH_E width)
1862 {
1863     uint8 rspBuf[16];
1864     uint16 RCA = cardHandle->RCA;
1865     uint32 argument = 0;
1866
1867
1868     if(width == cardHandle->bus_width)
1869     {
1870         return TRUE;
1871     }
1872
1873     argument = RCA;
1874     argument = argument << 16;
1875     if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_CMD55_APP_CMD, argument, NULL, rspBuf))
1876     {
1877         return FALSE;
1878     }
1879
1880     switch(width)
1881     {
1882     case CARD_WIDTH_1_BIT:
1883     {
1884         argument = 0;
1885     }
1886     break;
1887
1888     case CARD_WIDTH_4_BIT:
1889     {
1890         argument = 2;
1891     }
1892     break;
1893
1894     default:
1895     {
1896         CARD_SDIO_ASSERT(0);
1897     }
1898     break;
1899     }
1900     if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_ACMD6_SET_BUS_WIDTH, argument, NULL, rspBuf))
1901     {
1902         return FALSE;
1903     }
1904
1905     switch(width)
1906     {
1907     case CARD_WIDTH_1_BIT:
1908     {
1909         SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd, SDIO_CARD_PAL_1_BIT);
1910     }
1911     break;
1912
1913     case CARD_WIDTH_4_BIT:
1914     {
1915         SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd, SDIO_CARD_PAL_4_BIT);
1916     }
1917     break;
1918
1919     default:
1920     {
1921         CARD_SDIO_ASSERT(0);
1922     }
1923     break;
1924     }
1925     cardHandle->bus_width = width;
1926
1927     return TRUE;
1928 }
1929
1930 uint8 CARD_SDIO_getCID(unsigned int *uid)
1931 {
1932         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];
1933         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]);
1934         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);
1935         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;
1936
1937         return 1;
1938 }
1939
1940 /*****************************************************************************/
1941 //  Description:  Initialize card, change card from idle state to standy by state ,and get some information from card
1942 //  Author: Jason.wu
1943 //  Param
1944 //              cardHandle: the handle returned by CARD_SDIO_Open
1945 //  Return:
1946 //              TRUE: success
1947 //              FALSE: fail
1948 //  Note:
1949 /*****************************************************************************/
1950 PUBLIC BOOLEAN SDCARD_SDIO_InitCard(CARD_SDIO_HANDLE cardHandle, CARD_SPEED_MODE speedmode)
1951 {
1952         uint8 rspBuf[16];
1953         uint32 pre_tick, cur_tick,temp;
1954         CARD_CSD_T CSD;
1955         uint16 RCA;
1956         BOOLEAN vertion_flag; //TRUE: SD2.0 FALSE: SD1.x
1957         SDIO_CARD_PAL_ERROR_E errCode;
1958
1959         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1960
1961         cardHandle->bus_width = CARD_WIDTH_1_BIT;
1962         cardHandle->BlockLen = 0;
1963         cardHandle->vertion = CARD_V_UNKONWN;
1964 #if defined(CONFIG_SC8830)
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;
1967
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))
1971         {
1972                 return FALSE;
1973         }
1974
1975         *((volatile unsigned int *)(SPRD_PIN_PHYS+REG_PIN_SD0_D3)) = temp;
1976         udelay(5000);
1977 #else
1978         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD0_GO_IDLE_STATE,0,NULL,rspBuf))
1979         {
1980                 return FALSE;
1981         }
1982 #endif
1983 //Now the card is in Idle State
1984         vertion_flag = TRUE;
1985        pre_tick = SCI_GetTickCount();
1986         cur_tick = pre_tick;
1987         do
1988         {
1989                 if(CARD_CMD_MAX_TIME < (cur_tick - pre_tick))
1990                 {
1991                         return FALSE;
1992                 }
1993                 errCode = SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD8_SEND_IF_COND,0x000001AA,NULL,rspBuf);
1994                 if(SDIO_CARD_PAL_ERR_NONE != errCode)
1995                 {
1996                         if(0 != (errCode&SDIO_CARD_PAL_ERR_CMD_TIMEOUT))  //lint !e655
1997                         {
1998                                 //SD2.0 not support current voltage or it is SD1.x
1999                                 vertion_flag = FALSE;
2000                                 break;
2001                         }
2002                         else
2003                         {
2004                                 cur_tick = SCI_GetTickCount();
2005                                 continue;
2006                         }
2007                 }
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]))
2010                 {
2011                         //SD2.0 not support current voltage
2012                         CARD_SDIO_ASSERT(0);    /*assert verified*/
2013                         return FALSE;    /*lint !e527*/
2014                 }
2015                 cur_tick = SCI_GetTickCount();
2016         }
2017         while(0xAA != rspBuf[3]);       /*lint !e644 */
2018
2019         CARD_SDIO_PRINT(("SD20 vertion_flag = %x\r\n",vertion_flag));
2020
2021        pre_tick = SCI_GetTickCount(); /*set start tick value*/
2022         if(FALSE == vertion_flag)
2023         {
2024                 do
2025                 {
2026                         errCode = SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD55_APP_CMD,0,NULL,rspBuf);
2027                         if(SDIO_CARD_PAL_ERR_NONE != errCode)
2028                         {
2029                                 if(0 != (errCode&SDIO_CARD_PAL_ERR_CMD_TIMEOUT))  //lint !e655
2030                                 {
2031                                         //not SD1.x maybe it is MMC
2032                                         break;
2033                                 }
2034                                 else
2035                                 {
2036                                         return FALSE;
2037                                 }
2038                         }
2039
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)
2042                         {
2043                                 if(0 != (errCode&SDIO_CARD_PAL_ERR_CMD_TIMEOUT))  //lint !e655
2044                                 {
2045                                         //not SD1.x maybe it is MMC
2046                                         break;
2047                                 }
2048                                 else
2049                                 {
2050                                         return FALSE;
2051                                 }
2052                         }
2053                         //---
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))
2056                         {
2057                                 cardHandle->vertion = CARD_SD_V1_X;
2058                                 break;
2059                         }
2060
2061                         cur_tick = SCI_GetTickCount();
2062                         if(CARD_CMD_MAX_TIME < (cur_tick - pre_tick))
2063                         {
2064                                 /*cmd time out, return false*/
2065                                 return FALSE;
2066                         }
2067                 }
2068                 while(1); /*lint !e506*/
2069
2070                 //MMC_INIT
2071                 if(CARD_V_UNKONWN== cardHandle->vertion)
2072                 {
2073                        pre_tick = SCI_GetTickCount(); /*set start tick value*/
2074
2075                         do
2076                         {
2077                                 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD1_SEND_OP_COND,0x00FF8000,NULL,rspBuf))
2078                                 {
2079                                         return FALSE;
2080                                 }
2081                                 if(0 != (rspBuf[0]&BIT_7))
2082                                 {
2083                                         cardHandle->vertion = CARD_MMC_331;
2084                                         break;
2085                                 }
2086
2087                                 cur_tick = SCI_GetTickCount();
2088                                 if(CARD_CMD_MAX_TIME <  (cur_tick - pre_tick))
2089                                 {
2090                                         /*cmd time out, return false*/
2091                                         return FALSE;
2092                                 }
2093                         }
2094                         while(1); /*lint !e506*/
2095                 }
2096
2097
2098         }
2099         else
2100         {
2101                 do
2102                 {
2103                         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD55_APP_CMD,0,NULL,rspBuf))
2104                         {
2105                                 return FALSE;
2106                         }
2107
2108                         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD41_SD_SEND_OP_COND,0x40FF8000,NULL,rspBuf))
2109                         {
2110                                 return FALSE;
2111                         }
2112                         //---
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))
2115                         {
2116                                 if(0 != (rspBuf[0]&BIT_6))
2117                                 {
2118                                         cardHandle->vertion = CARD_SD_V2_0_HIGHCAP;
2119                                 }
2120                                 else
2121                                 {
2122                                         cardHandle->vertion = CARD_SD_V2_0_STANDARD;
2123                                 }
2124                                 break;
2125                         }
2126
2127                         cur_tick = SCI_GetTickCount();
2128                         if(CARD_CMD_MAX_TIME <  (cur_tick - pre_tick))
2129                         {
2130                                 /*cmd time out, return false*/
2131                                 return FALSE;
2132                         }
2133                 }
2134                 while(1); /*lint !e506*/
2135
2136         }
2137         if(CARD_V_UNKONWN == cardHandle->vertion)
2138         {
2139                 return FALSE;
2140         }
2141
2142 // Now SD is in Ready State
2143         if(FALSE == CARD_SDIO_ReadCID(cardHandle,&g_CID))
2144         {
2145                 return FALSE;
2146         }
2147 // Now SD is in Identification State
2148
2149         if(CARD_MMC_331 == cardHandle->vertion)
2150         {
2151                 if(FALSE == CARD_SDIO_SetRCA(cardHandle,cardHandle->RCA))
2152                 {
2153                         return FALSE;
2154                 }
2155         }
2156         else if(
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)
2161         )
2162         {
2163                 if(FALSE == SDCARD_SDIO_ReadRCA(cardHandle,&RCA))
2164                 {
2165                         printf("SDCARD_SDIO_ReadRCA failed!\r\n");
2166                         return FALSE;
2167                 }
2168                 cardHandle->RCA = RCA;
2169         }
2170         else
2171         {
2172                 CARD_SDIO_ASSERT(0);    /*assert verified*/
2173                 return FALSE;    /*lint !e527*/
2174         }
2175
2176 // Now SD is in Stand-by State
2177
2178         CARD_SDIO_PRINT(("SD20 type is %x",cardHandle->vertion));
2179
2180         if(FALSE == SDCARD_SDIO_ReadCSD(cardHandle,&CSD))
2181         {
2182                 printf("read csd failed!\r\n");
2183                 return FALSE;
2184         }
2185
2186         if(!(
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))
2190         ))
2191         {
2192                 printf("unkown sd type0!\r\n");
2193                 return FALSE;
2194         }
2195         if((CARD_SD_V1_X == cardHandle->vertion)||(CARD_SD_V2_0_STANDARD== cardHandle->vertion))
2196         {
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
2199         }
2200         else if(CARD_SD_V2_0_HIGHCAP== cardHandle->vertion)
2201         {
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
2204         }
2205         else if(CARD_MMC_331 == cardHandle->vertion)
2206         {
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
2210
2211         }
2212         else
2213         {
2214                 CARD_SDIO_ASSERT(0);    /*assert verified*/
2215                 printf("unkown sd type1!\r\n");
2216                 return FALSE;     /*lint !e527*/
2217         }
2218
2219         SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd,SDIO_CARD_PAL_50MHz);
2220         //SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd,SDIO_CARD_PAL_25MHz);
2221
2222         if(FALSE == _SelectCard(cardHandle))
2223         {
2224                 printf("select card failed!\r\n");
2225                 return FALSE;
2226         }
2227
2228         if(FALSE == SDSetBusWidth(cardHandle,CARD_WIDTH_4_BIT))
2229         {
2230                 printf("set bus width failed!\r\n");
2231                 return FALSE;
2232         }
2233
2234         if(FALSE == CARD_SDIO_SetBlockLength( cardHandle,DEFAULT_CARD_BLOCKLEN))
2235         {
2236                 printf("set block length failed!\r\n");
2237                 return FALSE;
2238         }
2239
2240         return TRUE;
2241 }
2242 #endif
2243
2244 //-----------------------------------------------------------------------------------
2245 //      Inquire Card whethe ready for data
2246 //-----------------------------------------------------------------------------------
2247 LOCAL BOOLEAN _IsCardReady(CARD_SDIO_HANDLE cardHandle)
2248 {
2249         uint32 pre_tick = 0, cur_tick = 0;
2250         uint8 rspBuf[16] = {0};
2251         uint16 RCA = cardHandle->RCA;
2252         uint32 argument = 0;
2253
2254         argument = RCA;
2255         argument = argument<<16;
2256         pre_tick = SCI_GetTickCount(); /*set start tick value*/
2257
2258         do
2259         {
2260                 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS,argument,NULL,rspBuf))
2261                 {
2262                         return FALSE;
2263                 }
2264
2265 //              CARD_SDIO_PRINT(("SD20 %x,%x,%x,%x",rspBuf[0],rspBuf[1],rspBuf[2],rspBuf[3]));
2266
2267                 if(0 != (rspBuf[2]&BIT_0))
2268                 {
2269                         return TRUE;
2270                 }
2271
2272                 cur_tick = SCI_GetTickCount();
2273                 if(CARD_CMD_MAX_TIME <  (cur_tick - pre_tick))
2274                 {
2275                         /*cmd time out, return false*/
2276                         CARD_SDIO_PRINT(("[Card_sdio] _IsCardReady timeout !"));
2277                         return FALSE;
2278                 }
2279         }
2280         while(1); /*lint !e506*/
2281
2282 }
2283
2284 /*****************************************************************************/
2285 //  Description:  Read single block data from card , unit is block
2286 //  Author: Jason.wu
2287 //  Param
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
2291 //  Return:
2292 //              TRUE: success
2293 //              FALSE: fail
2294 //  Note:
2295 /*****************************************************************************/
2296 PUBLIC BOOLEAN CARD_SDIO_ReadSingleBlock(CARD_EMMC_PARTITION_TPYE  cardPartiton, CARD_SDIO_HANDLE cardHandle,uint32 BlockId,uint8* buf)
2297 {
2298         uint8 rspBuf[16];
2299         uint32 address = 0xFFFFFFFF;
2300         CARD_DATA_PARAM_T data;
2301
2302         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
2303
2304         if((CARD_MMC_441_STANDARD == cardHandle->vertion))
2305         {
2306                 address = BlockId*cardHandle->BlockLen;
2307         }
2308         else if(CARD_MMC_441_HIGHCAP== cardHandle->vertion)
2309         {
2310                 address = BlockId;
2311         }
2312         else
2313         {
2314                 CARD_SDIO_ASSERT(0);    /*assert verified*/
2315         }
2316
2317         if(FALSE == _IsCardReady(cardHandle))
2318         {
2319                 return FALSE;
2320         }
2321
2322         data.blkLen = cardHandle->BlockLen;
2323         data.blkNum = 1;
2324         data.databuf = buf;
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))
2327         {
2328                 return FALSE;
2329         }
2330
2331         return TRUE;
2332
2333 }
2334
2335 /*****************************************************************************/
2336 //  Description:  Read multi block data from card , unit is block
2337 //  Author: Jason.wu
2338 //  Param
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
2343 //  Return:
2344 //              TRUE: success
2345 //              FALSE: fail
2346 //  Note:
2347 /*****************************************************************************/
2348 PUBLIC BOOLEAN CARD_SDIO_ReadMultiBlock(CARD_EMMC_PARTITION_TPYE  cardPartiton, CARD_SDIO_HANDLE cardHandle,uint32 startBlock,uint32 num,uint8* buf)
2349 {
2350         uint8 rspBuf[16];
2351         uint32 address = 0xFFFFFFFF;
2352         CARD_DATA_PARAM_T data;
2353         uint32 argument = 0;
2354         CARD_DATA_PARAM_T *dataParam = NULL;
2355
2356         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
2357
2358         if((CARD_MMC_441_STANDARD == cardHandle->vertion))
2359         {
2360                 address = startBlock*cardHandle->BlockLen;
2361         }
2362
2363         else if(CARD_MMC_441_HIGHCAP== cardHandle->vertion)
2364         {
2365                 address = startBlock;
2366         }
2367         else
2368         {
2369                 CARD_SDIO_ASSERT(0);    /*assert verified*/
2370         }
2371
2372         if(FALSE == _IsCardReady(cardHandle))
2373         {
2374                 return FALSE;
2375         }
2376
2377         data.blkLen = cardHandle->BlockLen;
2378         data.blkNum = num;
2379         data.databuf = buf;
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))
2382         {
2383                 SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD12_STOP_TRANSMISSION,argument,dataParam,rspBuf);
2384                 return FALSE;
2385         }
2386         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD12_STOP_TRANSMISSION,argument,dataParam,rspBuf))
2387         {
2388                 return FALSE;
2389         }
2390         return TRUE;
2391
2392 }
2393
2394 /*****************************************************************************/
2395 //  Description:  Wrtie single block data to card , unit is block
2396 //  Author: Jason.wu
2397 //  Param
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
2401 //  Return:
2402 //              TRUE: success
2403 //              FALSE: fail
2404 //  Note:
2405 /*****************************************************************************/
2406 PUBLIC BOOLEAN CARD_SDIO_WriteSingleBlock(CARD_EMMC_PARTITION_TPYE  cardPartiton, CARD_SDIO_HANDLE cardHandle,uint32 BlockId,uint8* buf)
2407 {
2408         uint8 rspBuf[16];
2409         uint32 address = 0xFFFFFFFF;
2410         CARD_DATA_PARAM_T data;
2411
2412         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
2413
2414         if((CARD_MMC_441_STANDARD == cardHandle->vertion))
2415         {
2416                 address = BlockId*cardHandle->BlockLen;
2417         }
2418
2419         else if(CARD_MMC_441_HIGHCAP== cardHandle->vertion)
2420         {
2421                 address = BlockId;
2422         }
2423         else
2424         {
2425                 CARD_SDIO_ASSERT(0);    /*assert verified*/
2426         }
2427
2428         if(FALSE == _IsCardReady(cardHandle))
2429         {
2430                 return FALSE;
2431         }
2432
2433         data.blkLen = cardHandle->BlockLen;
2434         data.blkNum = 1;
2435         data.databuf = buf;
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))
2438         {
2439                 return FALSE;
2440         }
2441
2442         return TRUE;
2443
2444 }
2445
2446 /*****************************************************************************/
2447 //  Description:  Wrtie multi block data to card , unit is block
2448 //  Author: Jason.wu
2449 //  Param
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
2454 //  Return:
2455 //              TRUE: success
2456 //              FALSE: fail
2457 //  Note:
2458 /*****************************************************************************/
2459 PUBLIC BOOLEAN CARD_SDIO_WriteMultiBlock(CARD_EMMC_PARTITION_TPYE  cardPartiton, CARD_SDIO_HANDLE cardHandle,uint32 startBlock,uint32 num,uint8* buf)
2460 {
2461         uint8 rspBuf[16];
2462         uint32 address = 0xFFFFFFFF;
2463         CARD_DATA_PARAM_T data;
2464         uint32 argument = 0;
2465         CARD_DATA_PARAM_T *dataParam = NULL;
2466
2467         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
2468
2469         if((CARD_MMC_441_STANDARD == cardHandle->vertion))
2470         {
2471                 address = startBlock*cardHandle->BlockLen;
2472         }
2473
2474         else if(CARD_MMC_441_HIGHCAP== cardHandle->vertion)
2475         {
2476                 address = startBlock;
2477         }
2478         else
2479         {
2480                 CARD_SDIO_ASSERT(0);    /*assert verified*/
2481         }
2482
2483         if(FALSE == _IsCardReady(cardHandle))
2484         {
2485                 return FALSE;
2486         }
2487
2488         data.blkLen = cardHandle->BlockLen;
2489         data.blkNum = num;
2490         data.databuf = buf;
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))
2493         {
2494                 SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD12_STOP_TRANSMISSION,argument,dataParam,rspBuf);
2495                 return FALSE;
2496         }
2497         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD12_STOP_TRANSMISSION,argument,dataParam,rspBuf))
2498         {
2499                 return FALSE;
2500         }
2501
2502         return TRUE;
2503
2504 }
2505
2506
2507 //-----------------------------------------------------------------------------------
2508 //      Set  SD20 erase start address
2509 //-----------------------------------------------------------------------------------
2510 LOCAL BOOLEAN _SD20_SetEraseStart(CARD_SDIO_HANDLE cardHandle,uint32 startBlock)
2511 {
2512         uint8 rspBuf[16];
2513
2514         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD32_ERASE_WR_BLK_START,startBlock,NULL,rspBuf))
2515         {
2516                 return FALSE;
2517         }
2518
2519         return TRUE;
2520 }
2521
2522 //-----------------------------------------------------------------------------------
2523 //      Set SD20 erase end address
2524 //-----------------------------------------------------------------------------------
2525 LOCAL BOOLEAN _SD20_SetEraseEnd(CARD_SDIO_HANDLE cardHandle,uint32 endBlock)
2526 {
2527         uint8 rspBuf[16];
2528
2529         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD33_ERASE_WR_BLK_END,endBlock,NULL,rspBuf))
2530         {
2531                 return FALSE;
2532         }
2533
2534         return TRUE;
2535 }
2536
2537 //-----------------------------------------------------------------------------------
2538 //      Set MMC441 erase start address
2539 //-----------------------------------------------------------------------------------
2540 LOCAL BOOLEAN _MMC441_SetEraseStart(CARD_SDIO_HANDLE cardHandle,uint32 startBlock)
2541 {
2542         uint8 rspBuf[16];
2543
2544         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD35_ERASE_GROUP_START,startBlock,NULL,rspBuf))
2545         {
2546                 return FALSE;
2547         }
2548
2549         return TRUE;
2550 }
2551
2552 //-----------------------------------------------------------------------------------
2553 //      Set MMC441erase end address
2554 //-----------------------------------------------------------------------------------
2555 LOCAL BOOLEAN _MMC441_SetEraseEnd(CARD_SDIO_HANDLE cardHandle,uint32 endBlock)
2556 {
2557         uint8 rspBuf[16];
2558
2559         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD36_ERASE_GROUP_END,endBlock,NULL,rspBuf))
2560         {
2561                 return FALSE;
2562         }
2563
2564         return TRUE;
2565 }
2566 /*****************************************************************************/
2567 //  Description:  erase card
2568 //  Author: Jason.wu
2569 //  Param
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
2573 //  Return:
2574 //              TRUE: success
2575 //              FALSE: fail
2576 //  Note:
2577 /*****************************************************************************/
2578 PUBLIC BOOLEAN CARD_SDIO_Erase(CARD_SDIO_HANDLE cardHandle,uint32 startBlock,uint32 endBlock)
2579 {
2580         uint8 rspBuf[16];
2581         uint32 startAddress = 0xFFFFFFFF, endAddress = 0xFFFFFFFF;
2582
2583         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
2584
2585         if((CARD_SD_V2_0_STANDARD == cardHandle->vertion)
2586                         ||(CARD_SD_V1_X == cardHandle->vertion)
2587                         || (CARD_MMC_441_STANDARD == cardHandle->vertion))
2588         {
2589                 startAddress = startBlock*cardHandle->BlockLen;
2590                 endAddress = endBlock*cardHandle->BlockLen;
2591         }
2592         else if((CARD_MMC_441_HIGHCAP== cardHandle->vertion) || (CARD_SD_V2_0_HIGHCAP== cardHandle->vertion))
2593         {
2594                 startAddress = startBlock;
2595                 endAddress = endBlock;
2596         }
2597         else if(CARD_MMC_331 == cardHandle->vertion)
2598         {
2599                 return TRUE;
2600         }
2601         else
2602         {
2603                 CARD_SDIO_ASSERT(0);    /*assert verified*/
2604         }
2605
2606         if((CARD_MMC_441_HIGHCAP== cardHandle->vertion) || (CARD_MMC_441_STANDARD == cardHandle->vertion))
2607         {
2608 //set  MMC441start group Id
2609                 if(FALSE == _MMC441_SetEraseStart( cardHandle,startAddress))
2610                 {
2611                         return FALSE;
2612                 }
2613 //set MMC441 end group Id
2614                 if(FALSE == _MMC441_SetEraseEnd( cardHandle,endAddress))
2615                 {
2616                         return FALSE;
2617                 }
2618         }
2619         else
2620         {
2621 //set SD20 start group Id
2622                 if(FALSE == _SD20_SetEraseStart( cardHandle,startAddress))
2623                 {
2624                         return FALSE;
2625                 }
2626 //set SD20 end group Id
2627                 if(FALSE == _SD20_SetEraseEnd( cardHandle,endAddress))
2628                 {
2629                         return FALSE;
2630                 }
2631         }
2632 //send erase command
2633         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD38_ERASE,0,NULL,rspBuf))
2634         {
2635                 return FALSE;
2636         }
2637
2638         return TRUE;
2639  //--
2640 }
2641
2642 /*****************************************************************************/
2643 //  Description:  Get total block number of card ,block length is fix to 512 byte
2644 //  Author: Jason.wu
2645 //  Param
2646 //              cardHandle: the handle returned by CARD_SDIO_Open
2647 //  Return:
2648 //              uint32 value : total block num
2649 //  Note:
2650 /*****************************************************************************/
2651 PUBLIC uint32 CARD_SDIO_GetCapacity(CARD_SDIO_HANDLE cardHandle)
2652 {
2653         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
2654
2655         return cardHandle->Capacity;
2656 }
2657
2658 /*****************************************************************************/
2659 /*****************************************************************************/
2660 PUBLIC uint32 CARD_SDIO_BOOT_Enable(CARD_SDIO_HANDLE cardHandle)
2661 {
2662     return 0;
2663 }
2664
2665 PUBLIC BOOLEAN Emmc_Init()
2666 {
2667         uint32 ret = 0;
2668 //      LDO_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);
2671 #else
2672         emmc_handle = CARD_SDIO_Open(CARD_SDIO_SLOT_1);
2673 #endif
2674         //CARD_SDIO_PwrCtl(emmc_handle, FALSE);
2675         CARD_SDIO_PwrCtl(emmc_handle, TRUE);
2676         ret = CARD_SDIO_InitCard(emmc_handle, HIGH_SPEED_MODE);
2677
2678         return ret;
2679 }
2680
2681 #if defined CONFIG_SC8830 || defined(CONFIG_SC9630)
2682 LOCAL CARD_SDIO_HANDLE  sdcard_handle = NULL;
2683
2684 LOCAL BOOLEAN SDCARD_SDIO_WriteMultiBlock(CARD_SDIO_HANDLE cardHandle,uint32 startBlock,uint32 num,uint8* buf)
2685 {
2686         uint8 rspBuf[16];
2687         uint32 address  = 0xFFFFFFFF;
2688         CARD_DATA_PARAM_T data;
2689         uint32 argument = 0;
2690         CARD_DATA_PARAM_T *dataParam = NULL;
2691
2692         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
2693
2694         if((CARD_SD_V2_0_STANDARD == cardHandle->vertion) || (CARD_SD_V1_X == cardHandle->vertion) || (CARD_MMC_331 == cardHandle->vertion))
2695     {
2696         address = startBlock * cardHandle->BlockLen;
2697     }
2698     else if(CARD_SD_V2_0_HIGHCAP == cardHandle->vertion)
2699     {
2700         address = startBlock;
2701     }
2702     else
2703     {
2704         CARD_SDIO_ASSERT(0);
2705     }
2706
2707         data.blkLen = cardHandle->BlockLen;
2708         data.blkNum = num;
2709         data.databuf = buf;
2710         if (num == 1)
2711         {
2712                 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_CMD24_WRITE_BLOCK, address, &data, rspBuf))
2713                 {
2714                         return FALSE;
2715                 }
2716         }
2717         else
2718         {
2719                 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD25_WRITE_MULTIPLE_BLOCK,address,&data,rspBuf))
2720                 {
2721                         SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD12_STOP_TRANSMISSION,argument,dataParam,rspBuf);
2722                         return FALSE;
2723                 }
2724                 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD12_STOP_TRANSMISSION,argument,dataParam,rspBuf))
2725                 {
2726                         return FALSE;
2727                 }
2728         }
2729         return TRUE;
2730 }
2731
2732 PUBLIC BOOLEAN SDCARD_Write(uint32 startBlcok, uint32 blkCnt, uint8* buf)
2733 {
2734         return SDCARD_SDIO_WriteMultiBlock(sdcard_handle, startBlcok, blkCnt, buf);
2735 }
2736
2737 LOCAL BOOLEAN SDCARD_SDIO_ReadMultiBlock(CARD_SDIO_HANDLE cardHandle, uint32 startBlock, uint32 num, uint8 *buf)
2738 {
2739     uint8 rspBuf[16] = {0};
2740     uint32 address = 0;
2741     CARD_DATA_PARAM_T data = {0};
2742
2743     CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));
2744
2745     if((CARD_SD_V2_0_STANDARD == cardHandle->vertion) || (CARD_SD_V1_X == cardHandle->vertion) || (CARD_MMC_331 == cardHandle->vertion))
2746     {
2747         address = startBlock * cardHandle->BlockLen;
2748     }
2749     else if(CARD_SD_V2_0_HIGHCAP == cardHandle->vertion)
2750     {
2751         address = startBlock;
2752     }
2753     else
2754     {
2755         CARD_SDIO_ASSERT(0);
2756     }
2757
2758     data.blkLen = cardHandle->BlockLen;
2759     data.blkNum = num;
2760     data.databuf = buf;
2761         if (num == 1)
2762         {
2763             if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_CMD17_READ_SINGLE_BLOCK, address, &data, rspBuf))
2764             {
2765                 return FALSE;
2766             }
2767         }
2768         else
2769         {
2770             if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_CMD18_READ_MULTIPLE_BLOCK_AUT12, address, &data, rspBuf))
2771             {
2772                 return FALSE;
2773             }
2774         }
2775     return TRUE;
2776 }
2777
2778 PUBLIC BOOLEAN SDCARD_Read(uint32 startBlcok, uint32 blkCnt, uint8* buf)
2779 {
2780         return SDCARD_SDIO_ReadMultiBlock(sdcard_handle, startBlcok, blkCnt, buf);
2781 }
2782
2783 PUBLIC BOOLEAN SDCARD_Init(void)
2784 {
2785         sdcard_handle = CARD_SDIO_Open(CARD_SDIO_SLOT_6);
2786
2787         SDIO_Card_Pal_SetType(sdcard_handle->sdioPalHd, SDIO_CARD_PAL_TYPE_SD);
2788         CARD_SDIO_PwrCtl(sdcard_handle, FALSE);
2789         CARD_SDIO_PwrCtl(sdcard_handle, TRUE);
2790         return SDCARD_SDIO_InitCard(sdcard_handle, HIGH_SPEED_MODE);
2791 }
2792
2793 #endif
2794
2795 PUBLIC BOOLEAN SDCARD_PowerOn(void)
2796 {
2797         sdcard_handle = CARD_SDIO_Open(CARD_SDIO_SLOT_6);
2798         SDIO_Card_Pal_SetType(sdcard_handle->sdioPalHd, SDIO_CARD_PAL_TYPE_SD);
2799         CARD_SDIO_PwrCtl(sdcard_handle, FALSE);
2800         CARD_SDIO_PwrCtl(sdcard_handle, TRUE);
2801         return 1;
2802 }
2803
2804 PUBLIC BOOLEAN Emmc_Write(CARD_EMMC_PARTITION_TPYE  cardPartiton, uint32 startBlock,uint32 num,uint8* buf)
2805 {
2806         uint32 ret = 0;
2807                 uint8 rspBuf[16];
2808         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2809         {
2810                 return FALSE;
2811         }
2812         if(emmc_handle->Cur_Partition != cardPartiton){
2813                 CARD_SDIO_Select_CurPartition(emmc_handle,cardPartiton);
2814
2815          if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2816            {
2817                    return FALSE;
2818            }
2819         }
2820         if ( 1 == num )
2821           ret = CARD_SDIO_WriteSingleBlock(cardPartiton,emmc_handle, startBlock, buf);
2822         else
2823           ret = CARD_SDIO_WriteMultiBlock(cardPartiton,emmc_handle, startBlock, num, buf);
2824
2825          return ret;
2826
2827 }
2828
2829 PUBLIC BOOLEAN Emmc_Read(CARD_EMMC_PARTITION_TPYE  cardPartiton, uint32 startBlock,uint32 num,uint8* buf)
2830 {
2831         uint32 ret = 0;
2832                 uint8 rspBuf[16];
2833
2834          if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2835          {
2836                  return FALSE;
2837          }
2838          if(emmc_handle->Cur_Partition != cardPartiton){
2839                 CARD_SDIO_Select_CurPartition(emmc_handle,cardPartiton);
2840
2841                  if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2842                 {
2843                         return FALSE;
2844                 }
2845
2846          }
2847          if ( 1 == num )
2848          ret = CARD_SDIO_ReadSingleBlock(cardPartiton,emmc_handle, startBlock, buf);
2849         else
2850          ret = CARD_SDIO_ReadMultiBlock(cardPartiton,emmc_handle, startBlock, num, buf);
2851
2852         return ret;
2853
2854 }
2855
2856 PUBLIC BOOLEAN Emmc_Erase(CARD_EMMC_PARTITION_TPYE cardPartiton, uint32 startBlock,uint32 num)
2857 {
2858         uint32 ret = 0;
2859         uint8 rspBuf[16];
2860         uint32 endBlock = startBlock +num -1;
2861
2862          if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2863          {
2864                  return FALSE;
2865          }
2866          if(emmc_handle->Cur_Partition != cardPartiton){
2867                 CARD_SDIO_Select_CurPartition(emmc_handle,cardPartiton);
2868
2869                 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2870                 {
2871                         return FALSE;
2872                 }
2873
2874          }
2875
2876          ret = CARD_SDIO_Erase(emmc_handle,startBlock, endBlock);
2877
2878         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2879         {
2880                 return FALSE;
2881         }
2882
2883         return ret;
2884
2885 }
2886
2887 PUBLIC uint32 Emmc_GetCapacity(CARD_EMMC_PARTITION_TPYE cardPartiton)
2888 {
2889         switch(cardPartiton)
2890         {
2891                 case PARTITION_USER:
2892                         return emmc_handle->Capacity;
2893
2894                 case PARTITION_BOOT1:
2895                         return emmc_handle->Boot1_Capacity;
2896
2897                 case PARTITION_BOOT2:
2898                         return emmc_handle->Boot2_Capacity;
2899
2900                 default:
2901                         return 0;
2902         }
2903 }
2904
2905 PUBLIC void Emmc_DisSdClk()
2906 {
2907         SDIO_Card_Pal_DisSdClk(emmc_handle->sdioPalHd);
2908 }