EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c

   1 /** @file
   2 *
   3 *  Copyright (c) 2011-2015, 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 <Library/BaseMemoryLib.h>
  16
  17 #include "Mmc.h"
  18
  19 EFI_STATUS
  20 MmcNotifyState (
  21   IN MMC_HOST_INSTANCE *MmcHostInstance,
  22   IN MMC_STATE State
  23   )
  24 {
  25   MmcHostInstance->State = State;
  26   return MmcHostInstance->MmcHost->NotifyState (MmcHostInstance->MmcHost, State);
  27 }
  28
  29 EFI_STATUS
  30 EFIAPI
  31 MmcGetCardStatus (
  32   IN MMC_HOST_INSTANCE     *MmcHostInstance
  33   )
  34 {
  35   EFI_STATUS              Status;
  36   UINT32                  Response[4];
  37   UINTN                   CmdArg;
  38   EFI_MMC_HOST_PROTOCOL   *MmcHost;
  39
  40   Status = EFI_SUCCESS;
  41   MmcHost = MmcHostInstance->MmcHost;
  42   CmdArg = 0;
  43
  44   if (MmcHost == NULL) {
  45     return EFI_INVALID_PARAMETER;
  46   }
  47   if (MmcHostInstance->State != MmcHwInitializationState) {
  48     //Get the Status of the card.
  49     CmdArg = MmcHostInstance->CardInfo.RCA << 16;
  50     Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
  51     if (EFI_ERROR (Status)) {
  52       DEBUG ((EFI_D_ERROR, "MmcGetCardStatus(MMC_CMD13): Error and Status = %r\n", Status));
  53       return Status;
  54     }
  55
  56     //Read Response
  57     MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
  58     PrintResponseR1 (Response[0]);
  59   }
  60
  61   return Status;
  62 }
  63
  64 EFI_STATUS
  65 EFIAPI
  66 MmcReset (
  67   IN EFI_BLOCK_IO_PROTOCOL    *This,
  68   IN BOOLEAN                  ExtendedVerification
  69   )
  70 {
  71   MMC_HOST_INSTANCE       *MmcHostInstance;
  72
  73   MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);
  74
  75   if (MmcHostInstance->MmcHost == NULL) {
  76     // Nothing to do
  77     return EFI_SUCCESS;
  78   }
  79
  80   // If a card is not present then clear all media settings
  81   if (!MmcHostInstance->MmcHost->IsCardPresent (MmcHostInstance->MmcHost)) {
  82     MmcHostInstance->BlockIo.Media->MediaPresent = FALSE;
  83     MmcHostInstance->BlockIo.Media->LastBlock    = 0;
  84     MmcHostInstance->BlockIo.Media->BlockSize    = 512;  // Should be zero but there is a bug in DiskIo
  85     MmcHostInstance->BlockIo.Media->ReadOnly     = FALSE;
  86
  87     // Indicate that the driver requires initialization
  88     MmcHostInstance->State = MmcHwInitializationState;
  89
  90     return EFI_SUCCESS;
  91   }
  92
  93   // Implement me. Either send a CMD0 (could not work for some MMC host) or just turn off/turn
  94   //      on power and restart Identification mode
  95   return EFI_SUCCESS;
  96 }
  97
  98 EFI_STATUS
  99 MmcDetectCard (
 100   EFI_MMC_HOST_PROTOCOL     *MmcHost
 101   )
 102 {
 103   if (!MmcHost->IsCardPresent (MmcHost)) {
 104     return EFI_NO_MEDIA;
 105   } else {
 106     return EFI_SUCCESS;
 107   }
 108 }
 109
 110 EFI_STATUS
 111 MmcStopTransmission (
 112   EFI_MMC_HOST_PROTOCOL     *MmcHost
 113   )
 114 {
 115   EFI_STATUS              Status;
 116   UINT32                  Response[4];
 117   // Command 12 - Stop transmission (ends read or write)
 118   // Normally only needed for streaming transfers or after error.
 119   Status = MmcHost->SendCommand (MmcHost, MMC_CMD12, 0);
 120   if (!EFI_ERROR (Status)) {
 121     MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1b, Response);
 122   }
 123   return Status;
 124 }
 125
 126 #define MMCI0_BLOCKLEN 512
 127 #define MMCI0_TIMEOUT  10000
 128
 129 STATIC
 130 EFI_STATUS
 131 MmcTransferBlock (
 132   IN EFI_BLOCK_IO_PROTOCOL    *This,
 133   IN UINTN                    Cmd,
 134   IN UINTN                    Transfer,
 135   IN UINT32                   MediaId,
 136   IN EFI_LBA                  Lba,
 137   IN UINTN                    BufferSize,
 138   OUT VOID                    *Buffer
 139   )
 140 {
 141   EFI_STATUS              Status;
 142   UINTN                   CmdArg;
 143   INTN                    Timeout;
 144   UINT32                  Response[4];
 145   MMC_HOST_INSTANCE       *MmcHostInstance;
 146   EFI_MMC_HOST_PROTOCOL   *MmcHost;
 147
 148   MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);
 149   MmcHost = MmcHostInstance->MmcHost;
 150
 151   if (MmcHostInstance->CardInfo.CardType != EMMC_CARD) {
 152     //Set command argument based on the card capacity
 153     //if 0 : SDSC card
 154     //if 1 : SDXC/SDHC
 155     if (MmcHostInstance->CardInfo.OCRData.AccessMode & SD_CARD_CAPACITY) {
 156       CmdArg = Lba;
 157     } else {
 158       CmdArg = Lba * This->Media->BlockSize;
 159     }
 160   } else {
 161     //Set command argument based on the card access mode (Byte mode or Block mode)
 162     if ((MmcHostInstance->CardInfo.OCRData.AccessMode & MMC_OCR_ACCESS_MASK) ==
 163         MMC_OCR_ACCESS_SECTOR) {
 164       CmdArg = Lba;
 165     } else {
 166       CmdArg = Lba * This->Media->BlockSize;
 167     }
 168   }
 169
 170   Status = MmcHost->SendCommand (MmcHost, Cmd, CmdArg);
 171   if (EFI_ERROR (Status)) {
 172     DEBUG ((EFI_D_ERROR, "%a(MMC_CMD%d): Error %r\n", __func__, Cmd, Status));
 173     return Status;
 174   }
 175
 176   if (Transfer == MMC_IOBLOCKS_READ) {
 177     // Read Data
 178     Status = MmcHost->ReadBlockData (MmcHost, Lba, BufferSize, Buffer);
 179     if (EFI_ERROR (Status)) {
 180       DEBUG ((EFI_D_BLKIO, "%a(): Error Read Block Data and Status = %r\n", __func__, Status));
 181       MmcStopTransmission (MmcHost);
 182       return Status;
 183     }
 184     Status = MmcNotifyState (MmcHostInstance, MmcProgrammingState);
 185     if (EFI_ERROR (Status)) {
 186       DEBUG ((EFI_D_ERROR, "%a() : Error MmcProgrammingState\n", __func__));
 187       return Status;
 188     }
 189   } else {
 190     // Write Data
 191     Status = MmcHost->WriteBlockData (MmcHost, Lba, BufferSize, Buffer);
 192     if (EFI_ERROR (Status)) {
 193       DEBUG ((EFI_D_BLKIO, "%a(): Error Write Block Data and Status = %r\n", __func__, Status));
 194       MmcStopTransmission (MmcHost);
 195       return Status;
 196     }
 197   }
 198
 199   // Command 13 - Read status and wait for programming to complete (return to tran)
 200   Timeout = MMCI0_TIMEOUT;
 201   CmdArg = MmcHostInstance->CardInfo.RCA << 16;
 202   Response[0] = 0;
 203   while(!(Response[0] & MMC_R0_READY_FOR_DATA)
 204         && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)
 205         && Timeout--) {
 206     Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
 207     if (!EFI_ERROR (Status)) {
 208       MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
 209       if (Response[0] & MMC_R0_READY_FOR_DATA) {
 210         break;  // Prevents delay once finished
 211       }
 212     }
 213   }
 214
 215   if (BufferSize > This->Media->BlockSize) {
 216     Status = MmcHost->SendCommand (MmcHost, MMC_CMD12, 0);
 217     if (EFI_ERROR (Status)) {
 218       DEBUG ((EFI_D_BLKIO, "%a(): Error and Status:%r\n", __func__, Status));
 219     }
 220     MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1b, Response);
 221   }
 222
 223   Status = MmcNotifyState (MmcHostInstance, MmcTransferState);
 224   if (EFI_ERROR (Status)) {
 225     DEBUG ((EFI_D_ERROR, "MmcIoBlocks() : Error MmcTransferState\n"));
 226     return Status;
 227   }
 228   return Status;
 229 }
 230
 231 EFI_STATUS
 232 MmcIoBlocks (
 233   IN EFI_BLOCK_IO_PROTOCOL    *This,
 234   IN UINTN                    Transfer,
 235   IN UINT32                   MediaId,
 236   IN EFI_LBA                  Lba,
 237   IN UINTN                    BufferSize,
 238   OUT VOID                    *Buffer
 239   )
 240 {
 241   UINT32                  Response[4];
 242   EFI_STATUS              Status;
 243   UINTN                   CmdArg;
 244   INTN                    Timeout;
 245   UINTN                   Cmd;
 246   MMC_HOST_INSTANCE       *MmcHostInstance;
 247   EFI_MMC_HOST_PROTOCOL   *MmcHost;
 248   UINTN                   BytesRemainingToBeTransfered;
 249   UINTN                   BlockCount;
 250   UINTN                   ConsumeSize;
 251
 252   BlockCount = 1;
 253   MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);
 254   ASSERT (MmcHostInstance != NULL);
 255   MmcHost = MmcHostInstance->MmcHost;
 256   ASSERT (MmcHost);
 257
 258   if (This->Media->MediaId != MediaId) {
 259     return EFI_MEDIA_CHANGED;
 260   }
 261
 262   if ((MmcHost == NULL) || (Buffer == NULL)) {
 263     return EFI_INVALID_PARAMETER;
 264   }
 265
 266   // Check if a Card is Present
 267   if (!MmcHostInstance->BlockIo.Media->MediaPresent) {
 268     return EFI_NO_MEDIA;
 269   }
 270
 271   if (MMC_HOST_HAS_ISMULTIBLOCK(MmcHost) && MmcHost->IsMultiBlock(MmcHost)) {
 272     BlockCount = (BufferSize + This->Media->BlockSize - 1) / This->Media->BlockSize;
 273   }
 274
 275   // All blocks must be within the device
 276   if ((Lba + (BufferSize / This->Media->BlockSize)) > (This->Media->LastBlock + 1)) {
 277     return EFI_INVALID_PARAMETER;
 278   }
 279
 280   if ((Transfer == MMC_IOBLOCKS_WRITE) && (This->Media->ReadOnly == TRUE)) {
 281     return EFI_WRITE_PROTECTED;
 282   }
 283
 284   // Reading 0 Byte is valid
 285   if (BufferSize == 0) {
 286     return EFI_SUCCESS;
 287   }
 288
 289   // The buffer size must be an exact multiple of the block size
 290   if ((BufferSize % This->Media->BlockSize) != 0) {
 291     return EFI_BAD_BUFFER_SIZE;
 292   }
 293
 294   // Check the alignment
 295   if ((This->Media->IoAlign > 2) && (((UINTN)Buffer & (This->Media->IoAlign - 1)) != 0)) {
 296     return EFI_INVALID_PARAMETER;
 297   }
 298
 299   BytesRemainingToBeTransfered = BufferSize;
 300   while (BytesRemainingToBeTransfered > 0) {
 301
 302     // Check if the Card is in Ready status
 303     CmdArg = MmcHostInstance->CardInfo.RCA << 16;
 304     Response[0] = 0;
 305     Timeout = 20;
 306     while(   (!(Response[0] & MMC_R0_READY_FOR_DATA))
 307           && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)
 308           && Timeout--) {
 309       Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
 310       if (!EFI_ERROR (Status)) {
 311         MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
 312       }
 313     }
 314
 315     if (0 == Timeout) {
 316       DEBUG ((EFI_D_ERROR, "The Card is busy\n"));
 317       return EFI_NOT_READY;
 318     }
 319
 320     if (Transfer == MMC_IOBLOCKS_READ) {
 321       if (BlockCount == 1) {
 322         // Read a single block
 323         Cmd = MMC_CMD17;
 324       } else {
 325         // Read multiple blocks
 326         Cmd = MMC_CMD18;
 327       }
 328     } else {
 329       if (BlockCount == 1) {
 330         // Write a single block
 331         Cmd = MMC_CMD24;
 332       } else {
 333         // Write multiple blocks
 334         Cmd = MMC_CMD25;
 335       }
 336     }
 337
 338     ConsumeSize = BlockCount * This->Media->BlockSize;
 339     if (BytesRemainingToBeTransfered < ConsumeSize) {
 340       ConsumeSize = BytesRemainingToBeTransfered;
 341     }
 342     Status = MmcTransferBlock (This, Cmd, Transfer, MediaId, Lba, ConsumeSize, Buffer);
 343     if (EFI_ERROR (Status)) {
 344       DEBUG ((EFI_D_ERROR, "%a(): Failed to transfer block and Status:%r\n", __func__, Status));
 345     }
 346
 347     BytesRemainingToBeTransfered -= ConsumeSize;
 348     if (BytesRemainingToBeTransfered > 0) {
 349       Lba    += BlockCount;
 350       Buffer = (UINT8 *)Buffer + ConsumeSize;
 351     }
 352   }
 353
 354   return EFI_SUCCESS;
 355 }
 356
 357 EFI_STATUS
 358 EFIAPI
 359 MmcReadBlocks (
 360   IN EFI_BLOCK_IO_PROTOCOL    *This,
 361   IN UINT32                   MediaId,
 362   IN EFI_LBA                  Lba,
 363   IN UINTN                    BufferSize,
 364   OUT VOID                    *Buffer
 365   )
 366 {
 367   return MmcIoBlocks (This, MMC_IOBLOCKS_READ, MediaId, Lba, BufferSize, Buffer);
 368 }
 369
 370 EFI_STATUS
 371 EFIAPI
 372 MmcWriteBlocks (
 373   IN EFI_BLOCK_IO_PROTOCOL    *This,
 374   IN UINT32                   MediaId,
 375   IN EFI_LBA                  Lba,
 376   IN UINTN                    BufferSize,
 377   IN VOID                     *Buffer
 378   )
 379 {
 380   return MmcIoBlocks (This, MMC_IOBLOCKS_WRITE, MediaId, Lba, BufferSize, Buffer);
 381 }
 382
 383 EFI_STATUS
 384 EFIAPI
 385 MmcFlushBlocks (
 386   IN EFI_BLOCK_IO_PROTOCOL  *This
 387   )
 388 {
 389   return EFI_SUCCESS;
 390 }