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 EFI_STATUS
 130 MmcIoBlocks (
 131   IN EFI_BLOCK_IO_PROTOCOL    *This,
 132   IN UINTN                    Transfer,
 133   IN UINT32                   MediaId,
 134   IN EFI_LBA                  Lba,
 135   IN UINTN                    BufferSize,
 136   OUT VOID                    *Buffer
 137   )
 138 {
 139   UINT32                  Response[4];
 140   EFI_STATUS              Status;
 141   UINTN                   CmdArg;
 142   INTN                    Timeout;
 143   UINTN                   Cmd;
 144   MMC_HOST_INSTANCE       *MmcHostInstance;
 145   EFI_MMC_HOST_PROTOCOL   *MmcHost;
 146   UINTN                   BytesRemainingToBeTransfered;
 147   UINTN                   BlockCount;
 148
 149   BlockCount = 1;
 150   MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);
 151   ASSERT (MmcHostInstance != NULL);
 152   MmcHost = MmcHostInstance->MmcHost;
 153   ASSERT (MmcHost);
 154
 155   if (This->Media->MediaId != MediaId) {
 156     return EFI_MEDIA_CHANGED;
 157   }
 158
 159   if ((MmcHost == NULL) || (Buffer == NULL)) {
 160     return EFI_INVALID_PARAMETER;
 161   }
 162
 163   // Check if a Card is Present
 164   if (!MmcHostInstance->BlockIo.Media->MediaPresent) {
 165     return EFI_NO_MEDIA;
 166   }
 167
 168   // All blocks must be within the device
 169   if ((Lba + (BufferSize / This->Media->BlockSize)) > (This->Media->LastBlock + 1)) {
 170     return EFI_INVALID_PARAMETER;
 171   }
 172
 173   if ((Transfer == MMC_IOBLOCKS_WRITE) && (This->Media->ReadOnly == TRUE)) {
 174     return EFI_WRITE_PROTECTED;
 175   }
 176
 177   // Reading 0 Byte is valid
 178   if (BufferSize == 0) {
 179     return EFI_SUCCESS;
 180   }
 181
 182   // The buffer size must be an exact multiple of the block size
 183   if ((BufferSize % This->Media->BlockSize) != 0) {
 184     return EFI_BAD_BUFFER_SIZE;
 185   }
 186
 187   // Check the alignment
 188   if ((This->Media->IoAlign > 2) && (((UINTN)Buffer & (This->Media->IoAlign - 1)) != 0)) {
 189     return EFI_INVALID_PARAMETER;
 190   }
 191
 192   BytesRemainingToBeTransfered = BufferSize;
 193   while (BytesRemainingToBeTransfered > 0) {
 194
 195     // Check if the Card is in Ready status
 196     CmdArg = MmcHostInstance->CardInfo.RCA << 16;
 197     Response[0] = 0;
 198     Timeout = 20;
 199     while(   (!(Response[0] & MMC_R0_READY_FOR_DATA))
 200           && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)
 201           && Timeout--) {
 202       Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
 203       if (!EFI_ERROR (Status)) {
 204         MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
 205       }
 206     }
 207
 208     if (0 == Timeout) {
 209       DEBUG ((EFI_D_ERROR, "The Card is busy\n"));
 210       return EFI_NOT_READY;
 211     }
 212
 213     //Set command argument based on the card access mode (Byte mode or Block mode)
 214     if (MmcHostInstance->CardInfo.OCRData.AccessMode & BIT1) {
 215       CmdArg = Lba;
 216     } else {
 217       CmdArg = Lba * This->Media->BlockSize;
 218     }
 219
 220     if (Transfer == MMC_IOBLOCKS_READ) {
 221       // Read a single block
 222       Cmd = MMC_CMD17;
 223     } else {
 224       // Write a single block
 225       Cmd = MMC_CMD24;
 226     }
 227     Status = MmcHost->SendCommand (MmcHost, Cmd, CmdArg);
 228     if (EFI_ERROR (Status)) {
 229       DEBUG ((EFI_D_ERROR, "MmcIoBlocks(MMC_CMD%d): Error %r\n", Cmd, Status));
 230       return Status;
 231     }
 232
 233     if (Transfer == MMC_IOBLOCKS_READ) {
 234       // Read one block of Data
 235       Status = MmcHost->ReadBlockData (MmcHost, Lba, This->Media->BlockSize, Buffer);
 236       if (EFI_ERROR (Status)) {
 237         DEBUG ((EFI_D_BLKIO, "MmcIoBlocks(): Error Read Block Data and Status = %r\n", Status));
 238         MmcStopTransmission (MmcHost);
 239         return Status;
 240       }
 241       Status = MmcNotifyState (MmcHostInstance, MmcProgrammingState);
 242       if (EFI_ERROR (Status)) {
 243         DEBUG ((EFI_D_ERROR, "MmcIoBlocks() : Error MmcProgrammingState\n"));
 244         return Status;
 245       }
 246     } else {
 247       // Write one block of Data
 248       Status = MmcHost->WriteBlockData (MmcHost, Lba, This->Media->BlockSize, Buffer);
 249       if (EFI_ERROR (Status)) {
 250         DEBUG ((EFI_D_BLKIO, "MmcIoBlocks(): Error Write Block Data and Status = %r\n", Status));
 251         MmcStopTransmission (MmcHost);
 252         return Status;
 253       }
 254     }
 255
 256     // Command 13 - Read status and wait for programming to complete (return to tran)
 257     Timeout = MMCI0_TIMEOUT;
 258     CmdArg = MmcHostInstance->CardInfo.RCA << 16;
 259     Response[0] = 0;
 260     while(   (!(Response[0] & MMC_R0_READY_FOR_DATA))
 261           && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)
 262           && Timeout--) {
 263       Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
 264       if (!EFI_ERROR (Status)) {
 265         MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
 266         if ((Response[0] & MMC_R0_READY_FOR_DATA)) {
 267           break;  // Prevents delay once finished
 268         }
 269       }
 270       gBS->Stall (1);
 271     }
 272
 273     Status = MmcNotifyState (MmcHostInstance, MmcTransferState);
 274     if (EFI_ERROR (Status)) {
 275       DEBUG ((EFI_D_ERROR, "MmcIoBlocks() : Error MmcTransferState\n"));
 276       return Status;
 277     }
 278
 279     BytesRemainingToBeTransfered -= This->Media->BlockSize;
 280     Lba    += BlockCount;
 281     Buffer = (UINT8 *)Buffer + This->Media->BlockSize;
 282   }
 283
 284   return EFI_SUCCESS;
 285 }
 286
 287 EFI_STATUS
 288 EFIAPI
 289 MmcReadBlocks (
 290   IN EFI_BLOCK_IO_PROTOCOL    *This,
 291   IN UINT32                   MediaId,
 292   IN EFI_LBA                  Lba,
 293   IN UINTN                    BufferSize,
 294   OUT VOID                    *Buffer
 295   )
 296 {
 297   return MmcIoBlocks (This, MMC_IOBLOCKS_READ, MediaId, Lba, BufferSize, Buffer);
 298 }
 299
 300 EFI_STATUS
 301 EFIAPI
 302 MmcWriteBlocks (
 303   IN EFI_BLOCK_IO_PROTOCOL    *This,
 304   IN UINT32                   MediaId,
 305   IN EFI_LBA                  Lba,
 306   IN UINTN                    BufferSize,
 307   IN VOID                     *Buffer
 308   )
 309 {
 310   return MmcIoBlocks (This, MMC_IOBLOCKS_WRITE, MediaId, Lba, BufferSize, Buffer);
 311 }
 312
 313 EFI_STATUS
 314 EFIAPI
 315 MmcFlushBlocks (
 316   IN EFI_BLOCK_IO_PROTOCOL  *This
 317   )
 318 {
 319   return EFI_SUCCESS;
 320 }