Omap35xxPkg/MMCHSDxe/MMCHS.c

   1 /** @file
   2   MMC/SD Card driver for OMAP 35xx (SDIO not supported)
   3
   4   This driver always produces a BlockIo protocol but it starts off with no Media
   5   present. A TimerCallBack detects when media is inserted or removed and after
   6   a media change event a call to BlockIo ReadBlocks/WriteBlocks will cause the
   7   media to be detected (or removed) and the BlockIo Media structure will get
   8   updated. No MMC/SD Card harward registers are updated until the first BlockIo
   9   ReadBlocks/WriteBlocks after media has been insterted (booting with a card
  10   plugged in counts as an insertion event).
  11
  12   Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
  13
  14   This program and the accompanying materials
  15   are licensed and made available under the terms and conditions of the BSD License
  16   which accompanies this distribution.  The full text of the license may be found at
  17   http://opensource.org/licenses/bsd-license.php
  18
  19   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  20   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  21
  22 **/
  23
  24 #include <Uefi.h>
  25
  26 #include "MMCHS.h"
  27
  28 EFI_BLOCK_IO_MEDIA gMMCHSMedia = {
  29   SIGNATURE_32('s','d','i','o'),            // MediaId
  30   TRUE,                                     // RemovableMedia
  31   FALSE,                                    // MediaPresent
  32   FALSE,                                    // LogicalPartition
  33   FALSE,                                    // ReadOnly
  34   FALSE,                                    // WriteCaching
  35   512,                                      // BlockSize
  36   4,                                        // IoAlign
  37   0,                                        // Pad
  38   0                                         // LastBlock
  39 };
  40
  41 typedef struct {
  42   VENDOR_DEVICE_PATH  Mmc;
  43   EFI_DEVICE_PATH     End;
  44 } MMCHS_DEVICE_PATH;
  45
  46 MMCHS_DEVICE_PATH gMmcHsDevicePath = {
  47   {
  48     HARDWARE_DEVICE_PATH,
  49     HW_VENDOR_DP,
  50     (UINT8)(sizeof(VENDOR_DEVICE_PATH)),
  51     (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),
  52     0xb615f1f5, 0x5088, 0x43cd, 0x80, 0x9c, 0xa1, 0x6e, 0x52, 0x48, 0x7d, 0x00
  53   },
  54   {
  55     END_DEVICE_PATH_TYPE,
  56     END_ENTIRE_DEVICE_PATH_SUBTYPE,
  57     sizeof (EFI_DEVICE_PATH_PROTOCOL),
  58     0
  59   }
  60 };
  61
  62 CARD_INFO                  gCardInfo;
  63 EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;
  64 EFI_EVENT                  gTimerEvent;
  65 BOOLEAN                    gMediaChange = FALSE;
  66
  67 //
  68 // Internal Functions
  69 //
  70
  71
  72 VOID
  73 ParseCardCIDData (
  74   UINT32 Response0,
  75   UINT32 Response1,
  76   UINT32 Response2,
  77   UINT32 Response3
  78   )
  79 {
  80   gCardInfo.CIDData.MDT = ((Response0 >> 8) & 0xFFF);
  81   gCardInfo.CIDData.PSN = (((Response0 >> 24) & 0xFF) | ((Response1 & 0xFFFFFF) << 8));
  82   gCardInfo.CIDData.PRV = ((Response1 >> 24) & 0xFF);
  83   gCardInfo.CIDData.PNM[4] = ((Response2) & 0xFF);
  84   gCardInfo.CIDData.PNM[3] = ((Response2 >> 8) & 0xFF);
  85   gCardInfo.CIDData.PNM[2] = ((Response2 >> 16) & 0xFF);
  86   gCardInfo.CIDData.PNM[1] = ((Response2 >> 24) & 0xFF);
  87   gCardInfo.CIDData.PNM[0] = ((Response3) & 0xFF);
  88   gCardInfo.CIDData.OID = ((Response3 >> 8) & 0xFFFF);
  89   gCardInfo.CIDData.MID = ((Response3 >> 24) & 0xFF);
  90 }
  91
  92
  93 VOID
  94 UpdateMMCHSClkFrequency (
  95   UINTN NewCLKD
  96   )
  97 {
  98   //Set Clock enable to 0x0 to not provide the clock to the card
  99   MmioAnd32 (MMCHS_SYSCTL, ~CEN);
 100
 101   //Set new clock frequency.
 102   MmioAndThenOr32 (MMCHS_SYSCTL, ~CLKD_MASK, NewCLKD << 6);
 103
 104   //Poll till Internal Clock Stable
 105   while ((MmioRead32 (MMCHS_SYSCTL) & ICS_MASK) != ICS);
 106
 107   //Set Clock enable to 0x1 to provide the clock to the card
 108   MmioOr32 (MMCHS_SYSCTL, CEN);
 109 }
 110
 111
 112 EFI_STATUS
 113 SendCmd (
 114   UINTN Cmd,
 115   UINTN CmdInterruptEnableVal,
 116   UINTN CmdArgument
 117   )
 118 {
 119   UINTN MmcStatus;
 120   UINTN RetryCount = 0;
 121
 122   //Check if command line is in use or not. Poll till command line is available.
 123   while ((MmioRead32 (MMCHS_PSTATE) & DATI_MASK) == DATI_NOT_ALLOWED);
 124
 125   //Provide the block size.
 126   MmioWrite32 (MMCHS_BLK, BLEN_512BYTES);
 127
 128   //Setting Data timeout counter value to max value.
 129   MmioAndThenOr32 (MMCHS_SYSCTL, ~DTO_MASK, DTO_VAL);
 130
 131   //Clear Status register.
 132   MmioWrite32 (MMCHS_STAT, 0xFFFFFFFF);
 133
 134   //Set command argument register
 135   MmioWrite32 (MMCHS_ARG, CmdArgument);
 136
 137   //Enable interrupt enable events to occur
 138   MmioWrite32 (MMCHS_IE, CmdInterruptEnableVal);
 139
 140   //Send a command
 141   MmioWrite32 (MMCHS_CMD, Cmd);
 142
 143   //Check for the command status.
 144   while (RetryCount < MAX_RETRY_COUNT) {
 145     do {
 146       MmcStatus = MmioRead32 (MMCHS_STAT);
 147     } while (MmcStatus == 0);
 148
 149     //Read status of command response
 150     if ((MmcStatus & ERRI) != 0) {
 151
 152       //Perform soft-reset for mmci_cmd line.
 153       MmioOr32 (MMCHS_SYSCTL, SRC);
 154       while ((MmioRead32 (MMCHS_SYSCTL) & SRC));
 155
 156       DEBUG ((EFI_D_INFO, "MmcStatus: %x\n", MmcStatus));
 157       return EFI_DEVICE_ERROR;
 158     }
 159
 160     //Check if command is completed.
 161     if ((MmcStatus & CC) == CC) {
 162       MmioWrite32 (MMCHS_STAT, CC);
 163       break;
 164     }
 165
 166     RetryCount++;
 167   }
 168
 169   if (RetryCount == MAX_RETRY_COUNT) {
 170     return EFI_TIMEOUT;
 171   }
 172
 173   return EFI_SUCCESS;
 174 }
 175
 176
 177 VOID
 178 GetBlockInformation (
 179   UINTN *BlockSize,
 180   UINTN *NumBlocks
 181   )
 182 {
 183   CSD_SDV2 *CsdSDV2Data;
 184   UINTN    CardSize;
 185
 186   if (gCardInfo.CardType == SD_CARD_2_HIGH) {
 187     CsdSDV2Data = (CSD_SDV2 *)&gCardInfo.CSDData;
 188
 189     //Populate BlockSize.
 190     *BlockSize = (0x1UL << CsdSDV2Data->READ_BL_LEN);
 191
 192     //Calculate Total number of blocks.
 193     CardSize = CsdSDV2Data->C_SIZELow16 | (CsdSDV2Data->C_SIZEHigh6 << 2);
 194     *NumBlocks = ((CardSize + 1) * 1024);
 195   } else {
 196     //Populate BlockSize.
 197     *BlockSize = (0x1UL << gCardInfo.CSDData.READ_BL_LEN);
 198
 199     //Calculate Total number of blocks.
 200     CardSize = gCardInfo.CSDData.C_SIZELow2 | (gCardInfo.CSDData.C_SIZEHigh10 << 2);
 201     *NumBlocks = (CardSize + 1) * (1 << (gCardInfo.CSDData.C_SIZE_MULT + 2));
 202   }
 203
 204   //For >=2G card, BlockSize may be 1K, but the transfer size is 512 bytes.
 205   if (*BlockSize > 512) {
 206     *NumBlocks = MultU64x32(*NumBlocks, *BlockSize/2);
 207     *BlockSize = 512;
 208   }
 209
 210   DEBUG ((EFI_D_INFO, "Card type: %x, BlockSize: %x, NumBlocks: %x\n", gCardInfo.CardType, *BlockSize, *NumBlocks));
 211 }
 212
 213
 214 VOID
 215 CalculateCardCLKD (
 216   UINTN *ClockFrequencySelect
 217   )
 218 {
 219   UINT8    MaxDataTransferRate;
 220   UINTN    TransferRateValue = 0;
 221   UINTN    TimeValue = 0 ;
 222   UINTN    Frequency = 0;
 223
 224   MaxDataTransferRate = gCardInfo.CSDData.TRAN_SPEED;
 225
 226   //Calculate Transfer rate unit (Bits 2:0 of TRAN_SPEED)
 227   switch (MaxDataTransferRate & 0x7) {
 228     case 0:
 229       TransferRateValue = 100 * 1000;
 230       break;
 231
 232     case 1:
 233       TransferRateValue = 1 * 1000 * 1000;
 234       break;
 235
 236     case 2:
 237       TransferRateValue = 10 * 1000 * 1000;
 238       break;
 239
 240     case 3:
 241       TransferRateValue = 100 * 1000 * 1000;
 242       break;
 243
 244     default:
 245       DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));
 246       ASSERT(FALSE);
 247   }
 248
 249   //Calculate Time value (Bits 6:3 of TRAN_SPEED)
 250   switch ((MaxDataTransferRate >> 3) & 0xF) {
 251     case 1:
 252       TimeValue = 10;
 253       break;
 254
 255     case 2:
 256       TimeValue = 12;
 257       break;
 258
 259     case 3:
 260       TimeValue = 13;
 261       break;
 262
 263     case 4:
 264       TimeValue = 15;
 265       break;
 266
 267     case 5:
 268       TimeValue = 20;
 269       break;
 270
 271     case 6:
 272       TimeValue = 25;
 273       break;
 274
 275     case 7:
 276       TimeValue = 30;
 277       break;
 278
 279     case 8:
 280       TimeValue = 35;
 281       break;
 282
 283     case 9:
 284       TimeValue = 40;
 285       break;
 286
 287     case 10:
 288       TimeValue = 45;
 289       break;
 290
 291     case 11:
 292       TimeValue = 50;
 293       break;
 294
 295     case 12:
 296       TimeValue = 55;
 297       break;
 298
 299     case 13:
 300       TimeValue = 60;
 301       break;
 302
 303     case 14:
 304       TimeValue = 70;
 305       break;
 306
 307     case 15:
 308       TimeValue = 80;
 309       break;
 310
 311     default:
 312       DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));
 313       ASSERT(FALSE);
 314   }
 315
 316   Frequency = TransferRateValue * TimeValue/10;
 317
 318   //Calculate Clock divider value to program in MMCHS_SYSCTL[CLKD] field.
 319   *ClockFrequencySelect = ((MMC_REFERENCE_CLK/Frequency) + 1);
 320
 321   DEBUG ((EFI_D_INFO, "MaxDataTransferRate: 0x%x, Frequency: %d KHz, ClockFrequencySelect: %x\n", MaxDataTransferRate, Frequency/1000, *ClockFrequencySelect));
 322 }
 323
 324
 325 VOID
 326 GetCardConfigurationData (
 327   VOID
 328   )
 329 {
 330   UINTN  BlockSize;
 331   UINTN  NumBlocks;
 332   UINTN  ClockFrequencySelect;
 333
 334   //Calculate BlockSize and Total number of blocks in the detected card.
 335   GetBlockInformation(&BlockSize, &NumBlocks);
 336   gCardInfo.BlockSize = BlockSize;
 337   gCardInfo.NumBlocks = NumBlocks;
 338
 339   //Calculate Card clock divider value.
 340   CalculateCardCLKD(&ClockFrequencySelect);
 341   gCardInfo.ClockFrequencySelect = ClockFrequencySelect;
 342 }
 343
 344
 345 EFI_STATUS
 346 InitializeMMCHS (
 347   VOID
 348   )
 349 {
 350   UINT8      Data = 0;
 351   EFI_STATUS Status;
 352
 353   //Select Device group to belong to P1 device group in Power IC.
 354   Data = DEV_GRP_P1;
 355   Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEV_GRP), 1, &Data);
 356   ASSERT_EFI_ERROR(Status);
 357
 358   //Configure voltage regulator for MMC1 in Power IC to output 3.0 voltage.
 359   Data = VSEL_3_00V;
 360   Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEDICATED_REG), 1, &Data);
 361   ASSERT_EFI_ERROR(Status);
 362
 363   //After ramping up voltage, set VDDS stable bit to indicate that voltage level is stable.
 364   MmioOr32 (CONTROL_PBIAS_LITE, (PBIASLITEVMODE0 | PBIASLITEPWRDNZ0 | PBIASSPEEDCTRL0 | PBIASLITEVMODE1 | PBIASLITEWRDNZ1));
 365
 366   // Enable WP GPIO
 367   MmioAndThenOr32 (GPIO1_BASE + GPIO_OE, ~BIT23, BIT23);
 368
 369   // Enable Card Detect
 370   Data = CARD_DETECT_ENABLE;
 371   gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, TPS65950_GPIO_CTRL), 1, &Data);
 372
 373
 374   return Status;
 375 }
 376
 377
 378 EFI_STATUS
 379 PerformCardIdenfication (
 380   VOID
 381   )
 382 {
 383   EFI_STATUS Status;
 384   UINTN      CmdArgument = 0;
 385   UINTN      Response = 0;
 386   UINTN      RetryCount = 0;
 387   BOOLEAN    SDCmd8Supported = FALSE;
 388
 389   //Enable interrupts.
 390   MmioWrite32 (MMCHS_IE, (BADA_EN | CERR_EN | DEB_EN | DCRC_EN | DTO_EN | CIE_EN |
 391     CEB_EN | CCRC_EN | CTO_EN | BRR_EN | BWR_EN | TC_EN | CC_EN));
 392
 393   //Controller INIT procedure start.
 394   MmioOr32 (MMCHS_CON, INIT);
 395   MmioWrite32 (MMCHS_CMD, 0x00000000);
 396   while (!(MmioRead32 (MMCHS_STAT) & CC));
 397
 398   //Wait for 1 ms
 399   gBS->Stall(1000);
 400
 401   //Set CC bit to 0x1 to clear the flag
 402   MmioOr32 (MMCHS_STAT, CC);
 403
 404   //Retry INIT procedure.
 405   MmioWrite32 (MMCHS_CMD, 0x00000000);
 406   while (!(MmioRead32 (MMCHS_STAT) & CC));
 407
 408   //End initialization sequence
 409   MmioAnd32 (MMCHS_CON, ~INIT);
 410
 411   MmioOr32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_ON));
 412
 413   //Change clock frequency to 400KHz to fit protocol
 414   UpdateMMCHSClkFrequency(CLKD_400KHZ);
 415
 416   MmioOr32 (MMCHS_CON, OD);
 417
 418   //Send CMD0 command.
 419   Status = SendCmd (CMD0, CMD0_INT_EN, CmdArgument);
 420   if (EFI_ERROR(Status)) {
 421     DEBUG ((EFI_D_ERROR, "Cmd0 fails.\n"));
 422     return Status;
 423   }
 424
 425   DEBUG ((EFI_D_INFO, "CMD0 response: %x\n", MmioRead32 (MMCHS_RSP10)));
 426
 427   //Send CMD5 command.
 428   Status = SendCmd (CMD5, CMD5_INT_EN, CmdArgument);
 429   if (Status == EFI_SUCCESS) {
 430     DEBUG ((EFI_D_ERROR, "CMD5 Success. SDIO card. Follow SDIO card specification.\n"));
 431     DEBUG ((EFI_D_INFO, "CMD5 response: %x\n", MmioRead32 (MMCHS_RSP10)));
 432     //NOTE: Returning unsupported error for now. Need to implement SDIO specification.
 433     return EFI_UNSUPPORTED;
 434   } else {
 435     DEBUG ((EFI_D_INFO, "CMD5 fails. Not an SDIO card.\n"));
 436   }
 437
 438   MmioOr32 (MMCHS_SYSCTL, SRC);
 439   gBS->Stall(1000);
 440   while ((MmioRead32 (MMCHS_SYSCTL) & SRC));
 441
 442   //Send CMD8 command. (New v2.00 command for Voltage check)
 443   //Only 2.7V - 3.6V is supported for SD2.0, only SD 2.0 card can pass.
 444   //MMC & SD1.1 card will fail this command.
 445   CmdArgument = CMD8_ARG;
 446   Status = SendCmd (CMD8, CMD8_INT_EN, CmdArgument);
 447   if (Status == EFI_SUCCESS) {
 448     Response = MmioRead32 (MMCHS_RSP10);
 449     DEBUG ((EFI_D_INFO, "CMD8 success. CMD8 response: %x\n", Response));
 450     if (Response != CmdArgument) {
 451       return EFI_DEVICE_ERROR;
 452     }
 453     DEBUG ((EFI_D_INFO, "Card is SD2.0\n"));
 454     SDCmd8Supported = TRUE; //Supports high capacity.
 455   } else {
 456     DEBUG ((EFI_D_INFO, "CMD8 fails. Not an SD2.0 card.\n"));
 457   }
 458
 459   MmioOr32 (MMCHS_SYSCTL, SRC);
 460   gBS->Stall(1000);
 461   while ((MmioRead32 (MMCHS_SYSCTL) & SRC));
 462
 463   //Poll till card is busy
 464   while (RetryCount < MAX_RETRY_COUNT) {
 465     //Send CMD55 command.
 466     CmdArgument = 0;
 467     Status = SendCmd (CMD55, CMD55_INT_EN, CmdArgument);
 468     if (Status == EFI_SUCCESS) {
 469       DEBUG ((EFI_D_INFO, "CMD55 success. CMD55 response: %x\n", MmioRead32 (MMCHS_RSP10)));
 470       gCardInfo.CardType = SD_CARD;
 471     } else {
 472       DEBUG ((EFI_D_INFO, "CMD55 fails.\n"));
 473       gCardInfo.CardType = MMC_CARD;
 474     }
 475
 476     //Send appropriate command for the card type which got detected.
 477     if (gCardInfo.CardType == SD_CARD) {
 478       CmdArgument = ((UINTN *) &(gCardInfo.OCRData))[0];
 479
 480       //Set HCS bit.
 481       if (SDCmd8Supported) {
 482         CmdArgument |= HCS;
 483       }
 484
 485       Status = SendCmd (ACMD41, ACMD41_INT_EN, CmdArgument);
 486       if (EFI_ERROR(Status)) {
 487         DEBUG ((EFI_D_INFO, "ACMD41 fails.\n"));
 488         return Status;
 489       }
 490       ((UINT32 *) &(gCardInfo.OCRData))[0] = MmioRead32 (MMCHS_RSP10);
 491       DEBUG ((EFI_D_INFO, "SD card detected. ACMD41 OCR: %x\n", ((UINT32 *) &(gCardInfo.OCRData))[0]));
 492     } else if (gCardInfo.CardType == MMC_CARD) {
 493       CmdArgument = 0;
 494       Status = SendCmd (CMD1, CMD1_INT_EN, CmdArgument);
 495       if (EFI_ERROR(Status)) {
 496         DEBUG ((EFI_D_INFO, "CMD1 fails.\n"));
 497         return Status;
 498       }
 499       Response = MmioRead32 (MMCHS_RSP10);
 500       DEBUG ((EFI_D_INFO, "MMC card detected.. CMD1 response: %x\n", Response));
 501
 502       //NOTE: For now, I am skipping this since I only have an SD card.
 503       //Compare card OCR and host OCR (Section 22.6.1.3.2.4)
 504       return EFI_UNSUPPORTED; //For now, MMC is not supported.
 505     }
 506
 507     //Poll the card until it is out of its power-up sequence.
 508     if (gCardInfo.OCRData.Busy == 1) {
 509
 510       if (SDCmd8Supported) {
 511         gCardInfo.CardType = SD_CARD_2;
 512       }
 513
 514       //Card is ready. Check CCS (Card capacity status) bit (bit#30).
 515       //SD 2.0 standard card will response with CCS 0, SD high capacity card will respond with CCS 1.
 516       if (gCardInfo.OCRData.AccessMode & BIT1) {
 517         gCardInfo.CardType = SD_CARD_2_HIGH;
 518         DEBUG ((EFI_D_INFO, "High capacity card.\n"));
 519       } else {
 520         DEBUG ((EFI_D_INFO, "Standard capacity card.\n"));
 521       }
 522
 523       break;
 524     }
 525
 526     gBS->Stall(1000);
 527     RetryCount++;
 528   }
 529
 530   if (RetryCount == MAX_RETRY_COUNT) {
 531     DEBUG ((EFI_D_ERROR, "Timeout error. RetryCount: %d\n", RetryCount));
 532     return EFI_TIMEOUT;
 533   }
 534
 535   //Read CID data.
 536   CmdArgument = 0;
 537   Status = SendCmd (CMD2, CMD2_INT_EN, CmdArgument);
 538   if (EFI_ERROR(Status)) {
 539     DEBUG ((EFI_D_ERROR, "CMD2 fails. Status: %x\n", Status));
 540     return Status;
 541   }
 542
 543   DEBUG ((EFI_D_INFO, "CMD2 response: %x %x %x %x\n", MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76)));
 544
 545   //Parse CID register data.
 546   ParseCardCIDData(MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76));
 547
 548   //Read RCA
 549   CmdArgument = 0;
 550   Status = SendCmd (CMD3, CMD3_INT_EN, CmdArgument);
 551   if (EFI_ERROR(Status)) {
 552     DEBUG ((EFI_D_ERROR, "CMD3 fails. Status: %x\n", Status));
 553     return Status;
 554   }
 555
 556   //Set RCA for the detected card. RCA is CMD3 response.
 557   gCardInfo.RCA = (MmioRead32 (MMCHS_RSP10) >> 16);
 558   DEBUG ((EFI_D_INFO, "CMD3 response: RCA %x\n", gCardInfo.RCA));
 559
 560   //MMC Bus setting change after card identification.
 561   MmioAnd32 (MMCHS_CON, ~OD);
 562   MmioOr32 (MMCHS_HCTL, SDVS_3_0_V);
 563   UpdateMMCHSClkFrequency(CLKD_400KHZ); //Set the clock frequency to 400KHz.
 564
 565   return EFI_SUCCESS;
 566 }
 567
 568
 569 EFI_STATUS
 570 GetCardSpecificData (
 571   VOID
 572   )
 573 {
 574   EFI_STATUS Status;
 575   UINTN      CmdArgument;
 576
 577   //Send CMD9 to retrieve CSD.
 578   CmdArgument = gCardInfo.RCA << 16;
 579   Status = SendCmd (CMD9, CMD9_INT_EN, CmdArgument);
 580   if (EFI_ERROR(Status)) {
 581     DEBUG ((EFI_D_ERROR, "CMD9 fails. Status: %x\n", Status));
 582     return Status;
 583   }
 584
 585   //Populate 128-bit CSD register data.
 586   ((UINT32 *)&(gCardInfo.CSDData))[0] = MmioRead32 (MMCHS_RSP10);
 587   ((UINT32 *)&(gCardInfo.CSDData))[1] = MmioRead32 (MMCHS_RSP32);
 588   ((UINT32 *)&(gCardInfo.CSDData))[2] = MmioRead32 (MMCHS_RSP54);
 589   ((UINT32 *)&(gCardInfo.CSDData))[3] = MmioRead32 (MMCHS_RSP76);
 590
 591   DEBUG ((EFI_D_INFO, "CMD9 response: %x %x %x %x\n", MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76)));
 592
 593   //Calculate total number of blocks and max. data transfer rate supported by the detected card.
 594   GetCardConfigurationData();
 595
 596   //Change MMCHS clock frequency to what detected card can support.
 597   UpdateMMCHSClkFrequency(gCardInfo.ClockFrequencySelect);
 598
 599   return Status;
 600 }
 601
 602
 603 EFI_STATUS
 604 PerformCardConfiguration (
 605   VOID
 606   )
 607 {
 608   UINTN      CmdArgument = 0;
 609   EFI_STATUS Status;
 610
 611   //Send CMD7
 612   CmdArgument = gCardInfo.RCA << 16;
 613   Status = SendCmd (CMD7, CMD7_INT_EN, CmdArgument);
 614   if (EFI_ERROR(Status)) {
 615     DEBUG ((EFI_D_ERROR, "CMD7 fails. Status: %x\n", Status));
 616     return Status;
 617   }
 618
 619   if ((gCardInfo.CardType != UNKNOWN_CARD) && (gCardInfo.CardType != MMC_CARD)) {
 620     // We could read SCR register, but SD Card Phys spec stats any SD Card shall
 621     // set SCR.SD_BUS_WIDTHS to support 4-bit mode, so why bother?
 622
 623     // Send ACMD6 (application specific commands must be prefixed with CMD55)
 624     Status = SendCmd (CMD55, CMD55_INT_EN, CmdArgument);
 625     if (!EFI_ERROR (Status)) {
 626       // set device into 4-bit data bus mode
 627       Status = SendCmd (ACMD6, ACMD6_INT_EN, 0x2);
 628       if (!EFI_ERROR (Status)) {
 629         // Set host controler into 4-bit mode
 630         MmioOr32 (MMCHS_HCTL, DTW_4_BIT);
 631         DEBUG ((EFI_D_INFO, "SD Memory Card set to 4-bit mode\n"));
 632       }
 633     }
 634   }
 635
 636   //Send CMD16 to set the block length
 637   CmdArgument = gCardInfo.BlockSize;
 638   Status = SendCmd (CMD16, CMD16_INT_EN, CmdArgument);
 639   if (EFI_ERROR(Status)) {
 640     DEBUG ((EFI_D_ERROR, "CMD16 fails. Status: %x\n", Status));
 641     return Status;
 642   }
 643
 644   return EFI_SUCCESS;
 645 }
 646
 647
 648 EFI_STATUS
 649 ReadBlockData (
 650   IN  EFI_BLOCK_IO_PROTOCOL       *This,
 651   OUT VOID                        *Buffer
 652   )
 653 {
 654   UINTN MmcStatus;
 655   UINTN *DataBuffer = Buffer;
 656   UINTN DataSize = This->Media->BlockSize/4;
 657   UINTN Count;
 658   UINTN RetryCount = 0;
 659
 660   //Check controller status to make sure there is no error.
 661   while (RetryCount < MAX_RETRY_COUNT) {
 662     do {
 663       //Read Status.
 664       MmcStatus = MmioRead32 (MMCHS_STAT);
 665     } while(MmcStatus == 0);
 666
 667     //Check if Buffer read ready (BRR) bit is set?
 668     if (MmcStatus & BRR) {
 669
 670       //Clear BRR bit
 671       MmioOr32 (MMCHS_STAT, BRR);
 672
 673       //Read block worth of data.
 674       for (Count = 0; Count < DataSize; Count++) {
 675         *DataBuffer++ = MmioRead32 (MMCHS_DATA);
 676       }
 677       break;
 678     }
 679     RetryCount++;
 680   }
 681
 682   if (RetryCount == MAX_RETRY_COUNT) {
 683     return EFI_TIMEOUT;
 684   }
 685
 686   return EFI_SUCCESS;
 687 }
 688
 689
 690 EFI_STATUS
 691 WriteBlockData (
 692   IN  EFI_BLOCK_IO_PROTOCOL       *This,
 693   OUT VOID                        *Buffer
 694   )
 695 {
 696   UINTN MmcStatus;
 697   UINTN *DataBuffer = Buffer;
 698   UINTN DataSize = This->Media->BlockSize/4;
 699   UINTN Count;
 700   UINTN RetryCount = 0;
 701
 702   //Check controller status to make sure there is no error.
 703   while (RetryCount < MAX_RETRY_COUNT) {
 704     do {
 705       //Read Status.
 706       MmcStatus = MmioRead32 (MMCHS_STAT);
 707     } while(MmcStatus == 0);
 708
 709     //Check if Buffer write ready (BWR) bit is set?
 710     if (MmcStatus & BWR) {
 711
 712       //Clear BWR bit
 713       MmioOr32 (MMCHS_STAT, BWR);
 714
 715       //Write block worth of data.
 716       for (Count = 0; Count < DataSize; Count++) {
 717         MmioWrite32 (MMCHS_DATA, *DataBuffer++);
 718       }
 719
 720       break;
 721     }
 722     RetryCount++;
 723   }
 724
 725   if (RetryCount == MAX_RETRY_COUNT) {
 726     return EFI_TIMEOUT;
 727   }
 728
 729   return EFI_SUCCESS;
 730 }
 731
 732
 733 EFI_STATUS
 734 TransferBlockData (
 735   IN  EFI_BLOCK_IO_PROTOCOL       *This,
 736   OUT VOID                        *Buffer,
 737   IN  OPERATION_TYPE              OperationType
 738   )
 739 {
 740   EFI_STATUS Status;
 741   UINTN      MmcStatus;
 742   UINTN      RetryCount = 0;
 743
 744   //Read or Write data.
 745   if (OperationType == READ) {
 746     Status = ReadBlockData(This, Buffer);
 747     if (EFI_ERROR(Status)) {
 748       DEBUG((EFI_D_ERROR, "ReadBlockData fails.\n"));
 749       return Status;
 750     }
 751   } else if (OperationType == WRITE) {
 752     Status = WriteBlockData(This, Buffer);
 753     if (EFI_ERROR(Status)) {
 754       DEBUG((EFI_D_ERROR, "WriteBlockData fails.\n"));
 755       return Status;
 756     }
 757   }
 758
 759   //Check for the Transfer completion.
 760   while (RetryCount < MAX_RETRY_COUNT) {
 761     //Read Status
 762     do {
 763       MmcStatus = MmioRead32 (MMCHS_STAT);
 764     } while (MmcStatus == 0);
 765
 766     //Check if Transfer complete (TC) bit is set?
 767     if (MmcStatus & TC) {
 768       break;
 769     } else {
 770       DEBUG ((EFI_D_ERROR, "MmcStatus for TC: %x\n", MmcStatus));
 771       //Check if DEB, DCRC or DTO interrupt occured.
 772       if ((MmcStatus & DEB) | (MmcStatus & DCRC) | (MmcStatus & DTO)) {
 773         //There was an error during the data transfer.
 774
 775         //Set SRD bit to 1 and wait until it return to 0x0.
 776         MmioOr32 (MMCHS_SYSCTL, SRD);
 777         while((MmioRead32 (MMCHS_SYSCTL) & SRD) != 0x0);
 778
 779         return EFI_DEVICE_ERROR;
 780       }
 781     }
 782     RetryCount++;
 783   }
 784
 785   if (RetryCount == MAX_RETRY_COUNT) {
 786     DEBUG ((EFI_D_ERROR, "TransferBlockData timed out.\n"));
 787     return EFI_TIMEOUT;
 788   }
 789
 790   return EFI_SUCCESS;
 791 }
 792
 793 BOOLEAN
 794 CardPresent (
 795   VOID
 796   )
 797 {
 798   EFI_STATUS  Status;
 799   UINT8       Data;
 800
 801   //
 802   // Card detect is a GPIO0 on the TPS65950
 803   //
 804   Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATAIN1), 1, &Data);
 805   if (EFI_ERROR (Status)) {
 806     return FALSE;
 807   }
 808
 809   if ((Data & CARD_DETECT_BIT) == CARD_DETECT_BIT) {
 810     // No Card present
 811     return FALSE;
 812   } else {
 813     return TRUE;
 814   }
 815 }
 816
 817 EFI_STATUS
 818 DetectCard (
 819   VOID
 820   )
 821 {
 822   EFI_STATUS    Status;
 823
 824   if (!CardPresent ()) {
 825     return EFI_NO_MEDIA;
 826   }
 827
 828   //Initialize MMC host controller clocks.
 829   Status = InitializeMMCHS ();
 830   if (EFI_ERROR(Status)) {
 831     DEBUG ((EFI_D_ERROR, "Initialize MMC host controller fails. Status: %x\n", Status));
 832     return Status;
 833   }
 834
 835   //Software reset of the MMCHS host controller.
 836   MmioWrite32 (MMCHS_SYSCONFIG, SOFTRESET);
 837   gBS->Stall(1000);
 838   while ((MmioRead32 (MMCHS_SYSSTATUS) & RESETDONE_MASK) != RESETDONE);
 839
 840   //Soft reset for all.
 841   MmioWrite32 (MMCHS_SYSCTL, SRA);
 842   gBS->Stall(1000);
 843   while ((MmioRead32 (MMCHS_SYSCTL) & SRA) != 0x0);
 844
 845   //Voltage capabilities initialization. Activate VS18 and VS30.
 846   MmioOr32 (MMCHS_CAPA, (VS30 | VS18));
 847
 848   //Wakeup configuration
 849   MmioOr32 (MMCHS_SYSCONFIG, ENAWAKEUP);
 850   MmioOr32 (MMCHS_HCTL, IWE);
 851
 852   //MMCHS Controller default initialization
 853   MmioOr32 (MMCHS_CON, (OD | DW8_1_4_BIT | CEATA_OFF));
 854
 855   MmioWrite32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_OFF));
 856
 857   //Enable internal clock
 858   MmioOr32 (MMCHS_SYSCTL, ICE);
 859
 860   //Set the clock frequency to 80KHz.
 861   UpdateMMCHSClkFrequency (CLKD_80KHZ);
 862
 863   //Enable SD bus power.
 864   MmioOr32 (MMCHS_HCTL, (SDBP_ON));
 865
 866   //Poll till SD bus power bit is set.
 867   while ((MmioRead32 (MMCHS_HCTL) & SDBP_MASK) != SDBP_ON);
 868
 869   //Card idenfication
 870   Status = PerformCardIdenfication ();
 871   if (EFI_ERROR(Status)) {
 872     DEBUG ((EFI_D_ERROR, "No MMC/SD card detected.\n"));
 873     return Status;
 874   }
 875
 876   //Get CSD (Card specific data) for the detected card.
 877   Status = GetCardSpecificData();
 878   if (EFI_ERROR(Status)) {
 879     return Status;
 880   }
 881
 882   //Configure the card in data transfer mode.
 883   Status = PerformCardConfiguration();
 884   if (EFI_ERROR(Status)) {
 885     return Status;
 886   }
 887
 888   //Patch the Media structure.
 889   gMMCHSMedia.LastBlock    = (gCardInfo.NumBlocks - 1);
 890   gMMCHSMedia.BlockSize    = gCardInfo.BlockSize;
 891   gMMCHSMedia.ReadOnly     = (MmioRead32 (GPIO1_BASE + GPIO_DATAIN) & BIT23) == BIT23;
 892   gMMCHSMedia.MediaPresent = TRUE;
 893   gMMCHSMedia.MediaId++;
 894   gMediaChange = FALSE;
 895
 896   DEBUG ((EFI_D_INFO, "SD Card Media Change\n"));
 897
 898   return Status;
 899 }
 900
 901
 902 EFI_STATUS
 903 SdReadWrite (
 904   IN EFI_BLOCK_IO_PROTOCOL    *This,
 905   IN  UINTN                   Lba,
 906   OUT VOID                    *Buffer,
 907   IN  UINTN                   BufferSize,
 908   IN  OPERATION_TYPE          OperationType
 909   )
 910 {
 911   EFI_STATUS Status = EFI_SUCCESS;
 912   UINTN      RetryCount = 0;
 913   UINTN      NumBlocks;
 914   UINTN      Cmd = 0;
 915   UINTN      CmdInterruptEnable = 0;
 916   UINTN      CmdArgument = 0;
 917   EFI_TPL    OldTpl;
 918   BOOLEAN    MediaPresentLastTime;
 919   BOOLEAN    Update;
 920
 921   OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 922
 923
 924   if (Buffer == NULL) {
 925     Status = EFI_INVALID_PARAMETER;
 926     goto Done;
 927   }
 928
 929   Update               = FALSE;
 930   MediaPresentLastTime = gMMCHSMedia.MediaPresent;
 931
 932   if (gMediaChange) {
 933     Status = DetectCard  ();
 934     if (EFI_ERROR (Status)) {
 935       // We detected a removal
 936       gMMCHSMedia.MediaPresent = FALSE;
 937       gMMCHSMedia.LastBlock    = 0;
 938       gMMCHSMedia.BlockSize    = 512;  // Should be zero but there is a bug in DiskIo
 939       gMMCHSMedia.ReadOnly     = FALSE;
 940     } else {
 941       Update = TRUE;
 942     }
 943     gMediaChange             = FALSE;
 944   } else if (!gMMCHSMedia.MediaPresent) {
 945     Status = EFI_NO_MEDIA;
 946     goto Done;
 947   }
 948
 949   if ((MediaPresentLastTime != gMMCHSMedia.MediaPresent) || Update) {
 950     gBS->ReinstallProtocolInterface (
 951           gImageHandle,
 952           &gEfiBlockIoProtocolGuid,
 953           &gBlockIo,
 954           &gBlockIo
 955           );
 956   }
 957
 958   if (EFI_ERROR (Status)) {
 959     goto Done;
 960   }
 961
 962    if (Lba > This->Media->LastBlock) {
 963     Status = EFI_INVALID_PARAMETER;
 964     goto Done;
 965   }
 966
 967   if ((BufferSize % This->Media->BlockSize) != 0) {
 968     Status = EFI_BAD_BUFFER_SIZE;
 969     goto Done;
 970   }
 971
 972   //Check if the data lines are not in use.
 973   while ((RetryCount++ < MAX_RETRY_COUNT) && ((MmioRead32 (MMCHS_PSTATE) & DATI_MASK) != DATI_ALLOWED));
 974   if (RetryCount == MAX_RETRY_COUNT) {
 975     Status = EFI_TIMEOUT;
 976     goto Done;
 977   }
 978
 979   //Populate the command information based on the operation type.
 980   if (OperationType == READ) {
 981     Cmd = CMD17; //Single block read
 982     CmdInterruptEnable = CMD17_INT_EN;
 983   } else if (OperationType == WRITE) {
 984     Cmd = CMD24; //Single block write
 985     CmdInterruptEnable = CMD24_INT_EN;
 986   }
 987
 988   //Calculate total number of blocks its going to read.
 989   NumBlocks = (BufferSize + (This->Media->BlockSize - 1))/This->Media->BlockSize;
 990
 991   //Set command argument based on the card access mode (Byte mode or Block mode)
 992   if (gCardInfo.OCRData.AccessMode & BIT1) {
 993     CmdArgument = (UINTN)Lba;
 994   } else {
 995     CmdArgument = (UINTN)Lba * This->Media->BlockSize;
 996   }
 997
 998   while(NumBlocks) {
 999     //Send Command.
1000     Status = SendCmd (Cmd, CmdInterruptEnable, CmdArgument);
1001     if (EFI_ERROR(Status)) {
1002       DEBUG ((EFI_D_ERROR, "CMD fails. Status: %x\n", Status));
1003       goto Done;
1004     }
1005
1006     //Transfer a block worth of data.
1007     Status = TransferBlockData(This, Buffer, OperationType);
1008     if (EFI_ERROR(Status)) {
1009       DEBUG ((EFI_D_ERROR, "TransferBlockData fails. %x\n", Status));
1010       goto Done;
1011     }
1012
1013     //Adjust command argument.
1014     if (gCardInfo.OCRData.AccessMode & BIT1) {
1015       CmdArgument++; //Increase BlockIndex by one.
1016     } else {
1017       CmdArgument += This->Media->BlockSize; //Increase BlockIndex by BlockSize
1018     }
1019
1020     //Adjust Buffer.
1021     Buffer = (UINT8 *)Buffer + This->Media->BlockSize;
1022     NumBlocks--;
1023   }
1024
1025 Done:
1026   gBS->RestoreTPL (OldTpl);
1027   return Status;
1028 }
1029
1030
1031 /**
1032   Reset the Block Device.
1033
1034   @param  This                 Indicates a pointer to the calling context.
1035   @param  ExtendedVerification Driver may perform diagnostics on reset.
1036
1037   @retval EFI_SUCCESS          The device was reset.
1038   @retval EFI_DEVICE_ERROR     The device is not functioning properly and could
1039                                not be reset.
1040
1041 **/
1042 EFI_STATUS
1043 EFIAPI
1044 MMCHSReset (
1045   IN EFI_BLOCK_IO_PROTOCOL          *This,
1046   IN BOOLEAN                        ExtendedVerification
1047   )
1048 {
1049   return EFI_SUCCESS;
1050 }
1051
1052
1053 /**
1054   Read BufferSize bytes from Lba into Buffer.
1055
1056   @param  This       Indicates a pointer to the calling context.
1057   @param  MediaId    Id of the media, changes every time the media is replaced.
1058   @param  Lba        The starting Logical Block Address to read from
1059   @param  BufferSize Size of Buffer, must be a multiple of device block size.
1060   @param  Buffer     A pointer to the destination buffer for the data. The caller is
1061                      responsible for either having implicit or explicit ownership of the buffer.
1062
1063   @retval EFI_SUCCESS           The data was read correctly from the device.
1064   @retval EFI_DEVICE_ERROR      The device reported an error while performing the read.
1065   @retval EFI_NO_MEDIA          There is no media in the device.
1066   @retval EFI_MEDIA_CHANGED     The MediaId does not matched the current device.
1067   @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
1068   @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid,
1069                                 or the buffer is not on proper alignment.
1070 EFI_STATUS
1071
1072 **/
1073 EFI_STATUS
1074 EFIAPI
1075 MMCHSReadBlocks (
1076   IN EFI_BLOCK_IO_PROTOCOL          *This,
1077   IN UINT32                         MediaId,
1078   IN EFI_LBA                        Lba,
1079   IN UINTN                          BufferSize,
1080   OUT VOID                          *Buffer
1081   )
1082 {
1083   EFI_STATUS Status;
1084
1085   //Perform Read operation.
1086   Status = SdReadWrite (This, (UINTN)Lba, Buffer, BufferSize, READ);
1087
1088   return Status;
1089 }
1090
1091
1092 /**
1093   Write BufferSize bytes from Lba into Buffer.
1094
1095   @param  This       Indicates a pointer to the calling context.
1096   @param  MediaId    The media ID that the write request is for.
1097   @param  Lba        The starting logical block address to be written. The caller is
1098                      responsible for writing to only legitimate locations.
1099   @param  BufferSize Size of Buffer, must be a multiple of device block size.
1100   @param  Buffer     A pointer to the source buffer for the data.
1101
1102   @retval EFI_SUCCESS           The data was written correctly to the device.
1103   @retval EFI_WRITE_PROTECTED   The device can not be written to.
1104   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
1105   @retval EFI_NO_MEDIA          There is no media in the device.
1106   @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
1107   @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
1108   @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid,
1109                                 or the buffer is not on proper alignment.
1110
1111 **/
1112 EFI_STATUS
1113 EFIAPI
1114 MMCHSWriteBlocks (
1115   IN EFI_BLOCK_IO_PROTOCOL          *This,
1116   IN UINT32                         MediaId,
1117   IN EFI_LBA                        Lba,
1118   IN UINTN                          BufferSize,
1119   IN VOID                           *Buffer
1120   )
1121 {
1122   EFI_STATUS  Status;
1123
1124   //Perform write operation.
1125   Status = SdReadWrite (This, (UINTN)Lba, Buffer, BufferSize, WRITE);
1126
1127   return Status;
1128 }
1129
1130
1131 /**
1132   Flush the Block Device.
1133
1134   @param  This              Indicates a pointer to the calling context.
1135
1136   @retval EFI_SUCCESS       All outstanding data was written to the device
1137   @retval EFI_DEVICE_ERROR  The device reported an error while writting back the data
1138   @retval EFI_NO_MEDIA      There is no media in the device.
1139
1140 **/
1141 EFI_STATUS
1142 EFIAPI
1143 MMCHSFlushBlocks (
1144   IN EFI_BLOCK_IO_PROTOCOL  *This
1145   )
1146 {
1147   return EFI_SUCCESS;
1148 }
1149
1150
1151 EFI_BLOCK_IO_PROTOCOL gBlockIo = {
1152   EFI_BLOCK_IO_INTERFACE_REVISION,   // Revision
1153   &gMMCHSMedia,                      // *Media
1154   MMCHSReset,                        // Reset
1155   MMCHSReadBlocks,                   // ReadBlocks
1156   MMCHSWriteBlocks,                  // WriteBlocks
1157   MMCHSFlushBlocks                   // FlushBlocks
1158 };
1159
1160
1161 /**
1162   Timer callback to convert card present hardware into a boolean that indicates
1163   a media change event has happened. If you just check the GPIO you could see
1164   card 1 and then check again after card 1 was removed and card 2 was inserted
1165   and you would still see media present. Thus you need the timer tick to catch
1166   the toggle event.
1167
1168   @param  Event                 Event whose notification function is being invoked.
1169   @param  Context               The pointer to the notification function's context,
1170                                 which is implementation-dependent. Not used.
1171
1172 **/
1173 VOID
1174 EFIAPI
1175 TimerCallback (
1176   IN  EFI_EVENT   Event,
1177   IN  VOID        *Context
1178   )
1179 {
1180   BOOLEAN Present;
1181
1182   Present = CardPresent ();
1183   if (gMMCHSMedia.MediaPresent) {
1184     if (!Present && !gMediaChange) {
1185       gMediaChange = TRUE;
1186     }
1187   } else {
1188     if (Present && !gMediaChange) {
1189       gMediaChange = TRUE;
1190     }
1191   }
1192 }
1193
1194
1195 EFI_STATUS
1196 EFIAPI
1197 MMCHSInitialize (
1198   IN EFI_HANDLE         ImageHandle,
1199   IN EFI_SYSTEM_TABLE   *SystemTable
1200   )
1201 {
1202   EFI_STATUS  Status;
1203
1204   Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);
1205   ASSERT_EFI_ERROR(Status);
1206
1207   ZeroMem (&gCardInfo, sizeof (CARD_INFO));
1208
1209   Status = gBS->CreateEvent (EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_CALLBACK, TimerCallback, NULL, &gTimerEvent);
1210   ASSERT_EFI_ERROR (Status);
1211
1212   Status = gBS->SetTimer (gTimerEvent, TimerPeriodic, 1000000ULL); // make me a PCD
1213   ASSERT_EFI_ERROR (Status);
1214
1215   //Publish BlockIO.
1216   Status = gBS->InstallMultipleProtocolInterfaces (
1217                   &ImageHandle,
1218                   &gEfiBlockIoProtocolGuid,    &gBlockIo,
1219                   &gEfiDevicePathProtocolGuid, &gMmcHsDevicePath,
1220                   NULL
1221                   );
1222   return Status;
1223 }