EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c

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