EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c

   1 /** @file
   2 *
   3 *  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
   4 *
   5 *  This program and the accompanying materials
   6 *  are licensed and made available under the terms and conditions of the BSD License
   7 *  which accompanies this distribution.  The full text of the license may be found at
   8 *  http://opensource.org/licenses/bsd-license.php
   9 *
  10 *  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 *  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 *
  13 **/
  14
  15 #include <Protocol/MmcHost.h>
  16 #include <Library/DebugLib.h>
  17 #include <Library/BaseMemoryLib.h>
  18 #include <Library/TimerLib.h>
  19
  20 #include "Mmc.h"
  21
  22 // Untested ...
  23 //#define USE_STREAM
  24
  25 #define MAX_RETRY_COUNT  1000
  26 #define CMD_RETRY_COUNT  20
  27
  28 EFI_STATUS
  29 MmcNotifyState (
  30   IN MMC_HOST_INSTANCE *MmcHostInstance,
  31   IN MMC_STATE State
  32   )
  33 {
  34   MmcHostInstance->State = State;
  35   return MmcHostInstance->MmcHost->NotifyState (MmcHostInstance->MmcHost, State);
  36 }
  37
  38 VOID
  39 PrintOCR (
  40   IN UINT32 Ocr
  41   )
  42 {
  43   UINTN minv;
  44   UINTN maxv;
  45   UINTN volts;
  46   UINTN loop;
  47
  48   minv  = 36;  // 3.6
  49   maxv  = 20;  // 2.0
  50   volts = 20;  // 2.0
  51
  52   // The MMC register bits [23:8] indicate the working range of the card
  53   for (loop = 8; loop < 24; loop++) {
  54     if (Ocr & (1 << loop)) {
  55       if (minv > volts) minv = volts;
  56       if (maxv < volts) maxv = volts + 1;
  57     }
  58     volts = volts + 1;
  59   }
  60
  61   DEBUG((EFI_D_ERROR, "- PrintOCR Ocr (0x%X)\n",Ocr));
  62   DEBUG((EFI_D_ERROR, "\t- Card operating voltage: %d.%d to %d.%d\n", minv/10, minv % 10, maxv/10, maxv % 10));
  63   if (((Ocr >> 29) & 3) == 0) {
  64     DEBUG((EFI_D_ERROR, "\t- AccessMode: Byte Mode\n"));
  65   } else {
  66     DEBUG((EFI_D_ERROR, "\t- AccessMode: Block Mode (0x%X)\n",((Ocr >> 29) & 3)));
  67   }
  68
  69   if (Ocr & MMC_OCR_POWERUP) {
  70     DEBUG((EFI_D_ERROR, "\t- PowerUp\n"));
  71   } else {
  72     DEBUG((EFI_D_ERROR, "\t- Voltage Not Supported\n"));
  73   }
  74 }
  75
  76 VOID PrintCID (
  77   IN UINT32* Cid
  78   )
  79 {
  80   DEBUG((EFI_D_ERROR, "- PrintCID\n"));
  81   DEBUG((EFI_D_ERROR, "\t- Manufacturing date: %d/%d\n",(Cid[0] >> 8) & 0xF,(Cid[0] >> 12) & 0xFF));
  82   DEBUG((EFI_D_ERROR, "\t- Product serial number: 0x%X%X\n",Cid[1] & 0xFFFFFF,(Cid[0] >> 24) & 0xFF));
  83   DEBUG((EFI_D_ERROR, "\t- Product revision: %d\n",Cid[1] >> 24));
  84   //DEBUG((EFI_D_ERROR, "\t- Product name: %s\n",(char*)(Cid + 2)));
  85   DEBUG((EFI_D_ERROR, "\t- OEM ID: %c%c\n",(Cid[3] >> 8) & 0xFF,(Cid[3] >> 16) & 0xFF));
  86 }
  87
  88 #if !defined(MDEPKG_NDEBUG)
  89 CONST CHAR8* mStrUnit[] = { "100kbit/s","1Mbit/s","10Mbit/s","100MBit/s","Unkbown","Unkbown","Unkbown","Unkbown" };
  90 CONST CHAR8* mStrValue[] = { "1.0","1.2","1.3","1.5","2.0","2.5","3.0","3.5","4.0","4.5","5.0","Unknown","Unknown","Unknown","Unknown" };
  91 #endif
  92
  93 VOID
  94 PrintCSD (
  95   IN UINT32* Csd
  96   )
  97 {
  98   UINTN Value;
  99
 100   if (((Csd[2] >> 30) & 0x3) == 0) {
 101     DEBUG((EFI_D_ERROR, "- PrintCSD Version 1.01-1.10/Version 2.00/Standard Capacity\n"));
 102   } else if (((Csd[2] >> 30) & 0x3) == 1) {
 103     DEBUG((EFI_D_ERROR, "- PrintCSD Version 2.00/High Capacity\n"));
 104   } else {
 105     DEBUG((EFI_D_ERROR, "- PrintCSD Version Higher than v3.3\n"));
 106   }
 107
 108   DEBUG((EFI_D_ERROR, "\t- Supported card command class: 0x%X\n",MMC_CSD_GET_CCC(Csd)));
 109   DEBUG((EFI_D_ERROR, "\t- Speed: %a %a\n",mStrValue[(MMC_CSD_GET_TRANSPEED(Csd) >> 3) & 0xF],mStrUnit[MMC_CSD_GET_TRANSPEED(Csd) & 7]));
 110   DEBUG((EFI_D_ERROR, "\t- Maximum Read Data Block: %d\n",2 << (MMC_CSD_GET_READBLLEN(Csd)-1)));
 111   DEBUG((EFI_D_ERROR, "\t- Maximum Write Data Block: %d\n",2 << (MMC_CSD_GET_WRITEBLLEN(Csd)-1)));
 112
 113   if (!MMC_CSD_GET_FILEFORMATGRP(Csd)) {
 114     Value = MMC_CSD_GET_FILEFORMAT(Csd);
 115     if (Value == 0)         DEBUG((EFI_D_ERROR, "\t- Format(0): Hard disk-like file system with partition table\n"));
 116     else if (Value == 1)    DEBUG((EFI_D_ERROR, "\t- Format(1): DOS FAT (floppy-like) with boot sector only (no partition table)\n"));
 117     else if (Value == 2)    DEBUG((EFI_D_ERROR, "\t- Format(2): Universal File Format\n"));
 118     else                    DEBUG((EFI_D_ERROR, "\t- Format(3): Others/Unknown\n"));
 119   } else {
 120     DEBUG((EFI_D_ERROR, "\t- Format: Reserved\n"));
 121   }
 122 }
 123
 124 VOID
 125 PrintRCA (
 126   IN UINT32 Rca
 127   )
 128 {
 129   DEBUG((EFI_D_ERROR, "- PrintRCA: 0x%X\n",Rca));
 130   DEBUG((EFI_D_ERROR, "\t- Status: 0x%X\n",Rca & 0xFFFF));
 131   DEBUG((EFI_D_ERROR, "\t- RCA: 0x%X\n",(Rca >> 16) & 0xFFFF));
 132 }
 133
 134 VOID
 135 PrintResponseR1 (
 136   IN  UINT32 Response
 137   )
 138 {
 139   DEBUG((EFI_D_INFO, "Response: 0x%X\n",Response));
 140   if (Response & MMC_R0_READY_FOR_DATA)     DEBUG((EFI_D_INFO, "\t- READY_FOR_DATA\n"));
 141
 142   if (((Response >> 9) & 0xF) == 0)         DEBUG((EFI_D_INFO, "\t- State: Idle\n"));
 143   else if (((Response >> 9) & 0xF) == 1)    DEBUG((EFI_D_INFO, "\t- State: Ready\n"));
 144   else if (((Response >> 9) & 0xF) == 2)    DEBUG((EFI_D_INFO, "\t- State: Ident\n"));
 145   else if (((Response >> 9) & 0xF) == 3)    DEBUG((EFI_D_INFO, "\t- State: StandBy\n"));
 146   else if (((Response >> 9) & 0xF) == 4)    DEBUG((EFI_D_INFO, "\t- State: Tran\n"));
 147   else if (((Response >> 9) & 0xF) == 5)    DEBUG((EFI_D_INFO, "\t- State: Data\n"));
 148   else if (((Response >> 9) & 0xF) == 6)    DEBUG((EFI_D_INFO, "\t- State: Rcv\n"));
 149   else if (((Response >> 9) & 0xF) == 7)    DEBUG((EFI_D_INFO, "\t- State: Prg\n"));
 150   else if (((Response >> 9) & 0xF) == 8)    DEBUG((EFI_D_INFO, "\t- State: Dis\n"));
 151   else                                      DEBUG((EFI_D_INFO, "\t- State: Reserved\n"));
 152 }
 153
 154 EFI_STATUS
 155 EFIAPI
 156 MmcGetCardStatus(
 157         IN MMC_HOST_INSTANCE     *MmcHostInstance
 158   )
 159 {
 160   EFI_STATUS              Status;
 161   UINT32                  Response[4];
 162   UINTN                   CmdArg;
 163   EFI_MMC_HOST_PROTOCOL   *MmcHost;
 164
 165   Status = EFI_SUCCESS;
 166   MmcHost = MmcHostInstance->MmcHost;
 167   CmdArg = 0;
 168
 169   if (MmcHost == NULL) {
 170     return EFI_INVALID_PARAMETER;
 171   }
 172   if(MmcHostInstance->State != MmcHwInitializationState){
 173     //Get the Status of the card.
 174     CmdArg = MmcHostInstance->CardInfo.RCA << 16;
 175     Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
 176     if (EFI_ERROR(Status)) {
 177       DEBUG((EFI_D_ERROR, "MmcGetCardStatus(MMC_CMD13): Error and Status = %r\n", Status));
 178       return Status;
 179     }
 180
 181     //Read Response
 182     MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1,Response);
 183     PrintResponseR1(Response[0]);
 184   }
 185
 186   return Status;
 187 }
 188
 189 EFI_STATUS
 190 EFIAPI
 191 MmcIdentificationMode (
 192   IN MMC_HOST_INSTANCE     *MmcHostInstance
 193   )
 194 {
 195   EFI_STATUS              Status;
 196   UINT32                  Response[4];
 197   UINTN                   Timeout;
 198   UINTN                   CmdArg;
 199   BOOLEAN                 IsHCS;
 200   EFI_MMC_HOST_PROTOCOL   *MmcHost;
 201
 202   MmcHost = MmcHostInstance->MmcHost;
 203   CmdArg = 0;
 204   IsHCS = FALSE;
 205
 206   if (MmcHost == NULL) {
 207     return EFI_INVALID_PARAMETER;
 208   }
 209
 210   // We can get into this function if we restart the identification mode
 211   if (MmcHostInstance->State == MmcHwInitializationState) {
 212     // Initialize the MMC Host HW
 213     Status = MmcNotifyState (MmcHostInstance, MmcHwInitializationState);
 214     if (EFI_ERROR(Status)) {
 215       DEBUG((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcHwInitializationState\n"));
 216       return Status;
 217     }
 218   } else {
 219     //Note: Could even be used in all cases. But it looks this command could put the state machine into inactive for some cards
 220     Status = MmcHost->SendCommand (MmcHost, MMC_CMD0, 0);
 221     if (EFI_ERROR(Status)) {
 222       DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD0): Error\n"));
 223       return Status;
 224     }
 225   }
 226
 227   Status = MmcNotifyState (MmcHostInstance, MmcIdleState);
 228   if (EFI_ERROR(Status)) {
 229     DEBUG((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcIdleState\n"));
 230     return Status;
 231   }
 232
 233   // Are we using SDIO ?
 234   Status = MmcHost->SendCommand (MmcHost, MMC_CMD5, 0);
 235   if (Status == EFI_SUCCESS) {
 236     DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD5): Error - SDIO not supported.\n"));
 237     return EFI_UNSUPPORTED;
 238   }
 239
 240   // Check which kind of card we are using. Ver2.00 or later SD Memory Card (PL180 is SD v1.1)
 241   CmdArg = (0x0UL << 12 | BIT8 | 0xCEUL << 0);
 242   Status = MmcHost->SendCommand (MmcHost, MMC_CMD8, CmdArg);
 243   if (Status == EFI_SUCCESS) {
 244     DEBUG ((EFI_D_ERROR, "Card is SD2.0 => Supports high capacity\n"));
 245     IsHCS = TRUE;
 246     MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R7,Response);
 247     PrintResponseR1(Response[0]);
 248     //check if it is valid response
 249     if(Response[0] != CmdArg){
 250       DEBUG ((EFI_D_ERROR, "The Card is not usable\n"));
 251       return EFI_UNSUPPORTED;
 252     }
 253   } else {
 254     DEBUG ((EFI_D_ERROR, "Not a SD2.0 Card\n"));
 255   }
 256
 257   // We need to wait for the MMC or SD card is ready => (gCardInfo.OCRData.PowerUp == 1)
 258   Timeout = MAX_RETRY_COUNT;
 259   while (Timeout > 0) {
 260     // SD Card or MMC Card ? CMD55 indicates to the card that the next command is an application specific command
 261     Status = MmcHost->SendCommand (MmcHost, MMC_CMD55, 0);
 262     if (Status == EFI_SUCCESS) {
 263         DEBUG ((EFI_D_INFO, "Card should be SD\n"));
 264         if (IsHCS) {
 265             MmcHostInstance->CardInfo.CardType = SD_CARD_2;
 266         } else {
 267             MmcHostInstance->CardInfo.CardType = SD_CARD;
 268         }
 269
 270         // Note: The first time CmdArg will be zero
 271         CmdArg = ((UINTN *) &(MmcHostInstance->CardInfo.OCRData))[0];
 272         if (IsHCS) {
 273             CmdArg |= BIT30;
 274         }
 275         Status = MmcHost->SendCommand (MmcHost, MMC_ACMD41, CmdArg);
 276         if (!EFI_ERROR(Status)) {
 277           MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_OCR,Response);
 278           ((UINT32 *) &(MmcHostInstance->CardInfo.OCRData))[0] = Response[0];
 279         }
 280     } else {
 281         DEBUG ((EFI_D_INFO, "Card should be MMC\n"));
 282         MmcHostInstance->CardInfo.CardType = MMC_CARD;
 283
 284         Status = MmcHost->SendCommand (MmcHost, MMC_CMD1, 0x800000);
 285         if (!EFI_ERROR(Status)) {
 286           MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_OCR,Response);
 287           ((UINT32 *) &(MmcHostInstance->CardInfo.OCRData))[0] = Response[0];
 288         }
 289     }
 290
 291     if (!EFI_ERROR(Status)) {
 292       if (!MmcHostInstance->CardInfo.OCRData.PowerUp) {
 293           MicroSecondDelay(1);
 294           Timeout--;
 295       } else {
 296           if ((MmcHostInstance->CardInfo.CardType == SD_CARD_2) && (MmcHostInstance->CardInfo.OCRData.AccessMode & BIT1)) {
 297               MmcHostInstance->CardInfo.CardType = SD_CARD_2_HIGH;
 298               DEBUG ((EFI_D_ERROR, "High capacity card.\n"));
 299           }
 300           break;  // The MMC/SD card is ready. Continue the Identification Mode
 301       }
 302     } else {
 303       MicroSecondDelay(1);
 304       Timeout--;
 305     }
 306   }
 307
 308   if (Timeout == 0) {
 309     DEBUG((EFI_D_ERROR, "MmcIdentificationMode(): No Card\n"));
 310     return EFI_NO_MEDIA;
 311   } else {
 312     PrintOCR(Response[0]);
 313   }
 314
 315   Status = MmcNotifyState (MmcHostInstance, MmcReadyState);
 316   if (EFI_ERROR(Status)) {
 317     DEBUG((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcReadyState\n"));
 318     return Status;
 319   }
 320
 321   Status = MmcHost->SendCommand (MmcHost, MMC_CMD2, 0);
 322   if (EFI_ERROR(Status)) {
 323     DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD2): Error\n"));
 324     return Status;
 325   }
 326   MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_CID,Response);
 327   PrintCID(Response);
 328
 329   Status = MmcNotifyState (MmcHostInstance, MmcIdentificationState);
 330   if (EFI_ERROR(Status)) {
 331     DEBUG((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcIdentificationState\n"));
 332     return Status;
 333   }
 334
 335   //
 336   // Note, SD specifications say that "if the command execution causes a state change, it
 337   // will be visible to the host in the response to the next command"
 338   // The status returned for this CMD3 will be 2 - identification
 339   //
 340   CmdArg = 1;
 341   Status = MmcHost->SendCommand (MmcHost, MMC_CMD3, CmdArg);
 342   if (EFI_ERROR(Status)) {
 343     DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD3): Error\n"));
 344     return Status;
 345   }
 346
 347   MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_RCA,Response);
 348   PrintRCA(Response[0]);
 349
 350   // For MMC card, RCA is assigned by CMD3 while CMD3 dumps the RCA for SD card
 351   if (MmcHostInstance->CardInfo.CardType != MMC_CARD) {
 352     MmcHostInstance->CardInfo.RCA = Response[0] >> 16;
 353   } else {
 354     MmcHostInstance->CardInfo.RCA = CmdArg;
 355   }
 356
 357   Status = MmcNotifyState (MmcHostInstance, MmcStandByState);
 358   if (EFI_ERROR(Status)) {
 359     DEBUG((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcStandByState\n"));
 360     return Status;
 361   }
 362
 363   return EFI_SUCCESS;
 364 }
 365
 366 EFI_STATUS InitializeMmcDevice (
 367   IN  MMC_HOST_INSTANCE   *MmcHostInstance
 368   )
 369 {
 370   UINT32                  Response[4];
 371   EFI_STATUS              Status;
 372   UINTN                   CardSize, NumBlocks, BlockSize, CmdArg;
 373   EFI_MMC_HOST_PROTOCOL   *MmcHost;
 374   UINTN                   BlockCount = 1;
 375
 376   MmcHost = MmcHostInstance->MmcHost;
 377
 378   MmcIdentificationMode (MmcHostInstance);
 379
 380   //Send a command to get Card specific data
 381   CmdArg = MmcHostInstance->CardInfo.RCA << 16;
 382   Status = MmcHost->SendCommand (MmcHost, MMC_CMD9, CmdArg);
 383   if (EFI_ERROR(Status)) {
 384     DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD9): Error, Status=%r\n", Status));
 385     return Status;
 386   }
 387   //Read Response
 388   MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_CSD,Response);
 389   PrintCSD(Response);
 390
 391   if (MmcHostInstance->CardInfo.CardType == SD_CARD_2_HIGH) {
 392     CardSize = HC_MMC_CSD_GET_DEVICESIZE(Response);
 393     NumBlocks = ((CardSize + 1) * 1024);
 394     BlockSize = 1 << MMC_CSD_GET_READBLLEN(Response);
 395   } else {
 396     CardSize = MMC_CSD_GET_DEVICESIZE(Response);
 397     NumBlocks = (CardSize + 1) * (1 << (MMC_CSD_GET_DEVICESIZEMULT(Response) + 2));
 398     BlockSize = 1 << MMC_CSD_GET_READBLLEN(Response);
 399   }
 400
 401   //For >=2G card, BlockSize may be 1K, but the transfer size is 512 bytes.
 402   if (BlockSize > 512) {
 403     NumBlocks = MultU64x32(NumBlocks, BlockSize/512);
 404     BlockSize = 512;
 405   }
 406
 407   MmcHostInstance->BlockIo.Media->LastBlock    = (NumBlocks - 1);
 408   MmcHostInstance->BlockIo.Media->BlockSize    = BlockSize;
 409   MmcHostInstance->BlockIo.Media->ReadOnly     = MmcHost->IsReadOnly (MmcHost);
 410   MmcHostInstance->BlockIo.Media->MediaPresent = TRUE;
 411   MmcHostInstance->BlockIo.Media->MediaId++;
 412
 413   CmdArg = MmcHostInstance->CardInfo.RCA << 16;
 414   Status = MmcHost->SendCommand (MmcHost, MMC_CMD7, CmdArg);
 415   if (EFI_ERROR(Status)) {
 416     DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD7): Error and Status = %r\n", Status));
 417     return Status;
 418   }
 419
 420   Status = MmcNotifyState (MmcHostInstance, MmcTransferState);
 421   if (EFI_ERROR(Status)) {
 422     DEBUG((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcTransferState\n"));
 423     return Status;
 424   }
 425
 426   // Set Block Length
 427   Status = MmcHost->SendCommand (MmcHost, MMC_CMD16, MmcHostInstance->BlockIo.Media->BlockSize);
 428   if (EFI_ERROR(Status)) {
 429     DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD16): Error MmcHostInstance->BlockIo.Media->BlockSize: %d and Error = %r\n",MmcHostInstance->BlockIo.Media->BlockSize, Status));
 430     return Status;
 431   }
 432
 433   // Block Count (not used). Could return an error for SD card
 434   if (MmcHostInstance->CardInfo.CardType == MMC_CARD) {
 435     MmcHost->SendCommand (MmcHost, MMC_CMD23, BlockCount);
 436   }
 437
 438   return EFI_SUCCESS;
 439 }
 440
 441 EFI_STATUS
 442 EFIAPI
 443 MmcReset (
 444   IN EFI_BLOCK_IO_PROTOCOL    *This,
 445   IN BOOLEAN                  ExtendedVerification
 446   )
 447 {
 448   MMC_HOST_INSTANCE       *MmcHostInstance;
 449
 450   MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS(This);
 451
 452   if (MmcHostInstance->MmcHost == NULL) {
 453     // Nothing to do
 454     return EFI_SUCCESS;
 455   }
 456
 457   // If a card is not present then clear all media settings
 458   if (!MmcHostInstance->MmcHost->IsCardPresent (MmcHostInstance->MmcHost)) {
 459     MmcHostInstance->BlockIo.Media->MediaPresent = FALSE;
 460     MmcHostInstance->BlockIo.Media->LastBlock    = 0;
 461     MmcHostInstance->BlockIo.Media->BlockSize    = 512;  // Should be zero but there is a bug in DiskIo
 462     MmcHostInstance->BlockIo.Media->ReadOnly     = FALSE;
 463
 464     // Indicate that the driver requires initialization
 465     MmcHostInstance->State = MmcHwInitializationState;
 466
 467     return EFI_SUCCESS;
 468   }
 469
 470   // Implement me. Either send a CMD0 (could not work for some MMC host) or just turn off/turn
 471   //      on power and restart Identification mode
 472   return EFI_SUCCESS;
 473 }
 474
 475 EFI_STATUS
 476 MmcDetectCard (
 477   EFI_MMC_HOST_PROTOCOL     *MmcHost
 478   )
 479 {
 480   if (!MmcHost->IsCardPresent (MmcHost)) {
 481     return EFI_NO_MEDIA;
 482   } else {
 483     return EFI_SUCCESS;
 484   }
 485 }
 486
 487 #define MMCI0_BLOCKLEN 512
 488 #define MMCI0_TIMEOUT  10000
 489
 490 EFI_STATUS
 491 MmcIoBlocks (
 492   IN EFI_BLOCK_IO_PROTOCOL    *This,
 493   IN UINTN                    Transfer,
 494   IN UINT32                   MediaId,
 495   IN EFI_LBA                  Lba,
 496   IN UINTN                    BufferSize,
 497   OUT VOID                    *Buffer
 498   )
 499 {
 500   UINT32                  Response[4];
 501   EFI_STATUS              Status;
 502   UINTN                   CmdArg;
 503   INTN                    Timeout;
 504   UINTN                   Cmd;
 505   MMC_HOST_INSTANCE       *MmcHostInstance;
 506   EFI_MMC_HOST_PROTOCOL   *MmcHost;
 507   UINTN                   BytesRemainingToBeTransfered;
 508   UINTN                   BlockCount = 1;
 509
 510   MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS(This);
 511   ASSERT(MmcHostInstance != 0);
 512   MmcHost = MmcHostInstance->MmcHost;
 513   ASSERT(MmcHost);
 514
 515   if ((MmcHost == 0)|| (Buffer == NULL)) {
 516     return EFI_INVALID_PARAMETER;
 517   }
 518
 519   // Check if a Card is Present
 520   if (!MmcHostInstance->BlockIo.Media->MediaPresent) {
 521     return EFI_NO_MEDIA;
 522   }
 523
 524   // All blocks must be within the device
 525   if ((Lba + (BufferSize / This->Media->BlockSize)) > (This->Media->LastBlock + 1)){
 526     return EFI_INVALID_PARAMETER;
 527   }
 528
 529   // The buffer size must not be zero and it must be an exact multiple of the block size
 530   if ((BufferSize == 0) || ((BufferSize % This->Media->BlockSize) != 0)) {
 531     return EFI_BAD_BUFFER_SIZE;
 532   }
 533
 534   if (This->Media->MediaId != MediaId) {
 535     return EFI_MEDIA_CHANGED;
 536   }
 537
 538   if((Transfer == MMC_IOBLOCKS_WRITE) && (This->Media->ReadOnly == TRUE)) {
 539     return EFI_WRITE_PROTECTED;
 540   }
 541
 542   BytesRemainingToBeTransfered = BufferSize;
 543   while (BytesRemainingToBeTransfered > 0) {
 544
 545     // Check if the Card is in Ready status
 546     CmdArg = MmcHostInstance->CardInfo.RCA << 16;
 547     Response[0] = 0;
 548     Timeout = 20;
 549     while(   (!(Response[0] & MMC_R0_READY_FOR_DATA))
 550           && (MMC_R0_CURRENTSTATE(Response) != MMC_R0_STATE_TRAN)
 551           && Timeout--) {
 552       Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
 553       if (!EFI_ERROR(Status)) {
 554         MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1,Response);
 555       }
 556     }
 557
 558     if (0 == Timeout) {
 559       DEBUG((EFI_D_ERROR, "The Card is busy\n"));
 560       return EFI_NOT_READY;
 561     }
 562
 563     //Set command argument based on the card access mode (Byte mode or Block mode)
 564     if (MmcHostInstance->CardInfo.OCRData.AccessMode & BIT1) {
 565       CmdArg = Lba;
 566     } else {
 567       CmdArg = Lba * This->Media->BlockSize;
 568     }
 569
 570     if (Transfer == MMC_IOBLOCKS_READ) {
 571 #ifndef USE_STREAM
 572       // Read a single block
 573       Cmd = MMC_CMD17;
 574 #else
 575       //TODO: Should we support read stream (MMC_CMD11)
 576 #endif
 577     } else {
 578 #ifndef USE_STREAM
 579       // Write a single block
 580       Cmd = MMC_CMD24;
 581 #else
 582       //TODO: Should we support write stream (MMC_CMD20)
 583 #endif
 584     }
 585     Status = MmcHost->SendCommand (MmcHost, Cmd, CmdArg);
 586     if (EFI_ERROR(Status)) {
 587       DEBUG((EFI_D_ERROR, "MmcIoBlocks(MMC_CMD%d): Error %r\n",Cmd, Status));
 588       return Status;
 589     }
 590
 591     if (Transfer == MMC_IOBLOCKS_READ) {
 592 #ifndef USE_STREAM
 593       // Read one block of Data
 594       Status = MmcHost->ReadBlockData (MmcHost, Lba,This->Media->BlockSize,Buffer);
 595       if (EFI_ERROR(Status)) {
 596         DEBUG((EFI_D_BLKIO, "MmcIoBlocks(): Error Read Block Data and Status = %r\n", Status));
 597         return Status;
 598       }
 599 #else
 600       //TODO: Read a stream
 601       ASSERT(0);
 602 #endif
 603       Status = MmcNotifyState (MmcHostInstance, MmcProgrammingState);
 604       if (EFI_ERROR(Status)) {
 605         DEBUG((EFI_D_ERROR, "MmcIoBlocks() : Error MmcProgrammingState\n"));
 606         return Status;
 607       }
 608     } else {
 609 #ifndef USE_STREAM
 610       // Write one block of Data
 611       Status = MmcHost->WriteBlockData (MmcHost, Lba,This->Media->BlockSize,Buffer);
 612       if (EFI_ERROR(Status)) {
 613         DEBUG((EFI_D_BLKIO, "MmcIoBlocks(): Error Write Block Data and Status = %r\n", Status));
 614         return Status;
 615       }
 616 #else
 617       //TODO: Write a stream
 618       ASSERT(0);
 619 #endif
 620     }
 621
 622     // Command 12 - Stop transmission (ends read)
 623     Status = MmcHost->SendCommand (MmcHost, MMC_CMD12, 0);
 624     if (!EFI_ERROR(Status)) {
 625       MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1b,Response);
 626     }
 627
 628     // Command 13 - Read status and wait for programming to complete (return to tran)
 629     Timeout = MMCI0_TIMEOUT;
 630     CmdArg = MmcHostInstance->CardInfo.RCA << 16;
 631     Response[0] = 0;
 632     while(   (!(Response[0] & MMC_R0_READY_FOR_DATA))
 633           && (MMC_R0_CURRENTSTATE(Response) != MMC_R0_STATE_TRAN)
 634           && Timeout--) {
 635       Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
 636       if (!EFI_ERROR(Status)) {
 637         MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
 638         if ((Response[0] & MMC_R0_READY_FOR_DATA)) {
 639           break;  // Prevents delay once finished
 640         }
 641       }
 642       NanoSecondDelay(100);
 643     }
 644
 645     Status = MmcNotifyState (MmcHostInstance, MmcTransferState);
 646     if (EFI_ERROR(Status)) {
 647       DEBUG((EFI_D_ERROR, "MmcIoBlocks() : Error MmcTransferState\n"));
 648       return Status;
 649     }
 650
 651     BytesRemainingToBeTransfered -= This->Media->BlockSize;
 652     Lba    += BlockCount;
 653     Buffer = (UINT8 *)Buffer + This->Media->BlockSize;
 654   }
 655
 656   return EFI_SUCCESS;
 657 }
 658
 659 EFI_STATUS
 660 EFIAPI
 661 MmcReadBlocks (
 662   IN EFI_BLOCK_IO_PROTOCOL    *This,
 663   IN UINT32                   MediaId,
 664   IN EFI_LBA                  Lba,
 665   IN UINTN                    BufferSize,
 666   OUT VOID                    *Buffer
 667   )
 668 {
 669   return MmcIoBlocks (This, MMC_IOBLOCKS_READ, MediaId, Lba, BufferSize, Buffer);
 670 }
 671
 672 EFI_STATUS
 673 EFIAPI
 674 MmcWriteBlocks (
 675   IN EFI_BLOCK_IO_PROTOCOL    *This,
 676   IN UINT32                   MediaId,
 677   IN EFI_LBA                  Lba,
 678   IN UINTN                    BufferSize,
 679   IN VOID                     *Buffer
 680   )
 681 {
 682   return MmcIoBlocks (This, MMC_IOBLOCKS_WRITE, MediaId, Lba, BufferSize, Buffer);
 683 }
 684
 685 EFI_STATUS
 686 EFIAPI
 687 MmcFlushBlocks (
 688   IN EFI_BLOCK_IO_PROTOCOL  *This
 689   )
 690 {
 691   return EFI_SUCCESS;
 692 }
 693