EmbeddedPkg: Apply uncrustify changes

REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3737

Apply uncrustify changes to .c/.h files in the EmbeddedPkg package

Cc: Andrew Fish <afish@apple.com>
Cc: Leif Lindholm <leif@nuviainc.com>
Cc: Michael D Kinney <michael.d.kinney@intel.com>
Signed-off-by: Michael Kubacki <michael.kubacki@microsoft.com>
Reviewed-by: Andrew Fish <afish@apple.com>

1 files changed, 96 insertions, 87 deletions

diff --git a/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c b/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c
index 7614ecdf0a..d695e25571 100644
--- a/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c
+++ b/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c
@@ -12,8 +12,8 @@
 

 EFI_STATUS

 MmcNotifyState (

-  IN MMC_HOST_INSTANCE *MmcHostInstance,

-  IN MMC_STATE State

+  IN MMC_HOST_INSTANCE  *MmcHostInstance,

+  IN MMC_STATE          State

   )

 {

   MmcHostInstance->State = State;

@@ -23,23 +23,24 @@ MmcNotifyState (
 EFI_STATUS

 EFIAPI

 MmcGetCardStatus (

-  IN MMC_HOST_INSTANCE     *MmcHostInstance

+  IN MMC_HOST_INSTANCE  *MmcHostInstance

   )

 {

-  EFI_STATUS              Status;

-  UINT32                  Response[4];

-  UINTN                   CmdArg;

-  EFI_MMC_HOST_PROTOCOL   *MmcHost;

+  EFI_STATUS             Status;

+  UINT32                 Response[4];

+  UINTN                  CmdArg;

+  EFI_MMC_HOST_PROTOCOL  *MmcHost;

 

-  Status = EFI_SUCCESS;

+  Status  = EFI_SUCCESS;

   MmcHost = MmcHostInstance->MmcHost;

-  CmdArg = 0;

+  CmdArg  = 0;

 

   if (MmcHost == NULL) {

     return EFI_INVALID_PARAMETER;

   }

+

   if (MmcHostInstance->State != MmcHwInitializationState) {

-    //Get the Status of the card.

+    // Get the Status of the card.

     CmdArg = MmcHostInstance->CardInfo.RCA << 16;

     Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);

     if (EFI_ERROR (Status)) {

@@ -47,7 +48,7 @@ MmcGetCardStatus (
       return Status;

     }

 

-    //Read Response

+    // Read Response

     MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);

     PrintResponseR1 (Response[0]);

   }

@@ -58,11 +59,11 @@ MmcGetCardStatus (
 EFI_STATUS

 EFIAPI

 MmcReset (

-  IN EFI_BLOCK_IO_PROTOCOL    *This,

-  IN BOOLEAN                  ExtendedVerification

+  IN EFI_BLOCK_IO_PROTOCOL  *This,

+  IN BOOLEAN                ExtendedVerification

   )

 {

-  MMC_HOST_INSTANCE       *MmcHostInstance;

+  MMC_HOST_INSTANCE  *MmcHostInstance;

 

   MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);

 

@@ -91,7 +92,7 @@ MmcReset (
 

 EFI_STATUS

 MmcDetectCard (

-  EFI_MMC_HOST_PROTOCOL     *MmcHost

+  EFI_MMC_HOST_PROTOCOL  *MmcHost

   )

 {

   if (!MmcHost->IsCardPresent (MmcHost)) {

@@ -103,58 +104,61 @@ MmcDetectCard (
 

 EFI_STATUS

 MmcStopTransmission (

-  EFI_MMC_HOST_PROTOCOL     *MmcHost

+  EFI_MMC_HOST_PROTOCOL  *MmcHost

   )

 {

-  EFI_STATUS              Status;

-  UINT32                  Response[4];

+  EFI_STATUS  Status;

+  UINT32      Response[4];

+

   // Command 12 - Stop transmission (ends read or write)

   // Normally only needed for streaming transfers or after error.

   Status = MmcHost->SendCommand (MmcHost, MMC_CMD12, 0);

   if (!EFI_ERROR (Status)) {

     MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1b, Response);

   }

+

   return Status;

 }

 

-#define MMCI0_BLOCKLEN 512

-#define MMCI0_TIMEOUT  10000

+#define MMCI0_BLOCKLEN  512

+#define MMCI0_TIMEOUT   10000

 

 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

+  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;

+  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;

+  MmcHost         = MmcHostInstance->MmcHost;

 

   if (MmcHostInstance->CardInfo.CardType != EMMC_CARD) {

-    //Set command argument based on the card capacity

-    //if 0 : SDSC card

-    //if 1 : SDXC/SDHC

+    // Set command argument based on the card capacity

+    // if 0 : SDSC card

+    // if 1 : SDXC/SDHC

     if (MmcHostInstance->CardInfo.OCRData.AccessMode & SD_CARD_CAPACITY) {

       CmdArg = Lba;

     } else {

       CmdArg = MultU64x32 (Lba, This->Media->BlockSize);

     }

   } else {

-    //Set command argument based on the card access mode (Byte mode or Block mode)

+    // Set command argument based on the card access mode (Byte mode or Block mode)

     if ((MmcHostInstance->CardInfo.OCRData.AccessMode & MMC_OCR_ACCESS_MASK) ==

-        MMC_OCR_ACCESS_SECTOR) {

+        MMC_OCR_ACCESS_SECTOR)

+    {

       CmdArg = Lba;

     } else {

       CmdArg = MultU64x32 (Lba, This->Media->BlockSize);

@@ -175,6 +179,7 @@ MmcTransferBlock (
       MmcStopTransmission (MmcHost);

       return Status;

     }

+

     Status = MmcNotifyState (MmcHostInstance, MmcProgrammingState);

     if (EFI_ERROR (Status)) {

       DEBUG ((DEBUG_ERROR, "%a() : Error MmcProgrammingState\n", __func__));

@@ -191,12 +196,13 @@ MmcTransferBlock (
   }

 

   // Command 13 - Read status and wait for programming to complete (return to tran)

-  Timeout = MMCI0_TIMEOUT;

-  CmdArg = MmcHostInstance->CardInfo.RCA << 16;

+  Timeout     = MMCI0_TIMEOUT;

+  CmdArg      = MmcHostInstance->CardInfo.RCA << 16;

   Response[0] = 0;

-  while(!(Response[0] & MMC_R0_READY_FOR_DATA)

+  while (  !(Response[0] & MMC_R0_READY_FOR_DATA)

         && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)

-        && Timeout--) {

+        && Timeout--)

+  {

     Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);

     if (!EFI_ERROR (Status)) {

       MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);

@@ -211,6 +217,7 @@ MmcTransferBlock (
     if (EFI_ERROR (Status)) {

       DEBUG ((DEBUG_BLKIO, "%a(): Error and Status:%r\n", __func__, Status));

     }

+

     MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1b, Response);

   }

 

@@ -219,33 +226,34 @@ MmcTransferBlock (
     DEBUG ((DEBUG_ERROR, "MmcIoBlocks() : Error MmcTransferState\n"));

     return Status;

   }

+

   return Status;

 }

 

 EFI_STATUS

 MmcIoBlocks (

-  IN EFI_BLOCK_IO_PROTOCOL    *This,

-  IN UINTN                    Transfer,

-  IN UINT32                   MediaId,

-  IN EFI_LBA                  Lba,

-  IN UINTN                    BufferSize,

-  OUT VOID                    *Buffer

+  IN EFI_BLOCK_IO_PROTOCOL  *This,

+  IN UINTN                  Transfer,

+  IN UINT32                 MediaId,

+  IN EFI_LBA                Lba,

+  IN UINTN                  BufferSize,

+  OUT VOID                  *Buffer

   )

 {

-  UINT32                  Response[4];

-  EFI_STATUS              Status;

-  UINTN                   CmdArg;

-  INTN                    Timeout;

-  UINTN                   Cmd;

-  MMC_HOST_INSTANCE       *MmcHostInstance;

-  EFI_MMC_HOST_PROTOCOL   *MmcHost;

-  UINTN                   BytesRemainingToBeTransfered;

-  UINTN                   BlockCount;

-  UINTN                   ConsumeSize;

-  UINT32                  MaxBlock;

-  UINTN                   RemainingBlock;

-

-  BlockCount = 1;

+  UINT32                 Response[4];

+  EFI_STATUS             Status;

+  UINTN                  CmdArg;

+  INTN                   Timeout;

+  UINTN                  Cmd;

+  MMC_HOST_INSTANCE      *MmcHostInstance;

+  EFI_MMC_HOST_PROTOCOL  *MmcHost;

+  UINTN                  BytesRemainingToBeTransfered;

+  UINTN                  BlockCount;

+  UINTN                  ConsumeSize;

+  UINT32                 MaxBlock;

+  UINTN                  RemainingBlock;

+

+  BlockCount      = 1;

   MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);

   ASSERT (MmcHostInstance != NULL);

   MmcHost = MmcHostInstance->MmcHost;

@@ -274,7 +282,7 @@ MmcIoBlocks (
     return EFI_BAD_BUFFER_SIZE;

   }

 

-  if (MMC_HOST_HAS_ISMULTIBLOCK(MmcHost) && MmcHost->IsMultiBlock(MmcHost)) {

+  if (MMC_HOST_HAS_ISMULTIBLOCK (MmcHost) && MmcHost->IsMultiBlock (MmcHost)) {

     BlockCount = BufferSize / This->Media->BlockSize;

   }

 

@@ -293,11 +301,10 @@ MmcIoBlocks (
   }

 

   // Max block number in single cmd is 65535 blocks.

-  MaxBlock = 0xFFFF;

-  RemainingBlock = BlockCount;

+  MaxBlock                     = 0xFFFF;

+  RemainingBlock               = BlockCount;

   BytesRemainingToBeTransfered = BufferSize;

   while (BytesRemainingToBeTransfered > 0) {

-

     if (RemainingBlock <= MaxBlock) {

       BlockCount = RemainingBlock;

     } else {

@@ -305,12 +312,13 @@ MmcIoBlocks (
     }

 

     // Check if the Card is in Ready status

-    CmdArg = MmcHostInstance->CardInfo.RCA << 16;

+    CmdArg      = MmcHostInstance->CardInfo.RCA << 16;

     Response[0] = 0;

-    Timeout = 20;

-    while(   (!(Response[0] & MMC_R0_READY_FOR_DATA))

+    Timeout     = 20;

+    while (  (!(Response[0] & MMC_R0_READY_FOR_DATA))

           && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)

-          && Timeout--) {

+          && Timeout--)

+    {

       Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);

       if (!EFI_ERROR (Status)) {

         MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);

@@ -327,16 +335,16 @@ MmcIoBlocks (
         // Read a single block

         Cmd = MMC_CMD17;

       } else {

-	// Read multiple blocks

-	Cmd = MMC_CMD18;

+        // Read multiple blocks

+        Cmd = MMC_CMD18;

       }

     } else {

       if (BlockCount == 1) {

         // Write a single block

         Cmd = MMC_CMD24;

       } else {

-	// Write multiple blocks

-	Cmd = MMC_CMD25;

+        // Write multiple blocks

+        Cmd = MMC_CMD25;

       }

     }

 

@@ -344,15 +352,16 @@ MmcIoBlocks (
     if (BytesRemainingToBeTransfered < ConsumeSize) {

       ConsumeSize = BytesRemainingToBeTransfered;

     }

+

     Status = MmcTransferBlock (This, Cmd, Transfer, MediaId, Lba, ConsumeSize, Buffer);

     if (EFI_ERROR (Status)) {

       DEBUG ((DEBUG_ERROR, "%a(): Failed to transfer block and Status:%r\n", __func__, Status));

     }

 

-    RemainingBlock -= BlockCount;

+    RemainingBlock               -= BlockCount;

     BytesRemainingToBeTransfered -= ConsumeSize;

     if (BytesRemainingToBeTransfered > 0) {

-      Lba    += BlockCount;

+      Lba   += BlockCount;

       Buffer = (UINT8 *)Buffer + ConsumeSize;

     }

   }

@@ -363,11 +372,11 @@ MmcIoBlocks (
 EFI_STATUS

 EFIAPI

 MmcReadBlocks (

-  IN EFI_BLOCK_IO_PROTOCOL    *This,

-  IN UINT32                   MediaId,

-  IN EFI_LBA                  Lba,

-  IN UINTN                    BufferSize,

-  OUT VOID                    *Buffer

+  IN EFI_BLOCK_IO_PROTOCOL  *This,

+  IN UINT32                 MediaId,

+  IN EFI_LBA                Lba,

+  IN UINTN                  BufferSize,

+  OUT VOID                  *Buffer

   )

 {

   return MmcIoBlocks (This, MMC_IOBLOCKS_READ, MediaId, Lba, BufferSize, Buffer);

@@ -376,11 +385,11 @@ MmcReadBlocks (
 EFI_STATUS

 EFIAPI

 MmcWriteBlocks (

-  IN EFI_BLOCK_IO_PROTOCOL    *This,

-  IN UINT32                   MediaId,

-  IN EFI_LBA                  Lba,

-  IN UINTN                    BufferSize,

-  IN VOID                     *Buffer

+  IN EFI_BLOCK_IO_PROTOCOL  *This,

+  IN UINT32                 MediaId,

+  IN EFI_LBA                Lba,

+  IN UINTN                  BufferSize,

+  IN VOID                   *Buffer

   )

 {

   return MmcIoBlocks (This, MMC_IOBLOCKS_WRITE, MediaId, Lba, BufferSize, Buffer);