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   //Set command argument based on the card access mode (Byte mode or Block mode)
 152   if ((MmcHostInstance->CardInfo.OCRData.AccessMode & MMC_OCR_ACCESS_MASK) ==
 153       MMC_OCR_ACCESS_SECTOR) {
 154     CmdArg = Lba;
 155   } else {
 156     CmdArg = Lba * This->Media->BlockSize;
 157   }
 158
 159   Status = MmcHost->SendCommand (MmcHost, Cmd, CmdArg);
 160   if (EFI_ERROR (Status)) {
 161     DEBUG ((EFI_D_ERROR, "%a(MMC_CMD%d): Error %r\n", __func__, Cmd, Status));
 162     return Status;
 163   }
 164
 165   if (Transfer == MMC_IOBLOCKS_READ) {
 166     // Read Data
 167     Status = MmcHost->ReadBlockData (MmcHost, Lba, BufferSize, Buffer);
 168     if (EFI_ERROR (Status)) {
 169       DEBUG ((EFI_D_BLKIO, "%a(): Error Read Block Data and Status = %r\n", __func__, Status));
 170       MmcStopTransmission (MmcHost);
 171       return Status;
 172     }
 173     Status = MmcNotifyState (MmcHostInstance, MmcProgrammingState);
 174     if (EFI_ERROR (Status)) {
 175       DEBUG ((EFI_D_ERROR, "%a() : Error MmcProgrammingState\n", __func__));
 176       return Status;
 177     }
 178   } else {
 179     // Write Data
 180     Status = MmcHost->WriteBlockData (MmcHost, Lba, BufferSize, Buffer);
 181     if (EFI_ERROR (Status)) {
 182       DEBUG ((EFI_D_BLKIO, "%a(): Error Write Block Data and Status = %r\n", __func__, Status));
 183       MmcStopTransmission (MmcHost);
 184       return Status;
 185     }
 186   }
 187
 188   // Command 13 - Read status and wait for programming to complete (return to tran)
 189   Timeout = MMCI0_TIMEOUT;
 190   CmdArg = MmcHostInstance->CardInfo.RCA << 16;
 191   Response[0] = 0;
 192   while(!(Response[0] & MMC_R0_READY_FOR_DATA)
 193         && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)
 194         && Timeout--) {
 195     Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
 196     if (!EFI_ERROR (Status)) {
 197       MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
 198       if (Response[0] & MMC_R0_READY_FOR_DATA) {
 199         break;  // Prevents delay once finished
 200       }
 201     }
 202   }
 203
 204   if (BufferSize > This->Media->BlockSize) {
 205     Status = MmcHost->SendCommand (MmcHost, MMC_CMD12, 0);
 206     if (EFI_ERROR (Status)) {
 207       DEBUG ((EFI_D_BLKIO, "%a(): Error and Status:%r\n", __func__, Status));
 208     }
 209   }
 210
 211   Status = MmcNotifyState (MmcHostInstance, MmcTransferState);
 212   if (EFI_ERROR (Status)) {
 213     DEBUG ((EFI_D_ERROR, "MmcIoBlocks() : Error MmcTransferState\n"));
 214     return Status;
 215   }
 216   return Status;
 217 }
 218
 219 EFI_STATUS
 220 MmcIoBlocks (
 221   IN EFI_BLOCK_IO_PROTOCOL    *This,
 222   IN UINTN                    Transfer,
 223   IN UINT32                   MediaId,
 224   IN EFI_LBA                  Lba,
 225   IN UINTN                    BufferSize,
 226   OUT VOID                    *Buffer
 227   )
 228 {
 229   UINT32                  Response[4];
 230   EFI_STATUS              Status;
 231   UINTN                   CmdArg;
 232   INTN                    Timeout;
 233   UINTN                   Cmd;
 234   MMC_HOST_INSTANCE       *MmcHostInstance;
 235   EFI_MMC_HOST_PROTOCOL   *MmcHost;
 236   UINTN                   BytesRemainingToBeTransfered;
 237   UINTN                   BlockCount;
 238   UINTN                   ConsumeSize;
 239
 240   BlockCount = 1;
 241   MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);
 242   ASSERT (MmcHostInstance != NULL);
 243   MmcHost = MmcHostInstance->MmcHost;
 244   ASSERT (MmcHost);
 245
 246   if (This->Media->MediaId != MediaId) {
 247     return EFI_MEDIA_CHANGED;
 248   }
 249
 250   if ((MmcHost == NULL) || (Buffer == NULL)) {
 251     return EFI_INVALID_PARAMETER;
 252   }
 253
 254   // Check if a Card is Present
 255   if (!MmcHostInstance->BlockIo.Media->MediaPresent) {
 256     return EFI_NO_MEDIA;
 257   }
 258
 259   if (MMC_HOST_HAS_ISMULTIBLOCK(MmcHost) && MmcHost->IsMultiBlock(MmcHost)) {
 260     BlockCount = (BufferSize + This->Media->BlockSize - 1) / This->Media->BlockSize;
 261   }
 262
 263   // All blocks must be within the device
 264   if ((Lba + (BufferSize / This->Media->BlockSize)) > (This->Media->LastBlock + 1)) {
 265     return EFI_INVALID_PARAMETER;
 266   }
 267
 268   if ((Transfer == MMC_IOBLOCKS_WRITE) && (This->Media->ReadOnly == TRUE)) {
 269     return EFI_WRITE_PROTECTED;
 270   }
 271
 272   // Reading 0 Byte is valid
 273   if (BufferSize == 0) {
 274     return EFI_SUCCESS;
 275   }
 276
 277   // The buffer size must be an exact multiple of the block size
 278   if ((BufferSize % This->Media->BlockSize) != 0) {
 279     return EFI_BAD_BUFFER_SIZE;
 280   }
 281
 282   // Check the alignment
 283   if ((This->Media->IoAlign > 2) && (((UINTN)Buffer & (This->Media->IoAlign - 1)) != 0)) {
 284     return EFI_INVALID_PARAMETER;
 285   }
 286
 287   BytesRemainingToBeTransfered = BufferSize;
 288   while (BytesRemainingToBeTransfered > 0) {
 289
 290     // Check if the Card is in Ready status
 291     CmdArg = MmcHostInstance->CardInfo.RCA << 16;
 292     Response[0] = 0;
 293     Timeout = 20;
 294     while(   (!(Response[0] & MMC_R0_READY_FOR_DATA))
 295           && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)
 296           && Timeout--) {
 297       Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
 298       if (!EFI_ERROR (Status)) {
 299         MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
 300       }
 301     }
 302
 303     if (0 == Timeout) {
 304       DEBUG ((EFI_D_ERROR, "The Card is busy\n"));
 305       return EFI_NOT_READY;
 306     }
 307
 308     if (Transfer == MMC_IOBLOCKS_READ) {
 309       if (BlockCount == 1) {
 310         // Read a single block
 311         Cmd = MMC_CMD17;
 312       } else {
 313         // Read multiple blocks
 314         Cmd = MMC_CMD18;
 315       }
 316     } else {
 317       if (BlockCount == 1) {
 318         // Write a single block
 319         Cmd = MMC_CMD24;
 320       } else {
 321         // Write multiple blocks
 322         Cmd = MMC_CMD25;
 323       }
 324     }
 325
 326     ConsumeSize = BlockCount * This->Media->BlockSize;
 327     if (BytesRemainingToBeTransfered < ConsumeSize) {
 328       ConsumeSize = BytesRemainingToBeTransfered;
 329     }
 330     Status = MmcTransferBlock (This, Cmd, Transfer, MediaId, Lba, ConsumeSize, Buffer);
 331     if (EFI_ERROR (Status)) {
 332       DEBUG ((EFI_D_ERROR, "%a(): Failed to transfer block and Status:%r\n", __func__, Status));
 333     }
 334
 335     BytesRemainingToBeTransfered -= ConsumeSize;
 336     if (BytesRemainingToBeTransfered > 0) {
 337       Lba    += BlockCount;
 338       Buffer = (UINT8 *)Buffer + ConsumeSize;
 339     }
 340   }
 341
 342   return EFI_SUCCESS;
 343 }
 344
 345 EFI_STATUS
 346 EFIAPI
 347 MmcReadBlocks (
 348   IN EFI_BLOCK_IO_PROTOCOL    *This,
 349   IN UINT32                   MediaId,
 350   IN EFI_LBA                  Lba,
 351   IN UINTN                    BufferSize,
 352   OUT VOID                    *Buffer
 353   )
 354 {
 355   return MmcIoBlocks (This, MMC_IOBLOCKS_READ, MediaId, Lba, BufferSize, Buffer);
 356 }
 357
 358 EFI_STATUS
 359 EFIAPI
 360 MmcWriteBlocks (
 361   IN EFI_BLOCK_IO_PROTOCOL    *This,
 362   IN UINT32                   MediaId,
 363   IN EFI_LBA                  Lba,
 364   IN UINTN                    BufferSize,
 365   IN VOID                     *Buffer
 366   )
 367 {
 368   return MmcIoBlocks (This, MMC_IOBLOCKS_WRITE, MediaId, Lba, BufferSize, Buffer);
 369 }
 370
 371 EFI_STATUS
 372 EFIAPI
 373 MmcFlushBlocks (
 374   IN EFI_BLOCK_IO_PROTOCOL  *This
 375   )
 376 {
 377   return EFI_SUCCESS;
 378 }