[mirror_edk2.git] / EmbeddedPkg / Universal / MmcDxe / MmcBlockIo.c

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