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

/** @file\r
*\r
*  Copyright (c) 2011-2015, 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 ((EFI_D_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 = 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 = Lba * This->Media->BlockSize;\r
    }\r
  }\r
\r
  Status = MmcHost->SendCommand (MmcHost, Cmd, CmdArg);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_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 ((EFI_D_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 ((EFI_D_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 ((EFI_D_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 ((EFI_D_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 ((EFI_D_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
\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
  if (MMC_HOST_HAS_ISMULTIBLOCK(MmcHost) && MmcHost->IsMultiBlock(MmcHost)) {\r
    BlockCount = (BufferSize + This->Media->BlockSize - 1) / 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
  // 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
  // Check the alignment\r
  if ((This->Media->IoAlign > 2) && (((UINTN)Buffer & (This->Media->IoAlign - 1)) != 0)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  BytesRemainingToBeTransfered = BufferSize;\r
  while (BytesRemainingToBeTransfered > 0) {\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 ((EFI_D_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 ((EFI_D_ERROR, "%a(): Failed to transfer block and Status:%r\n", __func__, Status));\r
    }\r
\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
1bfda055	1	/** @file\r
1bfda055	2	*\r
eff98cf9	3	* Copyright (c) 2011-2015, ARM Limited. All rights reserved.\r
1bfda055	4	*\r
878b807a	5	* SPDX-License-Identifier: BSD-2-Clause-Patent\r
1bfda055	6	*\r
	7	**/\r
	8	\r
1bfda055	9	#include <Library/BaseMemoryLib.h>\r
1bfda055	10	\r
	11	#include "Mmc.h"\r
	12	\r
1bfda055	13	EFI_STATUS\r
1bfda055	14	MmcNotifyState (\r
e8e95df4	15	IN MMC_HOST_INSTANCE *MmcHostInstance,\r
	16	IN MMC_STATE State\r
	17	)\r
	18	{\r
	19	MmcHostInstance->State = State;\r
16d88c2d	20	return MmcHostInstance->MmcHost->NotifyState (MmcHostInstance->MmcHost, State);\r
1bfda055	21	}\r
1bfda055	22	\r
a1ab9143	23	EFI_STATUS\r
a1ab9143	24	EFIAPI\r
842b02d8	25	MmcGetCardStatus (\r
4ca3c688	26	IN MMC_HOST_INSTANCE *MmcHostInstance\r
e8e95df4	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
842b02d8	41	if (MmcHostInstance->State != MmcHwInitializationState) {\r
e8e95df4	42	//Get the Status of the card.\r
e8e95df4	43	CmdArg = MmcHostInstance->CardInfo.RCA << 16;\r
16d88c2d	44	Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);\r
6f711615	45	if (EFI_ERROR (Status)) {\r
6f711615	46	DEBUG ((EFI_D_ERROR, "MmcGetCardStatus(MMC_CMD13): Error and Status = %r\n", Status));\r
e8e95df4	47	return Status;\r
a1ab9143	48	}\r
a1ab9143	49	\r
e8e95df4	50	//Read Response\r
6f711615	51	MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);\r
6f711615	52	PrintResponseR1 (Response[0]);\r
e8e95df4	53	}\r
	54	\r
	55	return Status;\r
1bfda055	56	}\r
1bfda055	57	\r
1bfda055	58	EFI_STATUS\r
	59	EFIAPI\r
	60	MmcReset (\r
	61	IN EFI_BLOCK_IO_PROTOCOL *This,\r
	62	IN BOOLEAN ExtendedVerification\r
e8e95df4	63	)\r
e8e95df4	64	{\r
3de99375	65	MMC_HOST_INSTANCE *MmcHostInstance;\r
3de99375	66	\r
6f711615	67	MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);\r
3de99375	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
16d88c2d	75	if (!MmcHostInstance->MmcHost->IsCardPresent (MmcHostInstance->MmcHost)) {\r
3de99375	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
e8e95df4	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
1bfda055	90	}\r
	91	\r
	92	EFI_STATUS\r
	93	MmcDetectCard (\r
	94	EFI_MMC_HOST_PROTOCOL *MmcHost\r
	95	)\r
	96	{\r
16d88c2d	97	if (!MmcHost->IsCardPresent (MmcHost)) {\r
e8e95df4	98	return EFI_NO_MEDIA;\r
	99	} else {\r
	100	return EFI_SUCCESS;\r
	101	}\r
1bfda055	102	}\r
1bfda055	103	\r
9532373b OM	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
1bfda055	120	#define MMCI0_BLOCKLEN 512\r
	121	#define MMCI0_TIMEOUT 10000\r
	122	\r
339c6e90 HZ	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
b566259c MA	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 = Lba * This->Media->BlockSize;\r
	153	}\r
339c6e90	154	} else {\r
b566259c MA	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 = Lba * This->Media->BlockSize;\r
	161	}\r
339c6e90 HZ	162	}\r
	163	\r
	164	Status = MmcHost->SendCommand (MmcHost, Cmd, CmdArg);\r
	165	if (EFI_ERROR (Status)) {\r
	166	DEBUG ((EFI_D_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 ((EFI_D_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 ((EFI_D_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 ((EFI_D_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 ((EFI_D_BLKIO, "%a(): Error and Status:%r\n", __func__, Status));\r
	213	}\r
1cc0f69b	214	MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1b, Response);\r
339c6e90 HZ	215	}\r
	216	\r
	217	Status = MmcNotifyState (MmcHostInstance, MmcTransferState);\r
	218	if (EFI_ERROR (Status)) {\r
	219	DEBUG ((EFI_D_ERROR, "MmcIoBlocks() : Error MmcTransferState\n"));\r
	220	return Status;\r
	221	}\r
	222	return Status;\r
	223	}\r
	224	\r
e8e95df4	225	EFI_STATUS\r
e8e95df4	226	MmcIoBlocks (\r
1bfda055	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
e8e95df4	233	)\r
	234	{\r
	235	UINT32 Response[4];\r
	236	EFI_STATUS Status;\r
40842a5e	237	UINTN CmdArg;\r
969ece79	238	INTN Timeout;\r
e8e95df4	239	UINTN Cmd;\r
	240	MMC_HOST_INSTANCE *MmcHostInstance;\r
	241	EFI_MMC_HOST_PROTOCOL *MmcHost;\r
	242	UINTN BytesRemainingToBeTransfered;\r
842b02d8	243	UINTN BlockCount;\r
339c6e90	244	UINTN ConsumeSize;\r
e8e95df4	245	\r
842b02d8	246	BlockCount = 1;\r
6f711615	247	MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);\r
842b02d8	248	ASSERT (MmcHostInstance != NULL);\r
e8e95df4	249	MmcHost = MmcHostInstance->MmcHost;\r
6f711615	250	ASSERT (MmcHost);\r
e8e95df4	251	\r
5ab765a7	252	if (This->Media->MediaId != MediaId) {\r
	253	return EFI_MEDIA_CHANGED;\r
	254	}\r
	255	\r
842b02d8	256	if ((MmcHost == NULL) \|\| (Buffer == NULL)) {\r
e8e95df4	257	return EFI_INVALID_PARAMETER;\r
	258	}\r
	259	\r
	260	// Check if a Card is Present\r
3de99375	261	if (!MmcHostInstance->BlockIo.Media->MediaPresent) {\r
e8e95df4	262	return EFI_NO_MEDIA;\r
	263	}\r
	264	\r
339c6e90 HZ	265	if (MMC_HOST_HAS_ISMULTIBLOCK(MmcHost) && MmcHost->IsMultiBlock(MmcHost)) {\r
	266	BlockCount = (BufferSize + This->Media->BlockSize - 1) / This->Media->BlockSize;\r
	267	}\r
	268	\r
969ece79	269	// All blocks must be within the device\r
842b02d8	270	if ((Lba + (BufferSize / This->Media->BlockSize)) > (This->Media->LastBlock + 1)) {\r
969ece79	271	return EFI_INVALID_PARAMETER;\r
e8e95df4	272	}\r
e8e95df4	273	\r
842b02d8	274	if ((Transfer == MMC_IOBLOCKS_WRITE) && (This->Media->ReadOnly == TRUE)) {\r
5ab765a7	275	return EFI_WRITE_PROTECTED;\r
969ece79	276	}\r
969ece79	277	\r
5ab765a7	278	// Reading 0 Byte is valid\r
	279	if (BufferSize == 0) {\r
	280	return EFI_SUCCESS;\r
969ece79	281	}\r
969ece79	282	\r
5ab765a7	283	// The buffer size must be an exact multiple of the block size\r
	284	if ((BufferSize % This->Media->BlockSize) != 0) {\r
	285	return EFI_BAD_BUFFER_SIZE;\r
	286	}\r
	287	\r
	288	// Check the alignment\r
	289	if ((This->Media->IoAlign > 2) && (((UINTN)Buffer & (This->Media->IoAlign - 1)) != 0)) {\r
	290	return EFI_INVALID_PARAMETER;\r
e8e95df4	291	}\r
	292	\r
	293	BytesRemainingToBeTransfered = BufferSize;\r
	294	while (BytesRemainingToBeTransfered > 0) {\r
	295	\r
	296	// Check if the Card is in Ready status\r
	297	CmdArg = MmcHostInstance->CardInfo.RCA << 16;\r
	298	Response[0] = 0;\r
	299	Timeout = 20;\r
260675b0	300	while( (!(Response[0] & MMC_R0_READY_FOR_DATA))\r
6f711615	301	&& (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)\r
260675b0	302	&& Timeout--) {\r
16d88c2d	303	Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);\r
6f711615	304	if (!EFI_ERROR (Status)) {\r
6f711615	305	MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);\r
e8e95df4	306	}\r
1bfda055	307	}\r
1bfda055	308	\r
e8e95df4	309	if (0 == Timeout) {\r
6f711615	310	DEBUG ((EFI_D_ERROR, "The Card is busy\n"));\r
e8e95df4	311	return EFI_NOT_READY;\r
b9d5fe03	312	}\r
b9d5fe03	313	\r
e8e95df4	314	if (Transfer == MMC_IOBLOCKS_READ) {\r
339c6e90 HZ	315	if (BlockCount == 1) {\r
	316	// Read a single block\r
	317	Cmd = MMC_CMD17;\r
	318	} else {\r
	319	// Read multiple blocks\r
	320	Cmd = MMC_CMD18;\r
e8e95df4	321	}\r
e8e95df4	322	} else {\r
339c6e90 HZ	323	if (BlockCount == 1) {\r
	324	// Write a single block\r
	325	Cmd = MMC_CMD24;\r
	326	} else {\r
	327	// Write multiple blocks\r
	328	Cmd = MMC_CMD25;\r
e8e95df4	329	}\r
e8e95df4	330	}\r
1bfda055	331	\r
339c6e90 HZ	332	ConsumeSize = BlockCount * This->Media->BlockSize;\r
	333	if (BytesRemainingToBeTransfered < ConsumeSize) {\r
	334	ConsumeSize = BytesRemainingToBeTransfered;\r
e8e95df4	335	}\r
339c6e90	336	Status = MmcTransferBlock (This, Cmd, Transfer, MediaId, Lba, ConsumeSize, Buffer);\r
6f711615	337	if (EFI_ERROR (Status)) {\r
339c6e90	338	DEBUG ((EFI_D_ERROR, "%a(): Failed to transfer block and Status:%r\n", __func__, Status));\r
1bfda055	339	}\r
1bfda055	340	\r
339c6e90 HZ	341	BytesRemainingToBeTransfered -= ConsumeSize;\r
	342	if (BytesRemainingToBeTransfered > 0) {\r
	343	Lba += BlockCount;\r
	344	Buffer = (UINT8 *)Buffer + ConsumeSize;\r
	345	}\r
e8e95df4	346	}\r
	347	\r
	348	return EFI_SUCCESS;\r
1bfda055	349	}\r
	350	\r
	351	EFI_STATUS\r
	352	EFIAPI\r
	353	MmcReadBlocks (\r
	354	IN EFI_BLOCK_IO_PROTOCOL *This,\r
	355	IN UINT32 MediaId,\r
	356	IN EFI_LBA Lba,\r
	357	IN UINTN BufferSize,\r
	358	OUT VOID *Buffer\r
e8e95df4	359	)\r
	360	{\r
	361	return MmcIoBlocks (This, MMC_IOBLOCKS_READ, MediaId, Lba, BufferSize, Buffer);\r
1bfda055	362	}\r
	363	\r
	364	EFI_STATUS\r
	365	EFIAPI\r
	366	MmcWriteBlocks (\r
	367	IN EFI_BLOCK_IO_PROTOCOL *This,\r
	368	IN UINT32 MediaId,\r
	369	IN EFI_LBA Lba,\r
	370	IN UINTN BufferSize,\r
	371	IN VOID *Buffer\r
e8e95df4	372	)\r
	373	{\r
	374	return MmcIoBlocks (This, MMC_IOBLOCKS_WRITE, MediaId, Lba, BufferSize, Buffer);\r
1bfda055	375	}\r
	376	\r
	377	EFI_STATUS\r
	378	EFIAPI\r
	379	MmcFlushBlocks (\r
	380	IN EFI_BLOCK_IO_PROTOCOL *This\r
e8e95df4	381	)\r
	382	{\r
	383	return EFI_SUCCESS;\r
1bfda055	384	}\r