Re: [PATCH v5 8/9] MmcDxe: expand to support multiple blocks

[Leif Lindholm <leif.lindholm@linaro.org>]

On Sun, Nov 13, 2016 at 02:47:57PM +0800, Haojian Zhuang wrote:
> Make use of DMA to transfer multiple blocks at one time. It could
> improve the performance on MMC/SD driver.
> 
> Contributed-under: TianoCore Contribution Agreement 1.0
> Signed-off-by: Haojian Zhuang <haojian.zhuang@linaro.org>
> Tested-by: Ryan Harkin <ryan.harkin@linaro.org>
> ---
>  EmbeddedPkg/Include/Protocol/MmcHost.h    |   6 +
>  EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c | 177 ++++++++++++++++++++----------
>  2 files changed, 123 insertions(+), 60 deletions(-)
> 
> diff --git a/EmbeddedPkg/Include/Protocol/MmcHost.h b/EmbeddedPkg/Include/Protocol/MmcHost.h
> index 5028045..cd5335a 100644
> --- a/EmbeddedPkg/Include/Protocol/MmcHost.h
> +++ b/EmbeddedPkg/Include/Protocol/MmcHost.h
> @@ -62,6 +62,7 @@ typedef UINT32 MMC_CMD;
>  #define MMC_CMD20             (MMC_INDX(20) | MMC_CMD_WAIT_RESPONSE)
>  #define MMC_CMD23             (MMC_INDX(23) | MMC_CMD_WAIT_RESPONSE)
>  #define MMC_CMD24             (MMC_INDX(24) | MMC_CMD_WAIT_RESPONSE)
> +#define MMC_CMD25             (MMC_INDX(25) | MMC_CMD_WAIT_RESPONSE)
>  #define MMC_CMD55             (MMC_INDX(55) | MMC_CMD_WAIT_RESPONSE)
>  #define MMC_ACMD41            (MMC_INDX(41) | MMC_CMD_WAIT_RESPONSE | MMC_CMD_NO_CRC_RESPONSE)
>  #define MMC_ACMD51            (MMC_INDX(51) | MMC_CMD_WAIT_RESPONSE)
> @@ -152,6 +153,10 @@ typedef EFI_STATUS (EFIAPI *MMC_SETIOS) (
>    IN  UINT32                    TimingMode
>    );
>  
> +typedef BOOLEAN (EFIAPI *MMC_ISMULTIBLOCK) (
> +  IN  EFI_MMC_HOST_PROTOCOL     *This
> +  );
> +
>  
>  struct _EFI_MMC_HOST_PROTOCOL {
>  
> @@ -169,6 +174,7 @@ struct _EFI_MMC_HOST_PROTOCOL {
>    MMC_WRITEBLOCKDATA      WriteBlockData;
>  
>    MMC_SETIOS              SetIos;
> +  MMC_ISMULTIBLOCK        IsMultiBlock;
>  
>  };
>  
> diff --git a/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c b/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c
> index 0e1ef57..1fcb3b5 100644
> --- a/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c
> +++ b/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c
> @@ -126,6 +126,95 @@ MmcStopTransmission (
>  #define MMCI0_BLOCKLEN 512
>  #define MMCI0_TIMEOUT  10000
>  
> +STATIC EFI_STATUS

STATIC
EFI_STATUS

> +MmcTransferBlock (
> +  IN EFI_BLOCK_IO_PROTOCOL    *This,
> +  IN UINTN                    Cmd,
> +  IN UINTN                    Transfer,
> +  IN UINT32                   MediaId,
> +  IN EFI_LBA                  Lba,
> +  IN UINTN                    BufferSize,
> +  OUT VOID                    *Buffer
> +  )
> +{
> +  EFI_STATUS              Status;
> +  UINTN                   CmdArg;
> +  INTN                    Timeout;
> +  UINT32                  Response[4];
> +  MMC_HOST_INSTANCE       *MmcHostInstance;
> +  EFI_MMC_HOST_PROTOCOL   *MmcHost;
> +
> +  MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);
> +  MmcHost = MmcHostInstance->MmcHost;
> +
> +  //Set command argument based on the card access mode (Byte mode or Block mode)
> +  if (MmcHostInstance->CardInfo.OCRData.AccessMode & BIT1) {

The code would be more readable if instead of BIT1 there was a
symbolic name of the flag we're testing for.

(OK, I see the code has been moved from elsewhere in this form, but it
would be good to make the code more clear.)

> +    CmdArg = Lba;
> +  } else {
> +    CmdArg = Lba * This->Media->BlockSize;
> +  }
> +
> +  Status = MmcHost->SendCommand (MmcHost, Cmd, CmdArg);
> +  if (EFI_ERROR (Status)) {
> +    DEBUG ((EFI_D_ERROR, "%a(MMC_CMD%d): Error %r\n", __func__, Cmd, Status));
> +    return Status;
> +  }
> +
> +  if (Transfer == MMC_IOBLOCKS_READ) {
> +    // Read Data
> +    Status = MmcHost->ReadBlockData (MmcHost, Lba, BufferSize, Buffer);
> +    if (EFI_ERROR (Status)) {
> +      DEBUG ((EFI_D_BLKIO, "%a(): Error Read Block Data and Status = %r\n", __func__, Status));
> +      MmcStopTransmission (MmcHost);
> +      return Status;
> +    }
> +    Status = MmcNotifyState (MmcHostInstance, MmcProgrammingState);
> +    if (EFI_ERROR (Status)) {
> +      DEBUG ((EFI_D_ERROR, "%a() : Error MmcProgrammingState\n", __func__));
> +      return Status;
> +    }
> +  } else {
> +    // Write Data
> +    Status = MmcHost->WriteBlockData (MmcHost, Lba, BufferSize, Buffer);
> +    if (EFI_ERROR (Status)) {
> +      DEBUG ((EFI_D_BLKIO, "%a(): Error Write Block Data and Status = %r\n", __func__, Status));
> +      MmcStopTransmission (MmcHost);
> +      return Status;
> +    }
> +  }
> +
> +  // Command 13 - Read status and wait for programming to complete (return to tran)
> +  Timeout = MMCI0_TIMEOUT;
> +  CmdArg = MmcHostInstance->CardInfo.RCA << 16;
> +  Response[0] = 0;
> +  while(!(Response[0] & MMC_R0_READY_FOR_DATA)
> +        && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)
> +        && Timeout--) {
> +    Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
> +    if (!EFI_ERROR (Status)) {
> +      MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
> +      if (Response[0] & MMC_R0_READY_FOR_DATA) {
> +        break;  // Prevents delay once finished
> +      }
> +    }
> +    gBS->Stall (1);

Can you provide a comment of why this stall was chosen?
(Ah, again, moved code. Ignore.)

> +  }
> +
> +  if (BufferSize > This->Media->BlockSize) {
> +    Status = MmcHost->SendCommand (MmcHost, MMC_CMD12, 0);
> +    if (EFI_ERROR (Status)) {
> +      DEBUG ((EFI_D_BLKIO, "%a(): Error and Status:%r\n", __func__, Status));
> +    }
> +  }
> +
> +  Status = MmcNotifyState (MmcHostInstance, MmcTransferState);
> +  if (EFI_ERROR (Status)) {
> +    DEBUG ((EFI_D_ERROR, "MmcIoBlocks() : Error MmcTransferState\n"));
> +    return Status;
> +  }
> +  return Status;
> +}
> +
>  EFI_STATUS
>  MmcIoBlocks (
>    IN EFI_BLOCK_IO_PROTOCOL    *This,
> @@ -145,6 +234,7 @@ MmcIoBlocks (
>    EFI_MMC_HOST_PROTOCOL   *MmcHost;
>    UINTN                   BytesRemainingToBeTransfered;
>    UINTN                   BlockCount;
> +  UINTN                   ConsumeSize;
>  
>    BlockCount = 1;
>    MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);
> @@ -165,6 +255,10 @@ MmcIoBlocks (
>      return EFI_NO_MEDIA;
>    }
>  
> +  if (MmcHost->IsMultiBlock && MmcHost->IsMultiBlock(MmcHost)) {
> +    BlockCount = (BufferSize + This->Media->BlockSize - 1) / This->Media->BlockSize;
> +  }
> +
>    // All blocks must be within the device
>    if ((Lba + (BufferSize / This->Media->BlockSize)) > (This->Media->LastBlock + 1)) {
>      return EFI_INVALID_PARAMETER;
> @@ -196,7 +290,7 @@ MmcIoBlocks (
>      CmdArg = MmcHostInstance->CardInfo.RCA << 16;
>      Response[0] = 0;
>      Timeout = 20;
> -    while(   (!(Response[0] & MMC_R0_READY_FOR_DATA))
> +    while(!(Response[0] & MMC_R0_READY_FOR_DATA)

This is cleanup, but it is unrelated to functional changes, so please
leave out.

>            && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)
>            && Timeout--) {
>        Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
> @@ -210,75 +304,38 @@ MmcIoBlocks (
>        return EFI_NOT_READY;
>      }
>  
> -    //Set command argument based on the card access mode (Byte mode or Block mode)
> -    if (MmcHostInstance->CardInfo.OCRData.AccessMode & BIT1) {
> -      CmdArg = Lba;
> -    } else {
> -      CmdArg = Lba * This->Media->BlockSize;
> -    }
> -
>      if (Transfer == MMC_IOBLOCKS_READ) {
> -      // Read a single block
> -      Cmd = MMC_CMD17;
> -    } else {
> -      // Write a single block
> -      Cmd = MMC_CMD24;
> -    }
> -    Status = MmcHost->SendCommand (MmcHost, Cmd, CmdArg);
> -    if (EFI_ERROR (Status)) {
> -      DEBUG ((EFI_D_ERROR, "MmcIoBlocks(MMC_CMD%d): Error %r\n", Cmd, Status));
> -      return Status;
> -    }
> -
> -    if (Transfer == MMC_IOBLOCKS_READ) {
> -      // Read one block of Data
> -      Status = MmcHost->ReadBlockData (MmcHost, Lba, This->Media->BlockSize, Buffer);
> -      if (EFI_ERROR (Status)) {
> -        DEBUG ((EFI_D_BLKIO, "MmcIoBlocks(): Error Read Block Data and Status = %r\n", Status));
> -        MmcStopTransmission (MmcHost);
> -        return Status;
> -      }
> -      Status = MmcNotifyState (MmcHostInstance, MmcProgrammingState);
> -      if (EFI_ERROR (Status)) {
> -        DEBUG ((EFI_D_ERROR, "MmcIoBlocks() : Error MmcProgrammingState\n"));
> -        return Status;
> +      if (BlockCount == 1) {
> +        // Read a single block
> +        Cmd = MMC_CMD17;
> +      } else {
> +	// Read multiple blocks
> +	Cmd = MMC_CMD18;
>        }
>      } else {
> -      // Write one block of Data
> -      Status = MmcHost->WriteBlockData (MmcHost, Lba, This->Media->BlockSize, Buffer);
> -      if (EFI_ERROR (Status)) {
> -        DEBUG ((EFI_D_BLKIO, "MmcIoBlocks(): Error Write Block Data and Status = %r\n", Status));
> -        MmcStopTransmission (MmcHost);
> -        return Status;
> +      if (BlockCount == 1) {
> +        // Write a single block
> +        Cmd = MMC_CMD24;
> +      } else {
> +	// Write multiple blocks
> +	Cmd = MMC_CMD25;
>        }
>      }
>  
> -    // Command 13 - Read status and wait for programming to complete (return to tran)
> -    Timeout = MMCI0_TIMEOUT;
> -    CmdArg = MmcHostInstance->CardInfo.RCA << 16;
> -    Response[0] = 0;
> -    while(   (!(Response[0] & MMC_R0_READY_FOR_DATA))
> -          && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)
> -          && Timeout--) {
> -      Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
> -      if (!EFI_ERROR (Status)) {
> -        MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
> -        if ((Response[0] & MMC_R0_READY_FOR_DATA)) {
> -          break;  // Prevents delay once finished
> -        }
> -      }
> -      gBS->Stall (1);
> +    ConsumeSize = BlockCount * This->Media->BlockSize;
> +    if (BytesRemainingToBeTransfered < ConsumeSize) {
> +      ConsumeSize = BytesRemainingToBeTransfered;
>      }
> -
> -    Status = MmcNotifyState (MmcHostInstance, MmcTransferState);
> +    Status = MmcTransferBlock (This, Cmd, Transfer, MediaId, Lba, ConsumeSize, Buffer);
>      if (EFI_ERROR (Status)) {
> -      DEBUG ((EFI_D_ERROR, "MmcIoBlocks() : Error MmcTransferState\n"));
> -      return Status;
> +      DEBUG ((EFI_D_ERROR, "%a(): Failed to transfer block and Status:%r\n", __func__, Status));
>      }
>  
> -    BytesRemainingToBeTransfered -= This->Media->BlockSize;
> -    Lba    += BlockCount;
> -    Buffer = (UINT8 *)Buffer + This->Media->BlockSize;
> +    BytesRemainingToBeTransfered -= ConsumeSize;
> +    if (BytesRemainingToBeTransfered > 0) {
> +      Lba    += BlockCount;
> +      Buffer = (UINT8 *)Buffer + ConsumeSize;
> +    }
>    }
>  
>    return EFI_SUCCESS;
> -- 
> 2.7.4
>