OvmfPkg: Apply uncrustify changes

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

Apply uncrustify changes to .c/.h files in the OvmfPkg 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, 203 insertions, 187 deletions

diff --git a/OvmfPkg/Sec/SecMain.c b/OvmfPkg/Sec/SecMain.c
index 707b0d4bbf..6d81d5b629 100644
--- a/OvmfPkg/Sec/SecMain.c
+++ b/OvmfPkg/Sec/SecMain.c
@@ -35,33 +35,33 @@
 #define SEC_IDT_ENTRY_COUNT  34

 

 typedef struct _SEC_IDT_TABLE {

-  EFI_PEI_SERVICES          *PeiService;

-  IA32_IDT_GATE_DESCRIPTOR  IdtTable[SEC_IDT_ENTRY_COUNT];

+  EFI_PEI_SERVICES            *PeiService;

+  IA32_IDT_GATE_DESCRIPTOR    IdtTable[SEC_IDT_ENTRY_COUNT];

 } SEC_IDT_TABLE;

 

 VOID

 EFIAPI

 SecStartupPhase2 (

-  IN VOID                     *Context

+  IN VOID  *Context

   );

 

 EFI_STATUS

 EFIAPI

 TemporaryRamMigration (

-  IN CONST EFI_PEI_SERVICES   **PeiServices,

-  IN EFI_PHYSICAL_ADDRESS     TemporaryMemoryBase,

-  IN EFI_PHYSICAL_ADDRESS     PermanentMemoryBase,

-  IN UINTN                    CopySize

+  IN CONST EFI_PEI_SERVICES  **PeiServices,

+  IN EFI_PHYSICAL_ADDRESS    TemporaryMemoryBase,

+  IN EFI_PHYSICAL_ADDRESS    PermanentMemoryBase,

+  IN UINTN                   CopySize

   );

 

 //

 //

 //

-EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI mTemporaryRamSupportPpi = {

+EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI  mTemporaryRamSupportPpi = {

   TemporaryRamMigration

 };

 

-EFI_PEI_PPI_DESCRIPTOR mPrivateDispatchTable[] = {

+EFI_PEI_PPI_DESCRIPTOR  mPrivateDispatchTable[] = {

   {

     (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),

     &gEfiTemporaryRamSupportPpiGuid,

@@ -94,18 +94,18 @@ IA32_IDT_GATE_DESCRIPTOR  mIdtEntryTemplate = {
 **/

 EFI_STATUS

 FindMainFv (

-  IN OUT  EFI_FIRMWARE_VOLUME_HEADER   **BootFv

+  IN OUT  EFI_FIRMWARE_VOLUME_HEADER  **BootFv

   )

 {

   EFI_FIRMWARE_VOLUME_HEADER  *Fv;

   UINTN                       Distance;

 

-  ASSERT (((UINTN) *BootFv & EFI_PAGE_MASK) == 0);

+  ASSERT (((UINTN)*BootFv & EFI_PAGE_MASK) == 0);

 

-  Fv = *BootFv;

-  Distance = (UINTN) (*BootFv)->FvLength;

+  Fv       = *BootFv;

+  Distance = (UINTN)(*BootFv)->FvLength;

   do {

-    Fv = (EFI_FIRMWARE_VOLUME_HEADER*) ((UINT8*) Fv - EFI_PAGE_SIZE);

+    Fv        = (EFI_FIRMWARE_VOLUME_HEADER *)((UINT8 *)Fv - EFI_PAGE_SIZE);

     Distance += EFI_PAGE_SIZE;

     if (Distance > SIZE_32MB) {

       return EFI_NOT_FOUND;

@@ -115,13 +115,12 @@ FindMainFv (
       continue;

     }

 

-    if ((UINTN) Fv->FvLength > Distance) {

+    if ((UINTN)Fv->FvLength > Distance) {

       continue;

     }

 

     *BootFv = Fv;

     return EFI_SUCCESS;

-

   } while (TRUE);

 }

 

@@ -145,34 +144,35 @@ FindMainFv (
 **/

 EFI_STATUS

 FindFfsSectionInstance (

-  IN  VOID                             *Sections,

-  IN  UINTN                            SizeOfSections,

-  IN  EFI_SECTION_TYPE                 SectionType,

-  IN  UINTN                            Instance,

-  OUT EFI_COMMON_SECTION_HEADER        **FoundSection

+  IN  VOID                       *Sections,

+  IN  UINTN                      SizeOfSections,

+  IN  EFI_SECTION_TYPE           SectionType,

+  IN  UINTN                      Instance,

+  OUT EFI_COMMON_SECTION_HEADER  **FoundSection

   )

 {

-  EFI_PHYSICAL_ADDRESS        CurrentAddress;

-  UINT32                      Size;

-  EFI_PHYSICAL_ADDRESS        EndOfSections;

-  EFI_COMMON_SECTION_HEADER   *Section;

-  EFI_PHYSICAL_ADDRESS        EndOfSection;

+  EFI_PHYSICAL_ADDRESS       CurrentAddress;

+  UINT32                     Size;

+  EFI_PHYSICAL_ADDRESS       EndOfSections;

+  EFI_COMMON_SECTION_HEADER  *Section;

+  EFI_PHYSICAL_ADDRESS       EndOfSection;

 

   //

   // Loop through the FFS file sections within the PEI Core FFS file

   //

-  EndOfSection = (EFI_PHYSICAL_ADDRESS)(UINTN) Sections;

+  EndOfSection  = (EFI_PHYSICAL_ADDRESS)(UINTN)Sections;

   EndOfSections = EndOfSection + SizeOfSections;

-  for (;;) {

+  for ( ; ;) {

     if (EndOfSection == EndOfSections) {

       break;

     }

+

     CurrentAddress = (EndOfSection + 3) & ~(3ULL);

     if (CurrentAddress >= EndOfSections) {

       return EFI_VOLUME_CORRUPTED;

     }

 

-    Section = (EFI_COMMON_SECTION_HEADER*)(UINTN) CurrentAddress;

+    Section = (EFI_COMMON_SECTION_HEADER *)(UINTN)CurrentAddress;

 

     Size = SECTION_SIZE (Section);

     if (Size < sizeof (*Section)) {

@@ -216,10 +216,10 @@ FindFfsSectionInstance (
 **/

 EFI_STATUS

 FindFfsSectionInSections (

-  IN  VOID                             *Sections,

-  IN  UINTN                            SizeOfSections,

-  IN  EFI_SECTION_TYPE                 SectionType,

-  OUT EFI_COMMON_SECTION_HEADER        **FoundSection

+  IN  VOID                       *Sections,

+  IN  UINTN                      SizeOfSections,

+  IN  EFI_SECTION_TYPE           SectionType,

+  OUT EFI_COMMON_SECTION_HEADER  **FoundSection

   )

 {

   return FindFfsSectionInstance (

@@ -247,38 +247,37 @@ FindFfsSectionInSections (
 **/

 EFI_STATUS

 FindFfsFileAndSection (

-  IN  EFI_FIRMWARE_VOLUME_HEADER       *Fv,

-  IN  EFI_FV_FILETYPE                  FileType,

-  IN  EFI_SECTION_TYPE                 SectionType,

-  OUT EFI_COMMON_SECTION_HEADER        **FoundSection

+  IN  EFI_FIRMWARE_VOLUME_HEADER  *Fv,

+  IN  EFI_FV_FILETYPE             FileType,

+  IN  EFI_SECTION_TYPE            SectionType,

+  OUT EFI_COMMON_SECTION_HEADER   **FoundSection

   )

 {

-  EFI_STATUS                  Status;

-  EFI_PHYSICAL_ADDRESS        CurrentAddress;

-  EFI_PHYSICAL_ADDRESS        EndOfFirmwareVolume;

-  EFI_FFS_FILE_HEADER         *File;

-  UINT32                      Size;

-  EFI_PHYSICAL_ADDRESS        EndOfFile;

+  EFI_STATUS            Status;

+  EFI_PHYSICAL_ADDRESS  CurrentAddress;

+  EFI_PHYSICAL_ADDRESS  EndOfFirmwareVolume;

+  EFI_FFS_FILE_HEADER   *File;

+  UINT32                Size;

+  EFI_PHYSICAL_ADDRESS  EndOfFile;

 

   if (Fv->Signature != EFI_FVH_SIGNATURE) {

     DEBUG ((DEBUG_ERROR, "FV at %p does not have FV header signature\n", Fv));

     return EFI_VOLUME_CORRUPTED;

   }

 

-  CurrentAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) Fv;

+  CurrentAddress      = (EFI_PHYSICAL_ADDRESS)(UINTN)Fv;

   EndOfFirmwareVolume = CurrentAddress + Fv->FvLength;

 

   //

   // Loop through the FFS files in the Boot Firmware Volume

   //

   for (EndOfFile = CurrentAddress + Fv->HeaderLength; ; ) {

-

     CurrentAddress = (EndOfFile + 7) & ~(7ULL);

     if (CurrentAddress > EndOfFirmwareVolume) {

       return EFI_VOLUME_CORRUPTED;

     }

 

-    File = (EFI_FFS_FILE_HEADER*)(UINTN) CurrentAddress;

+    File = (EFI_FFS_FILE_HEADER *)(UINTN)CurrentAddress;

     Size = FFS_FILE_SIZE (File);

     if (Size < (sizeof (*File) + sizeof (EFI_COMMON_SECTION_HEADER))) {

       return EFI_VOLUME_CORRUPTED;

@@ -297,8 +296,8 @@ FindFfsFileAndSection (
     }

 

     Status = FindFfsSectionInSections (

-               (VOID*) (File + 1),

-               (UINTN) EndOfFile - (UINTN) (File + 1),

+               (VOID *)(File + 1),

+               (UINTN)EndOfFile - (UINTN)(File + 1),

                SectionType,

                FoundSection

                );

@@ -321,30 +320,30 @@ FindFfsFileAndSection (
 **/

 EFI_STATUS

 DecompressMemFvs (

-  IN OUT EFI_FIRMWARE_VOLUME_HEADER       **Fv

+  IN OUT EFI_FIRMWARE_VOLUME_HEADER  **Fv

   )

 {

-  EFI_STATUS                        Status;

-  EFI_GUID_DEFINED_SECTION          *Section;

-  UINT32                            OutputBufferSize;

-  UINT32                            ScratchBufferSize;

-  UINT16                            SectionAttribute;

-  UINT32                            AuthenticationStatus;

-  VOID                              *OutputBuffer;

-  VOID                              *ScratchBuffer;

-  EFI_COMMON_SECTION_HEADER         *FvSection;

-  EFI_FIRMWARE_VOLUME_HEADER        *PeiMemFv;

-  EFI_FIRMWARE_VOLUME_HEADER        *DxeMemFv;

-  UINT32                            FvHeaderSize;

-  UINT32                            FvSectionSize;

-

-  FvSection = (EFI_COMMON_SECTION_HEADER*) NULL;

+  EFI_STATUS                  Status;

+  EFI_GUID_DEFINED_SECTION    *Section;

+  UINT32                      OutputBufferSize;

+  UINT32                      ScratchBufferSize;

+  UINT16                      SectionAttribute;

+  UINT32                      AuthenticationStatus;

+  VOID                        *OutputBuffer;

+  VOID                        *ScratchBuffer;

+  EFI_COMMON_SECTION_HEADER   *FvSection;

+  EFI_FIRMWARE_VOLUME_HEADER  *PeiMemFv;

+  EFI_FIRMWARE_VOLUME_HEADER  *DxeMemFv;

+  UINT32                      FvHeaderSize;

+  UINT32                      FvSectionSize;

+

+  FvSection = (EFI_COMMON_SECTION_HEADER *)NULL;

 

   Status = FindFfsFileAndSection (

              *Fv,

              EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE,

              EFI_SECTION_GUID_DEFINED,

-             (EFI_COMMON_SECTION_HEADER**) &Section

+             (EFI_COMMON_SECTION_HEADER **)&Section

              );

   if (EFI_ERROR (Status)) {

     DEBUG ((DEBUG_ERROR, "Unable to find GUID defined section\n"));

@@ -362,15 +361,24 @@ DecompressMemFvs (
     return Status;

   }

 

-  OutputBuffer = (VOID*) ((UINT8*)(UINTN) PcdGet32 (PcdOvmfDxeMemFvBase) + SIZE_1MB);

-  ScratchBuffer = ALIGN_POINTER ((UINT8*) OutputBuffer + OutputBufferSize, SIZE_1MB);

-

-  DEBUG ((DEBUG_VERBOSE, "%a: OutputBuffer@%p+0x%x ScratchBuffer@%p+0x%x "

-    "PcdOvmfDecompressionScratchEnd=0x%x\n", __FUNCTION__, OutputBuffer,

-    OutputBufferSize, ScratchBuffer, ScratchBufferSize,

-    PcdGet32 (PcdOvmfDecompressionScratchEnd)));

-  ASSERT ((UINTN)ScratchBuffer + ScratchBufferSize ==

-    PcdGet32 (PcdOvmfDecompressionScratchEnd));

+  OutputBuffer  = (VOID *)((UINT8 *)(UINTN)PcdGet32 (PcdOvmfDxeMemFvBase) + SIZE_1MB);

+  ScratchBuffer = ALIGN_POINTER ((UINT8 *)OutputBuffer + OutputBufferSize, SIZE_1MB);

+

+  DEBUG ((

+    DEBUG_VERBOSE,

+    "%a: OutputBuffer@%p+0x%x ScratchBuffer@%p+0x%x "

+    "PcdOvmfDecompressionScratchEnd=0x%x\n",

+    __FUNCTION__,

+    OutputBuffer,

+    OutputBufferSize,

+    ScratchBuffer,

+    ScratchBufferSize,

+    PcdGet32 (PcdOvmfDecompressionScratchEnd)

+    ));

+  ASSERT (

+    (UINTN)ScratchBuffer + ScratchBufferSize ==

+    PcdGet32 (PcdOvmfDecompressionScratchEnd)

+    );

 

   Status = ExtractGuidedSectionDecode (

              Section,

@@ -395,12 +403,14 @@ DecompressMemFvs (
     return Status;

   }

 

-  ASSERT (SECTION_SIZE (FvSection) ==

-          (PcdGet32 (PcdOvmfPeiMemFvSize) + sizeof (*FvSection)));

+  ASSERT (

+    SECTION_SIZE (FvSection) ==

+    (PcdGet32 (PcdOvmfPeiMemFvSize) + sizeof (*FvSection))

+    );

   ASSERT (FvSection->Type == EFI_SECTION_FIRMWARE_VOLUME_IMAGE);

 

-  PeiMemFv = (EFI_FIRMWARE_VOLUME_HEADER*)(UINTN) PcdGet32 (PcdOvmfPeiMemFvBase);

-  CopyMem (PeiMemFv, (VOID*) (FvSection + 1), PcdGet32 (PcdOvmfPeiMemFvSize));

+  PeiMemFv = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)PcdGet32 (PcdOvmfPeiMemFvBase);

+  CopyMem (PeiMemFv, (VOID *)(FvSection + 1), PcdGet32 (PcdOvmfPeiMemFvSize));

 

   if (PeiMemFv->Signature != EFI_FVH_SIGNATURE) {

     DEBUG ((DEBUG_ERROR, "Extracted FV at %p does not have FV header signature\n", PeiMemFv));

@@ -424,16 +434,16 @@ DecompressMemFvs (
 

   if (IS_SECTION2 (FvSection)) {

     FvSectionSize = SECTION2_SIZE (FvSection);

-    FvHeaderSize = sizeof (EFI_COMMON_SECTION_HEADER2);

+    FvHeaderSize  = sizeof (EFI_COMMON_SECTION_HEADER2);

   } else {

     FvSectionSize = SECTION_SIZE (FvSection);

-    FvHeaderSize = sizeof (EFI_COMMON_SECTION_HEADER);

+    FvHeaderSize  = sizeof (EFI_COMMON_SECTION_HEADER);

   }

 

   ASSERT (FvSectionSize == (PcdGet32 (PcdOvmfDxeMemFvSize) + FvHeaderSize));

 

-  DxeMemFv = (EFI_FIRMWARE_VOLUME_HEADER*)(UINTN) PcdGet32 (PcdOvmfDxeMemFvBase);

-  CopyMem (DxeMemFv, (VOID*) ((UINTN)FvSection + FvHeaderSize), PcdGet32 (PcdOvmfDxeMemFvSize));

+  DxeMemFv = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)PcdGet32 (PcdOvmfDxeMemFvBase);

+  CopyMem (DxeMemFv, (VOID *)((UINTN)FvSection + FvHeaderSize), PcdGet32 (PcdOvmfDxeMemFvSize));

 

   if (DxeMemFv->Signature != EFI_FVH_SIGNATURE) {

     DEBUG ((DEBUG_ERROR, "Extracted FV at %p does not have FV header signature\n", DxeMemFv));

@@ -458,12 +468,12 @@ DecompressMemFvs (
 **/

 EFI_STATUS

 FindPeiCoreImageBaseInFv (

-  IN  EFI_FIRMWARE_VOLUME_HEADER       *Fv,

-  OUT  EFI_PHYSICAL_ADDRESS             *PeiCoreImageBase

+  IN  EFI_FIRMWARE_VOLUME_HEADER  *Fv,

+  OUT  EFI_PHYSICAL_ADDRESS       *PeiCoreImageBase

   )

 {

-  EFI_STATUS                  Status;

-  EFI_COMMON_SECTION_HEADER   *Section;

+  EFI_STATUS                 Status;

+  EFI_COMMON_SECTION_HEADER  *Section;

 

   Status = FindFfsFileAndSection (

              Fv,

@@ -488,7 +498,6 @@ FindPeiCoreImageBaseInFv (
   return EFI_SUCCESS;

 }

 

-

 /**

   Reads 8-bits of CMOS data.

 

@@ -503,14 +512,13 @@ FindPeiCoreImageBaseInFv (
 STATIC

 UINT8

 CmosRead8 (

-  IN      UINTN                     Index

+  IN      UINTN  Index

   )

 {

-  IoWrite8 (0x70, (UINT8) Index);

+  IoWrite8 (0x70, (UINT8)Index);

   return IoRead8 (0x71);

 }

 

-

 STATIC

 BOOLEAN

 IsS3Resume (

@@ -520,18 +528,16 @@ IsS3Resume (
   return (CmosRead8 (0xF) == 0xFE);

 }

 

-

 STATIC

 EFI_STATUS

 GetS3ResumePeiFv (

-  IN OUT EFI_FIRMWARE_VOLUME_HEADER       **PeiFv

+  IN OUT EFI_FIRMWARE_VOLUME_HEADER  **PeiFv

   )

 {

-  *PeiFv = (EFI_FIRMWARE_VOLUME_HEADER*)(UINTN) PcdGet32 (PcdOvmfPeiMemFvBase);

+  *PeiFv = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)PcdGet32 (PcdOvmfPeiMemFvBase);

   return EFI_SUCCESS;

 }

 

-

 /**

   Locates the PEI Core entry point address

 

@@ -545,11 +551,11 @@ GetS3ResumePeiFv (
 **/

 VOID

 FindPeiCoreImageBase (

-  IN OUT  EFI_FIRMWARE_VOLUME_HEADER       **BootFv,

-     OUT  EFI_PHYSICAL_ADDRESS             *PeiCoreImageBase

+  IN OUT  EFI_FIRMWARE_VOLUME_HEADER  **BootFv,

+  OUT  EFI_PHYSICAL_ADDRESS           *PeiCoreImageBase

   )

 {

-  BOOLEAN S3Resume;

+  BOOLEAN  S3Resume;

 

   *PeiCoreImageBase = 0;

 

@@ -566,8 +572,11 @@ FindPeiCoreImageBase (
     // We're either not resuming, or resuming "securely" -- we'll decompress

     // both PEI FV and DXE FV from pristine flash.

     //

-    DEBUG ((DEBUG_VERBOSE, "SEC: %a\n",

-      S3Resume ? "S3 resume (with PEI decompression)" : "Normal boot"));

+    DEBUG ((

+      DEBUG_VERBOSE,

+      "SEC: %a\n",

+      S3Resume ? "S3 resume (with PEI decompression)" : "Normal boot"

+      ));

     FindMainFv (BootFv);

 

     DecompressMemFvs (BootFv);

@@ -582,34 +591,33 @@ FindPeiCoreImageBase (
 **/

 EFI_STATUS

 FindImageBase (

-  IN  EFI_FIRMWARE_VOLUME_HEADER       *BootFirmwareVolumePtr,

-  OUT EFI_PHYSICAL_ADDRESS             *SecCoreImageBase

+  IN  EFI_FIRMWARE_VOLUME_HEADER  *BootFirmwareVolumePtr,

+  OUT EFI_PHYSICAL_ADDRESS        *SecCoreImageBase

   )

 {

-  EFI_PHYSICAL_ADDRESS        CurrentAddress;

-  EFI_PHYSICAL_ADDRESS        EndOfFirmwareVolume;

-  EFI_FFS_FILE_HEADER         *File;

-  UINT32                      Size;

-  EFI_PHYSICAL_ADDRESS        EndOfFile;

-  EFI_COMMON_SECTION_HEADER   *Section;

-  EFI_PHYSICAL_ADDRESS        EndOfSection;

+  EFI_PHYSICAL_ADDRESS       CurrentAddress;

+  EFI_PHYSICAL_ADDRESS       EndOfFirmwareVolume;

+  EFI_FFS_FILE_HEADER        *File;

+  UINT32                     Size;

+  EFI_PHYSICAL_ADDRESS       EndOfFile;

+  EFI_COMMON_SECTION_HEADER  *Section;

+  EFI_PHYSICAL_ADDRESS       EndOfSection;

 

   *SecCoreImageBase = 0;

 

-  CurrentAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) BootFirmwareVolumePtr;

+  CurrentAddress      = (EFI_PHYSICAL_ADDRESS)(UINTN)BootFirmwareVolumePtr;

   EndOfFirmwareVolume = CurrentAddress + BootFirmwareVolumePtr->FvLength;

 

   //

   // Loop through the FFS files in the Boot Firmware Volume

   //

   for (EndOfFile = CurrentAddress + BootFirmwareVolumePtr->HeaderLength; ; ) {

-

     CurrentAddress = (EndOfFile + 7) & 0xfffffffffffffff8ULL;

     if (CurrentAddress > EndOfFirmwareVolume) {

       return EFI_NOT_FOUND;

     }

 

-    File = (EFI_FFS_FILE_HEADER*)(UINTN) CurrentAddress;

+    File = (EFI_FFS_FILE_HEADER *)(UINTN)CurrentAddress;

     Size = FFS_FILE_SIZE (File);

     if (Size < sizeof (*File)) {

       return EFI_NOT_FOUND;

@@ -630,10 +638,10 @@ FindImageBase (
     //

     // Loop through the FFS file sections within the FFS file

     //

-    EndOfSection = (EFI_PHYSICAL_ADDRESS)(UINTN) (File + 1);

-    for (;;) {

+    EndOfSection = (EFI_PHYSICAL_ADDRESS)(UINTN)(File + 1);

+    for ( ; ;) {

       CurrentAddress = (EndOfSection + 3) & 0xfffffffffffffffcULL;

-      Section = (EFI_COMMON_SECTION_HEADER*)(UINTN) CurrentAddress;

+      Section        = (EFI_COMMON_SECTION_HEADER *)(UINTN)CurrentAddress;

 

       Size = SECTION_SIZE (Section);

       if (Size < sizeof (*Section)) {

@@ -648,10 +656,11 @@ FindImageBase (
       //

       // Look for executable sections

       //

-      if (Section->Type == EFI_SECTION_PE32 || Section->Type == EFI_SECTION_TE) {

+      if ((Section->Type == EFI_SECTION_PE32) || (Section->Type == EFI_SECTION_TE)) {

         if (File->Type == EFI_FV_FILETYPE_SECURITY_CORE) {

-          *SecCoreImageBase = (PHYSICAL_ADDRESS) (UINTN) (Section + 1);

+          *SecCoreImageBase = (PHYSICAL_ADDRESS)(UINTN)(Section + 1);

         }

+

         break;

       }

     }

@@ -674,42 +683,42 @@ FindImageBase (
 **/

 VOID

 FindAndReportEntryPoints (

-  IN  EFI_FIRMWARE_VOLUME_HEADER       **BootFirmwareVolumePtr,

-  OUT EFI_PEI_CORE_ENTRY_POINT         *PeiCoreEntryPoint

+  IN  EFI_FIRMWARE_VOLUME_HEADER  **BootFirmwareVolumePtr,

+  OUT EFI_PEI_CORE_ENTRY_POINT    *PeiCoreEntryPoint

   )

 {

-  EFI_STATUS                       Status;

-  EFI_PHYSICAL_ADDRESS             SecCoreImageBase;

-  EFI_PHYSICAL_ADDRESS             PeiCoreImageBase;

-  PE_COFF_LOADER_IMAGE_CONTEXT     ImageContext;

+  EFI_STATUS                    Status;

+  EFI_PHYSICAL_ADDRESS          SecCoreImageBase;

+  EFI_PHYSICAL_ADDRESS          PeiCoreImageBase;

+  PE_COFF_LOADER_IMAGE_CONTEXT  ImageContext;

 

   //

   // Find SEC Core and PEI Core image base

-   //

+  //

   Status = FindImageBase (*BootFirmwareVolumePtr, &SecCoreImageBase);

   ASSERT_EFI_ERROR (Status);

 

   FindPeiCoreImageBase (BootFirmwareVolumePtr, &PeiCoreImageBase);

 

-  ZeroMem ((VOID *) &ImageContext, sizeof (PE_COFF_LOADER_IMAGE_CONTEXT));

+  ZeroMem ((VOID *)&ImageContext, sizeof (PE_COFF_LOADER_IMAGE_CONTEXT));

   //

   // Report SEC Core debug information when remote debug is enabled

   //

   ImageContext.ImageAddress = SecCoreImageBase;

-  ImageContext.PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageContext.ImageAddress);

+  ImageContext.PdbPointer   = PeCoffLoaderGetPdbPointer ((VOID *)(UINTN)ImageContext.ImageAddress);

   PeCoffLoaderRelocateImageExtraAction (&ImageContext);

 

   //

   // Report PEI Core debug information when remote debug is enabled

   //

   ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)PeiCoreImageBase;

-  ImageContext.PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageContext.ImageAddress);

+  ImageContext.PdbPointer   = PeCoffLoaderGetPdbPointer ((VOID *)(UINTN)ImageContext.ImageAddress);

   PeCoffLoaderRelocateImageExtraAction (&ImageContext);

 

   //

   // Find PEI Core entry point

   //

-  Status = PeCoffLoaderGetEntryPoint ((VOID *) (UINTN) PeiCoreImageBase, (VOID**) PeiCoreEntryPoint);

+  Status = PeCoffLoaderGetEntryPoint ((VOID *)(UINTN)PeiCoreImageBase, (VOID **)PeiCoreEntryPoint);

   if (EFI_ERROR (Status)) {

     *PeiCoreEntryPoint = 0;

   }

@@ -738,10 +747,10 @@ SevEsProtocolFailure (
   //

   // Use the GHCB MSR Protocol to request termination by the hypervisor

   //

-  Msr.GhcbPhysicalAddress = 0;

-  Msr.GhcbTerminate.Function = GHCB_INFO_TERMINATE_REQUEST;

+  Msr.GhcbPhysicalAddress         = 0;

+  Msr.GhcbTerminate.Function      = GHCB_INFO_TERMINATE_REQUEST;

   Msr.GhcbTerminate.ReasonCodeSet = GHCB_TERMINATE_GHCB;

-  Msr.GhcbTerminate.ReasonCode = ReasonCode;

+  Msr.GhcbTerminate.ReasonCode    = ReasonCode;

   AsmWriteMsr64 (MSR_SEV_ES_GHCB, Msr.GhcbPhysicalAddress);

 

   AsmVmgExit ();

@@ -771,7 +780,7 @@ SevEsProtocolCheck (
   // protocol checking

   //

   Msr.GhcbPhysicalAddress = 0;

-  Msr.GhcbInfo.Function = GHCB_INFO_SEV_INFO_GET;

+  Msr.GhcbInfo.Function   = GHCB_INFO_SEV_INFO_GET;

   AsmWriteMsr64 (MSR_SEV_ES_GHCB, Msr.GhcbPhysicalAddress);

 

   AsmVmgExit ();

@@ -787,7 +796,8 @@ SevEsProtocolCheck (
   }

 

   if ((Msr.GhcbProtocol.SevEsProtocolMin > GHCB_VERSION_MAX) ||

-      (Msr.GhcbProtocol.SevEsProtocolMax < GHCB_VERSION_MIN)) {

+      (Msr.GhcbProtocol.SevEsProtocolMax < GHCB_VERSION_MIN))

+  {

     SevEsProtocolFailure (GHCB_TERMINATE_GHCB_PROTOCOL);

   }

 

@@ -804,7 +814,7 @@ SevEsProtocolCheck (
   // Set the version to the maximum that can be supported

   //

   Ghcb->ProtocolVersion = MIN (Msr.GhcbProtocol.SevEsProtocolMax, GHCB_VERSION_MAX);

-  Ghcb->GhcbUsage = GHCB_STANDARD_USAGE;

+  Ghcb->GhcbUsage       = GHCB_STANDARD_USAGE;

 }

 

 /**

@@ -823,16 +833,18 @@ IsSevGuest (
   VOID

   )

 {

-  OVMF_WORK_AREA             *WorkArea;

+  OVMF_WORK_AREA  *WorkArea;

 

   //

   // Ensure that the size of the Confidential Computing work area header

   // is same as what is provided through a fixed PCD.

   //

-  ASSERT ((UINTN) FixedPcdGet32 (PcdOvmfConfidentialComputingWorkAreaHeader) ==

-          sizeof(CONFIDENTIAL_COMPUTING_WORK_AREA_HEADER));

+  ASSERT (

+    (UINTN)FixedPcdGet32 (PcdOvmfConfidentialComputingWorkAreaHeader) ==

+    sizeof (CONFIDENTIAL_COMPUTING_WORK_AREA_HEADER)

+    );

 

-  WorkArea = (OVMF_WORK_AREA *) FixedPcdGet32 (PcdOvmfWorkAreaBase);

+  WorkArea = (OVMF_WORK_AREA *)FixedPcdGet32 (PcdOvmfWorkAreaBase);

 

   return ((WorkArea != NULL) && (WorkArea->Header.GuestType == GUEST_TYPE_AMD_SEV));

 }

@@ -856,11 +868,11 @@ SevEsIsEnabled (
 {

   SEC_SEV_ES_WORK_AREA  *SevEsWorkArea;

 

-  if (!IsSevGuest()) {

+  if (!IsSevGuest ()) {

     return FALSE;

   }

 

-  SevEsWorkArea = (SEC_SEV_ES_WORK_AREA *) FixedPcdGet32 (PcdSevEsWorkAreaBase);

+  SevEsWorkArea = (SEC_SEV_ES_WORK_AREA *)FixedPcdGet32 (PcdSevEsWorkAreaBase);

 

   return (SevEsWorkArea->SevEsEnabled != 0);

 }

@@ -868,25 +880,26 @@ SevEsIsEnabled (
 VOID

 EFIAPI

 SecCoreStartupWithStack (

-  IN EFI_FIRMWARE_VOLUME_HEADER       *BootFv,

-  IN VOID                             *TopOfCurrentStack

+  IN EFI_FIRMWARE_VOLUME_HEADER  *BootFv,

+  IN VOID                        *TopOfCurrentStack

   )

 {

-  EFI_SEC_PEI_HAND_OFF        SecCoreData;

-  SEC_IDT_TABLE               IdtTableInStack;

-  IA32_DESCRIPTOR             IdtDescriptor;

-  UINT32                      Index;

-  volatile UINT8              *Table;

+  EFI_SEC_PEI_HAND_OFF  SecCoreData;

+  SEC_IDT_TABLE         IdtTableInStack;

+  IA32_DESCRIPTOR       IdtDescriptor;

+  UINT32                Index;

+  volatile UINT8        *Table;

 

   //

   // To ensure SMM can't be compromised on S3 resume, we must force re-init of

   // the BaseExtractGuidedSectionLib. Since this is before library contructors

   // are called, we must use a loop rather than SetMem.

   //

-  Table = (UINT8*)(UINTN)FixedPcdGet64 (PcdGuidedExtractHandlerTableAddress);

+  Table = (UINT8 *)(UINTN)FixedPcdGet64 (PcdGuidedExtractHandlerTableAddress);

   for (Index = 0;

        Index < FixedPcdGet32 (PcdGuidedExtractHandlerTableSize);

-       ++Index) {

+       ++Index)

+  {

     Table[Index] = 0;

   }

 

@@ -895,13 +908,13 @@ SecCoreStartupWithStack (
   // we use a loop rather than CopyMem.

   //

   IdtTableInStack.PeiService = NULL;

-  for (Index = 0; Index < SEC_IDT_ENTRY_COUNT; Index ++) {

+  for (Index = 0; Index < SEC_IDT_ENTRY_COUNT; Index++) {

     UINT8  *Src;

     UINT8  *Dst;

     UINTN  Byte;

 

-    Src = (UINT8 *) &mIdtEntryTemplate;

-    Dst = (UINT8 *) &IdtTableInStack.IdtTable[Index];

+    Src = (UINT8 *)&mIdtEntryTemplate;

+    Dst = (UINT8 *)&IdtTableInStack.IdtTable[Index];

     for (Byte = 0; Byte < sizeof (mIdtEntryTemplate); Byte++) {

       Dst[Byte] = Src[Byte];

     }

@@ -947,7 +960,8 @@ SecCoreStartupWithStack (
     AsmEnableCache ();

   }

 

-  DEBUG ((DEBUG_INFO,

+  DEBUG ((

+    DEBUG_INFO,

     "SecCoreStartupWithStack(0x%x, 0x%x)\n",

     (UINT32)(UINTN)BootFv,

     (UINT32)(UINTN)TopOfCurrentStack

@@ -959,13 +973,13 @@ SecCoreStartupWithStack (
   //

   InitializeFloatingPointUnits ();

 

-#if defined (MDE_CPU_X64)

+ #if defined (MDE_CPU_X64)

   //

   // ASSERT that the Page Tables were set by the reset vector code to

   // the address we expect.

   //

-  ASSERT (AsmReadCr3 () == (UINTN) PcdGet32 (PcdOvmfSecPageTablesBase));

-#endif

+  ASSERT (AsmReadCr3 () == (UINTN)PcdGet32 (PcdOvmfSecPageTablesBase));

+ #endif

 

   //

   // |-------------|       <-- TopOfCurrentStack

@@ -975,26 +989,28 @@ SecCoreStartupWithStack (
   // |-------------|       <-- SecCoreData.TemporaryRamBase

   //

 

-  ASSERT ((UINTN) (PcdGet32 (PcdOvmfSecPeiTempRamBase) +

-                   PcdGet32 (PcdOvmfSecPeiTempRamSize)) ==

-          (UINTN) TopOfCurrentStack);

+  ASSERT (

+    (UINTN)(PcdGet32 (PcdOvmfSecPeiTempRamBase) +

+            PcdGet32 (PcdOvmfSecPeiTempRamSize)) ==

+    (UINTN)TopOfCurrentStack

+    );

 

   //

   // Initialize SEC hand-off state

   //

-  SecCoreData.DataSize = sizeof(EFI_SEC_PEI_HAND_OFF);

+  SecCoreData.DataSize = sizeof (EFI_SEC_PEI_HAND_OFF);

 

-  SecCoreData.TemporaryRamSize       = (UINTN) PcdGet32 (PcdOvmfSecPeiTempRamSize);

-  SecCoreData.TemporaryRamBase       = (VOID*)((UINT8 *)TopOfCurrentStack - SecCoreData.TemporaryRamSize);

+  SecCoreData.TemporaryRamSize = (UINTN)PcdGet32 (PcdOvmfSecPeiTempRamSize);

+  SecCoreData.TemporaryRamBase = (VOID *)((UINT8 *)TopOfCurrentStack - SecCoreData.TemporaryRamSize);

 

-  SecCoreData.PeiTemporaryRamBase    = SecCoreData.TemporaryRamBase;

-  SecCoreData.PeiTemporaryRamSize    = SecCoreData.TemporaryRamSize >> 1;

+  SecCoreData.PeiTemporaryRamBase = SecCoreData.TemporaryRamBase;

+  SecCoreData.PeiTemporaryRamSize = SecCoreData.TemporaryRamSize >> 1;

 

-  SecCoreData.StackBase              = (UINT8 *)SecCoreData.TemporaryRamBase + SecCoreData.PeiTemporaryRamSize;

-  SecCoreData.StackSize              = SecCoreData.TemporaryRamSize >> 1;

+  SecCoreData.StackBase = (UINT8 *)SecCoreData.TemporaryRamBase + SecCoreData.PeiTemporaryRamSize;

+  SecCoreData.StackSize = SecCoreData.TemporaryRamSize >> 1;

 

   SecCoreData.BootFirmwareVolumeBase = BootFv;

-  SecCoreData.BootFirmwareVolumeSize = (UINTN) BootFv->FvLength;

+  SecCoreData.BootFirmwareVolumeSize = (UINTN)BootFv->FvLength;

 

   //

   // Make sure the 8259 is masked before initializing the Debug Agent and the debug timer is enabled

@@ -1028,15 +1044,15 @@ SecCoreStartupWithStack (
 **/

 VOID

 EFIAPI

-SecStartupPhase2(

-  IN VOID                     *Context

+SecStartupPhase2 (

+  IN VOID  *Context

   )

 {

   EFI_SEC_PEI_HAND_OFF        *SecCoreData;

   EFI_FIRMWARE_VOLUME_HEADER  *BootFv;

   EFI_PEI_CORE_ENTRY_POINT    PeiCoreEntryPoint;

 

-  SecCoreData = (EFI_SEC_PEI_HAND_OFF *) Context;

+  SecCoreData = (EFI_SEC_PEI_HAND_OFF *)Context;

 

   //

   // Find PEI Core entry point. It will report SEC and Pei Core debug information if remote debug

@@ -1045,12 +1061,12 @@ SecStartupPhase2(
   BootFv = (EFI_FIRMWARE_VOLUME_HEADER *)SecCoreData->BootFirmwareVolumeBase;

   FindAndReportEntryPoints (&BootFv, &PeiCoreEntryPoint);

   SecCoreData->BootFirmwareVolumeBase = BootFv;

-  SecCoreData->BootFirmwareVolumeSize = (UINTN) BootFv->FvLength;

+  SecCoreData->BootFirmwareVolumeSize = (UINTN)BootFv->FvLength;

 

   //

   // Transfer the control to the PEI core

   //

-  (*PeiCoreEntryPoint) (SecCoreData, (EFI_PEI_PPI_DESCRIPTOR *)&mPrivateDispatchTable);

+  (*PeiCoreEntryPoint)(SecCoreData, (EFI_PEI_PPI_DESCRIPTOR *)&mPrivateDispatchTable);

 

   //

   // If we get here then the PEI Core returned, which is not recoverable.

@@ -1062,10 +1078,10 @@ SecStartupPhase2(
 EFI_STATUS

 EFIAPI

 TemporaryRamMigration (

-  IN CONST EFI_PEI_SERVICES   **PeiServices,

-  IN EFI_PHYSICAL_ADDRESS     TemporaryMemoryBase,

-  IN EFI_PHYSICAL_ADDRESS     PermanentMemoryBase,

-  IN UINTN                    CopySize

+  IN CONST EFI_PEI_SERVICES  **PeiServices,

+  IN EFI_PHYSICAL_ADDRESS    TemporaryMemoryBase,

+  IN EFI_PHYSICAL_ADDRESS    PermanentMemoryBase,

+  IN UINTN                   CopySize

   )

 {

   IA32_DESCRIPTOR                  IdtDescriptor;

@@ -1077,24 +1093,25 @@ TemporaryRamMigration (
   BOOLEAN                          OldStatus;

   BASE_LIBRARY_JUMP_BUFFER         JumpBuffer;

 

-  DEBUG ((DEBUG_INFO,

+  DEBUG ((

+    DEBUG_INFO,

     "TemporaryRamMigration(0x%Lx, 0x%Lx, 0x%Lx)\n",

     TemporaryMemoryBase,

     PermanentMemoryBase,

     (UINT64)CopySize

     ));

 

-  OldHeap = (VOID*)(UINTN)TemporaryMemoryBase;

-  NewHeap = (VOID*)((UINTN)PermanentMemoryBase + (CopySize >> 1));

+  OldHeap = (VOID *)(UINTN)TemporaryMemoryBase;

+  NewHeap = (VOID *)((UINTN)PermanentMemoryBase + (CopySize >> 1));

 

-  OldStack = (VOID*)((UINTN)TemporaryMemoryBase + (CopySize >> 1));

-  NewStack = (VOID*)(UINTN)PermanentMemoryBase;

+  OldStack = (VOID *)((UINTN)TemporaryMemoryBase + (CopySize >> 1));

+  NewStack = (VOID *)(UINTN)PermanentMemoryBase;

 

-  DebugAgentContext.HeapMigrateOffset = (UINTN)NewHeap - (UINTN)OldHeap;

+  DebugAgentContext.HeapMigrateOffset  = (UINTN)NewHeap - (UINTN)OldHeap;

   DebugAgentContext.StackMigrateOffset = (UINTN)NewStack - (UINTN)OldStack;

 

   OldStatus = SaveAndSetDebugTimerInterrupt (FALSE);

-  InitializeDebugAgent (DEBUG_AGENT_INIT_POSTMEM_SEC, (VOID *) &DebugAgentContext, NULL);

+  InitializeDebugAgent (DEBUG_AGENT_INIT_POSTMEM_SEC, (VOID *)&DebugAgentContext, NULL);

 

   //

   // Migrate Heap

@@ -1118,14 +1135,14 @@ TemporaryRamMigration (
   // Use SetJump()/LongJump() to switch to a new stack.

   //

   if (SetJump (&JumpBuffer) == 0) {

-#if defined (MDE_CPU_IA32)

+ #if defined (MDE_CPU_IA32)

     JumpBuffer.Esp = JumpBuffer.Esp + DebugAgentContext.StackMigrateOffset;

     JumpBuffer.Ebp = JumpBuffer.Ebp + DebugAgentContext.StackMigrateOffset;

-#endif

-#if defined (MDE_CPU_X64)

+ #endif

+ #if defined (MDE_CPU_X64)

     JumpBuffer.Rsp = JumpBuffer.Rsp + DebugAgentContext.StackMigrateOffset;

     JumpBuffer.Rbp = JumpBuffer.Rbp + DebugAgentContext.StackMigrateOffset;

-#endif

+ #endif

     LongJump (&JumpBuffer, (UINTN)-1);

   }

 

@@ -1133,4 +1150,3 @@ TemporaryRamMigration (
 

   return EFI_SUCCESS;

 }

-