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 "asm/arch/sci_types.h"
  21 #include "asm/arch/os_api.h"
  22 #include "card_sdio.h"
  23 #include "sdio_card_pal.h"
  24 #ifdef MBBMS_SUPPORT
  25 #include "sdua_config.h"
  26 #endif
  27
  28 #define CARD_SDIO_HIGHSPEED_SUPPORT
  29
  30 //#define CARD_SDIO_PRINT(x)
  31 #define CARD_SDIO_PRINT(x) SCI_TRACE_LOW x
  32 #define CARD_SDIO_ASSERT SCI_ASSERT
  33 #define DEFAULT_CARD_BLOCKLEN 512
  34 #define CARD_CMD_MAX_TIME 5000
  35
  36 typedef enum CARD_VERTION_E_TAG
  37 {
  38         CARD_V_UNKONWN,
  39         CARD_SD_V1_X,
  40         CARD_SD_V2_0_STANDARD,
  41         CARD_SD_V2_0_HIGHCAP,
  42         CARD_MMC_331,
  43         CARD_MMC_441_STANDARD,
  44         CARD_MMC_441_HIGHCAP
  45 }CARD_VERTION_E;
  46
  47
  48 /*****************************************************************************/
  49 //      The struct of Card IDentification (CID) register of MMC. please refer to <Multi media card System Specification version 3.31>
  50 /*****************************************************************************/
  51 typedef struct CARD_MMC_CID_STRUCT_TAG
  52 {
  53         uint8 MID;      // 8 bit        Manufacturer ID
  54         uint16 OID;     // 16 bit       OEM/Application ID
  55         uint8 PNM[6];   // 48 bit       Product name
  56         uint8 PRV;      // 8 bit        Product revision
  57         uint32 PSN;     // 32 bit       Product serial number
  58         uint8 MDT;      // 8bit Manufacturing date
  59 //      uint8 CRC;      // 8 bit
  60 //      uint8 lastBit;  // 1 bit :always 1
  61 }CARD_MMC_CID_T;
  62
  63 /*****************************************************************************/
  64 // The struct of Card-Specific Data register of MMC. please refer to <Multi media card System Specification version 3.31>
  65 /*****************************************************************************/
  66 typedef struct CARD_MMC_CSD_STRUCT_TAG
  67 {
  68 //R
  69         uint8 CSD_STRUCTURE;    // 2 bit
  70         uint8 SPEC_VERS;                        // 4 bit
  71         uint8 reserved1;                        // 2 bit
  72         uint8 TAAC;                             // 8 bit
  73         uint8 NSAC;                             // 8 bit
  74         uint8 TRAN_SPEED;               // 8 bit
  75         uint16 CCC;                             //12 bit
  76         uint8 READ_BL_LEN;              // 4 bit
  77         uint8 READ_BL_PARTIAL;  // 1 bit
  78         uint8 WRITE_BLK_MISALIGN;       // 1 bit
  79         uint8 READ_BLK_MISALIGN;        // 1 bit
  80         uint8 DSR_IMP;                  // 1 bit
  81         uint8 reserved2;                        // 2 bit
  82         uint16 C_SIZE;                  //12 bit
  83         uint8 VDD_R_CURR_MIN;   // 3 bit
  84         uint8 VDD_R_CURR_MAX;   // 3 bit
  85         uint8 VDD_W_CURR_MIN;   // 3 bit
  86         uint8 VDD_W_CURR_MAX;   // 3 bit
  87         uint8 C_SIZE_MULT;              // 3 bit
  88         uint8 ERASE_GRP_SIZE;   // 5 bit
  89         uint8 ERASE_GRP_MULT;   // 5 bit
  90         uint8 WP_GRP_SIZE;              // 5 bit
  91         uint8 WP_GRP_ENABLE;    // 1 bit
  92         uint8 DEFAULT_ECC;              // 2 bit
  93         uint8 R2W_FACTOR;               // 3 bit
  94         uint8 WRITE_BL_LEN;             // 4 bit
  95         uint8 WRITE_BL_PARTIAL; // 1 bit
  96         uint8 reserved3;                        // 4 bit
  97         uint8 CONTENT_PROT_APP; // 1 bit
  98 //RW
  99         uint8 FILE_FORMAT_GRP;  // 1 bit
 100         uint8 COPY;                             // 1 bit
 101         uint8 PERM_WRITE_PROTECT;       // 1 bit
 102         uint8 TMP_WRITE_PROTECT;        // 1 bit
 103         uint8 FILE_FORMAT;              // 2 bit
 104         uint8 ECC;                              // 2 bit
 105 //      uint8 CRC;                              // 7 bit
 106 //      uint8 LastBit;                          // 1 bit: always 1
 107 }CARD_MMC_CSD_T;
 108
 109 /*****************************************************************************/
 110 //      The struct of Card IDentification (CID) register of SD. please refer to <SD Specifications Part 1 Physical Layer Specification Version 2.00>
 111 /*****************************************************************************/
 112 typedef struct CARD_SD_CID_STRUCT_TAG
 113 {
 114         uint8 MID;      // 8 bit
 115         uint16 OID;     // 16 bit
 116         uint8 PNM[5];   // 40 bit
 117         uint8 PRV;      // 8 bit
 118         uint32 PSN;     // 32 bit
 119         uint16 MDT;     // 12bit
 120 //      uint8 CRC;      // 1 bit
 121 //      uint8 lastBit;  // 1 bit :always 1
 122 }CARD_SD_CID_T;
 123
 124 /*****************************************************************************/
 125 // The struct of Card-Specific Data register of SD. please refer to <SD Specifications Part 1 Physical Layer Specification Version 2.00>
 126 /*****************************************************************************/
 127 typedef struct CARD_SD_CSD10_STRUCT_TAG
 128 {
 129 //R
 130         uint8 CSD_STRUCTURE;    // 2 bit
 131         uint8 reserved1;                        // 6 bit
 132         uint8 TAAC;                             // 8 bit
 133         uint8 NSAC;                             // 8 bit
 134         uint8 TRAN_SPEED;               // 8 bit
 135         uint16 CCC;                             //12 bit
 136         uint8 READ_BL_LEN;              // 4 bit
 137         uint8 READ_BL_PARTIAL;  // 1 bit
 138         uint8 WRITE_BLK_MISALIGN;       // 1 bit
 139         uint8 READ_BLK_MISALIGN;        // 1 bit
 140         uint8 DSR_IMP;                  // 1 bit
 141
 142         uint8 reserved2;                        // 2 bit
 143         uint16 C_SIZE;                  //12 bit
 144         uint8 VDD_R_CURR_MIN;   // 3 bit
 145         uint8 VDD_R_CURR_MAX;   // 3 bit
 146         uint8 VDD_W_CURR_MIN;   // 3 bit
 147         uint8 VDD_W_CURR_MAX;   // 3 bit
 148         uint8 C_SIZE_MULT;              // 3 bit
 149
 150         uint8 ERASE_BLK_EN;             // 1 bit
 151         uint8 SECTOR_SIZE;              // 7 bit
 152         uint8 WP_GRP_SIZE;              // 7 bit
 153         uint8 WP_GRP_ENABLE;    // 1 bit
 154         uint8 reserved3;                // 2 bit
 155
 156         uint8 R2W_FACTOR;               // 3 bit
 157         uint8 WRITE_BL_LEN;             // 4 bit
 158         uint8 WRITE_BL_PARTIAL; // 1 bit
 159         uint8 reserved4;                        // 5 bit
 160 //RW
 161         uint8 FILE_FORMAT_GRP;  // 1 bit
 162         uint8 COPY;                             // 1 bit
 163         uint8 PERM_WRITE_PROTECT;       // 1 bit
 164         uint8 TMP_WRITE_PROTECT;        // 1 bit
 165         uint8 FILE_FORMAT;              // 2 bit
 166         uint8 reserved5;                        // 2 bit
 167 //      uint8 CRC;                              // 7 bit
 168 //      uint8 LastBit;                          // 1 bit: always 1
 169 }CARD_SD_CSD10_T;
 170
 171 /*****************************************************************************/
 172 // The struct of Card-Specific Data register of SD. please refer to <SD Specifications Part 1 Physical Layer Specification Version 2.00>
 173 /*****************************************************************************/
 174 typedef struct CARD_SD_CSD20_STRUCT_TAG
 175 {
 176 //R
 177         uint8 CSD_STRUCTURE;    // 2 bit
 178         uint8 reserved1;                        // 6 bit
 179         uint8 TAAC;                             // 8 bit
 180         uint8 NSAC;                             // 8 bit
 181         uint8 TRAN_SPEED;               // 8 bit
 182         uint16 CCC;                             //12 bit
 183         uint8 READ_BL_LEN;              // 4 bit
 184         uint8 READ_BL_PARTIAL;  // 1 bit
 185         uint8 WRITE_BLK_MISALIGN;       // 1 bit
 186         uint8 READ_BLK_MISALIGN;        // 1 bit
 187         uint8 DSR_IMP;                  // 1 bit
 188
 189         uint8 reserved2;                        // 6 bit
 190         uint32 C_SIZE;                  //22 bit
 191         uint8 reserved3;                        // 1 bit
 192
 193         uint8 ERASE_BLK_EN;             // 1 bit
 194         uint8 SECTOR_SIZE;              // 7 bit
 195         uint8 WP_GRP_SIZE;              // 7 bit
 196         uint8 WP_GRP_ENABLE;    // 1 bit
 197         uint8 reserved4;                // 2 bit
 198
 199         uint8 R2W_FACTOR;               // 3 bit
 200         uint8 WRITE_BL_LEN;             // 4 bit
 201         uint8 WRITE_BL_PARTIAL; // 1 bit
 202         uint8 reserved5;                        // 5 bit
 203 //RW
 204         uint8 FILE_FORMAT_GRP;  // 1 bit
 205         uint8 COPY;                             // 1 bit
 206         uint8 PERM_WRITE_PROTECT;       // 1 bit
 207         uint8 TMP_WRITE_PROTECT;        // 1 bit
 208         uint8 FILE_FORMAT;              // 2 bit
 209         uint8 reserved6;                        // 2 bit
 210 //      uint8 CRC;                              // 7 bit
 211 //      uint8 LastBit;                          // 1 bit: always 1
 212 }CARD_SD_CSD20_T;
 213
 214 typedef union CARD_CSD_STRUCT_TAG
 215 {
 216         CARD_SD_CSD10_T SD_CSD10;
 217         CARD_SD_CSD20_T SD_CSD20;
 218         CARD_MMC_CSD_T MMC_CSD;
 219 }CARD_CSD_T;
 220
 221 typedef union CARD_CID_STRUCT_TAG
 222 {
 223         CARD_SD_CID_T SD_CID;
 224         CARD_MMC_CID_T MMC_CID;
 225 }CARD_CID_T;
 226 /*lint -save -e749*/
 227 typedef enum CARD_BUS_WIDTH_TAG
 228 {
 229         CARD_WIDTH_1_BIT,
 230         CARD_WIDTH_4_BIT,
 231         CARD_WIDTH_8_BIT
 232 }CARD_BUS_WIDTH_E;
 233
 234 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET   3
 235 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_MASK   0x38
 236 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_NONE   (0<<PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET)
 237 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT1   (1<<PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET)
 238 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT2   (2<<PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET)
 239 #define PARTITION_CFG_BOOT_PARTITION_ENABLE_USER   (7<<PARTITION_CFG_BOOT_PARTITION_ENABLE_OFFSET)
 240
 241 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_OFFSET  00
 242 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_MASK   0x07
 243 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_USER      0
 244 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_BOOT1     1
 245 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_BOOT2     2
 246 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_RPMB      3
 247 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_GENERAL_P1        4
 248 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_GENERAL_P2        5
 249 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_GENERAL_P3        6
 250 #define PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_GENERAL_P4        7
 251
 252 #define EXT_CSD_CARD_WIDTH_1_BIT                0
 253 #define EXT_CSD_CARD_WIDTH_4_BIT                1
 254 #define EXT_CSD_CARD_WIDTH_8_BIT                2
 255
 256 #define EXT_CSD_PARTITION_CFG_INDEX     179
 257 #define EXT_CSD_BUS_WIDTH_INDEX         183
 258
 259 #define CMD6_BIT_MODE_OFFSET_ACCESS     24
 260 #define CMD6_BIT_MODE_MASK_ACCESS       0x03000000
 261 #define CMD6_BIT_MODE_OFFSET_INDEX              16
 262 #define CMD6_BIT_MODE_MASK_INDEX        0x00FF0000
 263 #define CMD6_BIT_MODE_OFFSET_VALUE              8
 264 #define CMD6_BIT_MODE_MASK_VALUE        0x0000FF00
 265 #define CMD6_BIT_MODE_OFFSET_CMD_SET    0
 266 #define CMD6_BIT_MODE_MASK_CMD_SET      0x00000003
 267
 268 #define CMD6_ACCESS_MODE_COMMAND_SET    (0<<CMD6_BIT_MODE_OFFSET_ACCESS)
 269 #define CMD6_ACCESS_MODE_SET_BITS       (1<<CMD6_BIT_MODE_OFFSET_ACCESS)
 270 #define CMD6_ACCESS_MODE_CLEAR_BITS     (2<<CMD6_BIT_MODE_OFFSET_ACCESS)
 271 #define CMD6_ACCESS_MODE_WRITE_BYTE     (3<<CMD6_BIT_MODE_OFFSET_ACCESS)
 272
 273 #define CMD6_CMD_SET_OLD        (0<<CMD6_BIT_MODE_OFFSET_CMD_SET)
 274 #define CMD6_CMD_SET            (1<<CMD6_BIT_MODE_OFFSET_CMD_SET)
 275
 276 /*
 277  * CSD field definitions
 278  */
 279
 280 #define CSD_STRUCT_VER_1_0  0           /* Valid for system specification 1.0 - 1.2 */
 281 #define CSD_STRUCT_VER_1_1  1           /* Valid for system specification 1.4 - 2.2 */
 282 #define CSD_STRUCT_VER_1_2  2           /* Valid for system specification 3.1 - 3.2 - 3.31 - 4.0 - 4.1 */
 283 #define CSD_STRUCT_EXT_CSD  3           /* Version is coded in CSD_STRUCTURE in EXT_CSD */
 284
 285 #define CSD_SPEC_VER_0      0           /* Implements system specification 1.0 - 1.2 */
 286 #define CSD_SPEC_VER_1      1           /* Implements system specification 1.4 */
 287 #define CSD_SPEC_VER_2      2           /* Implements system specification 2.0 - 2.2 */
 288 #define CSD_SPEC_VER_3      3           /* Implements system specification 3.1 - 3.2 - 3.31 */
 289 #define CSD_SPEC_VER_4      4           /* Implements system specification 4.0 - 4.1 */
 290
 291 /*
 292  * EXT_CSD fields
 293  */
 294
 295 #define EXT_CSD_BUS_WIDTH_INDEX 183     /* R/W */
 296 #define EXT_CSD_HS_TIMING_INDEX 185     /* R/W */
 297 #define EXT_CSD_CARD_TYPE_INDEX 196     /* RO */
 298 #define EXT_CSD_SEC_CNT_INDEX   212     /* RO, 4 bytes */
 299 #define EXT_CSD_PARTITION_CFG_INDEX     179
 300 /*
 301  *
 302  */
 303
 304 #define EXT_CSD_CMD_SET_NORMAL          (1<<0)
 305 #define EXT_CSD_CMD_SET_SECURE          (1<<1)
 306 #define EXT_CSD_CMD_SET_CPSECURE        (1<<2)
 307
 308 #define EXT_CSD_CARD_TYPE_26    (1<<0)  /* Card can run at 26MHz */
 309 #define EXT_CSD_CARD_TYPE_52    (1<<1)  /* Card can run at 52MHz */
 310
 311 #define EXT_CSD_BUS_WIDTH_1     0       /* Card is in 1 bit mode */
 312 #define EXT_CSD_BUS_WIDTH_4     1       /* Card is in 4 bit mode */
 313 #define EXT_CSD_BUS_WIDTH_8     2       /* Card is in 8 bit mode */
 314
 315 /*
 316  * MMC_SWITCH access modes
 317  */
 318
 319 #define MMC_SWITCH_MODE_CMD_SET 0x00    /* Change the command set */
 320 #define MMC_SWITCH_MODE_SET_BITS        0x01    /* Set bits which are 1 in value */
 321 #define MMC_SWITCH_MODE_CLEAR_BITS      0x02    /* Clear bits which are 1 in value */
 322 #define MMC_SWITCH_MODE_WRITE_BYTE      0x03    /* Set target to value */
 323
 324
 325 typedef struct CARD_PORT_TAG
 326 {
 327         BOOLEAN open_flag;
 328
 329         SDIO_CARD_PAL_HANDLE sdioPalHd;
 330
 331         CARD_VERTION_E vertion;
 332         uint16 RCA;
 333         CARD_BUS_WIDTH_E bus_width;
 334
 335         uint32 ClockRate;
 336         uint32 BlockLen;
 337
 338         uint32 Nac_Max;
 339         uint32 GrpSize;
 340         uint32 Capacity;
 341         uint32 Rpmb_Capacity;
 342         uint32 Boot1_Capacity;
 343         uint32 Boot2_Capacity;
 344         CARD_EMMC_PARTITION_TPYE Cur_Partition;
 345
 346         uint16  CCC;
 347         BOOLEAN ifSupportEC;
 348         BOOLEAN ifSupportHighSpeed;
 349
 350         BOOLEAN ifEnterEC;
 351         BOOLEAN ifEnterHighSpeed;
 352 }CARD_PORT_T;
 353
 354 __align(32) uint8 s_extcsdbuf[512];
 355 __align(32) uint8 s_sendbuf[512];
 356 __align(32) uint8 s_receivebuf1[512];
 357 __align(32) uint8 s_receivebuf2[512];
 358
 359 CARD_SDIO_HANDLE  emmc_handle = NULL;
 360 CARD_CID_T g_CID;
 361
 362 LOCAL CARD_PORT_T cardPort[CARD_SDIO_SLOT_MAX] = {0};
 363
 364 extern int LDO_Init(void);
 365 extern  void  SDIO_Card_Pal_SetType(SDIO_CARD_PAL_HANDLE handle, SDIO_CARD_PAL_TYPE_E sdio_type);
 366
 367 //-----------------------------------------------------------------------------------
 368 //      To judge whether the handle is valid
 369 //-----------------------------------------------------------------------------------
 370 LOCAL BOOLEAN _IsCardHandleValid(CARD_SDIO_HANDLE cardHandle)
 371 {
 372         uint32 i;
 373
 374         for(i = 0; i < CARD_SDIO_SLOT_MAX; i++)
 375         {
 376                 if(cardHandle == &cardPort[i])
 377                 {
 378                         if(TRUE == cardHandle->open_flag)
 379                         {
 380                                 return TRUE;
 381                         }
 382                         else
 383                         {
 384                                 return FALSE;
 385                         }
 386                 }
 387         }
 388         return FALSE;
 389
 390 }
 391
 392
 393 /*****************************************************************************/
 394 //  Description:  Get Card operation handle,after we get the handle ,we can get next operation way of card
 395 //  Author: Jason.wu
 396 //  Param
 397 //              slotNo: slot number
 398 //  Return:
 399 //              Not zero: success
 400 //              zero : fail
 401 //  Note:
 402 /*****************************************************************************/
 403 PUBLIC CARD_SDIO_HANDLE CARD_SDIO_Open(CARD_SDIO_SLOT_NO slotNo)
 404 {
 405         CARD_SDIO_ASSERT(slotNo < CARD_SDIO_SLOT_MAX);  /*assert verified*/
 406
 407         if(TRUE == cardPort[slotNo].open_flag)
 408         {
 409                 return NULL;
 410         }
 411
 412         cardPort[slotNo].open_flag = TRUE;
 413         cardPort[slotNo].sdioPalHd = SDIO_Card_Pal_Open((SDIO_CARD_PAL_SLOT_E)slotNo);
 414         cardPort[slotNo].BlockLen = 0;
 415         cardPort[slotNo].RCA = 0x1000 | slotNo;
 416         cardPort[slotNo].bus_width = CARD_WIDTH_1_BIT;
 417
 418         return &cardPort[slotNo];
 419 }
 420
 421 /*****************************************************************************/
 422 //  Description:  close operation handle of card. afer we free it ,other application can operate on this card
 423 //  Author: Jason.wu
 424 //  Param
 425 //              cardHandle: the handle returned by CARD_SDIO_Open
 426 //  Return:
 427 //              NONE
 428 //  Note:
 429 /*****************************************************************************/
 430 PUBLIC void CARD_SDIO_Close(CARD_SDIO_HANDLE cardHandle)
 431 {
 432         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
 433
 434         SDIO_Card_Pal_Close(cardHandle->sdioPalHd);
 435         cardHandle->open_flag = FALSE;
 436 }
 437
 438 PUBLIC void CARD_SDIO_PwrCtl(CARD_SDIO_HANDLE cardHandle,BOOLEAN switchCtl)
 439 {
 440         if(TRUE == switchCtl)
 441         {
 442                 SDIO_Card_Pal_Pwr(cardHandle->sdioPalHd,SDIO_CARD_PAL_ON);
 443         }
 444         else if(FALSE == switchCtl)
 445         {
 446                 SDIO_Card_Pal_Pwr(cardHandle->sdioPalHd,SDIO_CARD_PAL_OFF);
 447         }
 448         else
 449         {
 450                 CARD_SDIO_ASSERT(0);    /*assert verified*/
 451         }
 452 }
 453
 454 //-----------------------------------------------------------------------------------
 455 //      Analyze SD CID buffer
 456 //-----------------------------------------------------------------------------------
 457 LOCAL void _SD_CID_Analyze(uint8* CIDbuf,CARD_SD_CID_T *CID)
 458 {
 459         uint16 tmp16;
 460         uint32 tmp32;
 461
 462         CID->MID = CIDbuf[0];
 463
 464         tmp16 = CIDbuf[1];
 465         tmp16 = tmp16<<8;
 466         CID->OID = tmp16 + CIDbuf[2];
 467
 468         CID->PNM[0] = CIDbuf[3];
 469         CID->PNM[1] = CIDbuf[4];
 470         CID->PNM[2] = CIDbuf[5];
 471         CID->PNM[3] = CIDbuf[6];
 472         CID->PNM[4] = CIDbuf[7];
 473
 474         CID->PRV = CIDbuf[8];
 475
 476         tmp32 = CIDbuf[9];
 477         tmp32 = tmp32<<8;
 478         tmp32 += CIDbuf[10];
 479         tmp32 = tmp32<<8;
 480         tmp32 += CIDbuf[11];
 481         tmp32 = tmp32<<8;
 482         tmp32 += CIDbuf[12];
 483         CID->PSN = tmp32;
 484
 485         tmp16 = CIDbuf[13]&0x0F;
 486         tmp16 = tmp16<<8;
 487         CID->MDT = tmp16 + CIDbuf[14];
 488
 489 //      CID->CRC = ((CIDbuf[15]&0xFE)>>1);
 490 //      CID->lastBit = (CIDbuf[15]&0x01);
 491 }
 492
 493 //-----------------------------------------------------------------------------------
 494 //      Analyze MMC CID buffer
 495 //-----------------------------------------------------------------------------------
 496 LOCAL void _MMC_CID_Analyze(uint8* CIDbuf,CARD_MMC_CID_T *CID)
 497 {
 498         uint16 tmp16;
 499         uint32 tmp32;
 500
 501         CID->MID = CIDbuf[0];
 502
 503         tmp16 = CIDbuf[1];
 504         tmp16 = tmp16<<8;
 505         CID->OID = tmp16 + CIDbuf[2];
 506
 507         CID->PNM[0] = CIDbuf[3];
 508         CID->PNM[1] = CIDbuf[4];
 509         CID->PNM[2] = CIDbuf[5];
 510         CID->PNM[3] = CIDbuf[6];
 511         CID->PNM[4] = CIDbuf[7];
 512         CID->PNM[5] = CIDbuf[8];
 513
 514         CID->PRV = CIDbuf[9];
 515
 516         tmp32 = CIDbuf[10];
 517         tmp32 = tmp32<<8;
 518         tmp32 += CIDbuf[11];
 519         tmp32 = tmp32<<8;
 520         tmp32 += CIDbuf[12];
 521         tmp32 = tmp32<<8;
 522         tmp32 += CIDbuf[13];
 523         CID->PSN = tmp32;
 524
 525         CID->MDT = CIDbuf[14];
 526
 527 //      CID->CRC = ((CIDbuf[15]&0xFE)>>1);
 528 //      CID->lastBit = (CIDbuf[15]&0x01);
 529 }
 530
 531
 532 //-----------------------------------------------------------------------------------
 533 //      Analyze SD CSD buffer
 534 //
 535 //      Expand SD CSD1.x to CSD struct member
 536 //
 537 //-----------------------------------------------------------------------------------
 538 LOCAL void _SD_CSD10_Analyze(uint8* CSDbuf,CARD_SD_CSD10_T *CSD)
 539 {
 540         uint8 tmp8;
 541         uint16 tmp16;
 542
 543 //R
 544         tmp8 = CSDbuf[0]&0xC0; //0b11000000
 545         CSD->CSD_STRUCTURE = tmp8>>6;   // 2 bit
 546
 547         tmp8 = CSDbuf[0]&0x3F;//0b00111111;
 548         CSD->reserved1 = tmp8;                  // 6 bit
 549
 550         tmp8 = CSDbuf[1];
 551         CSD->TAAC = tmp8;                       // 8 bit
 552
 553         tmp8 = CSDbuf[2];
 554         CSD->NSAC = tmp8;                       // 8 bit
 555
 556         tmp8 = CSDbuf[3];
 557         CSD->TRAN_SPEED = tmp8;         // 8 bit
 558
 559         tmp16 = CSDbuf[4];
 560         tmp16 = tmp16<<4;
 561         tmp8 = CSDbuf[5]&0xF0;//0b11110000;
 562         tmp8 = tmp8>>4;
 563         tmp16 += tmp8;
 564         CSD->CCC = tmp16;                       //12 bit
 565
 566         tmp8 = CSDbuf[5]&0x0F;//0b00001111;
 567         CSD->READ_BL_LEN = tmp8;                // 4 bit
 568
 569         tmp8 = CSDbuf[6]&0x80;//0b10000000;
 570         CSD->READ_BL_PARTIAL = tmp8>>7;         // 1 bit
 571
 572         tmp8 = CSDbuf[6]&0x40;//0b01000000;
 573         CSD->WRITE_BLK_MISALIGN = tmp8>>6;      // 1 bit
 574
 575         tmp8 = CSDbuf[6]&0x20;//0b00100000;
 576         CSD->READ_BLK_MISALIGN = tmp8>>5;       // 1 bit
 577
 578         tmp8 = CSDbuf[6]&0x10;//0b00010000;
 579         CSD->DSR_IMP = tmp8>>4;                 // 1 bit
 580
 581         tmp8 = CSDbuf[6]&0x0C;//0b00001100;
 582         CSD->reserved2 = tmp8>>2;                       // 2 bit
 583
 584         tmp16 = CSDbuf[6]&0x03;//0b00000011;
 585         tmp16 = tmp16<<8;
 586         tmp16 += CSDbuf[7];
 587         tmp16 = tmp16<<2;
 588         tmp8 = CSDbuf[8]&0xC0;//0b11000000;
 589         tmp8 = tmp8>>6;
 590         tmp16 = tmp16 + tmp8;
 591         CSD->C_SIZE = tmp16;                            //12 bit
 592
 593         tmp8 = CSDbuf[8]&0x38;//0b00111000;
 594         CSD->VDD_R_CURR_MIN = tmp8>>3;  // 3 bit
 595
 596         tmp8 = CSDbuf[8]&0x07;//0b00000111;
 597         CSD->VDD_R_CURR_MAX = tmp8;             // 3 bit
 598
 599         tmp8 = CSDbuf[9]&0xE0;//0b11100000;
 600         CSD->VDD_W_CURR_MIN = tmp8>>5;  // 3 bit
 601
 602         tmp8 = CSDbuf[9]&0x1C;//0b00011100;
 603         CSD->VDD_W_CURR_MAX = tmp8>>2;  // 3 bit
 604
 605         tmp8 = CSDbuf[9]&0x03;//0b00000011;
 606         tmp8 = tmp8<<1;
 607         tmp8 = tmp8 + ((CSDbuf[10]&0x80/*0b10000000*/)>>7);
 608         CSD->C_SIZE_MULT = tmp8;                        // 3 bit
 609 //--
 610         tmp8 = CSDbuf[10]&0x40;//0b01000000;
 611         CSD->ERASE_BLK_EN = tmp8>>6;    // 1 bit
 612
 613         tmp8 = CSDbuf[10]&0x3F;//0b00111111;
 614         tmp8 = tmp8<<1;
 615         tmp8 = tmp8 + ((CSDbuf[11]&0x80/*0b10000000*/)>>7);
 616         CSD->SECTOR_SIZE = tmp8;                // 7 bit
 617
 618         tmp8 = CSDbuf[11]&0x7F;//0b01111111;
 619         CSD->WP_GRP_SIZE = tmp8;                        // 7 bit
 620 //--
 621         tmp8 = CSDbuf[12]&0x80;//0b10000000;
 622         CSD->WP_GRP_ENABLE = tmp8>>7;   // 1 bit
 623
 624         tmp8 = CSDbuf[12]&0x60;//0b01100000;
 625         CSD->reserved3 = tmp8>>5;               // 2 bit
 626
 627         tmp8 = CSDbuf[12]&0x1C;//0b00011100;
 628         CSD->R2W_FACTOR = tmp8>>2;              // 3 bit
 629
 630         tmp8 = CSDbuf[12]&0x03;//0b00000011;
 631         tmp8 = tmp8<<2;
 632         tmp8 = tmp8 + ((CSDbuf[13]&0xC0/*0b11000000*/)>>6);
 633         CSD->WRITE_BL_LEN = tmp8;               // 4 bit
 634
 635         tmp8 = CSDbuf[13]&0x20;//0b00100000;
 636         CSD->WRITE_BL_PARTIAL = tmp8>>5;        // 1 bit
 637
 638         tmp8 = CSDbuf[13]&0x1F;//0b00011111;
 639         CSD->reserved4 = tmp8;                  // 5 bit
 640 //RW
 641         tmp8 = CSDbuf[14]&0x80;//0b10000000;
 642         CSD->FILE_FORMAT_GRP = tmp8>>7; // 1 bit
 643
 644         tmp8 = CSDbuf[14]&0x40;//0b01000000;
 645         CSD->COPY = tmp8>>6;                            // 1 bit
 646
 647         tmp8 = CSDbuf[14]&0x20;//0b00100000;
 648         CSD->PERM_WRITE_PROTECT = tmp8>>5;      // 1 bit
 649
 650         tmp8 = CSDbuf[14]&0x10;//0b00010000;
 651         CSD->TMP_WRITE_PROTECT = tmp8>>4;       // 1 bit
 652
 653         tmp8 = CSDbuf[14]&0x0C;//0b00001100;
 654         CSD->FILE_FORMAT = tmp8>>2;             // 2 bit
 655         tmp8 = CSDbuf[14]&0x03;//0b00000011;
 656         CSD->reserved5 = tmp8;                                  // 2 bit
 657
 658 //      tmp8 = CSDbuf[15]&0xFE;//0b11111110;
 659 //      CSD->CRC = tmp8>>1;                             // 7 bit
 660
 661 //      tmp8 = CSDbuf[15]&0x01;//0b00000001;
 662 //      CSD->LastBit = tmp8;                            // 1 bit: always 1
 663 }
 664
 665
 666 //-----------------------------------------------------------------------------------
 667 //      Analyze SD CSD buffer
 668 //
 669 //      Expand SD CSD2.0 to CSD struct member
 670 //
 671 //-----------------------------------------------------------------------------------
 672 LOCAL void _SD_CSD20_Analyze(uint8* CSDbuf,CARD_SD_CSD20_T *CSD)
 673 {
 674         uint8 tmp8;
 675         uint16 tmp16;
 676         uint32 tmp32;
 677
 678 //R
 679         tmp8 = CSDbuf[0]&0xC0; //0b11000000
 680         CSD->CSD_STRUCTURE = tmp8>>6;   // 2 bit
 681
 682         tmp8 = CSDbuf[0]&0x3F;//0b00111111;
 683         CSD->reserved1 = tmp8;                  // 6 bit
 684
 685         tmp8 = CSDbuf[1];
 686         CSD->TAAC = tmp8;                       // 8 bit
 687
 688         tmp8 = CSDbuf[2];
 689         CSD->NSAC = tmp8;                       // 8 bit
 690
 691         tmp8 = CSDbuf[3];
 692         CSD->TRAN_SPEED = tmp8;         // 8 bit
 693
 694         tmp16 = CSDbuf[4];
 695         tmp16 = tmp16<<4;
 696         tmp8 = CSDbuf[5]&0xF0;//0b11110000;
 697         tmp8 = tmp8>>4;
 698         tmp16 += tmp8;
 699         CSD->CCC = tmp16;                       //12 bit
 700
 701         tmp8 = CSDbuf[5]&0x0F;//0b00001111;
 702         CSD->READ_BL_LEN = tmp8;                // 4 bit
 703
 704         tmp8 = CSDbuf[6]&0x80;//0b10000000;
 705         CSD->READ_BL_PARTIAL = tmp8>>7;         // 1 bit
 706
 707         tmp8 = CSDbuf[6]&0x40;//0b01000000;
 708         CSD->WRITE_BLK_MISALIGN = tmp8>>6;      // 1 bit
 709
 710         tmp8 = CSDbuf[6]&0x20;//0b00100000;
 711         CSD->READ_BLK_MISALIGN = tmp8>>5;       // 1 bit
 712
 713         tmp8 = CSDbuf[6]&0x10;//0b00010000;
 714         CSD->DSR_IMP = tmp8>>4;                 // 1 bit
 715 //--
 716         tmp8 = CSDbuf[6]&0x0F;//0b00001111;
 717         tmp8 = tmp8<<2;
 718         tmp8 += ((CSDbuf[7]&0xC0/*0b11000000*/)>>6);
 719         CSD->reserved2 = tmp8;                          // 6 bit
 720
 721         tmp32 = CSDbuf[7]&0x3F;//0b00111111
 722         tmp32 = tmp32<<8;
 723         tmp32 += CSDbuf[8];
 724         tmp32 = tmp32<<8;
 725         tmp32 += CSDbuf[9];
 726         CSD->C_SIZE = tmp32;                            // 22 bit
 727
 728         tmp8 = CSDbuf[10]&0x80;//0b10000000
 729         tmp8 = tmp8>>7;
 730         CSD->reserved3 = tmp8;
 731 //--
 732         tmp8 = CSDbuf[10]&0x40;//0b01000000;
 733         CSD->ERASE_BLK_EN = tmp8>>6;    // 1 bit
 734
 735         tmp8 = CSDbuf[10]&0x3F;//0b00111111;
 736         tmp8 = tmp8<<1;
 737         tmp8 = tmp8 + ((CSDbuf[11]&0x80/*0b10000000*/)>>7);
 738         CSD->SECTOR_SIZE = tmp8;                // 7 bit
 739
 740         tmp8 = CSDbuf[11]&0x7F;//0b01111111;
 741         CSD->WP_GRP_SIZE = tmp8;                        // 7 bit
 742 //--
 743         tmp8 = CSDbuf[12]&0x80;//0b10000000;
 744         CSD->WP_GRP_ENABLE = tmp8>>7;   // 1 bit
 745
 746         tmp8 = CSDbuf[12]&0x60;//0b01100000;
 747         CSD->reserved4 = tmp8>>5;               // 2 bit
 748
 749         tmp8 = CSDbuf[12]&0x1C;//0b00011100;
 750         CSD->R2W_FACTOR = tmp8>>2;              // 3 bit
 751
 752         tmp8 = CSDbuf[12]&0x03;//0b00000011;
 753         tmp8 = tmp8<<2;
 754         tmp8 = tmp8 + ((CSDbuf[13]&0xC0/*0b11000000*/)>>6);
 755         CSD->WRITE_BL_LEN = tmp8;               // 4 bit
 756
 757         tmp8 = CSDbuf[13]&0x20;//0b00100000;
 758         CSD->WRITE_BL_PARTIAL = tmp8>>5;        // 1 bit
 759
 760         tmp8 = CSDbuf[13]&0x1F;//0b00011111;
 761         CSD->reserved5 = tmp8;                  // 5 bit
 762 //RW
 763         tmp8 = CSDbuf[14]&0x80;//0b10000000;
 764         CSD->FILE_FORMAT_GRP = tmp8>>7; // 1 bit
 765
 766         tmp8 = CSDbuf[14]&0x40;//0b01000000;
 767         CSD->COPY = tmp8>>6;                            // 1 bit
 768
 769         tmp8 = CSDbuf[14]&0x20;//0b00100000;
 770         CSD->PERM_WRITE_PROTECT = tmp8>>5;      // 1 bit
 771
 772         tmp8 = CSDbuf[14]&0x10;//0b00010000;
 773         CSD->TMP_WRITE_PROTECT = tmp8>>4;       // 1 bit
 774
 775         tmp8 = CSDbuf[14]&0x0C;//0b00001100;
 776         CSD->FILE_FORMAT = tmp8>>2;             // 2 bit
 777         tmp8 = CSDbuf[14]&0x03;//0b00000011;
 778         CSD->reserved6 = tmp8;                                  // 2 bit
 779
 780 //      tmp8 = CSDbuf[15]&0xFE;//0b11111110;
 781 //      CSD->CRC = tmp8>>1;                             // 7 bit
 782
 783 //      tmp8 = CSDbuf[15]&0x01;//0b00000001;
 784 //      CSD->LastBit = tmp8;                            // 1 bit: always 1
 785 }
 786
 787 //-----------------------------------------------------------------------------------
 788 //      Analyze MMC CSD buffer
 789 //
 790 //      Expand MMC CSD to CSD struct member
 791 //
 792 //-----------------------------------------------------------------------------------
 793 LOCAL void _MMC_CSD_Analyze(uint8* CSDbuf,CARD_MMC_CSD_T *CSD)
 794 {
 795         uint8 tmp8;
 796         uint16 tmp16;
 797
 798 //R
 799         tmp8 = CSDbuf[0]&0xC0; //0b11000000
 800         CSD->CSD_STRUCTURE = tmp8>>6;   // 2 bit
 801
 802         tmp8 = CSDbuf[0]&0x3C;//0b00111100;
 803         CSD->SPEC_VERS = tmp8>>2;       // 4 bit
 804
 805         tmp8 = CSDbuf[0]&0x03;//0b00000011;
 806         CSD->reserved1 = tmp8;                  // 2 bit
 807
 808         tmp8 = CSDbuf[1];
 809         CSD->TAAC = tmp8;                       // 8 bit
 810
 811         tmp8 = CSDbuf[2];
 812         CSD->NSAC = tmp8;                       // 8 bit
 813
 814         tmp8 = CSDbuf[3];
 815         CSD->TRAN_SPEED = tmp8;         // 8 bit
 816
 817         tmp16 = CSDbuf[4];
 818         tmp16 = tmp16<<4;
 819         tmp8 = CSDbuf[5]&0xF0;//0b11110000;
 820         tmp8 = tmp8>>4;
 821         tmp16 += tmp8;
 822         CSD->CCC = tmp16;                       //12 bit
 823
 824         tmp8 = CSDbuf[5]&0x0F;//0b00001111;
 825         CSD->READ_BL_LEN = tmp8;                // 4 bit
 826
 827         tmp8 = CSDbuf[6]&0x80;//0b10000000;
 828         CSD->READ_BL_PARTIAL = tmp8>>7;         // 1 bit
 829
 830         tmp8 = CSDbuf[6]&0x40;//0b01000000;
 831         CSD->WRITE_BLK_MISALIGN = tmp8>>6;      // 1 bit
 832
 833         tmp8 = CSDbuf[6]&0x20;//0b00100000;
 834         CSD->READ_BLK_MISALIGN = tmp8>>5;       // 1 bit
 835
 836         tmp8 = CSDbuf[6]&0x10;//0b00010000;
 837         CSD->DSR_IMP = tmp8>>4;                 // 1 bit
 838
 839         tmp8 = CSDbuf[6]&0x0C;//0b00001100;
 840         CSD->reserved2 = tmp8>>2;                       // 2 bit
 841
 842         tmp16 = CSDbuf[6]&0x03;//0b00000011;
 843         tmp16 = tmp16<<8;
 844         tmp16 += CSDbuf[7];
 845         tmp16 = tmp16<<2;
 846         tmp8 = CSDbuf[8]&0xC0;//0b11000000;
 847         tmp8 = tmp8>>6;
 848         tmp16 = tmp16 + tmp8;
 849         CSD->C_SIZE = tmp16;                            //12 bit
 850
 851         tmp8 = CSDbuf[8]&0x38;//0b00111000;
 852         CSD->VDD_R_CURR_MIN = tmp8>>3;  // 3 bit
 853
 854         tmp8 = CSDbuf[8]&0x07;//0b00000111;
 855         CSD->VDD_R_CURR_MAX = tmp8;             // 3 bit
 856
 857         tmp8 = CSDbuf[9]&0xE0;//0b11100000;
 858         CSD->VDD_W_CURR_MIN = tmp8>>5;  // 3 bit
 859
 860         tmp8 = CSDbuf[9]&0x1C;//0b00011100;
 861         CSD->VDD_W_CURR_MAX = tmp8>>2;  // 3 bit
 862
 863         tmp8 = CSDbuf[9]&0x03;//0b00000011;
 864         tmp8 = tmp8<<1;
 865         tmp8 = tmp8 + ((CSDbuf[10]&0x80/*0b10000000*/)>>7);
 866         CSD->C_SIZE_MULT = tmp8;                        // 3 bit
 867
 868         tmp8 = CSDbuf[10]&0x7C;//0b01111100;
 869         CSD->ERASE_GRP_SIZE = tmp8>>2;  // 5 bit
 870
 871         tmp8 = CSDbuf[10]&0x03;//0b00000011;
 872         tmp8 = tmp8<<3;
 873         tmp8 = tmp8 + ((CSDbuf[11]&0xE0/*0b11100000*/)>>5);
 874         CSD->ERASE_GRP_MULT = tmp8;             // 5 bit
 875
 876         tmp8 = CSDbuf[11]&0x1F;//0b00011111;
 877         CSD->WP_GRP_SIZE = tmp8;                        // 5 bit
 878
 879         tmp8 = CSDbuf[12]&0x80;//0b10000000;
 880         CSD->WP_GRP_ENABLE = tmp8>>7;   // 1 bit
 881
 882         tmp8 = CSDbuf[12]&0x60;//0b01100000;
 883         CSD->DEFAULT_ECC = tmp8>>5;             // 2 bit
 884
 885         tmp8 = CSDbuf[12]&0x1C;//0b00011100;
 886         CSD->R2W_FACTOR = tmp8>>2;              // 3 bit
 887
 888         tmp8 = CSDbuf[12]&0x03;//0b00000011;
 889         tmp8 = tmp8<<2;
 890         tmp8 = tmp8 + ((CSDbuf[13]&0xC0/*0b11000000*/)>>6);
 891         CSD->WRITE_BL_LEN = tmp8;               // 4 bit
 892
 893         tmp8 = CSDbuf[13]&0x20;//0b00100000;
 894         CSD->WRITE_BL_PARTIAL = tmp8>>5;        // 1 bit
 895
 896         tmp8 = CSDbuf[13]&0x1E;//0b00011110;
 897         CSD->reserved3 = tmp8>>1;                       // 4 bit
 898
 899         tmp8 = CSDbuf[13]&0x01;//0b00000001;
 900         CSD->CONTENT_PROT_APP = tmp8;   // 1 bit
 901 //RW
 902         tmp8 = CSDbuf[14]&0x80;//0b10000000;
 903         CSD->FILE_FORMAT_GRP = tmp8>>7; // 1 bit
 904
 905         tmp8 = CSDbuf[14]&0x40;//0b01000000;
 906         CSD->COPY = tmp8>>6;                            // 1 bit
 907
 908         tmp8 = CSDbuf[14]&0x20;//0b00100000;
 909         CSD->PERM_WRITE_PROTECT = tmp8>>5;      // 1 bit
 910
 911         tmp8 = CSDbuf[14]&0x10;//0b00010000;
 912         CSD->TMP_WRITE_PROTECT = tmp8>>4;       // 1 bit
 913
 914         tmp8 = CSDbuf[14]&0x0C;//0b00001100;
 915         CSD->FILE_FORMAT = tmp8>>2;             // 2 bit
 916         tmp8 = CSDbuf[14]&0x03;//0b00000011;
 917         CSD->ECC = tmp8;                                        // 2 bit
 918
 919 //      tmp8 = CSDbuf[15]&0xFE;//0b11111110;
 920 //      CSD->CRC = tmp8>>1;                             // 7 bit
 921
 922 //      tmp8 = CSDbuf[15]&0x01;//0b00000001;
 923 //      CSD->LastBit = tmp8;                            // 1 bit: always 1
 924 }
 925
 926
 927
 928 /*****************************************************************************/
 929 //  Description:  Read CSD register and analyze it
 930 //  Author: Jason.wu
 931 //  Param
 932 //              cardHandle: the handle returned by CARD_SDIO_Open
 933 //              CSD: CSD data will be stored in this place
 934 //  Return:
 935 //              TRUE: success
 936 //              FALSE: fail
 937 //  Note:
 938 /*****************************************************************************/
 939 LOCAL BOOLEAN CARD_SDIO_ReadCSD(CARD_SDIO_HANDLE cardHandle,CARD_CSD_T* CSD)
 940 {
 941         uint8 rspBuf[16];
 942         uint16 RCA = cardHandle->RCA;
 943         uint32 argument = 0;
 944
 945         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
 946         cardHandle->CCC = 0;
 947
 948         argument = RCA;
 949         argument = argument<<16;
 950
 951
 952         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD9_SEND_CSD,argument,NULL,rspBuf))
 953         {
 954                 return FALSE;
 955         }
 956 //--
 957         CARD_SDIO_PRINT(("SD20 %x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x",rspBuf[0],rspBuf[1],rspBuf[2],rspBuf[3],rspBuf[4],rspBuf[5],rspBuf[6],rspBuf[7],rspBuf[8],rspBuf[9],rspBuf[10],rspBuf[11],rspBuf[12],rspBuf[13],rspBuf[14]));
 958
 959  if((CARD_MMC_441_STANDARD == cardHandle->vertion)||(CARD_MMC_441_HIGHCAP == cardHandle->vertion))
 960         {
 961                 _MMC_CSD_Analyze(rspBuf,&(CSD->MMC_CSD));
 962                 cardHandle->CCC = CSD->MMC_CSD.CCC;
 963                 cardHandle->CCC &= (~((1<<10)|(1<<11)));        // for MMC mode This two classes is reserved
 964
 965                 CARD_SDIO_PRINT(("CARD_MMC_331:"));
 966                 CARD_SDIO_PRINT(("CSD_STRUCTURE\t\t  = 0x%x",CSD->MMC_CSD.CSD_STRUCTURE));
 967                 CARD_SDIO_PRINT(("SPEC_VERS\t\t  = 0x%x",CSD->MMC_CSD.SPEC_VERS));
 968                 CARD_SDIO_PRINT(("reserved1\t\t  = 0x%x",CSD->MMC_CSD.reserved1));
 969                 CARD_SDIO_PRINT(("TAAC\t\t\t  = 0x%x",CSD->MMC_CSD.TAAC));
 970                 CARD_SDIO_PRINT(("NSAC\t\t\t  = 0x%x",CSD->MMC_CSD.NSAC));
 971                 CARD_SDIO_PRINT(("TRAN_SPEED\t\t  = 0x%x",CSD->MMC_CSD.TRAN_SPEED));
 972                 CARD_SDIO_PRINT(("CCC\t\t\t  = 0x%x",CSD->MMC_CSD.CCC));
 973                 CARD_SDIO_PRINT(("READ_BL_LEN\t\t  = 0x%x",CSD->MMC_CSD.READ_BL_LEN));
 974                 CARD_SDIO_PRINT(("READ_BL_PARTIAL\t\t  = 0x%x",CSD->MMC_CSD.READ_BL_PARTIAL));
 975                 CARD_SDIO_PRINT(("WRITE_BLK_MISALIGN\t  = 0x%x",CSD->MMC_CSD.WRITE_BLK_MISALIGN));
 976                 CARD_SDIO_PRINT(("READ_BLK_MISALIGN\t  = 0x%x",CSD->MMC_CSD.READ_BLK_MISALIGN));
 977                 CARD_SDIO_PRINT(("DSR_IMP\t\t\t  = 0x%x",CSD->MMC_CSD.DSR_IMP));
 978                 CARD_SDIO_PRINT(("reserved2\t\t  = 0x%x",CSD->MMC_CSD.reserved2));
 979                 CARD_SDIO_PRINT(("C_SIZE\t\t\t  = 0x%x",CSD->MMC_CSD.C_SIZE));
 980                 CARD_SDIO_PRINT(("VDD_R_CURR_MIN\t\t  = 0x%x",CSD->MMC_CSD.VDD_R_CURR_MIN));
 981                 CARD_SDIO_PRINT(("VDD_R_CURR_MAX\t\t  = 0x%x",CSD->MMC_CSD.VDD_R_CURR_MAX));
 982                 CARD_SDIO_PRINT(("VDD_W_CURR_MIN\t\t  = 0x%x",CSD->MMC_CSD.VDD_W_CURR_MIN));
 983                 CARD_SDIO_PRINT(("VDD_W_CURR_MAX\t\t  = 0x%x",CSD->MMC_CSD.VDD_W_CURR_MAX));
 984                 CARD_SDIO_PRINT(("C_SIZE_MULT\t\t  = 0x%x",CSD->MMC_CSD.C_SIZE_MULT));
 985                 CARD_SDIO_PRINT(("ERASE_GRP_SIZE\t\t  = 0x%x",CSD->MMC_CSD.ERASE_GRP_SIZE));
 986                 CARD_SDIO_PRINT(("ERASE_GRP_MULT\t\t  = 0x%x",CSD->MMC_CSD.ERASE_GRP_MULT));
 987                 CARD_SDIO_PRINT(("WP_GRP_SIZE\t\t  = 0x%x",CSD->MMC_CSD.WP_GRP_SIZE));
 988                 CARD_SDIO_PRINT(("WP_GRP_ENABLE\t\t  = 0x%x",CSD->MMC_CSD.WP_GRP_ENABLE));
 989                 CARD_SDIO_PRINT(("DEFAULT_ECC\t\t  = 0x%x",CSD->MMC_CSD.DEFAULT_ECC));
 990                 CARD_SDIO_PRINT(("R2W_FACTOR\t\t  = 0x%x",CSD->MMC_CSD.R2W_FACTOR));
 991                 CARD_SDIO_PRINT(("WRITE_BL_LEN\t\t  = 0x%x",CSD->MMC_CSD.WRITE_BL_LEN));
 992                 CARD_SDIO_PRINT(("WRITE_BL_PARTIAL\t  = 0x%x",CSD->MMC_CSD.WRITE_BL_PARTIAL));
 993                 CARD_SDIO_PRINT(("reserved3\t\t  = 0x%x",CSD->MMC_CSD.reserved3));
 994                 CARD_SDIO_PRINT(("CONTENT_PROT_APP\t  = 0x%x",CSD->MMC_CSD.CONTENT_PROT_APP));
 995                 CARD_SDIO_PRINT(("----RW bit---"));
 996                 CARD_SDIO_PRINT(("FILE_FORMAT_GRP\t\t  = 0x%x",CSD->MMC_CSD.FILE_FORMAT_GRP));
 997                 CARD_SDIO_PRINT(("COPY\t\t\t  = 0x%x",CSD->MMC_CSD.COPY));
 998                 CARD_SDIO_PRINT(("PERM_WRITE_PROTECT\t  = 0x%x",CSD->MMC_CSD.PERM_WRITE_PROTECT));
 999                 CARD_SDIO_PRINT(("TMP_WRITE_PROTECT\t  = 0x%x",CSD->MMC_CSD.TMP_WRITE_PROTECT));
1000                 CARD_SDIO_PRINT(("FILE_FORMAT\t\t  = 0x%x",CSD->MMC_CSD.FILE_FORMAT));
1001                 CARD_SDIO_PRINT(("ECC\t\t\t  = 0x%x",CSD->MMC_CSD.ECC));
1002 //              CARD_SDIO_PRINT(("CRC\t\t\t  = 0x%x",CSD->MMC_CSD.CRC));
1003 //              CARD_SDIO_PRINT(("LastBit\t\t\t  = 0x%x",CSD->MMC_CSD.LastBit));
1004
1005         }
1006         else
1007         {
1008                 CARD_SDIO_ASSERT(0);    /*assert verified*/
1009         }
1010
1011         return TRUE;
1012 }
1013 #if defined CONFIG_SC8830 || defined(CONFIG_SC9630)
1014 PUBLIC BOOLEAN SDCARD_SDIO_ReadCSD(CARD_SDIO_HANDLE cardHandle, CARD_CSD_T *CSD)
1015 {
1016     uint8 rspBuf[16];
1017     uint16 RCA = cardHandle->RCA;
1018     uint32 argument = 0;
1019
1020     CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));
1021     cardHandle->CCC = 0;
1022
1023     argument = RCA;
1024     argument = argument << 16;
1025
1026
1027     if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_CMD9_SEND_CSD, argument, NULL, rspBuf))
1028     {
1029         return FALSE;
1030     }
1031     //--
1032     CARD_SDIO_PRINT(("SD20 %x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x", rspBuf[0], rspBuf[1], rspBuf[2], rspBuf[3], rspBuf[4], rspBuf[5], rspBuf[6], rspBuf[7], rspBuf[8], rspBuf[9], rspBuf[10], rspBuf[11], rspBuf[12], rspBuf[13], rspBuf[14]));
1033
1034     if(CARD_SD_V2_0_HIGHCAP == cardHandle->vertion)
1035     {
1036         _SD_CSD20_Analyze(rspBuf, &(CSD->SD_CSD20));
1037         cardHandle->CCC = CSD->SD_CSD20.CCC;
1038
1039         CARD_SDIO_PRINT(("CARD_SD_V2_0_HIGHCAP:"));
1040         CARD_SDIO_PRINT(("CSD_STRUCTURE = %x", CSD->SD_CSD20.CSD_STRUCTURE));
1041         CARD_SDIO_PRINT(("reserved1= %x", CSD->SD_CSD20.reserved1));
1042         CARD_SDIO_PRINT(("TAAC= %x", CSD->SD_CSD20.TAAC));
1043         CARD_SDIO_PRINT(("NSAC= %x", CSD->SD_CSD20.NSAC));
1044         CARD_SDIO_PRINT(("TRAN_SPEED= %x", CSD->SD_CSD20.TRAN_SPEED));
1045         CARD_SDIO_PRINT(("CCC= %x", CSD->SD_CSD20.CCC));
1046         CARD_SDIO_PRINT(("READ_BL_LEN= %x", CSD->SD_CSD20.READ_BL_LEN));
1047         CARD_SDIO_PRINT(("READ_BL_PARTIAL= %x", CSD->SD_CSD20.READ_BL_PARTIAL));
1048         CARD_SDIO_PRINT(("WRITE_BLK_MISALIGN= %x", CSD->SD_CSD20.WRITE_BLK_MISALIGN));
1049         CARD_SDIO_PRINT(("READ_BLK_MISALIGN= %x", CSD->SD_CSD20.READ_BLK_MISALIGN));
1050         CARD_SDIO_PRINT(("DSR_IMP= %x", CSD->SD_CSD20.DSR_IMP));
1051
1052         CARD_SDIO_PRINT(("reserved2= %x", CSD->SD_CSD20.reserved2));
1053         CARD_SDIO_PRINT(("C_SIZE= %x", CSD->SD_CSD20.C_SIZE));
1054         CARD_SDIO_PRINT(("reserved3= %x", CSD->SD_CSD20.reserved3));
1055
1056         CARD_SDIO_PRINT(("ERASE_BLK_EN= %x", CSD->SD_CSD20.ERASE_BLK_EN));
1057         CARD_SDIO_PRINT(("SECTOR_SIZE= %x", CSD->SD_CSD20.SECTOR_SIZE));
1058         CARD_SDIO_PRINT(("WP_GRP_SIZE= %x", CSD->SD_CSD20.WP_GRP_SIZE));
1059         CARD_SDIO_PRINT(("WP_GRP_ENABLE= %x", CSD->SD_CSD20.WP_GRP_ENABLE));
1060         CARD_SDIO_PRINT(("reserved4= %x", CSD->SD_CSD20.reserved4));
1061
1062         CARD_SDIO_PRINT(("R2W_FACTOR= %x", CSD->SD_CSD20.R2W_FACTOR));
1063         CARD_SDIO_PRINT(("WRITE_BL_LEN= %x", CSD->SD_CSD20.WRITE_BL_LEN));
1064         CARD_SDIO_PRINT(("WRITE_BL_PARTIAL= %x", CSD->SD_CSD20.WRITE_BL_PARTIAL));
1065         CARD_SDIO_PRINT(("reserved5= %x", CSD->SD_CSD20.reserved5));
1066
1067         CARD_SDIO_PRINT(("FILE_FORMAT_GRP= %x", CSD->SD_CSD20.FILE_FORMAT_GRP));
1068         CARD_SDIO_PRINT(("COPY= %x", CSD->SD_CSD20.COPY));
1069         CARD_SDIO_PRINT(("PERM_WRITE_PROTECT= %x", CSD->SD_CSD20.PERM_WRITE_PROTECT));
1070         CARD_SDIO_PRINT(("TMP_WRITE_PROTECT= %x", CSD->SD_CSD20.TMP_WRITE_PROTECT));
1071         CARD_SDIO_PRINT(("FILE_FORMAT= %x", CSD->SD_CSD20.FILE_FORMAT));
1072         CARD_SDIO_PRINT(("reserved6= %x", CSD->SD_CSD20.reserved6));
1073         //      CARD_SDIO_PRINT(("CRC= %x",CSD->SD_CSD20.CRC));
1074         //      CARD_SDIO_PRINT(("LastBit= %x",CSD->SD_CSD20.LastBit));
1075     }
1076     else if(
1077         (CARD_SD_V2_0_STANDARD == cardHandle->vertion)
1078         || (CARD_SD_V1_X == cardHandle->vertion)
1079     )
1080     {
1081         _SD_CSD10_Analyze(rspBuf, &(CSD->SD_CSD10));
1082         cardHandle->CCC = CSD->SD_CSD10.CCC;
1083
1084         CARD_SDIO_PRINT(("CARD_SD_V2_0_STANDARD||CARD_SD_V1_X:"));
1085         CARD_SDIO_PRINT(("CSD_STRUCTURE = %x", CSD->SD_CSD10.CSD_STRUCTURE));
1086         CARD_SDIO_PRINT(("reserved1= %x", CSD->SD_CSD10.reserved1));
1087         CARD_SDIO_PRINT(("TAAC= %x", CSD->SD_CSD10.TAAC));
1088         CARD_SDIO_PRINT(("NSAC= %x", CSD->SD_CSD10.NSAC));
1089         CARD_SDIO_PRINT(("TRAN_SPEED= %x", CSD->SD_CSD10.TRAN_SPEED));
1090         CARD_SDIO_PRINT(("CCC= %x", CSD->SD_CSD10.CCC));
1091         CARD_SDIO_PRINT(("READ_BL_LEN= %x", CSD->SD_CSD10.READ_BL_LEN));
1092         CARD_SDIO_PRINT(("READ_BL_PARTIAL= %x", CSD->SD_CSD10.READ_BL_PARTIAL));
1093         CARD_SDIO_PRINT(("WRITE_BLK_MISALIGN= %x", CSD->SD_CSD10.WRITE_BLK_MISALIGN));
1094         CARD_SDIO_PRINT(("READ_BLK_MISALIGN= %x", CSD->SD_CSD10.READ_BLK_MISALIGN));
1095         CARD_SDIO_PRINT(("DSR_IMP= %x", CSD->SD_CSD10.DSR_IMP));
1096
1097         CARD_SDIO_PRINT(("reserved2= %x", CSD->SD_CSD10.reserved2));
1098         CARD_SDIO_PRINT(("C_SIZE= %x", CSD->SD_CSD10.C_SIZE));
1099         CARD_SDIO_PRINT(("VDD_R_CURR_MIN = %x", CSD->SD_CSD10.VDD_R_CURR_MIN));
1100         CARD_SDIO_PRINT(("VDD_R_CURR_MAX = %x", CSD->SD_CSD10.VDD_R_CURR_MAX));
1101         CARD_SDIO_PRINT(("VDD_W_CURR_MIN = %x", CSD->SD_CSD10.VDD_W_CURR_MIN));
1102         CARD_SDIO_PRINT(("VDD_W_CURR_MAX = %x", CSD->SD_CSD10.VDD_W_CURR_MAX));
1103         CARD_SDIO_PRINT(("C_SIZE_MULT = %x", CSD->SD_CSD10.C_SIZE_MULT));
1104
1105         CARD_SDIO_PRINT(("ERASE_BLK_EN= %x", CSD->SD_CSD10.ERASE_BLK_EN));
1106         CARD_SDIO_PRINT(("SECTOR_SIZE= %x", CSD->SD_CSD10.SECTOR_SIZE));
1107         CARD_SDIO_PRINT(("WP_GRP_SIZE= %x", CSD->SD_CSD10.WP_GRP_SIZE));
1108         CARD_SDIO_PRINT(("WP_GRP_ENABLE= %x", CSD->SD_CSD10.WP_GRP_ENABLE));
1109         CARD_SDIO_PRINT(("reserved3= %x", CSD->SD_CSD10.reserved3));
1110
1111         CARD_SDIO_PRINT(("R2W_FACTOR= %x", CSD->SD_CSD10.R2W_FACTOR));
1112         CARD_SDIO_PRINT(("WRITE_BL_LEN= %x", CSD->SD_CSD10.WRITE_BL_LEN));
1113         CARD_SDIO_PRINT(("WRITE_BL_PARTIAL= %x", CSD->SD_CSD10.WRITE_BL_PARTIAL));
1114         CARD_SDIO_PRINT(("reserved4= %x", CSD->SD_CSD10.reserved4));
1115
1116         CARD_SDIO_PRINT(("FILE_FORMAT_GRP= %x", CSD->SD_CSD10.FILE_FORMAT_GRP));
1117         CARD_SDIO_PRINT(("COPY= %x", CSD->SD_CSD10.COPY));
1118         CARD_SDIO_PRINT(("PERM_WRITE_PROTECT= %x", CSD->SD_CSD10.PERM_WRITE_PROTECT));
1119         CARD_SDIO_PRINT(("TMP_WRITE_PROTECT= %x", CSD->SD_CSD10.TMP_WRITE_PROTECT));
1120         CARD_SDIO_PRINT(("FILE_FORMAT= %x", CSD->SD_CSD10.FILE_FORMAT));
1121         CARD_SDIO_PRINT(("reserved5= %x", CSD->SD_CSD10.reserved5));
1122         //      CARD_SDIO_PRINT(("CRC= %x",CSD->SD_CSD10.CRC));
1123         //      CARD_SDIO_PRINT(("LastBit= %x",CSD->SD_CSD10.LastBit));
1124     }
1125     else if(CARD_MMC_331 == cardHandle->vertion)
1126     {
1127         _MMC_CSD_Analyze(rspBuf, &(CSD->MMC_CSD));
1128         cardHandle->CCC = CSD->MMC_CSD.CCC;
1129         cardHandle->CCC &= (~((1 << 10) | (1 << 11)));  // for MMC mode This two classes is reserved
1130
1131         CARD_SDIO_PRINT(("CARD_MMC_331:"));
1132         CARD_SDIO_PRINT(("CSD_STRUCTURE\t\t  = 0x%x", CSD->MMC_CSD.CSD_STRUCTURE));
1133         CARD_SDIO_PRINT(("SPEC_VERS\t\t  = 0x%x", CSD->MMC_CSD.SPEC_VERS));
1134         CARD_SDIO_PRINT(("reserved1\t\t  = 0x%x", CSD->MMC_CSD.reserved1));
1135         CARD_SDIO_PRINT(("TAAC\t\t\t  = 0x%x", CSD->MMC_CSD.TAAC));
1136         CARD_SDIO_PRINT(("NSAC\t\t\t  = 0x%x", CSD->MMC_CSD.NSAC));
1137         CARD_SDIO_PRINT(("TRAN_SPEED\t\t  = 0x%x", CSD->MMC_CSD.TRAN_SPEED));
1138         CARD_SDIO_PRINT(("CCC\t\t\t  = 0x%x", CSD->MMC_CSD.CCC));
1139         CARD_SDIO_PRINT(("READ_BL_LEN\t\t  = 0x%x", CSD->MMC_CSD.READ_BL_LEN));
1140         CARD_SDIO_PRINT(("READ_BL_PARTIAL\t\t  = 0x%x", CSD->MMC_CSD.READ_BL_PARTIAL));
1141         CARD_SDIO_PRINT(("WRITE_BLK_MISALIGN\t  = 0x%x", CSD->MMC_CSD.WRITE_BLK_MISALIGN));
1142         CARD_SDIO_PRINT(("READ_BLK_MISALIGN\t  = 0x%x", CSD->MMC_CSD.READ_BLK_MISALIGN));
1143         CARD_SDIO_PRINT(("DSR_IMP\t\t\t  = 0x%x", CSD->MMC_CSD.DSR_IMP));
1144         CARD_SDIO_PRINT(("reserved2\t\t  = 0x%x", CSD->MMC_CSD.reserved2));
1145         CARD_SDIO_PRINT(("C_SIZE\t\t\t  = 0x%x", CSD->MMC_CSD.C_SIZE));
1146         CARD_SDIO_PRINT(("VDD_R_CURR_MIN\t\t  = 0x%x", CSD->MMC_CSD.VDD_R_CURR_MIN));
1147         CARD_SDIO_PRINT(("VDD_R_CURR_MAX\t\t  = 0x%x", CSD->MMC_CSD.VDD_R_CURR_MAX));
1148         CARD_SDIO_PRINT(("VDD_W_CURR_MIN\t\t  = 0x%x", CSD->MMC_CSD.VDD_W_CURR_MIN));
1149         CARD_SDIO_PRINT(("VDD_W_CURR_MAX\t\t  = 0x%x", CSD->MMC_CSD.VDD_W_CURR_MAX));
1150         CARD_SDIO_PRINT(("C_SIZE_MULT\t\t  = 0x%x", CSD->MMC_CSD.C_SIZE_MULT));
1151         CARD_SDIO_PRINT(("ERASE_GRP_SIZE\t\t  = 0x%x", CSD->MMC_CSD.ERASE_GRP_SIZE));
1152         CARD_SDIO_PRINT(("ERASE_GRP_MULT\t\t  = 0x%x", CSD->MMC_CSD.ERASE_GRP_MULT));
1153         CARD_SDIO_PRINT(("WP_GRP_SIZE\t\t  = 0x%x", CSD->MMC_CSD.WP_GRP_SIZE));
1154         CARD_SDIO_PRINT(("WP_GRP_ENABLE\t\t  = 0x%x", CSD->MMC_CSD.WP_GRP_ENABLE));
1155         CARD_SDIO_PRINT(("DEFAULT_ECC\t\t  = 0x%x", CSD->MMC_CSD.DEFAULT_ECC));
1156         CARD_SDIO_PRINT(("R2W_FACTOR\t\t  = 0x%x", CSD->MMC_CSD.R2W_FACTOR));
1157         CARD_SDIO_PRINT(("WRITE_BL_LEN\t\t  = 0x%x", CSD->MMC_CSD.WRITE_BL_LEN));
1158         CARD_SDIO_PRINT(("WRITE_BL_PARTIAL\t  = 0x%x", CSD->MMC_CSD.WRITE_BL_PARTIAL));
1159         CARD_SDIO_PRINT(("reserved3\t\t  = 0x%x", CSD->MMC_CSD.reserved3));
1160         CARD_SDIO_PRINT(("CONTENT_PROT_APP\t  = 0x%x", CSD->MMC_CSD.CONTENT_PROT_APP));
1161         CARD_SDIO_PRINT(("----RW bit---"));
1162         CARD_SDIO_PRINT(("FILE_FORMAT_GRP\t\t  = 0x%x", CSD->MMC_CSD.FILE_FORMAT_GRP));
1163         CARD_SDIO_PRINT(("COPY\t\t\t  = 0x%x", CSD->MMC_CSD.COPY));
1164         CARD_SDIO_PRINT(("PERM_WRITE_PROTECT\t  = 0x%x", CSD->MMC_CSD.PERM_WRITE_PROTECT));
1165         CARD_SDIO_PRINT(("TMP_WRITE_PROTECT\t  = 0x%x", CSD->MMC_CSD.TMP_WRITE_PROTECT));
1166         CARD_SDIO_PRINT(("FILE_FORMAT\t\t  = 0x%x", CSD->MMC_CSD.FILE_FORMAT));
1167         CARD_SDIO_PRINT(("ECC\t\t\t  = 0x%x", CSD->MMC_CSD.ECC));
1168         //              CARD_SDIO_PRINT(("CRC\t\t\t  = 0x%x",CSD->MMC_CSD.CRC));
1169         //              CARD_SDIO_PRINT(("LastBit\t\t\t  = 0x%x",CSD->MMC_CSD.LastBit));
1170
1171     }
1172     else
1173     {
1174         CARD_SDIO_ASSERT(0);
1175     }
1176
1177
1178     return TRUE;
1179 }
1180 #endif
1181 /*****************************************************************************/
1182 //  Description:  Read EXT CSD register and analyze it
1183 //  Author: Jason.wu
1184 //  Param
1185 //              cardHandle: the handle returned by CARD_SDIO_Open
1186 //              CSD: CSD data will be stored in this place
1187 //  Return:
1188 //              TRUE: success
1189 //              FALSE: fail
1190 //  Note:
1191 /*****************************************************************************/
1192 LOCAL BOOLEAN CARD_SDIO_ReadExtCSD(CARD_SDIO_HANDLE cardHandle)
1193 {
1194           uint8 rspBuf[16];
1195
1196         uint32 argument = 0;
1197          CARD_DATA_PARAM_T data;
1198
1199         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1200         cardHandle->CCC = 0;
1201
1202          data.blkLen = 512;
1203         data.blkNum = 1;
1204         data.databuf = s_extcsdbuf;
1205         data.direction = SDIO_DMA_IN;
1206         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD8_SEND_IF_COND,argument,&data,rspBuf))
1207         {
1208                 return FALSE;
1209         }
1210
1211         return TRUE;
1212 }
1213
1214
1215 #define CID_BYTE_SIZE   16
1216 unsigned char g_regCID[CID_BYTE_SIZE];
1217
1218 unsigned char *get_global_cid(void)
1219 {
1220         return g_regCID;
1221 }
1222
1223 /*****************************************************************************/
1224 //  Description:  Read CID register and analyze it
1225 //  Author: Jason.wu
1226 //  Param
1227 //              cardHandle: the handle returned by CARD_SDIO_Open
1228 //              CID: CID data will be stored in this place
1229 //  Return:
1230 //              TRUE: success
1231 //              FALSE: fail
1232 //  Note:
1233 /*****************************************************************************/
1234 uint8 CARD_SDIO_ReadCID(CARD_SDIO_HANDLE cardHandle,CARD_CID_T* CID)
1235 {
1236         uint8 rspBuf[16];
1237
1238         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1239
1240         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD2_ALL_SEND_CID,0,NULL,rspBuf))
1241         {
1242                 return 0;
1243         }
1244
1245         if(CARD_MMC_441_STANDARD == cardHandle->vertion)
1246         {
1247                 _MMC_CID_Analyze(rspBuf,&CID->MMC_CID);
1248                 CARD_SDIO_PRINT(("-----MMC CID value---\r\n"));
1249                 CARD_SDIO_PRINT(("MID\t\t = 0x%x\r\n",CID->MMC_CID.MID));
1250                 CARD_SDIO_PRINT(("OID\t\t = 0x%x\r\n",CID->MMC_CID.OID));
1251                 CARD_SDIO_PRINT(("PNM\t\t = %c,%c,%c,%c,%c,%c\r\n",CID->MMC_CID.PNM[0],CID->MMC_CID.PNM[1],CID->MMC_CID.PNM[2],CID->MMC_CID.PNM[3],CID->MMC_CID.PNM[4],CID->MMC_CID.PNM[5]));
1252                 CARD_SDIO_PRINT(("PRV\t\t = 0x%x\r\n",CID->MMC_CID.PRV));
1253                 CARD_SDIO_PRINT(("PSN\t\t = 0x%x\r\n",CID->MMC_CID.PSN));
1254                 CARD_SDIO_PRINT(("MDT\t\t = 0x%x\r\n",CID->MMC_CID.MDT));
1255
1256                 memcpy(g_regCID, rspBuf, CID_BYTE_SIZE);
1257         }
1258         else
1259         {
1260                 CARD_SDIO_ASSERT(0);    /*assert verified*/
1261         }
1262
1263         return 1;
1264 }
1265
1266 /*****************************************************************************/
1267 //  Description:  Set relate address to card ,this address is used to select card
1268 //  Author: Jason.wu
1269 //  Param
1270 //              cardHandle: the handle returned by CARD_SDIO_Open
1271 //              RCA: new relative address
1272 //  Return:
1273 //              TRUE: success
1274 //              FALSE: fail
1275 //  Note:
1276 /*****************************************************************************/
1277 LOCAL BOOLEAN CARD_SDIO_SetRCA(CARD_SDIO_HANDLE cardHandle,uint16 RCA)
1278 {
1279         uint8 rspBuf[16];
1280         uint32 argument = 0;
1281
1282         if(CARD_MMC_331 != cardHandle->vertion)
1283         {
1284         // only MMC card can set RCA
1285                 return FALSE;
1286         }
1287
1288         argument = RCA;
1289         argument = argument<<16;
1290
1291         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1292
1293         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD3_SET_RELATIVE_ADDR,argument,NULL,rspBuf))
1294         {
1295                 return FALSE;
1296         }
1297
1298         return TRUE;
1299
1300 }
1301
1302 /*****************************************************************************/
1303 //  Description:  Get relate address from card ,this address is used to select card
1304 //  Author: Jason.wu
1305 //  Param
1306 //              cardHandle: the handle returned by CARD_SDIO_Open
1307 //              RCA: relative address will stored in this place
1308 //  Return:
1309 //              TRUE: success
1310 //              FALSE: fail
1311 //  Note:
1312 /*****************************************************************************/
1313 LOCAL BOOLEAN CARD_SDIO_ReadRCA(CARD_SDIO_HANDLE cardHandle,uint16*RCA)
1314 {
1315         uint8 rspBuf[16];
1316
1317         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1318
1319
1320         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD3_SEND_RELATIVE_ADDR,1<<16,NULL,rspBuf))
1321         {
1322                 return FALSE;
1323         }
1324
1325         *RCA = 1;
1326         return TRUE;
1327 }
1328 #if defined( CONFIG_SC8830 ) || defined(CONFIG_SC9630)
1329 LOCAL BOOLEAN SDCARD_SDIO_ReadRCA(CARD_SDIO_HANDLE cardHandle,uint16*RCA)
1330 {
1331         uint8  rspBuf[16];
1332         uint16 tmpRCA;
1333
1334         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1335
1336
1337         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD3_SEND_RELATIVE_ADDR,1<<16,NULL,rspBuf))
1338         {
1339                 return FALSE;
1340         }
1341     tmpRCA = 0;
1342     tmpRCA = rspBuf[0];
1343     tmpRCA = tmpRCA << 8;
1344     tmpRCA |= rspBuf[1];
1345
1346     *RCA = tmpRCA;
1347
1348         return TRUE;
1349 }
1350 #endif
1351
1352
1353 //-----------------------------------------------------------------------------------
1354 //      Before operate card ,we must active card first,this function is used to active card
1355 //-----------------------------------------------------------------------------------
1356 LOCAL BOOLEAN _SelectCard(CARD_SDIO_HANDLE cardHandle)
1357 {
1358         uint8 rspBuf[16];
1359         uint16 RCA = cardHandle->RCA;
1360         uint32 argument = 0;
1361
1362         argument = RCA;
1363         argument = argument<<16;
1364
1365         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD7_SELECT_DESELECT_CARD,argument,NULL,rspBuf))
1366         {
1367                 return FALSE;
1368         }
1369
1370         return TRUE;
1371 }
1372
1373 LOCAL BOOLEAN MMC_SWITCH(CARD_SDIO_HANDLE cardHandle, uint8 index, uint8 value)
1374 {
1375         uint8 rspBuf[16];
1376         uint32 argument = 0;
1377
1378         argument = CMD6_ACCESS_MODE_WRITE_BYTE | CMD6_CMD_SET;
1379         argument |= index<<CMD6_BIT_MODE_OFFSET_INDEX;
1380         argument |= value<<CMD6_BIT_MODE_OFFSET_VALUE;
1381
1382
1383         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD6_SET_EXT_CSD,argument,NULL,rspBuf))
1384         {
1385                 return FALSE;
1386         }
1387
1388         return TRUE;
1389 }
1390
1391 BOOLEAN CARD_SDIO_Select_CurPartition(CARD_SDIO_HANDLE cardHandle, CARD_EMMC_PARTITION_TPYE cardPartiton)
1392 {
1393         uint8 rspBuf[16];
1394         uint16 RCA = cardHandle->RCA;
1395         uint32 argument = 0;
1396
1397         argument = CMD6_ACCESS_MODE_WRITE_BYTE | ( EXT_CSD_PARTITION_CFG_INDEX<<CMD6_BIT_MODE_OFFSET_INDEX & CMD6_BIT_MODE_MASK_INDEX) | CMD6_CMD_SET;
1398
1399         switch(cardPartiton)
1400         {
1401                 case PARTITION_USER:
1402                         argument |= (PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT1 |PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_USER)<<CMD6_BIT_MODE_OFFSET_VALUE;
1403                         break;
1404
1405                 case PARTITION_BOOT1:
1406                         argument |= (PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT1 |PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_BOOT1)<<CMD6_BIT_MODE_OFFSET_VALUE;
1407                         break;
1408
1409                 case PARTITION_BOOT2:
1410                         argument |= (PARTITION_CFG_BOOT_PARTITION_ENABLE_BOOT1 |PARTITION_CFG_BOOT_PARTITION_ACCESS_PARTITION_BOOT2)<<CMD6_BIT_MODE_OFFSET_VALUE;
1411                         break;
1412
1413                 case PARTITION_RPMB:
1414                 case PARTITION_GENERAL_P1:
1415                 case PARTITION_GENERAL_P2:
1416                 case PARTITION_GENERAL_P3:
1417                 case PARTITION_GENERAL_P4:
1418                         CARD_SDIO_ASSERT(0);    //if want to support RPMB or GENERAL Partiton, need add code
1419                         break;
1420                 default:
1421                         CARD_SDIO_ASSERT(0);    /*assert verified*/
1422                         break;
1423
1424         }
1425
1426         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD6_SET_EXT_CSD,argument,NULL,rspBuf))
1427         {
1428                 return FALSE;
1429         }
1430
1431         cardHandle->Cur_Partition = cardPartiton;
1432         return TRUE;
1433
1434 }
1435
1436 //-----------------------------------------------------------------------------------
1437 //      Set data bus width of card
1438 //-----------------------------------------------------------------------------------
1439 LOCAL BOOLEAN _SetBusWidth(CARD_SDIO_HANDLE cardHandle,CARD_BUS_WIDTH_E width)
1440 {
1441         uint8 rspBuf[16];
1442         uint16 RCA = cardHandle->RCA;
1443         uint32 argument = 0;
1444
1445         argument = CMD6_ACCESS_MODE_WRITE_BYTE | ( EXT_CSD_BUS_WIDTH_INDEX<<CMD6_BIT_MODE_OFFSET_INDEX & CMD6_BIT_MODE_MASK_INDEX) ;
1446
1447         switch(width)
1448         {
1449                 case CARD_WIDTH_1_BIT:
1450                 {
1451                         argument |= EXT_CSD_CARD_WIDTH_1_BIT<<CMD6_BIT_MODE_OFFSET_VALUE;
1452                 }
1453                 break;
1454
1455                 case CARD_WIDTH_4_BIT:
1456                 {
1457                         argument |=EXT_CSD_CARD_WIDTH_4_BIT<<CMD6_BIT_MODE_OFFSET_VALUE;
1458                 }
1459                 break;
1460                 case CARD_WIDTH_8_BIT:
1461                 {
1462                         argument |=EXT_CSD_CARD_WIDTH_8_BIT<<CMD6_BIT_MODE_OFFSET_VALUE;
1463                 }
1464                 break;
1465
1466                 default:
1467                 {
1468                         CARD_SDIO_ASSERT(0);    /*assert verified*/
1469                 }
1470                 break;
1471         }
1472         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD6_SET_EXT_CSD,argument,NULL,rspBuf))
1473         {
1474                 return FALSE;
1475         }
1476
1477         switch(width)
1478         {
1479                 case CARD_WIDTH_1_BIT:
1480                 {
1481                         SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd,SDIO_CARD_PAL_1_BIT);
1482                 }
1483                 break;
1484
1485                 case CARD_WIDTH_4_BIT:
1486                 {
1487                         SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd,SDIO_CARD_PAL_4_BIT);
1488                 }
1489                 break;
1490 #if defined (CONFIG_SC8825) || defined(CONFIG_SC7710G2) || defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
1491                 case CARD_WIDTH_8_BIT:
1492                 {
1493                         SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd,SDIO_CARD_PAL_8_BIT);
1494                 }
1495                 break;
1496 #endif
1497                 default:
1498                 {
1499                         CARD_SDIO_ASSERT(0);    /*assert verified*/
1500                 }
1501                 break;
1502         }
1503         cardHandle->bus_width = width;
1504
1505         return TRUE;
1506 }
1507
1508 /*****************************************************************************/
1509 //  Description:  Set block length of card.  the data will be transmited in block unit
1510 //  Author: Jason.wu
1511 //  Param
1512 //              cardHandle: the handle returned by CARD_SDIO_Open
1513 //              length: block length
1514 //  Return:
1515 //              TRUE: success
1516 //              FALSE: fail
1517 //  Note:
1518 /*****************************************************************************/
1519 PUBLIC BOOLEAN CARD_SDIO_SetBlockLength(CARD_SDIO_HANDLE cardHandle,uint32 length)
1520 {
1521         uint8 rspBuf[16];
1522
1523         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1524
1525         if((CARD_SD_V2_0_HIGHCAP == cardHandle->vertion)&&(512 != length))
1526         {
1527                 CARD_SDIO_PRINT(("SD20 Block Length of SD V2.0 High capacity is fixed to 512,you cannot set to value 0x%x\r\n",length));
1528                 return FALSE;
1529         }
1530         if(length == cardHandle->BlockLen)
1531         {
1532                 return TRUE;
1533         }
1534         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD16_SET_BLOCKLEN,length,NULL,rspBuf))
1535         {
1536                 return FALSE;
1537         }
1538
1539         cardHandle->BlockLen = length;
1540
1541         return TRUE;
1542 }
1543
1544
1545
1546 /*
1547
1548 */
1549
1550
1551 typedef struct
1552 {
1553         uint16  currentVal;
1554         uint16  grp6Supported;
1555         uint16  grp5Supported;
1556         uint16  grp4Supported;
1557         uint16  grp3Supported;
1558         uint16  grp2Supported;
1559         uint16  grp1Supported;
1560
1561         uint8   grp6SwitchResult;
1562         uint8   grp5SwitchResult;
1563         uint8   grp4SwitchResult;
1564         uint8   grp3SwitchResult;
1565         uint8   grp2SwitchResult;
1566         uint8   grp1SwitchResult;
1567
1568         uint8   version;
1569
1570         uint16  grp6BusyStatus;
1571         uint16  grp5BusyStatus;
1572         uint16  grp4BusyStatus;
1573         uint16  grp3BusyStatus;
1574         uint16  grp2BusyStatus;
1575         uint16  grp1BusyStatus;
1576
1577 }CARD_CMD6_STATUS_T;
1578
1579
1580 LOCAL void _CMD6_Response_Analyze(uint8* resBuf,CARD_CMD6_STATUS_T* cmdStatus)
1581 {
1582         cmdStatus->currentVal           = ((resBuf[0]<<8)|(resBuf[1]));
1583         cmdStatus->grp6Supported        = ((resBuf[2]<<8)|(resBuf[3]));
1584         cmdStatus->grp5Supported        = ((resBuf[4]<<8)|(resBuf[5]));
1585         cmdStatus->grp4Supported        = ((resBuf[6]<<8)|(resBuf[7]));
1586         cmdStatus->grp3Supported        = ((resBuf[8]<<8)|(resBuf[9]));
1587         cmdStatus->grp2Supported        = ((resBuf[10]<<8)|(resBuf[11]));
1588         cmdStatus->grp1Supported        = ((resBuf[12]<<8)|(resBuf[13]));
1589
1590         cmdStatus->grp6SwitchResult     = ((resBuf[14]&0xF0)>>4);
1591         cmdStatus->grp5SwitchResult     = (resBuf[14]&0x0F);
1592         cmdStatus->grp4SwitchResult     = ((resBuf[15]&0xF0)>>4);
1593         cmdStatus->grp3SwitchResult     = (resBuf[15]&0x0F);
1594         cmdStatus->grp2SwitchResult     = ((resBuf[16]&0xF0)>>4);
1595         cmdStatus->grp1SwitchResult     = (resBuf[16]&0x0F);
1596
1597         cmdStatus->version              = resBuf[17];
1598
1599         cmdStatus->grp6BusyStatus       = ((resBuf[18]<<8)|(resBuf[19]));
1600         cmdStatus->grp5BusyStatus       = ((resBuf[20]<<8)|(resBuf[21]));
1601         cmdStatus->grp4BusyStatus       = ((resBuf[22]<<8)|(resBuf[23]));
1602         cmdStatus->grp3BusyStatus       = ((resBuf[24]<<8)|(resBuf[25]));
1603         cmdStatus->grp2BusyStatus       = ((resBuf[26]<<8)|(resBuf[27]));
1604         cmdStatus->grp1BusyStatus       = ((resBuf[28]<<8)|(resBuf[29]));
1605
1606         CARD_SDIO_PRINT(("currentVal = 0x%x",cmdStatus->currentVal));
1607
1608         CARD_SDIO_PRINT(("grp6Supported = 0x%x",cmdStatus->grp6Supported));
1609         CARD_SDIO_PRINT(("grp5Supported = 0x%x",cmdStatus->grp5Supported));
1610         CARD_SDIO_PRINT(("grp4Supported = 0x%x",cmdStatus->grp4Supported));
1611         CARD_SDIO_PRINT(("grp3Supported = 0x%x",cmdStatus->grp3Supported));
1612         CARD_SDIO_PRINT(("grp2Supported = 0x%x",cmdStatus->grp2Supported));
1613         CARD_SDIO_PRINT(("grp1Supported = 0x%x",cmdStatus->grp1Supported));
1614
1615         CARD_SDIO_PRINT(("grp6SwitchResult = 0x%x",cmdStatus->grp6SwitchResult));
1616         CARD_SDIO_PRINT(("grp5SwitchResult = 0x%x",cmdStatus->grp5SwitchResult));
1617         CARD_SDIO_PRINT(("grp4SwitchResult = 0x%x",cmdStatus->grp4SwitchResult));
1618         CARD_SDIO_PRINT(("grp3SwitchResult = 0x%x",cmdStatus->grp3SwitchResult));
1619         CARD_SDIO_PRINT(("grp2SwitchResult = 0x%x",cmdStatus->grp2SwitchResult));
1620         CARD_SDIO_PRINT(("grp1SwitchResult = 0x%x",cmdStatus->grp1SwitchResult));
1621
1622         CARD_SDIO_PRINT(("status version = 0x%x",cmdStatus->version));
1623
1624         CARD_SDIO_PRINT(("grp6BusyStatus = 0x%x",cmdStatus->grp6BusyStatus));
1625         CARD_SDIO_PRINT(("grp5BusyStatus = 0x%x",cmdStatus->grp5BusyStatus));
1626         CARD_SDIO_PRINT(("grp4BusyStatus = 0x%x",cmdStatus->grp4BusyStatus));
1627         CARD_SDIO_PRINT(("grp3BusyStatus = 0x%x",cmdStatus->grp3BusyStatus));
1628         CARD_SDIO_PRINT(("grp2BusyStatus = 0x%x",cmdStatus->grp2BusyStatus));
1629         CARD_SDIO_PRINT(("grp1BusyStatus = 0x%x",cmdStatus->grp1BusyStatus));
1630
1631         return;
1632 }
1633
1634
1635 #define SECTOR_MODE 0x40000000
1636 #define BYTE_MODE   0x00000000
1637
1638 PUBLIC BOOLEAN CARD_SDIO_InitCard(CARD_SDIO_HANDLE cardHandle, CARD_SPEED_MODE speedmode)
1639 {
1640         uint8 rspBuf[16];
1641         uint32 pre_tick, cur_tick;
1642         CARD_CSD_T CSD;
1643         CARD_BUS_WIDTH_E busWidth = CARD_WIDTH_1_BIT;
1644         uint16 RCA;
1645         BOOLEAN vertion_flag; //TRUE: SD2.0 FALSE: SD1.x
1646         SDIO_CARD_PAL_ERROR_E errCode;
1647
1648         uint8 extcsd_Part_Config;
1649
1650         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1651
1652 //      CARD_SDIO_PwrCtl(cardHandle,TRUE);
1653         cardHandle->bus_width = CARD_WIDTH_1_BIT;
1654         cardHandle->BlockLen = 0;
1655         cardHandle->vertion = CARD_V_UNKONWN;
1656         cardHandle->Cur_Partition =  PARTITION_MAX;
1657
1658         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD0_GO_IDLE_STATE,0,NULL,rspBuf))
1659         {
1660                 return FALSE;
1661         }
1662 //Now the card is in Idle State
1663     if(CARD_V_UNKONWN== cardHandle->vertion)
1664     {
1665            pre_tick = SCI_GetTickCount(); /*set start tick value*/
1666         do
1667         {
1668                 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD1_SEND_OP_COND,0x00FF8000 | SECTOR_MODE,NULL,rspBuf))
1669                 {
1670                         //return FALSE;
1671                 }
1672                   //break;
1673                 if(0 != (rspBuf[0]&BIT_7))
1674                 {
1675                         cardHandle->vertion = CARD_MMC_441_STANDARD;
1676                         break;
1677                 }
1678
1679                 cur_tick = SCI_GetTickCount();
1680                 if(CARD_CMD_MAX_TIME <  (cur_tick - pre_tick))
1681                 {
1682                         /*cmd time out, return false*/
1683                         return FALSE;
1684                 }
1685
1686         }
1687         while(1); /*lint !e506*/
1688     }
1689
1690 // Now SD is in Ready State
1691     if(1 != CARD_SDIO_ReadCID(cardHandle,&g_CID))
1692         {
1693                 return FALSE;
1694         }
1695 // Now SD is in Identification State
1696     if(FALSE == CARD_SDIO_ReadRCA(cardHandle,&RCA))
1697     {
1698         return FALSE;
1699     }
1700     cardHandle->RCA = 1;
1701     if(FALSE == CARD_SDIO_ReadCSD(cardHandle,&CSD))
1702         {
1703                 return FALSE;
1704         }
1705      if(!(CARD_MMC_441_STANDARD == cardHandle->vertion))
1706         {
1707                 return FALSE;
1708         }
1709         if(0xFFF != CSD.MMC_CSD.C_SIZE)
1710         {
1711                 cardHandle->GrpSize = (CSD.MMC_CSD.ERASE_GRP_SIZE+1)*(CSD.MMC_CSD.ERASE_GRP_MULT+1)*(1 << CSD.MMC_CSD.WRITE_BL_LEN);
1712                 cardHandle->Nac_Max = (uint32)((((CSD.MMC_CSD.TAAC*cardHandle->ClockRate) + (100*CSD.MMC_CSD.NSAC))*10) / 8);
1713                 cardHandle->Capacity = (CSD.MMC_CSD.C_SIZE+1) <<(CSD.MMC_CSD.C_SIZE_MULT+2 + CSD.MMC_CSD.READ_BL_LEN - 9); //unit is 512 byte
1714
1715         }
1716         else
1717         {
1718                 cardHandle->vertion = CARD_MMC_441_HIGHCAP;
1719         }
1720
1721         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1722         {
1723                 return FALSE;
1724         }
1725
1726         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD7_SELECT_DESELECT_CARD,  1<<16,NULL,rspBuf))
1727            {
1728                    return FALSE;
1729            }
1730          if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1731         {
1732                 return FALSE;
1733         }
1734
1735        //get card  Capacity and RPMB Capacity
1736        //(void)memset(s_extcsdbuf, 0x0, 512);
1737        CARD_SDIO_ReadExtCSD(cardHandle);
1738       if(CARD_MMC_441_HIGHCAP == cardHandle->vertion)
1739         {
1740         cardHandle->Capacity = (((uint32)s_extcsdbuf[215])<<24)+ (((uint32)s_extcsdbuf[214])<<16)+ (((uint32)s_extcsdbuf[213])<<8)+ ((uint32)s_extcsdbuf[212]); //unit is 512 byte
1741         }
1742         extcsd_Part_Config = s_extcsdbuf[179];
1743         cardHandle->Rpmb_Capacity = s_extcsdbuf[168]*256; //128/512 ==256 ,unit is 512 byte
1744         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1745         {
1746                 return FALSE;
1747         }
1748
1749         //get Boot1 Capacity
1750         CARD_SDIO_Select_CurPartition(cardHandle, PARTITION_BOOT1);
1751         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1752                   {
1753                           return FALSE;
1754                   }
1755         CARD_SDIO_ReadExtCSD(cardHandle);
1756         extcsd_Part_Config = s_extcsdbuf[179];
1757         cardHandle->Boot1_Capacity = s_extcsdbuf[226]*256; //128/512 ==256 ,unit is 512 byte
1758          if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1759          {
1760                  return FALSE;
1761          }
1762
1763          //get Boot2 Capacity
1764         CARD_SDIO_Select_CurPartition(cardHandle, PARTITION_BOOT2);
1765         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1766         {
1767                 return FALSE;
1768          }
1769         CARD_SDIO_ReadExtCSD(cardHandle);
1770         extcsd_Part_Config = s_extcsdbuf[179];
1771         cardHandle->Boot2_Capacity = s_extcsdbuf[226]*256; //128/512 ==256 ,unit is 512 byte
1772         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1773         {
1774                 return FALSE;
1775         }
1776
1777         MMC_SWITCH(cardHandle, EXT_CSD_HS_TIMING_INDEX, 1);
1778         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1779         {
1780                 return FALSE;
1781         }
1782 #if defined (CONFIG_SC8825) || defined(CONFIG_SC7710G2) ||defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
1783         SDIO_Card_Pal_DisSdClk(cardHandle->sdioPalHd);
1784         SDIO_Card_Pal_SetSpeedMode(cardHandle->sdioPalHd, EMMC_SPEED_SDR25);
1785 #if defined(CONFIG_FPGA)
1786         SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd, SDIO_CARD_PAL_2MHz);
1787 #else
1788         SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd, SDIO_CARD_PAL_50MHz);
1789 #endif
1790 #else
1791         SDIO_Card_Pal_SetClk(cardHandle->sdioPalHd,SDIO_CARD_PAL_25MHz);
1792 #endif
1793 #if defined (CONFIG_SC8825) || defined(CONFIG_SC7710G2) || defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
1794         busWidth = CARD_WIDTH_8_BIT;
1795 #else
1796         busWidth = CARD_WIDTH_4_BIT;
1797 #endif
1798         if(FALSE == _SetBusWidth(cardHandle,busWidth))
1799         {
1800                 return FALSE;
1801         }
1802         if(FALSE == CARD_SDIO_SetBlockLength(cardHandle,DEFAULT_CARD_BLOCKLEN))
1803         {
1804                 return FALSE;
1805         }
1806
1807     #if 0
1808         uint16 i, j;
1809         for(i=0; i<512; i++)
1810                 s_sendbuf[i] = 0x1f;
1811         CARD_SDIO_WriteSingleBlock(cardHandle, 0, (uint8*)s_sendbuf);
1812         for(i=0; i<512; i++)
1813                 s_sendbuf[i] = 0x5a;
1814         CARD_SDIO_WriteSingleBlock(cardHandle, 1, (uint8*)s_sendbuf);
1815 #endif
1816          /*
1817         CARD_SDIO_ReadSingleBlock(cardHandle, 0, (uint8*)s_receivebuf1);
1818         CARD_SDIO_ReadSingleBlock(cardHandle, 1, (uint8*)s_receivebuf2);
1819
1820         (void)memset((uint8*)0x2000000, 0x0, 0x100000);
1821         (void)memset((uint8*)0x3000000, 0x0, 0x100000);
1822          CARD_SDIO_WriteMultiBlock(cardHandle, 0, 50, (uint8*)0x2000000);
1823
1824          CARD_SDIO_ReadMultiBlock(cardHandle, 0, 50, (uint8*)0x3000000);
1825
1826         {
1827             uint32 argument = 0;
1828             argument = CMD6_ACCESS_MODE_WRITE_BYTE | ( 162<<CMD6_BIT_MODE_OFFSET_INDEX & CMD6_BIT_MODE_MASK_INDEX) | CMD6_CMD_SET |(1<<8);
1829             if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_ACMD6_SET_EXT_CSD,argument,NULL,rspBuf))
1830             {
1831                 return FALSE;
1832             }
1833             if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1834             {
1835                 return FALSE;
1836             }
1837         }
1838
1839          CARD_SDIO_Select_CurPartition(cardHandle, PARTITION_BOOT2);
1840
1841          if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
1842          {
1843                  return FALSE;
1844          }
1845
1846           CARD_SDIO_ReadSingleBlock(cardHandle, 0, (uint8*)s_receivebuf1);
1847          CARD_SDIO_ReadSingleBlock(cardHandle, 1, (uint8*)s_receivebuf2);
1848
1849        */
1850
1851 //---
1852         return TRUE;
1853
1854 }
1855
1856
1857 #if defined CONFIG_SC8830 || defined(CONFIG_SC9630)
1858
1859 PUBLIC BOOLEAN SDSetBusWidth(CARD_SDIO_HANDLE cardHandle, CARD_BUS_WIDTH_E width)
1860 {
1861     uint8 rspBuf[16];
1862     uint16 RCA = cardHandle->RCA;
1863     uint32 argument = 0;
1864
1865
1866     if(width == cardHandle->bus_width)
1867     {
1868         return TRUE;
1869     }
1870
1871     argument = RCA;
1872     argument = argument << 16;
1873     if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_CMD55_APP_CMD, argument, NULL, rspBuf))
1874     {
1875         return FALSE;
1876     }
1877
1878     switch(width)
1879     {
1880     case CARD_WIDTH_1_BIT:
1881     {
1882         argument = 0;
1883     }
1884     break;
1885
1886     case CARD_WIDTH_4_BIT:
1887     {
1888         argument = 2;
1889     }
1890     break;
1891
1892     default:
1893     {
1894         CARD_SDIO_ASSERT(0);
1895     }
1896     break;
1897     }
1898     if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(cardHandle->sdioPalHd, CARD_ACMD6_SET_BUS_WIDTH, argument, NULL, rspBuf))
1899     {
1900         return FALSE;
1901     }
1902
1903     switch(width)
1904     {
1905     case CARD_WIDTH_1_BIT:
1906     {
1907         SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd, SDIO_CARD_PAL_1_BIT);
1908     }
1909     break;
1910
1911     case CARD_WIDTH_4_BIT:
1912     {
1913         SDIO_Card_Pal_SetBusWidth(cardHandle->sdioPalHd, SDIO_CARD_PAL_4_BIT);
1914     }
1915     break;
1916
1917     default:
1918     {
1919         CARD_SDIO_ASSERT(0);
1920     }
1921     break;
1922     }
1923     cardHandle->bus_width = width;
1924
1925     return TRUE;
1926 }
1927
1928 uint8 CARD_SDIO_getCID(unsigned int *uid)
1929 {
1930         uid[0] = g_CID.MMC_CID.MID << 24 | g_CID.MMC_CID.OID & 0xff << 16 | (g_CID.MMC_CID.OID >> 8) & 0xff << 8 | g_CID.MMC_CID.PNM[0];
1931         uid[1] = g_CID.MMC_CID.PNM[1] << 24 | g_CID.MMC_CID.PNM[2] << 16 | g_CID.MMC_CID.PNM[3] << 8 | g_CID.MMC_CID.PNM[4];
1932         uid[2] = g_CID.MMC_CID.PRV << 24 | g_CID.MMC_CID.PSN & 0xff << 16 | (g_CID.MMC_CID.PSN >> 8) & 0xff << 8 | (g_CID.MMC_CID.PSN >> 16) & 0xff;
1933         uid[3] = (g_CID.MMC_CID.PSN >> 24) & 0xff << 24 | g_CID.MMC_CID.MDT & 0xff << 16 | (g_CID.MMC_CID.MDT >> 8) & 0xff << 8 | 1;
1934
1935         return 1;
1936 }
1937
1938 /*****************************************************************************/
1939 //  Description:  Initialize card, change card from idle state to standy by state ,and get some information from card
1940 //  Author: Jason.wu
1941 //  Param
1942 //              cardHandle: the handle returned by CARD_SDIO_Open
1943 //  Return:
1944 //              TRUE: success
1945 //              FALSE: fail
1946 //  Note:
1947 /*****************************************************************************/
1948 PUBLIC BOOLEAN SDCARD_SDIO_InitCard(CARD_SDIO_HANDLE cardHandle, CARD_SPEED_MODE speedmode)
1949 {
1950         uint8 rspBuf[16];
1951         uint32 pre_tick, cur_tick,temp;
1952         CARD_CSD_T CSD;
1953         CARD_BUS_WIDTH_E busWidth = CARD_WIDTH_1_BIT;
1954         uint16 RCA;
1955         BOOLEAN vertion_flag; //TRUE: SD2.0 FALSE: SD1.x
1956         SDIO_CARD_PAL_ERROR_E errCode;
1957
1958         CARD_SDIO_ASSERT(TRUE == _IsCardHandleValid(cardHandle));       /*assert verified*/
1959
1960         cardHandle->bus_width = CARD_WIDTH_1_BIT;
1961         cardHandle->BlockLen = 0;
1962         cardHandle->vertion = CARD_V_UNKONWN;
1963 #if defined(CONFIG_SC8830)
1964 #include <asm/arch/pinmap.h>
1965         temp = (*(volatile unsigned int *)((SPRD_PIN_PHYS+REG_PIN_SD0_D3)));
1966         *((volatile unsigned int *)(SPRD_PIN_PHYS+REG_PIN_SD0_D3)) = BIT_PIN_NULL|BITS_PIN_DS(1)|BITS_PIN_AF(3)|BIT_PIN_SLP_NUL|BIT_PIN_SLP_Z;
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()
2784 {
2785         uint32 ret = 0;
2786
2787         sdcard_handle = CARD_SDIO_Open(CARD_SDIO_SLOT_6);
2788
2789         SDIO_Card_Pal_SetType(sdcard_handle->sdioPalHd, SDIO_CARD_PAL_TYPE_SD);
2790         CARD_SDIO_PwrCtl(sdcard_handle, FALSE);
2791         CARD_SDIO_PwrCtl(sdcard_handle, TRUE);
2792         return SDCARD_SDIO_InitCard(sdcard_handle, HIGH_SPEED_MODE);
2793 }
2794
2795 #endif
2796
2797 PUBLIC BOOLEAN SDCARD_PowerOn()
2798 {
2799         sdcard_handle = CARD_SDIO_Open(CARD_SDIO_SLOT_6);
2800         SDIO_Card_Pal_SetType(sdcard_handle->sdioPalHd, SDIO_CARD_PAL_TYPE_SD);
2801         CARD_SDIO_PwrCtl(sdcard_handle, FALSE);
2802         CARD_SDIO_PwrCtl(sdcard_handle, TRUE);
2803         return 1;
2804 }
2805
2806 PUBLIC BOOLEAN Emmc_Write(CARD_EMMC_PARTITION_TPYE  cardPartiton, uint32 startBlock,uint32 num,uint8* buf)
2807 {
2808         uint32 ret = 0;
2809                 uint8 rspBuf[16];
2810         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2811         {
2812                 return FALSE;
2813         }
2814         if(emmc_handle->Cur_Partition != cardPartiton){
2815                 CARD_SDIO_Select_CurPartition(emmc_handle,cardPartiton);
2816
2817          if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2818            {
2819                    return FALSE;
2820            }
2821         }
2822         if ( 1 == num )
2823           ret = CARD_SDIO_WriteSingleBlock(cardPartiton,emmc_handle, startBlock, buf);
2824         else
2825           ret = CARD_SDIO_WriteMultiBlock(cardPartiton,emmc_handle, startBlock, num, buf);
2826
2827          return ret;
2828
2829 }
2830
2831 PUBLIC BOOLEAN Emmc_Read(CARD_EMMC_PARTITION_TPYE  cardPartiton, uint32 startBlock,uint32 num,uint8* buf)
2832 {
2833         uint32 ret = 0;
2834                 uint8 rspBuf[16];
2835
2836          if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2837          {
2838                  return FALSE;
2839          }
2840          if(emmc_handle->Cur_Partition != cardPartiton){
2841                 CARD_SDIO_Select_CurPartition(emmc_handle,cardPartiton);
2842
2843                  if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2844                 {
2845                         return FALSE;
2846                 }
2847
2848          }
2849          if ( 1 == num )
2850          ret = CARD_SDIO_ReadSingleBlock(cardPartiton,emmc_handle, startBlock, buf);
2851         else
2852          ret = CARD_SDIO_ReadMultiBlock(cardPartiton,emmc_handle, startBlock, num, buf);
2853
2854         return ret;
2855
2856 }
2857
2858 PUBLIC BOOLEAN Emmc_Erase(CARD_EMMC_PARTITION_TPYE cardPartiton, uint32 startBlock,uint32 num)
2859 {
2860         uint32 ret = 0;
2861         uint8 rspBuf[16];
2862         uint32 endBlock = startBlock +num -1;
2863
2864          if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2865          {
2866                  return FALSE;
2867          }
2868          if(emmc_handle->Cur_Partition != cardPartiton){
2869                 CARD_SDIO_Select_CurPartition(emmc_handle,cardPartiton);
2870
2871                 if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2872                 {
2873                         return FALSE;
2874                 }
2875
2876          }
2877
2878          ret = CARD_SDIO_Erase(emmc_handle,startBlock, endBlock);
2879
2880         if(SDIO_CARD_PAL_ERR_NONE != SDIO_Card_Pal_SendCmd(emmc_handle->sdioPalHd,CARD_CMD13_SEND_STATUS, 1<<16,NULL,rspBuf))
2881         {
2882                 return FALSE;
2883         }
2884
2885         return ret;
2886
2887 }
2888
2889 PUBLIC uint32 Emmc_GetCapacity(CARD_EMMC_PARTITION_TPYE cardPartiton)
2890 {
2891         switch(cardPartiton)
2892         {
2893                 case PARTITION_USER:
2894                         return emmc_handle->Capacity;
2895
2896                 case PARTITION_BOOT1:
2897                         return emmc_handle->Boot1_Capacity;
2898
2899                 case PARTITION_BOOT2:
2900                         return emmc_handle->Boot2_Capacity;
2901
2902                 default:
2903                         return 0;
2904         }
2905 }
2906
2907 PUBLIC void Emmc_DisSdClk()
2908 {
2909         SDIO_Card_Pal_DisSdClk(emmc_handle->sdioPalHd);
2910 }