Changeset 58466 for trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library – Oracle VirtualBox

trunk/src/VBox/Devices/EFI/Firmware

Property svn:mergeinfo changed
/vendor/edk2/current merged: 103769-103776

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/BasePlatformHookLibNull/BasePlatformHookLibNull.c

-              r48674
+              r58466
   Performs platform specific initialization required for the CPU to access
   the hardware associated with a SerialPortLib instance.  This function does
   not intiailzie the serial port hardware itself.  Instead, it initializes
   hardware devices that are required for the CPU to access the serial port
+  not intiailzie the serial port hardware itself.  Instead, it initializes
+  hardware devices that are required for the CPU to access the serial port
   hardware.  This function may be called more than once.
   @retval RETURN_SUCCESS       The platform specific initialization succeeded.
   @retval RETURN_DEVICE_ERROR  The platform specific initialization could not be completed.
 **/
 RETURN_STATUS

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/BaseResetSystemLibNull/BaseResetSystemLibNull.c

-              r48674
+              r58466
 /**
   This function causes a system-wide reset (cold reset), in which
   all circuitry within the system returns to its initial state. This type of reset
+  all circuitry within the system returns to its initial state. This type of reset
   is asynchronous to system operation and operates without regard to
   cycle boundaries.
   If this function returns, it means that the system does not support cold reset.
+  If this function returns, it means that the system does not support cold reset.
 **/
 VOID
 …
 /**
   This function causes a system-wide initialization (warm reset), in which all processors
+  This function causes a system-wide initialization (warm reset), in which all processors
   are set to their initial state. Pending cycles are not corrupted.
 …
 /**
   This function causes the system to enter a power state equivalent
+  This function causes the system to enter a power state equivalent
   to the ACPI G2/S5 or G3 states.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/BaseSerialPortLib16550/BaseSerialPortLib16550.c

-              r58459
+              r58466
 /**
   Read an 8-bit 16550 register.  If PcdSerialUseMmio is TRUE, then the value is read from
+  Read an 8-bit 16550 register.  If PcdSerialUseMmio is TRUE, then the value is read from
   MMIO space.  If PcdSerialUseMmio is FALSE, then the value is read from I/O space.  The
   parameter Offset is added to the base address of the 16550 registers that is specified
   by PcdSerialRegisterBase.
+  parameter Offset is added to the base address of the 16550 registers that is specified
+  by PcdSerialRegisterBase.
   @param  Base    The base address register of UART device.
   @param  Offset  The offset of the 16550 register to read.
 …
   Write an 8-bit 16550 register.  If PcdSerialUseMmio is TRUE, then the value is written to
   MMIO space.  If PcdSerialUseMmio is FALSE, then the value is written to I/O space.  The
   parameter Offset is added to the base address of the 16550 registers that is specified
   by PcdSerialRegisterBase.
+  parameter Offset is added to the base address of the 16550 registers that is specified
+  by PcdSerialRegisterBase.
   @param  Base    The base address register of UART device.
   @param  Offset  The offset of the 16550 register to write.
 …
 /**
   Update the value of an 16-bit PCI configuration register in a PCI device.  If the
   PCI Configuration register specified by PciAddress is already programmed with a
   non-zero value, then return the current value.  Otherwise update the PCI configuration
+  Update the value of an 16-bit PCI configuration register in a PCI device.  If the
+  PCI Configuration register specified by PciAddress is already programmed with a
+  non-zero value, then return the current value.  Otherwise update the PCI configuration
   register specified by PciAddress with the value specified by Value and return the
   value programmed into the PCI configuration register.  All values must be masked
+  value programmed into the PCI configuration register.  All values must be masked
   using the bitmask specified by Mask.
 …
+{
   UINT16  CurrentValue;
   CurrentValue = PciRead16 (PciAddress) & Mask;
   if (CurrentValue != 0) {
 …
 /**
   Update the value of an 32-bit PCI configuration register in a PCI device.  If the
   PCI Configuration register specified by PciAddress is already programmed with a
   non-zero value, then return the current value.  Otherwise update the PCI configuration
+  Update the value of an 32-bit PCI configuration register in a PCI device.  If the
+  PCI Configuration register specified by PciAddress is already programmed with a
+  non-zero value, then return the current value.  Otherwise update the PCI configuration
   register specified by PciAddress with the value specified by Value and return the
   value programmed into the PCI configuration register.  All values must be masked
+  value programmed into the PCI configuration register.  All values must be masked
   using the bitmask specified by Mask.
 …
+{
   UINT32  CurrentValue;
   CurrentValue = PciRead32 (PciAddress) & Mask;
   if (CurrentValue != 0) {
 …
 /**
   Retrieve the I/O or MMIO base address register for the PCI UART device.
   This function assumes Root Bus Numer is Zero, and enables I/O and MMIO in PCI UART
   Device if they are not already enabled.
+  Retrieve the I/O or MMIO base address register for the PCI UART device.
+  This function assumes Root Bus Numer is Zero, and enables I/O and MMIO in PCI UART
+  Device if they are not already enabled.
   @return  The base address register of the UART device.
 …
   //
   DeviceInfo = (PCI_UART_DEVICE_INFO *) PcdGetPtr (PcdSerialPciDeviceInfo);
   //
   // If PCI Device Info is empty, then assume fixed address UART and return PcdSerialRegisterBase
   //
+  //
   if (DeviceInfo->Device == 0xff) {
     return (UINTN)PcdGet64 (PcdSerialRegisterBase);
 …
   ParentIoBase      = 0 >> 12;
   ParentIoLimit     = 0xf000 >> 12;
   //
   // Enable I/O and MMIO in PCI Bridge
   // Assume Root Bus Numer is Zero.
+  // Assume Root Bus Numer is Zero.
   //
   for (BusNumber = 0; (DeviceInfo + 1)->Device != 0xff; DeviceInfo++) {
 …
     //
     PciLibAddress = PCI_LIB_ADDRESS (BusNumber, DeviceInfo->Device, DeviceInfo->Function, 0);
     //
     // Retrieve and verify the bus numbers in the PCI to PCI Bridge
 …
         return 0;
+      }
       //
       // If PCI Bridge MMIO window is not in the address range decoded by the parent PCI Bridge, then return 0
       //
+      //
       if (MemoryBase < ParentMemoryBase || MemoryBase > ParentMemoryLimit || MemoryLimit > ParentMemoryLimit) {
         return 0;
 …
         IoBase = (PciRead16 (PciLibAddress + OFFSET_OF (PCI_TYPE01, Bridge.IoBaseUpper16)) << 4) | (IoBase >> 4);
+      }
       //
       // If PCI Bridge I/O window is disabled, then return 0
 …
         return 0;
+      }
       //
       // If PCI Bridge I/O window is not in the address range decoded by the parent PCI Bridge, then return 0
       //
+      //
       if (IoBase < ParentIoBase || IoBase > ParentIoLimit || IoLimit > ParentIoLimit) {
         return 0;
 …
   //
   PciLibAddress = PCI_LIB_ADDRESS (BusNumber, DeviceInfo->Device, DeviceInfo->Function, 0);
   //
   // Find the first IO or MMIO BAR
 …
   //
   // Program UART BAR
   //
+  //
   SerialRegisterBase = SerialPortLibUpdatePciRegister32 (
                          PciLibAddress + PCI_BASE_ADDRESSREG_OFFSET + BarIndex * 4,
                          (UINT32)PcdGet64 (PcdSerialRegisterBase),
+                         (UINT32)PcdGet64 (PcdSerialRegisterBase),
                          RegisterBaseMask
                          );
 …
   //
   // Verify that the UART BAR is in the address range decoded by the parent PCI Bridge
   //
+  //
   if (PcdGetBool (PcdSerialUseMmio)) {
     if (((SerialRegisterBase >> 16) & 0xfff0) < ParentMemoryBase || ((SerialRegisterBase >> 16) & 0xfff0) > ParentMemoryLimit) {
 …
+    }
+  }
   //
   // Enable I/O and MMIO in PCI UART Device if they are not already enabled
 …
+    }
+  }
   //
   // Get PCI Device Info
 …
   //
   // Enable I/O or MMIO in PCI Bridge
   // Assume Root Bus Numer is Zero.
+  // Assume Root Bus Numer is Zero.
   //
   for (BusNumber = 0; (DeviceInfo + 1)->Device != 0xff; DeviceInfo++) {
 …
     //
     PciLibAddress = PCI_LIB_ADDRESS (BusNumber, DeviceInfo->Device, DeviceInfo->Function, 0);
     //
     // Enable the I/O or MMIO decode windows in the PCI to PCI Bridge
     //
     PciOr16 (
       PciLibAddress + PCI_COMMAND_OFFSET,
+      PciLibAddress + PCI_COMMAND_OFFSET,
       PcdGetBool (PcdSerialUseMmio) ? EFI_PCI_COMMAND_MEMORY_SPACE : EFI_PCI_COMMAND_IO_SPACE
       );
     //
     // Force D0 state if a Power Management and Status Register is specified
 …
+      }
+    }
     BusNumber = PciRead8 (PciLibAddress + PCI_BRIDGE_SECONDARY_BUS_REGISTER_OFFSET);
+  }
   return SerialRegisterBase;
+}
 …
     } else {
       //
       // Wait for both DSR and CTS to be set OR for DSR to be clear.
+      // Wait for both DSR and CTS to be set OR for DSR to be clear.
       //   DSR is set if a cable is connected.
       //   CTS is set if it is ok to transmit data
 …
 /**
   Initialize the serial device hardware.
   If no initialization is required, then return RETURN_SUCCESS.
   If the serial device was successfully initialized, then return RETURN_SUCCESS.
   If the serial device could not be initialized, then return RETURN_DEVICE_ERROR.
   @retval RETURN_SUCCESS        The serial device was initialized.
   @retval RETURN_DEVICE_ERROR   The serial device could not be initialized.
 …
   UINTN          SerialRegisterBase;
   UINT32         Divisor;
   UINT32         CurrentDivisor;
+  UINT32         CurrentDivisor;
   BOOLEAN        Initialized;
 …
   //
   while ((SerialPortReadRegister (SerialRegisterBase, R_UART_LSR) & (B_UART_LSR_TEMT | B_UART_LSR_TXRDY)) != (B_UART_LSR_TEMT | B_UART_LSR_TXRDY));
   //
   // Configure baud rate
 …
   //
   // Put Modem Control Register(MCR) into its reset state of 0x00.
   //
+  //
   SerialPortWriteRegister (SerialRegisterBase, R_UART_MCR, 0x00);
 …
 /**
   Write data from buffer to serial device.
   Writes NumberOfBytes data bytes from Buffer to the serial device.
+  Write data from buffer to serial device.
+  Writes NumberOfBytes data bytes from Buffer to the serial device.
   The number of bytes actually written to the serial device is returned.
   If the return value is less than NumberOfBytes, then the write operation failed.
   If Buffer is NULL, then ASSERT().
+  If Buffer is NULL, then ASSERT().
   If NumberOfBytes is zero, then return 0.
 …
   @retval 0                NumberOfBytes is 0.
   @retval >0               The number of bytes written to the serial device.
+  @retval >0               The number of bytes written to the serial device.
                            If this value is less than NumberOfBytes, then the read operation failed.
 …
     return 0;
+  }
   if (NumberOfBytes == 0) {
     //
 …
   @retval 0                NumberOfBytes is 0.
   @retval >0               The number of bytes read from the serial device.
+  @retval >0               The number of bytes read from the serial device.
                            If this value is less than NumberOfBytes, then the read operation failed.
 …
   Mcr = (UINT8)(SerialPortReadRegister (SerialRegisterBase, R_UART_MCR) & ~B_UART_MCR_RTS);
   for (Result = 0; NumberOfBytes-- != 0; Result++, Buffer++) {
     //
 …
       SerialPortWriteRegister (SerialRegisterBase, R_UART_MCR, Mcr);
+    }
     //
     // Read byte from the receive buffer.
 …
     *Buffer = SerialPortReadRegister (SerialRegisterBase, R_UART_RXBUF);
+  }
   return Result;
+}
 …
+{
   UINTN  SerialRegisterBase;
   SerialRegisterBase = GetSerialRegisterBase ();
   if (SerialRegisterBase ==0) {
 …
+    }
     return TRUE;
+  }
+  }
   if (PcdGetBool (PcdSerialUseHardwareFlowControl)) {
     //
 …
     SerialPortWriteRegister (SerialRegisterBase, R_UART_MCR, (UINT8)(SerialPortReadRegister (SerialRegisterBase, R_UART_MCR) | B_UART_MCR_RTS));
+  }
   return FALSE;
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/BaseSerialPortLib16550/BaseSerialPortLib16550.inf

r58459	r58466
34	34	[Sources]
35	35	BaseSerialPortLib16550.c
36
	36
37	37	[Pcd]
38	38	gEfiMdeModulePkgTokenSpaceGuid.PcdSerialUseMmio ## CONSUMES

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/CpuExceptionHandlerLibNull/CpuExceptionHandlerLibNull.c

-              r58464
+              r58466
 /**
   Initializes all CPU exceptions entries and provides the default exception handlers.
   Caller should try to get an array of interrupt and/or exception vectors that are in use and need to
   persist by EFI_VECTOR_HANDOFF_INFO defined in PI 1.3 specification.
   If caller cannot get reserved vector list or it does not exists, set VectorInfo to NULL.
+  If caller cannot get reserved vector list or it does not exists, set VectorInfo to NULL.
   If VectorInfo is not NULL, the exception vectors will be initialized per vector attribute accordingly.
   @param[in]  VectorInfo    Pointer to reserved vector list.
   @retval EFI_SUCCESS           CPU Exception Entries have been successfully initialized
+  @retval EFI_SUCCESS           CPU Exception Entries have been successfully initialized
                                 with default exception handlers.
   @retval EFI_INVALID_PARAMETER VectorInfo includes the invalid content if VectorInfo is not NULL.
 …
 /**
   Initializes all CPU interrupt/exceptions entries and provides the default interrupt/exception handlers.
   Caller should try to get an array of interrupt and/or exception vectors that are in use and need to
   persist by EFI_VECTOR_HANDOFF_INFO defined in PI 1.3 specification.
   If caller cannot get reserved vector list or it does not exists, set VectorInfo to NULL.
+  If caller cannot get reserved vector list or it does not exists, set VectorInfo to NULL.
   If VectorInfo is not NULL, the exception vectors will be initialized per vector attribute accordingly.
   @param[in]  VectorInfo    Pointer to reserved vector list.
   @retval EFI_SUCCESS           All CPU interrupt/exception entries have been successfully initialized
+  @retval EFI_SUCCESS           All CPU interrupt/exception entries have been successfully initialized
                                 with default interrupt/exception handlers.
   @retval EFI_INVALID_PARAMETER VectorInfo includes the invalid content if VectorInfo is not NULL.
 …
   Registers a function to be called from the processor interrupt handler.
   This function registers and enables the handler specified by InterruptHandler for a processor
   interrupt or exception type specified by InterruptType. If InterruptHandler is NULL, then the
   handler for the processor interrupt or exception type specified by InterruptType is uninstalled.
+  This function registers and enables the handler specified by InterruptHandler for a processor
+  interrupt or exception type specified by InterruptType. If InterruptHandler is NULL, then the
+  handler for the processor interrupt or exception type specified by InterruptType is uninstalled.
   The installed handler is called once for each processor interrupt or exception.
   NOTE: This function should be invoked after InitializeCpuExceptionHandlers() or

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/CustomizedDisplayLib/CustomizedDisplayLib.c

-              r58464
+              r58466
 Copyright (c) 2013 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials are licensed and made available under
 the terms and conditions of the BSD License that accompanies this distribution.
+This program and the accompanying materials are licensed and made available under
+the terms and conditions of the BSD License that accompanies this distribution.
 The full text of the license may be found at
 http://opensource.org/licenses/bsd-license.php.
 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+http://opensource.org/licenses/bsd-license.php.
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 …
 /**
   This funtion defines Page Frame and Backgroud.
   Based on the above layout, it will be responsible for HeaderHeight, FooterHeight,
   StatusBarHeight and Backgroud. And, it will reserve Screen for Statement.
+  This funtion defines Page Frame and Backgroud.
+  Based on the above layout, it will be responsible for HeaderHeight, FooterHeight,
+  StatusBarHeight and Backgroud. And, it will reserve Screen for Statement.
   @param[in]  FormData             Form Data to be shown in Page.
   @param[out] ScreenForStatement   Screen to be used for Statement. (Prompt, Value and Help)
   @return Status
 **/
 …
   The library will prepare those Strings for the basic key, ESC, Enter, Up/Down/Left/Right, +/-.
   and arrange them in Footer panel.
   @param[in]  FormData       Form Data to be shown in Page. FormData has the highlighted statement.
+  @param[in]  FormData       Form Data to be shown in Page. FormData has the highlighted statement.
   @param[in]  Statement      The statement current selected.
   @param[in]  Selected       Whether or not a tag be selected. TRUE means Enter has hit this question.
 …
     TimeOp  = (EFI_IFR_TIME *) Statement->OpCode;
     HexDisplay = (TimeOp->Flags & EFI_IFR_DISPLAY_UINT_HEX) == EFI_IFR_DISPLAY_UINT_HEX;
+  }
+  }
   switch (Statement->OpCode->OpCode) {
   case EFI_IFR_ORDERED_LIST_OP:
 …
           (Statement->OpCode->OpCode == EFI_IFR_TIME_OP)) {
         PrintAt (
           ColumnWidth1,
+          ColumnWidth1,
           StartColumnOfHelp,
           BottomRowOfHelp,
 …
       // If it is a selected numeric with manual input, display different message
       //
       if ((Statement->OpCode->OpCode == EFI_IFR_NUMERIC_OP) ||
+      if ((Statement->OpCode->OpCode == EFI_IFR_NUMERIC_OP) ||
           (Statement->OpCode->OpCode == EFI_IFR_DATE_OP) ||
           (Statement->OpCode->OpCode == EFI_IFR_TIME_OP)) {
 …
   default:
     break;
+  }
+  }
+}
 …
   Update status bar.
   This function updates the status bar on the bottom of menu screen. It just shows StatusBar.
+  This function updates the status bar on the bottom of menu screen. It just shows StatusBar.
   Original logic in this function should be splitted out.
   @param[in]  MessageType            The type of message to be shown. InputError or Configuration Changed.
+  @param[in]  MessageType            The type of message to be shown. InputError or Configuration Changed.
   @param[in]  State                  Show or Clear Message.
 **/
 …
   default:
     break;
+  }
+}
 /**
   Create popup window. It will replace CreateDialog().
+  }
+}
+/**
+  Create popup window. It will replace CreateDialog().
   This function draws OEM/Vendor specific pop up windows.
 …
   @param[out]  Key    User Input Key
   @param       ...    String to be shown in Popup. The variable argument list is terminated by a NULL.
 **/
 VOID
 …
   while  ((String = VA_ARG (Marker, CHAR16 *)) != NULL) {
     LineNum ++;
     if ((LibGetStringWidth (String) / 2) > LargestString) {
       LargestString = (LibGetStringWidth (String) / 2);
+    }
+  }
+  }
   VA_END (Marker);
 …
     LargestString = DimensionsWidth - 2;
+  }
   CurrentAttribute  = gST->ConOut->Mode->Attribute;
   CursorVisible     = gST->ConOut->Mode->CursorVisible;
 …
 /**
   Confirm how to handle the changed data.
+  Confirm how to handle the changed data.
   @return Action BROWSER_ACTION_SUBMIT, BROWSER_ACTION_DISCARD or other values.
 **/
 …
   gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
   YesResponse = gYesResponse[0];
   NoResponse  = gNoResponse[0];
   //
   // If NV flag is up, prompt user
 …
     ((Key.UnicodeChar | UPPER_LOWER_CASE_OFFSET) != (YesResponse | UPPER_LOWER_CASE_OFFSET))
   );
   if (Key.ScanCode == SCAN_ESC) {
     return BROWSER_ACTION_NONE;
 …
   OEM specifies whether Setup exits Page by ESC key.
   This function customized the behavior that whether Setup exits Page so that
+  This function customized the behavior that whether Setup exits Page so that
   system able to boot when configuration is not changed.
 …
 /**
   Set Timeout value for a ceratain Form to get user response.
+  Set Timeout value for a ceratain Form to get user response.
   This function allows to set timeout value on a ceratain form if necessary.
   If timeout is not zero, the form will exit if user has no response in timeout.
+  If timeout is not zero, the form will exit if user has no response in timeout.
   @param[in]  FormData   Form Data to be shown in Page
   @return 0     No timeout for this form.
+  @return 0     No timeout for this form.
   @return > 0   Timeout value in 100 ns units.
 **/
 …
 **/
 VOID
 EFIAPI
+EFIAPI
 ClearDisplayPage (
   VOID
 …
+{
   HiiRemovePackages(mCDLStringPackHandle);
   FreeLibStrings ();

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/CustomizedDisplayLib/CustomizedDisplayLib.inf

-              r58464
+              r58466
   CustomizedDisplayLibInternal.c
   CustomizedDisplayLib.uni
 [Packages]
   MdePkg/MdePkg.dec
 …
 [Guids]
   gEfiIfrTianoGuid  ## SOMETIMES_CONSUMES   ## UNDEFINED
 [Protocols]

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/CustomizedDisplayLib/CustomizedDisplayLibInternal.c

-              r58464
+              r58466
 Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials are licensed and made available under
 the terms and conditions of the BSD License that accompanies this distribution.
+This program and the accompanying materials are licensed and made available under
+the terms and conditions of the BSD License that accompanies this distribution.
 The full text of the license may be found at
 http://opensource.org/licenses/bsd-license.php.
 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+http://opensource.org/licenses/bsd-license.php.
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 …
   @param[in]  FormData             Form Data to be shown in Page
 **/
 VOID
 PrintBannerInfo (
+PrintBannerInfo (
   IN FORM_DISPLAY_ENGINE_FORM       *FormData
+  )
 …
       RowIdx    = (UINT8) (Line - (UINT8) gScreenDimensions.TopRow);
       ColumnIdx = (UINT8) (Alignment - (UINT8) gScreenDimensions.LeftColumn);
       ASSERT (RowIdx < BANNER_HEIGHT && ColumnIdx < BANNER_COLUMNS);
       if (gBannerData!= NULL && gBannerData->Banner[RowIdx][ColumnIdx] != 0x0000) {
         StrFrontPageBanner = LibGetToken (gBannerData->Banner[RowIdx][ColumnIdx], FormData->HiiHandle);
 …
         continue;
+      }
       switch (Alignment - gScreenDimensions.LeftColumn) {
       case 0:
 …
         PrintStringAt (gScreenDimensions.LeftColumn + BANNER_LEFT_COLUMN_INDENT, Line, StrFrontPageBanner);
         break;
       case 1:
         //
 …
           );
         break;
       case 2:
         //
 …
         break;
+      }
       FreePool (StrFrontPageBanner);
+    }
 …
     return;
+  }
   Buffer = AllocateZeroPool (0x10000);
   ASSERT (Buffer != NULL);
 …
     PrintCharAt (gScreenDimensions.RightColumn - 1, Row, Character);
+  }
   //
   // Print Form Title
 …
   Character = BOXDRAW_UP_LEFT;
   PrintCharAt ((UINTN) -1, (UINTN) -1, Character);
   FreePool (Buffer);
+}
 …
+{
   switch (OpCodeData->OpCode) {
     case EFI_IFR_GUID_OP:
+    case EFI_IFR_GUID_OP:
       if (CompareGuid (&gEfiIfrTianoGuid, (EFI_GUID *)((CHAR8*) OpCodeData + sizeof (EFI_IFR_OP_HEADER)))) {
         //
 …
               ASSERT (gBannerData != NULL);
+            }
             CopyMem (
               &gBannerData->Banner[((EFI_IFR_GUID_BANNER *) OpCodeData)->LineNumber][
 …
 /**
   Process some op codes which is out side of current form.
   @param FormData                Pointer to the form data.
 …
 **/
 EFI_STATUS
+EFI_STATUS
 ScreenDiemensionInfoValidate (
   IN FORM_DISPLAY_ENGINE_FORM       *FormData
 …
   //
   // Calculate total number of Register HotKeys.
+  // Calculate total number of Register HotKeys.
   //
   Index = 0;
 …
   //
   // Calculate total number of Register HotKeys.
+  // Calculate total number of Register HotKeys.
   //
   Index = 0;
 …
     //
     // Help string can't exceed ColumnWidth. One Row will show three Help information.
+    // Help string can't exceed ColumnWidth. One Row will show three Help information.
     //
     BakChar = L'\0';
 …
     Index ++;
+  }
   if (SetState) {
     //
 …
+    }
+  }
   return;
+}
 …
 /**
   Get step info from numeric opcode.
   @param[in] OpCode     The input numeric op code.
 …
   NumericOp = (EFI_IFR_NUMERIC *) OpCode;
   switch (NumericOp->Flags & EFI_IFR_NUMERIC_SIZE) {
   case EFI_IFR_NUMERIC_SIZE_1:
     Step    = NumericOp->data.u8.Step;
     break;
   case EFI_IFR_NUMERIC_SIZE_2:
     Step    = NumericOp->data.u16.Step;
     break;
   case EFI_IFR_NUMERIC_SIZE_4:
     Step    = NumericOp->data.u32.Step;
     break;
   case EFI_IFR_NUMERIC_SIZE_8:
     Step    = NumericOp->data.u64.Step;
     break;
   default:
     Step = 0;
 …
   gNvUpdateMessage      = LibGetToken (STRING_TOKEN (NV_UPDATE_MESSAGE), mCDLStringPackHandle);
   gInputErrorMessage    = LibGetToken (STRING_TOKEN (INPUT_ERROR_MESSAGE), mCDLStringPackHandle);
   //
   // SpaceBuffer;
 …
   FreePool (gNvUpdateMessage);
   FreePool (gInputErrorMessage);
   FreePool (mSpaceBuffer);
+}
 …
       continue;
+    }
     gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &Index);
+  }
 …
 UINTN
 PrintInternal (
   IN UINTN                            Width,
+  IN UINTN                            Width,
   IN UINTN                            Column,
   IN UINTN                            Row,

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/CustomizedDisplayLib/CustomizedDisplayLibInternal.h

-              r58464
+              r58466
 Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials are licensed and made available under
 the terms and conditions of the BSD License that accompanies this distribution.
+This program and the accompanying materials are licensed and made available under
+the terms and conditions of the BSD License that accompanies this distribution.
 The full text of the license may be found at
 http://opensource.org/licenses/bsd-license.php.
 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+http://opensource.org/licenses/bsd-license.php.
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 …
   @param[in]  FormData             Form Data to be shown in Page
 **/
 VOID
 PrintBannerInfo (
+**/
+VOID
+PrintBannerInfo (
   IN FORM_DISPLAY_ENGINE_FORM       *FormData
   );
 …
 **/
 EFI_STATUS
+EFI_STATUS
 ScreenDiemensionInfoValidate (
   IN FORM_DISPLAY_ENGINE_FORM       *FormData
 …
   IN BOOLEAN                       SetState
   );
 /**
   Get step info from numeric opcode.
   @param[in] OpCode     The input numeric op code.
 …
 /**
   Process some op codes which is out side of current form.
   @param FormData                Pointer to the form data.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeCapsuleLibNull/DxeCapsuleLibNull.c

-              r48674
+              r58466
 /**
   The firmware checks whether the capsule image is supported
+  The firmware checks whether the capsule image is supported
   by the CapsuleGuid in CapsuleHeader or other specific information in capsule image.
   @param  CapsuleHeader    Point to the UEFI capsule image to be checked.
   @retval EFI_UNSUPPORTED  Input capsule is not supported by the firmware.
 **/
 …
   The firmware specific implementation processes the capsule image
   if it recognized the format of this capsule image.
   @param  CapsuleHeader    Point to the UEFI capsule image to be processed.
+  @param  CapsuleHeader    Point to the UEFI capsule image to be processed.
   @retval EFI_UNSUPPORTED  Capsule image is not supported by the firmware.
 **/

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeCoreMemoryAllocationLib/DxeCoreMemoryAllocationLib.inf

-              r58459
+              r58466
 # The implementation borrows the DxeCore Memory Allocation services as the primitive
 # for memory allocation instead of using UEFI boot servces in an indirect way.
 # It is assumed that this library instance must be linked with DxeCore in this package.
+# It is assumed that this library instance must be linked with DxeCore in this package.
+#
 # Copyright (c) 2008 - 2014, Intel Corporation. All rights reserved.<BR>
 …
   VERSION_STRING                 = 1.0
   LIBRARY_CLASS                  = MemoryAllocationLib|DXE_CORE
+#
 # The following information is for reference only and not required by the build tools.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeCoreMemoryAllocationLib/DxeCoreMemoryAllocationServices.h

-              r48674
+              r58466
   This header file borrows the DxeCore Memory Allocation services as the primitive
   for memory allocation.
+  for memory allocation.
   Copyright (c) 2008, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
   which accompanies this distribution.  The full text of the license may be found at
   http://opensource.org/licenses/bsd-license.php
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 **/

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeCoreMemoryAllocationLib/MemoryAllocationLib.c

-              r58459
+              r58466
 /** @file
   Support routines for memory allocation routines based
+  Support routines for memory allocation routines based
   on boot services for Dxe phase drivers.
   Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
   which accompanies this distribution.  The full text of the license may be found at
   http://opensource.org/licenses/bsd-license.php
   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 **/
 …
 VOID *
 InternalAllocatePages (
   IN EFI_MEMORY_TYPE  MemoryType,
+  IN EFI_MEMORY_TYPE  MemoryType,
   IN UINTN            Pages
+  )
+{
   EFI_STATUS            Status;
   EFI_PHYSICAL_ADDRESS  Memory;
+  EFI_PHYSICAL_ADDRESS  Memory;
   if (Pages == 0) {
 …
   Allocation Library.  If it is not possible to free allocated pages, then this function will
   perform no actions.
   If Buffer was not allocated with a page allocation function in the Memory Allocation Library,
   then ASSERT().
   If Pages is zero, then ASSERT().
   @param  Buffer                Pointer to the buffer of pages to free.
   @param  Pages                 The number of 4 KB pages to free.
 …
 VOID *
 InternalAllocateAlignedPages (
   IN EFI_MEMORY_TYPE  MemoryType,
+  IN EFI_MEMORY_TYPE  MemoryType,
   IN UINTN            Pages,
   IN UINTN            Alignment
 …
   //
   ASSERT ((Alignment & (Alignment - 1)) == 0);
   if (Pages == 0) {
     return NULL;
 …
     //
     ASSERT (RealPages > Pages);
     Status         = CoreAllocatePages (AllocateAnyPages, MemoryType, RealPages, &Memory);
     if (EFI_ERROR (Status)) {
 …
   returned.  If there is not enough memory at the specified alignment remaining to satisfy the
   request, then NULL is returned.
   If Alignment is not a power of two and Alignment is not zero, then ASSERT().
   If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
 …
   returned.  If there is not enough memory at the specified alignment remaining to satisfy the
   request, then NULL is returned.
   If Alignment is not a power of two and Alignment is not zero, then ASSERT().
   If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
 …
   returned.  If there is not enough memory at the specified alignment remaining to satisfy the
   request, then NULL is returned.
   If Alignment is not a power of two and Alignment is not zero, then ASSERT().
   If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
 …
   Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  Buffer
   must have been allocated on a previous call to the aligned page allocation services of the Memory
   Allocation Library.  If it is not possible to free allocated pages, then this function will
+  Allocation Library.  If it is not possible to free allocated pages, then this function will
   perform no actions.
   If Buffer was not allocated with an aligned page allocation function in the Memory Allocation
   Library, then ASSERT().
   If Pages is zero, then ASSERT().
   @param  Buffer                Pointer to the buffer of pages to free.
   @param  Pages                 The number of 4 KB pages to free.
 …
 VOID *
 InternalAllocatePool (
   IN EFI_MEMORY_TYPE  MemoryType,
+  IN EFI_MEMORY_TYPE  MemoryType,
   IN UINTN            AllocationSize
+  )
 …
 VOID *
 InternalAllocateZeroPool (
   IN EFI_MEMORY_TYPE  PoolType,
+  IN EFI_MEMORY_TYPE  PoolType,
   IN UINTN            AllocationSize
+  )
+  )
+{
   VOID  *Memory;
 …
   is not enough memory remaining to satisfy the request, then NULL is returned.
   If Buffer is NULL, then ASSERT().
   If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
   @param  PoolType              The type of pool to allocate.
 …
 VOID *
 InternalAllocateCopyPool (
   IN EFI_MEMORY_TYPE  PoolType,
+  IN EFI_MEMORY_TYPE  PoolType,
   IN UINTN            AllocationSize,
   IN CONST VOID       *Buffer
+  )
+  )
+{
   VOID  *Memory;
 …
+  }
   return Memory;
+}
+}
 /**
 …
   allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
   is not enough memory remaining to satisfy the request, then NULL is returned.
   If Buffer is NULL, then ASSERT().
   If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
   @param  AllocationSize        The number of bytes to allocate and zero.
 …
   allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
   is not enough memory remaining to satisfy the request, then NULL is returned.
   If Buffer is NULL, then ASSERT().
   If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
   @param  AllocationSize        The number of bytes to allocate and zero.
 …
   allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
   is not enough memory remaining to satisfy the request, then NULL is returned.
   If Buffer is NULL, then ASSERT().
   If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
   @param  AllocationSize        The number of bytes to allocate and zero.
 …
   Allocates and zeros the number bytes specified by NewSize from memory of the type
   specified by PoolType.  If OldBuffer is not NULL, then the smaller of OldSize and
   NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
   OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
   If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
+  specified by PoolType.  If OldBuffer is not NULL, then the smaller of OldSize and
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
   enough memory remaining to satisfy the request, then NULL is returned.
   If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
   is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
 …
   @param  OldSize        The size, in bytes, of OldBuffer.
   @param  NewSize        The size, in bytes, of the buffer to reallocate.
   @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
                          parameter that may be NULL.
 …
 VOID *
 InternalReallocatePool (
   IN EFI_MEMORY_TYPE  PoolType,
+  IN EFI_MEMORY_TYPE  PoolType,
   IN UINTN            OldSize,
   IN UINTN            NewSize,
 …
   Allocates and zeros the number bytes specified by NewSize from memory of type
   EfiBootServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and
   NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
   OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
   If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
+  EfiBootServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
   enough memory remaining to satisfy the request, then NULL is returned.
   If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
   is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
 …
   @param  OldSize        The size, in bytes, of OldBuffer.
   @param  NewSize        The size, in bytes, of the buffer to reallocate.
   @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
                          parameter that may be NULL.
 …
   Allocates and zeros the number bytes specified by NewSize from memory of type
   EfiRuntimeServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and
   NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
   OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
   If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
+  EfiRuntimeServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
   enough memory remaining to satisfy the request, then NULL is returned.
 …
   @param  OldSize        The size, in bytes, of OldBuffer.
   @param  NewSize        The size, in bytes, of the buffer to reallocate.
   @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
                          parameter that may be NULL.
 …
   Allocates and zeros the number bytes specified by NewSize from memory of type
   EfiReservedMemoryType.  If OldBuffer is not NULL, then the smaller of OldSize and
   NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
   OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
   If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
+  EfiReservedMemoryType.  If OldBuffer is not NULL, then the smaller of OldSize and
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
   enough memory remaining to satisfy the request, then NULL is returned.
 …
   @param  OldSize        The size, in bytes, of OldBuffer.
   @param  NewSize        The size, in bytes, of the buffer to reallocate.
   @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
                          parameter that may be NULL.
 …
   pool allocation services of the Memory Allocation Library.  If it is not possible to free pool
   resources, then this function will perform no actions.
   If Buffer was not allocated with a pool allocation function in the Memory Allocation Library,
   then ASSERT().

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeCorePerformanceLib/DxeCorePerformanceLib.c

-              r58459
+              r58466
   This library provides the performance measurement interfaces and initializes performance
   logging for DXE phase. It first initializes its private global data structure for
   performance logging and saves the performance GUIDed HOB passed from PEI phase.
+  performance logging and saves the performance GUIDed HOB passed from PEI phase.
   It initializes DXE phase performance logging by publishing the Performance and PerformanceEx Protocol,
   which are consumed by DxePerformanceLib to logging performance data in DXE phase.
 …
 //
 // The current maximum number of logging entries. If current number of
+// The current maximum number of logging entries. If current number of
 // entries exceeds this value, it will re-allocate a larger array and
 // migration the old data to the larger array.
 …
 EFIAPI
 GetPerformanceMeasurementEx (
   IN  UINTN       LogEntryKey,
+  IN  UINTN       LogEntryKey,
   OUT CONST VOID  **Handle,
   OUT CONST CHAR8 **Token,
 …
   GaugeData = NULL;
   ASSERT (Handle != NULL);
   ASSERT (Token != NULL);

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeCorePerformanceLib/DxeCorePerformanceLib.inf

-              r58459
+              r58466
 ## @file
 #  Performance library instance mainly for DxeCore usage.
+#
+#
 #  This library provides the performance measurement interfaces and initializes performance
 #  logging for DXE phase. It first initializes its private global data structure for
 #  performance logging and saves the performance GUIDed HOB passed from PEI phase.
+#  performance logging and saves the performance GUIDed HOB passed from PEI phase.
 #  It initializes DXE phase performance logging by publishing the Performance and PerformanceEx Protocol,
 #  which is consumed by DxePerformanceLib to logging performance data in DXE phase.
 #  This library is mainly used by DxeCore to start performance logging to ensure that
 #  Performance and PerformanceEx Protocol are installed at the very beginning of DXE phase.
+#
+#
 #  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 …
 #  which accompanies this distribution.  The full text of the license may be found at
 #  http://opensource.org/licenses/bsd-license.php
+#
+#
 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#
 ##

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeCorePerformanceLib/DxeCorePerformanceLibInternal.h

r48674	r58466
15	15
16	16	**/
17
	17
18	18	#ifndef _DXE_CORE_PERFORMANCE_LIB_INTERNAL_H_
19	19	#define _DXE_CORE_PERFORMANCE_LIB_INTERNAL_H_

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeCrc32GuidedSectionExtractLib/DxeCrc32GuidedSectionExtractLib.c

-              r48674
+              r58466
 /** @file
   This library registers CRC32 guided section handler
+  This library registers CRC32 guided section handler
   to parse CRC32 encapsulation section and extract raw data.
   It uses UEFI boot service CalculateCrc32 to authenticate 32 bit CRC value.
 Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 which accompanies this distribution.  The full text of the license may be found at
 http://opensource.org/licenses/bsd-license.php
 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 **/
 …
   GetInfo gets raw data size and attribute of the input guided section.
   It first checks whether the input guid section is supported.
+  It first checks whether the input guid section is supported.
   If not, EFI_INVALID_PARAMETER will return.
 …
   @param SectionAttribute   The attribute of the input guided section.
   @retval EFI_SUCCESS            The size of destination buffer, the size of scratch buffer and
+  @retval EFI_SUCCESS            The size of destination buffer, the size of scratch buffer and
                                  the attribute of the input section are successull retrieved.
   @retval EFI_INVALID_PARAMETER  The GUID in InputSection does not match this instance guid.
 …
   Extraction handler tries to extract raw data from the input guided section.
   It also does authentication check for 32bit CRC value in the input guided section.
   It first checks whether the input guid section is supported.
+  It first checks whether the input guid section is supported.
   If not, EFI_INVALID_PARAMETER will return.
 …
       return EFI_INVALID_PARAMETER;
+    }
     //
     // Get section Crc32 checksum.
 …
       return EFI_INVALID_PARAMETER;
+    }
     //
     // Get section Crc32 checksum.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeCrc32GuidedSectionExtractLib/DxeCrc32GuidedSectionExtractLib.inf

r58459	r58466
2	2	# Dxe Crc32 Guided Section Extract library.
3	3	#
4		# This library doesn't produce any library class. The constructor function uses
	4	# This library doesn't produce any library class. The constructor function uses
5	5	# ExtractGuidedSectionLib service to register CRC32 guided section handler
6	6	# that parses CRC32 encapsulation section and extracts raw data.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeDebugPrintErrorLevelLib/DxeDebugPrintErrorLevelLib.c

-              r48674
+              r58466
 /** @file
   Debug Print Error Level library instance that provide compatibility with the
+  Debug Print Error Level library instance that provide compatibility with the
   "err" shell command.  This includes support for the Debug Mask Protocol
   supports for global debug print error level mask stored in an EFI Variable.
 …
   @param  This              The protocol instance pointer.
   @param  CurrentDebugMask  Pointer to the debug print error level mask that
+  @param  CurrentDebugMask  Pointer to the debug print error level mask that
                             is returned.
 …
 EFIAPI
 GetDebugMask (
   IN EFI_DEBUG_MASK_PROTOCOL  *This,
   IN OUT UINTN                *CurrentDebugMask
+  IN EFI_DEBUG_MASK_PROTOCOL  *This,
+  IN OUT UINTN                *CurrentDebugMask
   );
 …
 ///
 /// Global variable that is set to TRUE after the first attempt is made to
+/// Global variable that is set to TRUE after the first attempt is made to
 /// retrieve the global error level mask through the EFI Varibale Services.
 /// This variable prevents the EFI Variable Services from being called fort
 …
 /// set to the PcdDebugPrintErrorLevel value.  If the EFI Variable exists that
 /// contains the global debug print error level mask, then that overrides the
 /// PcdDebugPrintErrorLevel value. The EFI Variable can optionally be
+/// PcdDebugPrintErrorLevel value. The EFI Variable can optionally be
 /// discovered via a HOB so early DXE drivers can access the variable. If the
 /// Debug Mask Protocol SetDebugMask() service is called, then that overrides
+/// Debug Mask Protocol SetDebugMask() service is called, then that overrides
 /// the PcdDebugPrintErrorLevel and the EFI Variable setting.
 ///
 …
 /**
   The constructor function caches the PCI Express Base Address and creates a
+  The constructor function caches the PCI Express Base Address and creates a
   Set Virtual Address Map event to convert physical address to virtual addresses.
   @param  ImageHandle   The firmware allocated handle for the EFI image.
   @param  SystemTable   A pointer to the EFI System Table.
   @retval EFI_SUCCESS   The constructor completed successfully.
   @retval Other value   The constructor did not complete successfully.
 …
+{
   EFI_STATUS                  Status;
   //
   // Initialize the error level mask from PCD setting.
   //
   mDebugPrintErrorLevel = PcdGet32 (PcdDebugPrintErrorLevel);
   //
   // Install Debug Mask Protocol onto ImageHandle
   //
+  //
   mSystemTable = SystemTable;
   Status = SystemTable->BootServices->InstallMultipleProtocolInterfaces (
 …
   // Attempt to retrieve the global debug print error level mask from the EFI Variable
   // If the EFI Variable can not be accessed when this module's library constructors are
   // executed a HOB can be used to set the global debug print error level. If no value
+  // executed a HOB can be used to set the global debug print error level. If no value
   // was found then the EFI Variable access will be reattempted on every DEBUG() print
   // from this module until the EFI Variable services are available.
   //
   GetDebugPrintErrorLevel ();
   return Status;
+}
 /**
   The destructor function frees any allocated buffers and closes the Set Virtual
+  The destructor function frees any allocated buffers and closes the Set Virtual
   Address Map event.
   @param  ImageHandle   The firmware allocated handle for the EFI image.
   @param  SystemTable   A pointer to the EFI System Table.
   @retval EFI_SUCCESS   The destructor completed successfully.
   @retval Other value   The destructor did not complete successfully.
 …
   //
   // Uninstall the Debug Mask Protocol from ImageHandle
   //
+  //
   return SystemTable->BootServices->UninstallMultipleProtocolInterfaces (
                                       ImageHandle,
 …
     return PcdGet32 (PcdDebugPrintErrorLevel);
+  }
   //
   // Check to see if an attempt has been made to retrieve the global debug print
+  //
+  // Check to see if an attempt has been made to retrieve the global debug print
   // error level mask.  Since this library instance stores the global debug print
   // error level mask in an EFI Variable, the EFI Variable should only be accessed
   // once to reduce the overhead of reading the EFI Variable on every debug print
   //
+  //
   if (!mGlobalErrorLevelInitialized) {
     //
 …
     if (CurrentTpl <= TPL_CALLBACK) {
       //
       // Attempt to retrieve the global debug print error level mask from the
+      // Attempt to retrieve the global debug print error level mask from the
       // EFI Variable
       //
       Size = sizeof (GlobalErrorLevel);
       Status = mSystemTable->RuntimeServices->GetVariable (
                                        DEBUG_MASK_VARIABLE_NAME,
                                        &gEfiGenericVariableGuid,
                                        NULL,
                                        &Size,
+                                       DEBUG_MASK_VARIABLE_NAME,
+                                       &gEfiGenericVariableGuid,
+                                       NULL,
+                                       &Size,
                                        &GlobalErrorLevel
                                        );
 …
 /**
   Sets the global debug print error level mask fpr the entire platform.
   @param   ErrorLevel     Global debug print error level
   @retval  TRUE           The debug print error level mask was sucessfully set.
   @retval  FALSE          The debug print error level mask could not be set.
 …
       Size = sizeof (GlobalErrorLevel);
       Status = mSystemTable->RuntimeServices->SetVariable (
                                        DEBUG_MASK_VARIABLE_NAME,
                                        &gEfiGenericVariableGuid,
+                                       DEBUG_MASK_VARIABLE_NAME,
+                                       &gEfiGenericVariableGuid,
                                        (EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS),
                                        Size,
 …
       if (!EFI_ERROR (Status)) {
         //
         // If the EFI Variable was updated, then update the mask value for this
+        // If the EFI Variable was updated, then update the mask value for this
         // module and return TRUE.
         //
         mGlobalErrorLevelInitialized = TRUE;
+        mGlobalErrorLevelInitialized = TRUE;
         mDebugPrintErrorLevel = ErrorLevel;
         return TRUE;
 …
   @param  This              The protocol instance pointer.
   @param  CurrentDebugMask  Pointer to the debug print error level mask that
+  @param  CurrentDebugMask  Pointer to the debug print error level mask that
                             is returned.
 …
 EFIAPI
 GetDebugMask (
   IN EFI_DEBUG_MASK_PROTOCOL  *This,
   IN OUT UINTN                *CurrentDebugMask
+  IN EFI_DEBUG_MASK_PROTOCOL  *This,
+  IN OUT UINTN                *CurrentDebugMask
+  )
+{
 …
     return EFI_INVALID_PARAMETER;
+  }
   //
   // Retrieve the current debug mask from mDebugPrintErrorLevel

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeDebugPrintErrorLevelLib/DxeDebugPrintErrorLevelLib.inf

-              r58459
+              r58466
   MODULE_TYPE                    = DXE_DRIVER
   VERSION_STRING                 = 1.0
   LIBRARY_CLASS                  = DebugPrintErrorLevelLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER UEFI_APPLICATION UEFI_DRIVER
+  LIBRARY_CLASS                  = DebugPrintErrorLevelLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER UEFI_APPLICATION UEFI_DRIVER
   CONSTRUCTOR                    = DxeDebugPrintErrorLevelLibConstructor
   DESTRUCTOR                     = DxeDebugPrintErrorLevelLibDestructor
 …
   PcdLib
   HobLib
 [Protocols]
   gEfiDebugMaskProtocolGuid     ## PRODUCES
 [Guids]
   ## SOMETIMES_PRODUCES   ## Variable:L"EFIDebug"

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeDpcLib/DpcLib.c

r48674	r58466
1	1	/** @file
2	2	Help functions to access UDP service.
3
	3
4	4	Copyright (c) 2005 - 2007, Intel Corporation. All rights reserved.<BR>
5	5	This program and the accompanying materials

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.c

-              r48674
+              r58466
   {FALSE, TRUE}, // ICMP6_ERR_UNREACH_HOST
   {TRUE,  TRUE}, // ICMP6_ERR_UNREACH_PROTOCOL
   {TRUE,  TRUE}, // ICMP6_ERR_UNREACH_PORT
+  {TRUE,  TRUE}, // ICMP6_ERR_UNREACH_PORT
   {TRUE,  TRUE}, // ICMP6_ERR_PACKAGE_TOOBIG
   {FALSE, TRUE}, // ICMP6_ERR_TIMXCEED_HOPLIMIT
   {FALSE, TRUE}, // ICMP6_ERR_TIMXCEED_REASS
   {FALSE, TRUE}, // ICMP6_ERR_PARAMPROB_HEADER
+  {FALSE, TRUE}, // ICMP6_ERR_PARAMPROB_HEADER
   {FALSE, TRUE}, // ICMP6_ERR_PARAMPROB_NEXHEADER
   {FALSE, TRUE}  // ICMP6_ERR_PARAMPROB_IPV6OPTION
 …
 /**
   This function handles ICMPv4 packets. It is the worker function of
+  This function handles ICMPv4 packets. It is the worker function of
   IpIoIcmpHandler.
 …
   IpIo->PktRcvdNotify (EFI_ICMP_ERROR, IcmpErr, Session, Pkt, IpIo->RcvdContext);
   return EFI_SUCCESS;
+}
 /**
   This function handles ICMPv6 packets. It is the worker function of
+  return EFI_SUCCESS;
+}
+/**
+  This function handles ICMPv6 packets. It is the worker function of
   IpIoIcmpHandler.
 …
   //
   // Analyze the ICMPv6 Error in this ICMPv6 packet
   //
+  //
   switch (Type) {
   case ICMP_V6_DEST_UNREACHABLE:
 …
      return EFI_ABORTED;
+   }
+   }
   //
 …
   PayLoadHdr = (UINT8 *) ((UINT8 *) IcmpHdr + sizeof (IP6_ICMP_ERROR_HEAD));
   Flag       = TRUE;
   do {
     switch (NextHeader) {
 …
   TrimBytes = (UINT32) (PayLoadHdr - (UINT8 *) IcmpHdr);
   NetbufTrim (Pkt, TrimBytes, TRUE);
 …
+{
   IP_IO_SEND_ENTRY          *SndEntry;
   EFI_EVENT                 Event;
+  EFI_EVENT                 Event;
   EFI_STATUS                Status;
   NET_FRAGMENT              *ExtFragment;
 …
   //
   // Build a fragment table to contain the fragments in the packet.
+  // Build a fragment table to contain the fragments in the packet.
   //
   if (IpIo->IpVersion == IP_VERSION_4) {
 …
     Ip6TxData->ExtHdrsLength = 0;
     Ip6TxData->ExtHdrs       = NULL;
     //
     // Set the fields of SndToken
 …
 /**
   Destroy the SndEntry.
   This function pairs with IpIoCreateSndEntry().
 …
       goto CleanUp;
+    }
     //
     // Create a netbuffer representing IPv6 packet
 …
     //
     CopyMem (
       &Session.Source,
+      &Session.Source,
       &RxData->Ip6RxData.Header->SourceAddress,
       sizeof(EFI_IPv6_ADDRESS)
       );
     CopyMem (
       &Session.Dest,
       &RxData->Ip6RxData.Header->DestinationAddress,
+      &Session.Dest,
+      &RxData->Ip6RxData.Header->DestinationAddress,
       sizeof(EFI_IPv6_ADDRESS)
       );
 …
     Session.IpHdrLen     = RxData->Ip6RxData.HeaderLength;
     Session.IpVersion    = IP_VERSION_6;
+  }
+  }
   if (EFI_SUCCESS == Status) {
 …
     gBS->SignalEvent (RxData->Ip4RxData.RecycleSignal);
   } else {
     gBS->SignalEvent (RxData->Ip6RxData.RecycleSignal);
+    gBS->SignalEvent (RxData->Ip6RxData.RecycleSignal);
+  }
 …
 /**
   Create a new IP_IO instance.
   This function uses IP4/IP6 service binding protocol in Controller to create
   an IP4/IP6 child (aka IP4/IP6 instance).
 …
                                 binding protocol installed.
   @param[in]  IpVersion         The version of the IP protocol to use, either
                                 IPv4 or IPv6.
+                                IPv4 or IPv6.
   @return Pointer to a newly created IP_IO instance, or NULL if failed.
 …
              Image,
              &IpIo->ChildHandle,
              IpVersion,
+             IpVersion,
              (VOID **)&(IpIo->Ip)
              );
 …
 /**
   Open an IP_IO instance for use.
   This function is called after IpIoCreate(). It is used for configuring the IP
   instance and register the callbacks and their context data for sending and
 …
   @retval          EFI_SUCCESS        The IP_IO instance opened with OpenData
                                       successfully.
   @retval          EFI_ACCESS_DENIED  The IP_IO instance is configured, avoid to
+  @retval          EFI_ACCESS_DENIED  The IP_IO instance is configured, avoid to
                                       reopen it.
   @retval          Others             Error condition occurred.
 …
     Status = IpIo->Ip.Ip6->Configure (
                              IpIo->Ip.Ip6,
+                             IpIo->Ip.Ip6,
                              &OpenData->IpConfigData.Ip6CfgData
                              );
 …
 /**
   Stop an IP_IO instance.
   This function is paired with IpIoOpen(). The IP_IO will be unconfigured and all
   the pending send/receive tokens will be canceled.
 …
 /**
   Destroy an IP_IO instance.
   This function is paired with IpIoCreate(). The IP_IO will be closed first.
   Resource will be freed afterwards. See IpIoCloseProtocolDestroyIpChild().
 …
 /**
   Send out an IP packet.
   This function is called after IpIoOpen(). The data to be sent are wrapped in
   Pkt. The IP instance wrapped in IpIo is used for sending by default but can be
 …
 /**
   Add a new IP instance for sending data.
   The function is used to add the IP_IO to the IP_IO sending list. The caller
   can later use IpIoFindSender() to get the IP_IO and call IpIoSend() to send
 …
       if (((EFI_IP4_CONFIG_DATA *) IpConfigData)->UseDefaultAddress) {
         Ip.Ip4->GetModeData (
                   Ip.Ip4,
                   &Ip4ModeData,
                   NULL,
+                  Ip.Ip4,
+                  &Ip4ModeData,
+                  NULL,
                   NULL
                   );
 …
       CopyMem (
         &IpInfo->Addr.Addr,
         &((EFI_IP4_CONFIG_DATA *) IpConfigData)->StationAddress,
+        &IpInfo->Addr.Addr,
+        &((EFI_IP4_CONFIG_DATA *) IpConfigData)->StationAddress,
         sizeof (IP4_ADDR)
         );
       CopyMem (
         &IpInfo->PreMask.SubnetMask,
+        &IpInfo->PreMask.SubnetMask,
         &((EFI_IP4_CONFIG_DATA *) IpConfigData)->SubnetMask,
         sizeof (IP4_ADDR)
 …
         Status = EFI_NO_MAPPING;
         goto OnExit;
+      }
+      }
       CopyMem (
         &IpInfo->Addr,
         &Ip6ModeData.ConfigData.StationAddress,
+        &IpInfo->Addr,
+        &Ip6ModeData.ConfigData.StationAddress,
         sizeof (EFI_IPv6_ADDRESS)
         );
 …
         Ip.Ip6->Configure (Ip.Ip6, NULL);
+      }
+    }
+    }
   } else {
     //
 …
   Destroy an IP instance maintained in IpIo->IpList for
   sending purpose.
   This function pairs with IpIoAddIp(). The IpInfo is previously created by
   IpIoAddIp(). The IP_IO_IP_INFO::RefCnt is decremented and the IP instance
 …
   Find the first IP protocol maintained in IpIo whose local
   address is the same as Src.
   This function is called when the caller needs the IpIo to send data to the
   specified Src. The IpIo was added previously by IpIoAddIp().
 …
   IP_IO_IP_INFO   *IpInfo;
   ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6));
+  ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6));
   NET_LIST_FOR_EACH (IpIoEntry, &mActiveIpIoList) {
 …
         if (EFI_IP6_EQUAL (&IpInfo->Addr.v6, &Src->v6)) {
           *IpIo = IpIoPtr;
           return IpInfo;
+          return IpInfo;
+        }
+      }
+      }
+    }
 …
 /**
   Get the ICMP error map information.
   The ErrorStatus will be returned. The IsHard and Notify are optional. If they
   are not NULL, this routine will fill them.
 …
   @param[in]   IcmpError             IcmpError Type.
   @param[in]   IpVersion             The version of the IP protocol to use,
                                      either IPv4 or IPv6.
+                                     either IPv4 or IPv6.
   @param[out]  IsHard                If TRUE, indicates that it is a hard error.
   @param[out]  Notify                If TRUE, SockError needs to be notified.
 …
     case ICMP6_ERR_UNREACH_HOST:
     case ICMP6_ERR_TIMXCEED_HOPLIMIT:
     case ICMP6_ERR_TIMXCEED_REASS:
+    case ICMP6_ERR_TIMXCEED_REASS:
       return EFI_HOST_UNREACHABLE;
     case ICMP6_ERR_UNREACH_PROTOCOL:
       return EFI_PROTOCOL_UNREACHABLE;
     case ICMP6_ERR_UNREACH_PORT:
       return EFI_PORT_UNREACHABLE;
 …
   This function is called when the caller needs the IpIo to refresh the existing
   IPv6 neighbor cache entries since the neighbor is considered reachable by the
   node has recently received a confirmation that packets sent recently to the
   neighbor were received by its IP layer.
+  IPv6 neighbor cache entries since the neighbor is considered reachable by the
+  node has recently received a confirmation that packets sent recently to the
+  neighbor were received by its IP layer.
   @param[in]   IpIo                  Pointer to an IP_IO instance
   @param[in]   Neighbor              The IP address of the neighbor
   @param[in]   Timeout               Time in 100-ns units that this entry will
                                      remain in the neighbor cache. A value of
                                      zero means that the entry is permanent.
                                      A value of non-zero means that the entry is
+                                     remain in the neighbor cache. A value of
+                                     zero means that the entry is permanent.
+                                     A value of non-zero means that the entry is
                                      dynamic and will be deleted after Timeout.
 …
   @retval      EFI_NOT_STARTED       The IpIo is not configured.
   @retval      EFI_INVALID_PARAMETER Neighbor Address is invalid.
   @retval      EFI_NOT_FOUND         The neighbor cache entry is not in the
                                      neighbor table.
+  @retval      EFI_NOT_FOUND         The neighbor cache entry is not in the
+                                     neighbor table.
   @retval      EFI_OUT_OF_RESOURCES  Failed due to resource limit.
 …
   IN IP_IO           *IpIo,
   IN EFI_IP_ADDRESS  *Neighbor,
   IN UINT32          Timeout
+  IN UINT32          Timeout
+  )
+{

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeNetLib/DxeNetLib.c

-              r58459
+              r58466
   If it hasn't been removed, then continue with the next node directly.
   This function will end the iterate and return the CallBack's last return value if error happens,
   or retrun EFI_SUCCESS if 2 complete passes are made with no changes in the number of children in the list.
+  or retrun EFI_SUCCESS if 2 complete passes are made with no changes in the number of children in the list.
   @param[in]    List             The head of the list.
 …
+{
   UINTN     Index;
   if (NumberOfChildren == 0 || ChildHandleBuffer == NULL) {
     return FALSE;
 …
       continue;
+    }
     //
     // Disconnect the driver specified by ImageHandle from all
 …
                       );
+    }
     //
     // Uninstall all the protocols installed in the driver entry point
     //
+    //
     gBS->UninstallProtocolInterface (
           DriverBinding->DriverBindingHandle,
 …
           DriverBinding
           );
     Status = gBS->HandleProtocol (
                     DeviceHandleBuffer[Index],
 …
     if (*Ip6Str == ':') {
       if (*(Ip6Str + 1) == ':') {
         if ((NodeCnt > 6) ||
+        if ((NodeCnt > 6) ||
             ((*(Ip6Str + 2) != '\0') && (AsciiStrHexToUintn (Ip6Str + 2) == 0))) {
           //
 …
           return EFI_INVALID_PARAMETER;
+        }
         if ((NodeCnt == 6) && (*(Ip6Str + 2) != '\0') &&
+        if ((NodeCnt == 6) && (*(Ip6Str + 2) != '\0') &&
             (AsciiStrHexToUintn (Ip6Str + 2) != 0)) {
           return EFI_INVALID_PARAMETER;
 …
+    }
     if (NodeVal != 0) {
       if ((*TempStr  == '0') &&
           ((*(TempStr + 2) == ':') || (*(TempStr + 3) == ':') ||
+      if ((*TempStr  == '0') &&
+          ((*(TempStr + 2) == ':') || (*(TempStr + 3) == ':') ||
           (*(TempStr + 2) == '\0') || (*(TempStr + 3) == '\0'))) {
         return EFI_INVALID_PARAMETER;
+      }
       if ((*TempStr  == '0') && (*(TempStr + 4) != '\0') &&
           (*(TempStr + 4) != ':')) {
+      if ((*TempStr  == '0') && (*(TempStr + 4) != '\0') &&
+          (*(TempStr + 4) != ':')) {
         return EFI_INVALID_PARAMETER;
+      }
     } else {
       if (((*TempStr  == '0') && (*(TempStr + 1) == '0') &&
+      if (((*TempStr  == '0') && (*(TempStr + 1) == '0') &&
           ((*(TempStr + 2) == ':') || (*(TempStr + 2) == '\0'))) ||
           ((*TempStr  == '0') && (*(TempStr + 1) == '0') && (*(TempStr + 2) == '0') &&
+          ((*TempStr  == '0') && (*(TempStr + 1) == '0') && (*(TempStr + 2) == '0') &&
           ((*(TempStr + 3) == ':') || (*(TempStr + 3) == '\0')))) {
         return EFI_INVALID_PARAMETER;
 …
     Cnt = 0;
     while ((TempStr[Cnt] != ':') && (TempStr[Cnt] != '\0')) {
       Cnt++;
+      Cnt++;
+    }
     if (LeadZeroCnt == 0) {
 …
         return EFI_INVALID_PARAMETER;
+      }
+    }
+    }
     Ip6Address->Addr[Index] = (UINT8) (NodeVal >> 8);
 …
   Convert one EFI_IPv6_ADDRESS to Null-terminated Unicode string.
   The text representation of address is defined in RFC 4291.
   @param[in]       Ip6Address     The pointer to the IPv6 address.
   @param[out]      String         The buffer to return the converted string.
   @param[in]       StringSize     The length in bytes of the input String.
   @retval EFI_SUCCESS             Convert to string successfully.
   @retval EFI_INVALID_PARAMETER   The input parameter is invalid.
   @retval EFI_BUFFER_TOO_SMALL    The BufferSize is too small for the result. BufferSize has been
+  @retval EFI_BUFFER_TOO_SMALL    The BufferSize is too small for the result. BufferSize has been
                                   updated with the size needed to complete the request.
 **/
 …
   //
   // Convert the UINT8 array to an UINT16 array for easy handling.
   //
+  //
   ZeroMem (Ip6Addr, sizeof (Ip6Addr));
   for (Index = 0; Index < 16; Index++) {
 …
+    }
+  }
   if (CurrentZerosStart != DEFAULT_ZERO_START && CurrentZerosLength > 2) {
     if (LongestZerosStart == DEFAULT_ZERO_START || LongestZerosLength < CurrentZerosLength) {
 …
     Ptr += UnicodeSPrint(Ptr, 10, L"%x", Ip6Addr[Index]);
+  }
   if (LongestZerosStart != DEFAULT_ZERO_START && LongestZerosStart + LongestZerosLength == 8) {
     *Ptr++ = L':';
 …
         return EFI_NOT_FOUND;
+      }
       //
       // SMBIOS tables are byte packed so we need to do a byte copy to
 …
     // to skip one SMBIOS structure.
     //
     //
     // Step 1: Skip over formatted section.
     //
     String = (CHAR8 *) (Smbios.Raw + Smbios.Hdr->Length);
     //
     // Step 2: Skip over unformated string section.
 …
         Smbios.Raw = (UINT8 *)++String;
         break;
+      }
+      }
     } while (TRUE);
   } while (Smbios.Raw < SmbiosEnd.Raw);

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf

-              r58459
+              r58466
 [Guids]
   ## SOMETIMES_PRODUCES ## UNDEFINED # HiiConstructConfigHdr EFI_NIC_IP4_CONFIG_VARIABLE
   ## UNDEFINED # Device Path Node
   gEfiNicIp4ConfigVariableGuid
+  ## UNDEFINED # Device Path Node
+  gEfiNicIp4ConfigVariableGuid
   gEfiSmbiosTableGuid                           ## SOMETIMES_CONSUMES  ## SystemTable

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeNetLib/NetBuffer.c

-              r48674
+              r58466
 /**
   The function frees the net buffer which allocated by the IP protocol. It releases
   only the net buffer and doesn't call the external free function.
   This function should be called after finishing the process of mIpSec->ProcessExt()
   for outbound traffic. The (EFI_IPSEC2_PROTOCOL)->ProcessExt() allocates a new
+  The function frees the net buffer which allocated by the IP protocol. It releases
+  only the net buffer and doesn't call the external free function.
+  This function should be called after finishing the process of mIpSec->ProcessExt()
+  for outbound traffic. The (EFI_IPSEC2_PROTOCOL)->ProcessExt() allocates a new
   buffer for the ESP, so there needs a function to free the old net buffer.
 …
   if (Nbuf->RefCnt == 0) {
     //
     // Update Vector only when NBuf is to be released. That is,
 …
     //
     // If NET_VECTOR_OWN_FIRST is set, release the first block since it is
+    // If NET_VECTOR_OWN_FIRST is set, release the first block since it is
     // allocated by us
     //
 …
+    }
     FreePool (Nbuf->Vector);
     FreePool (Nbuf);
+  }
+}
+    FreePool (Nbuf);
+  }
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxePerformanceLib/DxePerformanceLib.c

r58459	r58466
225	225	EFIAPI
226	226	GetPerformanceMeasurementEx (
227		IN UINTN LogEntryKey,
	227	IN UINTN LogEntryKey,
228	228	OUT CONST VOID **Handle,
229	229	OUT CONST CHAR8 **Token,

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxePerformanceLib/DxePerformanceLib.inf

-              r58459
+              r58466
 ## @file
 #  Performance library instance used in DXE phase.
+#
+#
 #  This library instance provides infrastructure for DXE phase drivers to log performance
 #  data. It consumes PerformanceEx or Performance Protocol published by DxeCorePerformanceLib
 #  to log performance data. If both PerformanceEx and Performance Protocol are not available,
 #  it does not log any performance information.
+#
+#
 #  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 …
 #  which accompanies this distribution.  The full text of the license may be found at
 #  http://opensource.org/licenses/bsd-license.php
+#
+#
 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#
 ##

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxePrintLibPrint2Protocol/PrintLib.c

-              r58459
+              r58466
   Instance of Print Library based on gEfiPrint2ProtocolGuid.
   Implement the print library instance by wrap the interface
+  Implement the print library instance by wrap the interface
   provided in the Print2 protocol. This protocol is defined as the internal
   protocol related to this implementation, not in the public spec. So, this
+  protocol related to this implementation, not in the public spec. So, this
   library instance is only for this code base.
 …
 /**
   The constructor function caches the pointer to Print2 protocol.
   The constructor function locates Print2 protocol from protocol database.
   It will ASSERT() if that operation fails and it will always return EFI_SUCCESS.
+  It will ASSERT() if that operation fails and it will always return EFI_SUCCESS.
   @param  ImageHandle   The firmware allocated handle for the EFI image.
   @param  SystemTable   A pointer to the EFI System Table.
   @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
 …
 /**
   Worker function that converts a VA_LIST to a BASE_LIST based on a Null-terminated
+  Worker function that converts a VA_LIST to a BASE_LIST based on a Null-terminated
   format string.
 …
         switch (FormatCharacter) {
         case '.':
         case '-':
         case '+':
         case ' ':
         case ',':
+        case '.':
+        case '-':
+        case '+':
+        case ' ':
+        case ',':
         case '0':
         case '1':
 …
           break;
         case 'L':
         case 'l':
+        case 'l':
           Long = TRUE;
           break;
 …
           //
           // Make no output if Format string terminates unexpectedly when
           // looking up for flag, width, precision and type.
+          // looking up for flag, width, precision and type.
           //
           Format -= BytesPerFormatCharacter;
 …
           break;
+        }
+      }
+      }
       //
       // Handle each argument type
 …
 /**
   Produces a Null-terminated Unicode string in an output buffer based on
+  Produces a Null-terminated Unicode string in an output buffer based on
   a Null-terminated Unicode format string and a VA_LIST argument list
   Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
   and BufferSize.
   The Unicode string is produced by parsing the format string specified by FormatString.
   Arguments are pulled from the variable argument list specified by Marker based on the
   contents of the format string.
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on the
+  contents of the format string.
   The number of Unicode characters in the produced output buffer is returned not including
   the Null-terminator.
 …
   If BufferSize > 1 and FormatString is NULL, then ASSERT().
   If BufferSize > 1 and FormatString is not aligned on a 16-bit boundary, then ASSERT().
   If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
   PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
   ASSERT().
 …
   Null-terminator, then ASSERT().
   @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
                           Unicode string.
   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
   @param  FormatString    Null-terminated Unicode format string.
   @param  Marker          VA_LIST marker for the variable argument list.
   @return The number of Unicode characters in the produced output buffer not including the
           Null-terminator.
 …
   DxePrintLibPrint2ProtocolVaListToBaseList (
     FALSE,
     (CHAR8 *)FormatString,
     Marker,
     (BASE_LIST)BaseListMarker,
+    FALSE,
+    (CHAR8 *)FormatString,
+    Marker,
+    (BASE_LIST)BaseListMarker,
     sizeof (BaseListMarker) - 8
     );
 …
 /**
   Produces a Null-terminated Unicode string in an output buffer based on
+  Produces a Null-terminated Unicode string in an output buffer based on
   a Null-terminated Unicode format string and a BASE_LIST argument list
   Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
   and BufferSize.
   The Unicode string is produced by parsing the format string specified by FormatString.
   Arguments are pulled from the variable argument list specified by Marker based on the
   contents of the format string.
+  and BufferSize.
+  The Unicode string is produced by parsing the format string specified by FormatString.
+  Arguments are pulled from the variable argument list specified by Marker based on the
+  contents of the format string.
   The number of Unicode characters in the produced output buffer is returned not including
   the Null-terminator.
 …
   If BufferSize > 1 and FormatString is NULL, then ASSERT().
   If BufferSize > 1 and FormatString is not aligned on a 16-bit boundary, then ASSERT().
   If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
   PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
   ASSERT().
 …
   Null-terminator, then ASSERT().
   @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
                           Unicode string.
   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
   @param  FormatString    Null-terminated Unicode format string.
   @param  Marker          BASE_LIST marker for the variable argument list.
   @return The number of Unicode characters in the produced output buffer not including the
           Null-terminator.
 …
 /**
   Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
+  Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
   Unicode format string and variable argument list.
   Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
   and BufferSize.
 …
   If BufferSize > 1 and FormatString is NULL, then ASSERT().
   If BufferSize > 1 and FormatString is not aligned on a 16-bit boundary, then ASSERT().
   If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
+  If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than
   PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then
   ASSERT().
 …
   Null-terminator, then ASSERT().
   @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
                           Unicode string.
   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
   @param  FormatString    Null-terminated Unicode format string.
   @param  ...             Variable argument list whose contents are accessed based on the
+  @param  ...             Variable argument list whose contents are accessed based on the
                           format string specified by FormatString.
 …
   Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
   ASCII format string and a VA_LIST argument list
   Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
   and BufferSize.
   The Unicode string is produced by parsing the format string specified by FormatString.
   Arguments are pulled from the variable argument list specified by Marker based on the
+  Arguments are pulled from the variable argument list specified by Marker based on the
   contents of the format string.
   The number of Unicode characters in the produced output buffer is returned not including
 …
   Null-terminator, then ASSERT().
   @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
                           Unicode string.
   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
   @param  FormatString    Null-terminated Unicode format string.
   @param  Marker          VA_LIST marker for the variable argument list.
   @return The number of Unicode characters in the produced output buffer not including the
           Null-terminator.
 …
   DxePrintLibPrint2ProtocolVaListToBaseList (
     TRUE,
     FormatString,
     Marker,
     (BASE_LIST)BaseListMarker,
+    TRUE,
+    FormatString,
+    Marker,
+    (BASE_LIST)BaseListMarker,
     sizeof (BaseListMarker) - 8
     );
 …
   Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
   ASCII format string and a BASE_LIST argument list
   Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
   and BufferSize.
   The Unicode string is produced by parsing the format string specified by FormatString.
   Arguments are pulled from the variable argument list specified by Marker based on the
+  Arguments are pulled from the variable argument list specified by Marker based on the
   contents of the format string.
   The number of Unicode characters in the produced output buffer is returned not including
 …
   Null-terminator, then ASSERT().
   @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
                           Unicode string.
   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
   @param  FormatString    Null-terminated Unicode format string.
   @param  Marker          BASE_LIST marker for the variable argument list.
   @return The number of Unicode characters in the produced output buffer not including the
           Null-terminator.
 …
 /**
   Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
+  Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated
   ASCII format string and  variable argument list.
   Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer
   and BufferSize.
   The Unicode string is produced by parsing the format string specified by FormatString.
   Arguments are pulled from the variable argument list based on the contents of the
+  Arguments are pulled from the variable argument list based on the contents of the
   format string.
   The number of Unicode characters in the produced output buffer is returned not including
 …
   Null-terminator, then ASSERT().
   @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
                           Unicode string.
   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
   @param  FormatString    Null-terminated Unicode format string.
   @param  ...             Variable argument list whose contents are accessed based on the
+  @param  ...             Variable argument list whose contents are accessed based on the
                           format string specified by FormatString.
   @return The number of Unicode characters in the produced output buffer not including the
           Null-terminator.
 …
 /**
   Converts a decimal value to a Null-terminated Unicode string.
   Converts the decimal number specified by Value to a Null-terminated Unicode
   string specified by Buffer containing at most Width characters. No padding of spaces
+  Converts the decimal number specified by Value to a Null-terminated Unicode
+  string specified by Buffer containing at most Width characters. No padding of spaces
   is ever performed. If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.
   The number of Unicode characters in Buffer is returned not including the Null-terminator.
   If the conversion contains more than Width characters, then only the first
   Width characters are returned, and the total number of characters
+  Width characters are returned, and the total number of characters
   required to perform the conversion is returned.
   Additional conversion parameters are specified in Flags.
+  Additional conversion parameters are specified in Flags.
   The Flags bit LEFT_JUSTIFY is always ignored.
   All conversions are left justified in Buffer.
 …
   If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
   are inserted every 3rd digit starting from the right.
   If RADIX_HEX is set in Flags, then the output buffer will be
+  If RADIX_HEX is set in Flags, then the output buffer will be
   formatted in hexadecimal format.
   If Value is < 0 and RADIX_HEX is not set in Flags, then the fist character in Buffer is a '-'.
   If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
   then Buffer is padded with '0' characters so the combination of the optional '-'
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
+  then Buffer is padded with '0' characters so the combination of the optional '-'
   sign character, '0' characters, digit characters for Value, and the Null-terminator
   add up to Width characters.
 …
   @param  Width   The maximum number of Unicode characters to place in Buffer, not including
                   the Null-terminator.
   @return The number of Unicode characters in Buffer not including the Null-terminator.
 …
   Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
   ASCII format string and a VA_LIST argument list.
   Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
   and BufferSize.
   The ASCII string is produced by parsing the format string specified by FormatString.
   Arguments are pulled from the variable argument list specified by Marker based on
+  Arguments are pulled from the variable argument list specified by Marker based on
   the contents of the format string.
   The number of ASCII characters in the produced output buffer is returned not including
 …
   Null-terminator, then ASSERT().
   @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
                           ASCII string.
   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
   @param  FormatString    Null-terminated Unicode format string.
   @param  Marker          VA_LIST marker for the variable argument list.
   @return The number of ASCII characters in the produced output buffer not including the
           Null-terminator.
 …
   DxePrintLibPrint2ProtocolVaListToBaseList (
     TRUE,
     FormatString,
     Marker,
     (BASE_LIST)BaseListMarker,
+    TRUE,
+    FormatString,
+    Marker,
+    (BASE_LIST)BaseListMarker,
     sizeof (BaseListMarker) - 8
     );
 …
   Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
   ASCII format string and a BASE_LIST argument list.
   Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
   and BufferSize.
   The ASCII string is produced by parsing the format string specified by FormatString.
   Arguments are pulled from the variable argument list specified by Marker based on
+  Arguments are pulled from the variable argument list specified by Marker based on
   the contents of the format string.
   The number of ASCII characters in the produced output buffer is returned not including
 …
   Null-terminator, then ASSERT().
   @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
                           ASCII string.
   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
   @param  FormatString    Null-terminated Unicode format string.
   @param  Marker          BASE_LIST marker for the variable argument list.
   @return The number of ASCII characters in the produced output buffer not including the
           Null-terminator.
 …
   Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
   ASCII format string and  variable argument list.
   Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
   and BufferSize.
   The ASCII string is produced by parsing the format string specified by FormatString.
   Arguments are pulled from the variable argument list based on the contents of the
+  Arguments are pulled from the variable argument list based on the contents of the
   format string.
   The number of ASCII characters in the produced output buffer is returned not including
 …
   Null-terminator, then ASSERT().
   @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
                           ASCII string.
   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
   @param  FormatString    Null-terminated Unicode format string.
   @param  ...             Variable argument list whose contents are accessed based on the
+  @param  ...             Variable argument list whose contents are accessed based on the
                           format string specified by FormatString.
 …
   Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
   ASCII format string and a VA_LIST argument list.
   Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
   and BufferSize.
   The ASCII string is produced by parsing the format string specified by FormatString.
   Arguments are pulled from the variable argument list specified by Marker based on
+  Arguments are pulled from the variable argument list specified by Marker based on
   the contents of the format string.
   The number of ASCII characters in the produced output buffer is returned not including
 …
   Null-terminator, then ASSERT().
   @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
                           ASCII string.
   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
   @param  FormatString    Null-terminated Unicode format string.
   @param  Marker          VA_LIST marker for the variable argument list.
   @return The number of ASCII characters in the produced output buffer not including the
           Null-terminator.
 …
   DxePrintLibPrint2ProtocolVaListToBaseList (
     FALSE,
     (CHAR8 *)FormatString,
     Marker,
     (BASE_LIST)BaseListMarker,
+    FALSE,
+    (CHAR8 *)FormatString,
+    Marker,
+    (BASE_LIST)BaseListMarker,
     sizeof (BaseListMarker) - 8
     );
 …
   Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
   ASCII format string and a BASE_LIST argument list.
   Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
   and BufferSize.
   The ASCII string is produced by parsing the format string specified by FormatString.
   Arguments are pulled from the variable argument list specified by Marker based on
+  Arguments are pulled from the variable argument list specified by Marker based on
   the contents of the format string.
   The number of ASCII characters in the produced output buffer is returned not including
 …
   Null-terminator, then ASSERT().
   @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
                           ASCII string.
   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
   @param  FormatString    Null-terminated Unicode format string.
   @param  Marker          BASE_LIST marker for the variable argument list.
   @return The number of ASCII characters in the produced output buffer not including the
           Null-terminator.
 …
   Produces a Null-terminated ASCII string in an output buffer based on a Null-terminated
   ASCII format string and  variable argument list.
   Produces a Null-terminated ASCII string in the output buffer specified by StartOfBuffer
   and BufferSize.
   The ASCII string is produced by parsing the format string specified by FormatString.
   Arguments are pulled from the variable argument list based on the contents of the
+  Arguments are pulled from the variable argument list based on the contents of the
   format string.
   The number of ASCII characters in the produced output buffer is returned not including
 …
   Null-terminator, then ASSERT().
   @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
+  @param  StartOfBuffer   A pointer to the output buffer for the produced Null-terminated
                           ASCII string.
   @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.
   @param  FormatString    Null-terminated Unicode format string.
   @param  ...             Variable argument list whose contents are accessed based on the
+  @param  ...             Variable argument list whose contents are accessed based on the
                           format string specified by FormatString.
 …
 /**
   Converts a decimal value to a Null-terminated ASCII string.
   Converts the decimal number specified by Value to a Null-terminated ASCII string
   specified by Buffer containing at most Width characters. No padding of spaces
+  Converts the decimal number specified by Value to a Null-terminated ASCII string
+  specified by Buffer containing at most Width characters. No padding of spaces
   is ever performed.
   If Width is 0 then a width of  MAXIMUM_VALUE_CHARACTERS is assumed.
 …
   characters are returned, and the total number of characters required to perform
   the conversion is returned.
   Additional conversion parameters are specified in Flags.
+  Additional conversion parameters are specified in Flags.
   The Flags bit LEFT_JUSTIFY is always ignored.
   All conversions are left justified in Buffer.
 …
   If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
   are inserted every 3rd digit starting from the right.
   If RADIX_HEX is set in Flags, then the output buffer will be
+  If RADIX_HEX is set in Flags, then the output buffer will be
   formatted in hexadecimal format.
   If Value is < 0 and RADIX_HEX is not set in Flags, then the fist character in Buffer is a '-'.
   If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
   then Buffer is padded with '0' characters so the combination of the optional '-'
+  If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
+  then Buffer is padded with '0' characters so the combination of the optional '-'
   sign character, '0' characters, digit characters for Value, and the Null-terminator
   add up to Width characters.
   If Buffer is NULL, then ASSERT().
   If unsupported bits are set in Flags, then ASSERT().
 …
   @param  Width   The maximum number of ASCII characters to place in Buffer, not including
                   the Null-terminator.
   @return The number of ASCII characters in Buffer not including the Null-terminator.
 …
 CHAR8 *
 InternalPrintLibValueToString (
   IN OUT CHAR8  *Buffer,
   IN INT64      Value,
+  IN OUT CHAR8  *Buffer,
+  IN INT64      Value,
   IN UINTN      Radix
+  )
 …
 /**
   Worker function that produces a Null-terminated string in an output buffer
+  Worker function that produces a Null-terminated string in an output buffer
   based on a Null-terminated format string and a VA_LIST argument list.
   VSPrint function to process format and place the results in Buffer. Since a
   VA_LIST is used this routine allows the nesting of Vararg routines. Thus
+  VSPrint function to process format and place the results in Buffer. Since a
+  VA_LIST is used this routine allows the nesting of Vararg routines. Thus
   this is the main print working routine.
   If COUNT_ONLY_NO_PRINT is set in Flags, Buffer will not be modified at all.
   @param[out] Buffer          The character buffer to print the results of the
+  @param[out] Buffer          The character buffer to print the results of the
                               parsing of Format into.
   @param[in]  BufferSize      The maximum number of characters to put into
+  @param[in]  BufferSize      The maximum number of characters to put into
                               buffer.
   @param[in]  Flags           Initial flags value.
                               Can only have FORMAT_UNICODE, OUTPUT_UNICODE,
+                              Can only have FORMAT_UNICODE, OUTPUT_UNICODE,
                               and COUNT_ONLY_NO_PRINT set.
   @param[in]  Format          A Null-terminated format string.
 …
 /**
   Worker function that produces a Null-terminated string in an output buffer
+  Worker function that produces a Null-terminated string in an output buffer
   based on a Null-terminated format string and variable argument list.
   VSPrint function to process format and place the results in Buffer. Since a
   VA_LIST is used this routine allows the nesting of Vararg routines. Thus
+  VSPrint function to process format and place the results in Buffer. Since a
+  VA_LIST is used this routine allows the nesting of Vararg routines. Thus
   this is the main print working routine
 …
   @param  Buffer      The buffer to place the Unicode or ASCII string.
   @param  EndBuffer   The end of the input Buffer. No characters will be
                       placed after that.
+                      placed after that.
   @param  Length      The count of character to be placed into Buffer.
                       (Negative value indicates no buffer fill.)
 …
+{
   INTN  Index;
   for (Index = 0; Index < Length && Buffer < EndBuffer; Index++) {
     *Buffer = (CHAR8) Character;
 …
 /**
   Worker function that produces a Null-terminated string in an output buffer
+  Worker function that produces a Null-terminated string in an output buffer
   based on a Null-terminated format string and a VA_LIST argument list.
   VSPrint function to process format and place the results in Buffer. Since a
   VA_LIST is used this routine allows the nesting of Vararg routines. Thus
+  VSPrint function to process format and place the results in Buffer. Since a
+  VA_LIST is used this routine allows the nesting of Vararg routines. Thus
   this is the main print working routine.
   If COUNT_ONLY_NO_PRINT is set in Flags, Buffer will not be modified at all.
   @param[out] Buffer          The character buffer to print the results of the
+  @param[out] Buffer          The character buffer to print the results of the
                               parsing of Format into.
   @param[in]  BufferSize      The maximum number of characters to put into
+  @param[in]  BufferSize      The maximum number of characters to put into
                               buffer.
   @param[in]  Flags           Initial flags value.
                               Can only have FORMAT_UNICODE, OUTPUT_UNICODE,
+                              Can only have FORMAT_UNICODE, OUTPUT_UNICODE,
                               and COUNT_ONLY_NO_PRINT set.
   @param[in]  Format          A Null-terminated format string.
 …
   //
   // If you change this code be sure to match the 2 versions of this function.
   // Nearly identical logic is found in the BasePrintLib and
+  // Nearly identical logic is found in the BasePrintLib and
   // DxePrintLibPrint2Protocol (both PrintLib instances).
   //
 …
     //
     // Make sure format string cannot contain more than PcdMaximumUnicodeStringLength
     // Unicode characters if PcdMaximumUnicodeStringLength is not zero.
+    // Unicode characters if PcdMaximumUnicodeStringLength is not zero.
     //
     ASSERT (StrSize ((CHAR16 *) Format) != 0);
 …
     //
     // Make sure format string cannot contain more than PcdMaximumAsciiStringLength
     // Ascii characters if PcdMaximumAsciiStringLength is not zero.
+    // Ascii characters if PcdMaximumAsciiStringLength is not zero.
     //
     ASSERT (AsciiStrSize (Format) != 0);
 …
         FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;
         switch (FormatCharacter) {
         case '.':
           Flags |= PRECISION;
+        case '.':
+          Flags |= PRECISION;
           break;
         case '-':
           Flags |= LEFT_JUSTIFY;
+        case '-':
+          Flags |= LEFT_JUSTIFY;
           break;
         case '+':
           Flags |= PREFIX_SIGN;
+        case '+':
+          Flags |= PREFIX_SIGN;
           break;
         case ' ':
           Flags |= PREFIX_BLANK;
+        case ' ':
+          Flags |= PREFIX_BLANK;
           break;
         case ',':
           Flags |= COMMA_TYPE;
+        case ',':
+          Flags |= COMMA_TYPE;
           break;
         case 'L':
         case 'l':
           Flags |= LONG_TYPE;
+        case 'l':
+          Flags |= LONG_TYPE;
           break;
         case '*':
 …
+          }
           break;
         case '\0':
           //
           // Make no output if Format string terminates unexpectedly when
           // looking up for flag, width, precision and type.
+          // looking up for flag, width, precision and type.
           //
           Format   -= BytesPerFormatCharacter;
 …
           break;
+        }
+      }
+      }
       //
 …
           // 'd','x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int".
           // This assumption is made so the format string definition is compatible with the ANSI C
           // Specification for formatted strings.  It is recommended that the Base Types be used
           // everywhere, but in this one case, compliance with ANSI C is more important, and
           // provides an implementation that is compatible with that largest possible set of CPU
+          // Specification for formatted strings.  It is recommended that the Base Types be used
+          // everywhere, but in this one case, compliance with ANSI C is more important, and
+          // provides an implementation that is compatible with that largest possible set of CPU
           // architectures.  This is why the type "int" is used in this one case.
           //
 …
             // 'd','x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int".
             // This assumption is made so the format string definition is compatible with the ANSI C
             // Specification for formatted strings.  It is recommended that the Base Types be used
             // everywhere, but in this one case, compliance with ANSI C is more important, and
             // provides an implementation that is compatible with that largest possible set of CPU
+            // Specification for formatted strings.  It is recommended that the Base Types be used
+            // everywhere, but in this one case, compliance with ANSI C is more important, and
+            // provides an implementation that is compatible with that largest possible set of CPU
             // architectures.  This is why the type "unsigned int" is used in this one case.
             //
 …
+        }
         ArgumentString = (CHAR8 *)ValueBuffer + Count;
         Digits = Count % 3;
         if (Digits != 0) {
 …
           InternalPrintLibSPrint (
             ValueBuffer,
             MAXIMUM_VALUE_CHARACTERS,
+            MAXIMUM_VALUE_CHARACTERS,
 ,
             "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 …
       case 't':
         if (BaseListMarker == NULL) {
           TmpTime = VA_ARG (VaListMarker, TIME *);
+          TmpTime = VA_ARG (VaListMarker, TIME *);
         } else {
           TmpTime = BASE_ARG (BaseListMarker, TIME *);
+          TmpTime = BASE_ARG (BaseListMarker, TIME *);
+        }
         if (TmpTime == NULL) {
 …
+      }
       break;
     case '\r':
       Format += BytesPerFormatCharacter;
 …
   //
   // Make sure output buffer cannot contain more than PcdMaximumUnicodeStringLength
   // Unicode characters if PcdMaximumUnicodeStringLength is not zero.
+  // Unicode characters if PcdMaximumUnicodeStringLength is not zero.
   //
   ASSERT ((((Flags & OUTPUT_UNICODE) == 0)) || (StrSize ((CHAR16 *) OriginalBuffer) != 0));
   //
   // Make sure output buffer cannot contain more than PcdMaximumAsciiStringLength
   // ASCII characters if PcdMaximumAsciiStringLength is not zero.
+  // ASCII characters if PcdMaximumAsciiStringLength is not zero.
   //
   ASSERT ((((Flags & OUTPUT_UNICODE) != 0)) || (AsciiStrSize (OriginalBuffer) != 0));
 …
 /**
   Returns the number of characters that would be produced by if the formatted
+  Returns the number of characters that would be produced by if the formatted
   output were produced not including the Null-terminator.
 …
   @param[in]  Marker          VA_LIST marker for the variable argument list.
   @return The number of characters that would be produced, not including the
+  @return The number of characters that would be produced, not including the
           Null-terminator.
 **/
 …
 /**
   Returns the number of characters that would be produced by if the formatted
+  Returns the number of characters that would be produced by if the formatted
   output were produced not including the Null-terminator.
 …
   @param[in]  Marker          VA_LIST marker for the variable argument list.
   @return The number of characters that would be produced, not including the
+  @return The number of characters that would be produced, not including the
           Null-terminator.
 **/

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeReportStatusCodeLib/ReportStatusCodeLib.c

-              r48674
+              r58466
     return mReportStatusCodeLibStatusCodeProtocol->ReportStatusCode (Type, Value, Instance, (EFI_GUID *)CallerId, Data);
+  }
   return EFI_UNSUPPORTED;
+}
 …
   Tpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);
   gBS->RestoreTPL (Tpl);
   StatusCodeData = NULL;
   if (Tpl <= TPL_NOTIFY) {

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeSecurityManagementLib/DxeSecurityManagementLib.c

-              r58459
+              r58466
   //
   mSecurityTable = ReallocatePool (
                      mMaxNumberOfSecurityHandler * sizeof (SECURITY_INFO),
                      (mMaxNumberOfSecurityHandler + SECURITY_HANDLER_TABLE_SIZE) * sizeof (SECURITY_INFO),
+                     mMaxNumberOfSecurityHandler * sizeof (SECURITY_INFO),
+                     (mMaxNumberOfSecurityHandler + SECURITY_HANDLER_TABLE_SIZE) * sizeof (SECURITY_INFO),
                      mSecurityTable
                      );
 …
 /**
  Check whether an operation is valid according to the requirement of current operation,
+ Check whether an operation is valid according to the requirement of current operation,
  which must make sure that the measure image operation is the last one.
 …
   IN  UINT32    CheckAuthOperation
+  )
+{
+{
   //
   // Make sure new auth operation can be recognized.
   //
   ASSERT ((CheckAuthOperation & ~(EFI_AUTH_IMAGE_OPERATION_MASK | EFI_AUTH_OPERATION_AUTHENTICATION_STATE | EFI_AUTH_OPERATION_IMAGE_REQUIRED)) == 0);
   //
   // When current operation includes measure image operation,
+  //
+  // When current operation includes measure image operation,
   // only another measure image operation or none operation will be allowed.
   //
 …
+    }
+  }
   //
   // When current operation doesn't include measure image operation,
+  //
+  // When current operation doesn't include measure image operation,
   // any new operation will be allowed.
   //
 …
   If none of the handlers return an error, then EFI_SUCCESS is returned.
   Before exectue handler, get the image buffer by file device path if a handler
+  Before exectue handler, get the image buffer by file device path if a handler
   requires the image file. And return the image buffer to each handler when exectue handler.
   The handlers are executed in same order to their registered order.
   @param[in]  AuthenticationStatus
+  @param[in]  AuthenticationStatus
                            This is the authentication type returned from the Section
                            Extraction protocol. See the Section Extraction Protocol
 …
   @retval EFI_SUCCESS            The file specified by File did authenticate when more
                                  than one security handler services were registered,
                                  or the file did not authenticate when no security
                                  handler service was registered. And the platform policy
+                                 than one security handler services were registered,
+                                 or the file did not authenticate when no security
+                                 handler service was registered. And the platform policy
                                  dictates that the DXE Core may use File.
   @retval EFI_INVALID_PARAMETER  File is NULL.
 …
   VOID          *FileBuffer;
   UINTN         FileSize;
   if (FilePath == NULL) {
     return EFI_INVALID_PARAMETER;
 …
     return EFI_SUCCESS;
+  }
   Status                      = EFI_SUCCESS;
   FileBuffer                  = NULL;
 …
   //
   mSecurity2Table = ReallocatePool (
                      mMaxNumberOfSecurity2Handler * sizeof (SECURITY2_INFO),
                      (mMaxNumberOfSecurity2Handler + SECURITY_HANDLER_TABLE_SIZE) * sizeof (SECURITY2_INFO),
+                     mMaxNumberOfSecurity2Handler * sizeof (SECURITY2_INFO),
+                     (mMaxNumberOfSecurity2Handler + SECURITY_HANDLER_TABLE_SIZE) * sizeof (SECURITY2_INFO),
                      mSecurity2Table
                      );
 …
 /**
   Check whether an operation is valid according to the requirement of current operation,
+  Check whether an operation is valid according to the requirement of current operation,
   which must make sure that the measure image operation is the last one.
   If AuthenticationOperation is not recongnized, return FALSE.
   If AuthenticationOperation is EFI_AUTH_OPERATION_NONE, return FALSE.
   If AuthenticationOperation includes security operation and authentication operation, return FALSE.
   If the previous register handler can't be executed before the later register handler, return FALSE.
   @param CurrentAuthOperation  Current operation.
   @param CheckAuthOperation    Operation to be checked.
   @retval  TRUE   Operation is valid for current operation.
   @retval  FALSE  Operation is invalid for current operation.
 …
   IN  UINT32    CheckAuthOperation
+  )
+{
+{
   //
   // Make sure new auth operation can be recognized.
 …
     return FALSE;
+  }
   if ((CheckAuthOperation & ~(EFI_AUTH_IMAGE_OPERATION_MASK |
                               EFI_AUTH_NONE_IMAGE_OPERATION_MASK |
+  if ((CheckAuthOperation & ~(EFI_AUTH_IMAGE_OPERATION_MASK |
+                              EFI_AUTH_NONE_IMAGE_OPERATION_MASK |
                               EFI_AUTH_OPERATION_IMAGE_REQUIRED)) != 0) {
     return FALSE;
 …
   //
   // When current operation includes measure image operation,
+  // When current operation includes measure image operation,
   // only another measure image or none image operation will be allowed.
   //
 …
+    }
+  }
   //
   // Any other operation will be allowed.
 …
 /**
   Execute registered handlers based on input AuthenticationOperation until
   one returns an error and that error is returned.
+  Execute registered handlers based on input AuthenticationOperation until
+  one returns an error and that error is returned.
   If none of the handlers return an error, then EFI_SUCCESS is returned.
   The handlers those satisfy AuthenticationOperation will only be executed.
   The handlers are executed in same order to their registered order.
   @param[in]  AuthenticationOperation
+  @param[in]  AuthenticationOperation
                            The operation type specifies which handlers will be executed.
   @param[in]  AuthenticationStatus
+  @param[in]  AuthenticationStatus
                            The authentication status for the input file.
   @param[in]  File         This is a pointer to the device path of the file that is
 …
                                   UEFI device drivers on the device path specified by DevicePath.
   @retval EFI_SECURITY_VIOLATION  The file specified by File or FileBuffer did not
                                   authenticate, and the platform policy dictates that
+                                  authenticate, and the platform policy dictates that
                                   the file should be placed in the untrusted state.
   @retval EFI_SECURITY_VIOLATION  FileBuffer FileBuffer is NULL and the user has no
 …
                                   the platform policy dictates that the DXE
                                   Foundation may not use File.
   @retval EFI_INVALID_PARAMETER   File and FileBuffer are both NULL.
+  @retval EFI_INVALID_PARAMETER   File and FileBuffer are both NULL.
 **/
 EFI_STATUS

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeSecurityManagementLib/DxeSecurityManagementLib.inf

-              r58459
+              r58466
   MODULE_TYPE                    = DXE_DRIVER
   VERSION_STRING                 = 1.0
   LIBRARY_CLASS                  = SecurityManagementLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
+  LIBRARY_CLASS                  = SecurityManagementLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
+#
 …
   DebugLib
   DxeServicesLib

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeSmmPerformanceLib/DxeSmmPerformanceLib.c

-              r58459
+              r58466
   //
   // Initialize communicate buffer
+  // Initialize communicate buffer
   //
   SmmCommBufferHeader = (EFI_SMM_COMMUNICATE_HEADER *)mSmmPerformanceBuffer;
   SmmPerfCommData = (SMM_PERF_COMMUNICATE *)SmmCommBufferHeader->Data;
   ZeroMem((UINT8*)SmmPerfCommData, sizeof(SMM_PERF_COMMUNICATE));
   CopyGuid (&SmmCommBufferHeader->HeaderGuid, &gSmmPerformanceProtocolGuid);
   SmmCommBufferHeader->MessageLength = sizeof(SMM_PERF_COMMUNICATE);
 …
   mGaugeNumberOfEntries = SmmPerfCommData->NumberOfEntries;
   DataSize = mGaugeNumberOfEntries * sizeof(GAUGE_DATA_ENTRY);
   mGaugeData = AllocateZeroPool(DataSize);
   ASSERT (mGaugeData != NULL);
   //
   // Get all SMM gauge data
   //
+  //
   SmmPerfCommData->Function = SMM_PERF_FUNCTION_GET_GAUGE_DATA;
   SmmPerfCommData->LogEntryKey = 0;
 …
   //
   // Initialize communicate buffer
+  // Initialize communicate buffer
   //
   SmmCommBufferHeader = (EFI_SMM_COMMUNICATE_HEADER *)mSmmPerformanceBuffer;
   SmmPerfCommData = (SMM_PERF_COMMUNICATE_EX *)SmmCommBufferHeader->Data;
   ZeroMem((UINT8*)SmmPerfCommData, sizeof(SMM_PERF_COMMUNICATE_EX));
   CopyGuid (&SmmCommBufferHeader->HeaderGuid, &gSmmPerformanceExProtocolGuid);
   SmmCommBufferHeader->MessageLength = sizeof(SMM_PERF_COMMUNICATE_EX);
 …
   mGaugeNumberOfEntriesEx = SmmPerfCommData->NumberOfEntries;
   DataSize = mGaugeNumberOfEntriesEx * sizeof(GAUGE_DATA_ENTRY_EX);
   mGaugeDataEx = AllocateZeroPool(DataSize);
   ASSERT (mGaugeDataEx != NULL);
   //
   // Get all SMM gauge data
   //
+  //
   SmmPerfCommData->Function = SMM_PERF_FUNCTION_GET_GAUGE_DATA;
   SmmPerfCommData->LogEntryKey = 0;
 …
     mGaugeNumberOfEntriesEx = 0;
+  }
   return mGaugeDataEx;
+}
 …
 EFIAPI
 GetPerformanceMeasurementEx (
   IN  UINTN       LogEntryKey,
+  IN  UINTN       LogEntryKey,
   OUT CONST VOID  **Handle,
   OUT CONST CHAR8 **Token,

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeSmmPerformanceLib/DxeSmmPerformanceLib.inf

-              r58459
+              r58466
 ## @file
 #  Performance library instance used in DXE phase to dump SMM performance data.
+#
+#
 #  This library instance allows a DXE driver or UEFI application to dump the SMM performance data.
 #  StartPerformanceMeasurement(), EndPerformanceMeasurement(), StartPerformanceMeasurementEx()
 #  and EndPerformanceMeasurementEx() are not implemented.
+#
+#
 #  Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 …
 #  which accompanies this distribution.  The full text of the license may be found at
 #  http://opensource.org/licenses/bsd-license.php
+#
+#
 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#
 ##

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeTcpIoLib/DxeTcpIoLib.c

-              r48674
+              r58466
 /**
   The common notify function associated with various TcpIo events.
+  The common notify function associated with various TcpIo events.
   @param[in]  Event   The event signaled.
 …
 /**
   Create a TCP socket with the specified configuration data.
+  Create a TCP socket with the specified configuration data.
   @param[in]  Image      The handle of the driver image.
 …
   @param[in]  ConfigData The Tcp configuration data.
   @param[out] TcpIo      The TcpIo.
   @retval EFI_SUCCESS            The TCP socket is created and configured.
   @retval EFI_INVALID_PARAMETER  One or more parameters are invalid.
 …
   //
   // Create the TCP child instance and get the TCP protocol.
   //
+  //
   Status = NetLibCreateServiceChild (
              Controller,
 …
   return Status;
+}
 /**
   Destroy the socket.
+  Destroy the socket.
   @param[in]  TcpIo The TcpIo which wraps the socket to be destroyed.
 …
   @param[in, out]  TcpIo     The TcpIo wrapping the TCP socket.
   @param[in]       Timeout   The time to wait for connection done.
   @retval EFI_SUCCESS            Connect to the other endpoint of the TCP socket
                                  successfully.
 …
   @param[in]       Timeout   The time to wait for connection done.
   @retval EFI_SUCCESS            Connect to the other endpoint of the TCP socket
                                  successfully.
 …
   @retval EFI_TIMEOUT            Failed to connect to the other endpoint of the
                                  TCP socket in the specified time period.
+                                 TCP socket in the specified time period.
   @retval Others                 Other errors as indicated.
 …
   //
   // The new TCP instance handle created for the established connection is
+  // The new TCP instance handle created for the established connection is
   // in ListenToken.
   //
 …
       ProtocolGuid = &gEfiTcp6ProtocolGuid;
+    }
     Status = gBS->OpenProtocol (
                     TcpIo->ListenToken.Tcp4Token.NewChildHandle,
 …
   Tcp6               = NULL;
   if (TcpIo->TcpVersion == TCP_VERSION_4) {
+  if (TcpIo->TcpVersion == TCP_VERSION_4) {
     TcpIo->CloseToken.Tcp4Token.AbortOnClose = TRUE;
     Tcp4 = TcpIo->Tcp.Tcp4;
 …
+}
 /**
   Transmit the Packet to the other endpoint of the socket.
 …
   @param[in]   TcpIo           The TcpIo wrapping the TCP socket.
   @param[in]   Packet          The packet to transmit.
   @retval EFI_SUCCESS            The packet is trasmitted.
   @retval EFI_INVALID_PARAMETER  One or more parameters are invalid.
 …
   if (TcpIo->TcpVersion == TCP_VERSION_4) {
     Size = sizeof (EFI_TCP4_TRANSMIT_DATA) +
+    Size = sizeof (EFI_TCP4_TRANSMIT_DATA) +
            (Packet->BlockOpNum - 1) * sizeof (EFI_TCP4_FRAGMENT_DATA);
   } else if (TcpIo->TcpVersion == TCP_VERSION_6) {
 …
       goto ON_EXIT;
+    }
     Status  = Tcp4->Transmit (Tcp4, &TcpIo->TxToken.Tcp4Token);
   } else {
 …
     if (Tcp6 == NULL) {
       return EFI_DEVICE_ERROR;
+      return EFI_DEVICE_ERROR;
+    }
 …
       Status = Tcp6->Receive (Tcp6, &TcpIo->RxToken.Tcp6Token);
+    }
     if (EFI_ERROR (Status)) {
       goto ON_EXIT;
+    }
     while (!TcpIo->IsRxDone && ((Timeout == NULL) || EFI_ERROR (gBS->CheckEvent (Timeout)))) {
       //

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeTcpIoLib/DxeTcpIoLib.inf

r58459	r58466
1	1	## @file
2	2	# This library instance provides TCP services by EFI TCPv4/TCPv6 Protocols.
3		#
	3	#
4	4	# Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
5	5	# This program and the accompanying materials

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.inf

r58459	r58466
1	1	## @file
2	2	# This library instance provides UDP services by consuming EFI UDPv4/UDPv6 Protocols.
3		#
	3	#
4	4	# Copyright (c) 2008 - 2014, Intel Corporation. All rights reserved.<BR>
5	5	# This program and the accompanying materials

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/LockBoxNullLib/LockBoxNullLib.c

r48674	r58466
104	104	@retval RETURN_SUCCESS the information is restored successfully.
105	105	@retval RETURN_INVALID_PARAMETER the Guid is NULL, or one of Buffer and Length is NULL.
106		@retval RETURN_WRITE_PROTECTED Buffer and Length are NULL, but the LockBox has no
	106	@retval RETURN_WRITE_PROTECTED Buffer and Length are NULL, but the LockBox has no
107	107	LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE attribute.
108	108	@retval RETURN_BUFFER_TOO_SMALL the Length is too small to hold the confidential information.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/LockBoxNullLib/LockBoxNullLib.inf

r58459	r58466
28	28	# The following information is for reference only and not required by the build tools.
29	29	#
30		# VALID_ARCHITECTURES = IA32 X64
	30	# VALID_ARCHITECTURES = IA32 X64
31	31	#
32	32

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/LzmaCustomDecompressLib/F86GuidedSectionExtraction.c

-              r58464
+              r58466
 /** @file
   LZMA Decompress GUIDed Section Extraction Library, which produces LZMA custom
+  LZMA Decompress GUIDed Section Extraction Library, which produces LZMA custom
   decompression algorithm with the converter for the different arch code.
   It wraps Lzma decompress interfaces to GUIDed Section Extraction interfaces
 …
   size of an scratch buffer required to actually decode the data in a GUIDed section.
   Examines a GUIDed section specified by InputSection.
+  Examines a GUIDed section specified by InputSection.
   If GUID for InputSection does not match the GUID that this handler supports,
   then RETURN_UNSUPPORTED is returned.
+  then RETURN_UNSUPPORTED is returned.
   If the required information can not be retrieved from InputSection,
   then RETURN_INVALID_PARAMETER is returned.
 …
   the size of an optional scratch buffer is returned in ScratchSize, and the Attributes field
   from EFI_GUID_DEFINED_SECTION header of InputSection is returned in SectionAttribute.
   If InputSection is NULL, then ASSERT().
   If OutputBufferSize is NULL, then ASSERT().
 …
 /**
   Decompress a LZAM compressed GUIDed section into a caller allocated output buffer.
   Decodes the GUIDed section specified by InputSection.
   If GUID for InputSection does not match the GUID that this handler supports, then RETURN_UNSUPPORTED is returned.
+  Decodes the GUIDed section specified by InputSection.
+  If GUID for InputSection does not match the GUID that this handler supports, then RETURN_UNSUPPORTED is returned.
   If the data in InputSection can not be decoded, then RETURN_INVALID_PARAMETER is returned.
   If the GUID of InputSection does match the GUID that this handler supports, then InputSection
 …
   data in InputSection, then OutputBuffer is set to point at the data in InputSection.  Otherwise,
   the decoded data will be placed in caller allocated buffer specified by OutputBuffer.
   If InputSection is NULL, then ASSERT().
   If OutputBuffer is NULL, then ASSERT().
 …
   @param[in]  InputSection  A pointer to a GUIDed section of an FFS formatted file.
   @param[out] OutputBuffer  A pointer to a buffer that contains the result of a decode operation.
+  @param[out] OutputBuffer  A pointer to a buffer that contains the result of a decode operation.
   @param[out] ScratchBuffer A caller allocated buffer that may be required by this function
                             as a scratch buffer to perform the decode operation.
   @param[out] AuthenticationStatus
+                            as a scratch buffer to perform the decode operation.
+  @param[out] AuthenticationStatus
                             A pointer to the authentication status of the decoded output buffer.
                             See the definition of authentication status in the EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI
 …
   UINT32            OutputBufferSize;
   UINT32            ScratchBufferSize;
   ASSERT (OutputBuffer != NULL);
   ASSERT (InputSection != NULL);
 …
   //
   // After decompress, the data need to be converted to the raw data.
+  // After decompress, the data need to be converted to the raw data.
   //
   if (!EFI_ERROR (Status)) {
 …
              &ScratchBufferSize
              );
     if (!EFI_ERROR (Status)) {
       x86_Convert_Init(X86State);
 …
+    }
+  }
   return Status;
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/LzmaCustomDecompressLib/GuidedSectionExtraction.c

-              r58464
+              r58466
   size of an scratch buffer required to actually decode the data in a GUIDed section.
   Examines a GUIDed section specified by InputSection.
+  Examines a GUIDed section specified by InputSection.
   If GUID for InputSection does not match the GUID that this handler supports,
   then RETURN_UNSUPPORTED is returned.
+  then RETURN_UNSUPPORTED is returned.
   If the required information can not be retrieved from InputSection,
   then RETURN_INVALID_PARAMETER is returned.
 …
   the size of an optional scratch buffer is returned in ScratchSize, and the Attributes field
   from EFI_GUID_DEFINED_SECTION header of InputSection is returned in SectionAttribute.
   If InputSection is NULL, then ASSERT().
   If OutputBufferSize is NULL, then ASSERT().
 …
 /**
   Decompress a LZAM compressed GUIDed section into a caller allocated output buffer.
   Decodes the GUIDed section specified by InputSection.
   If GUID for InputSection does not match the GUID that this handler supports, then RETURN_UNSUPPORTED is returned.
+  Decodes the GUIDed section specified by InputSection.
+  If GUID for InputSection does not match the GUID that this handler supports, then RETURN_UNSUPPORTED is returned.
   If the data in InputSection can not be decoded, then RETURN_INVALID_PARAMETER is returned.
   If the GUID of InputSection does match the GUID that this handler supports, then InputSection
 …
   data in InputSection, then OutputBuffer is set to point at the data in InputSection.  Otherwise,
   the decoded data will be placed in caller allocated buffer specified by OutputBuffer.
   If InputSection is NULL, then ASSERT().
   If OutputBuffer is NULL, then ASSERT().
 …
   @param[in]  InputSection  A pointer to a GUIDed section of an FFS formatted file.
   @param[out] OutputBuffer  A pointer to a buffer that contains the result of a decode operation.
+  @param[out] OutputBuffer  A pointer to a buffer that contains the result of a decode operation.
   @param[out] ScratchBuffer A caller allocated buffer that may be required by this function
                             as a scratch buffer to perform the decode operation.
   @param[out] AuthenticationStatus
+                            as a scratch buffer to perform the decode operation.
+  @param[out] AuthenticationStatus
                             A pointer to the authentication status of the decoded output buffer.
                             See the definition of authentication status in the EFI_PEI_GUIDED_SECTION_EXTRACTION_PPI
 …
           LzmaGuidedSectionGetInfo,
           LzmaGuidedSectionExtraction
           );
+          );
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/LzmaCustomDecompressLib/LzmaArchCustomDecompressLib.inf

r58464	r58466
44	44	Sdk/C/LzHash.h
45	45	Sdk/C/LzmaDec.h
46		Sdk/C/Types.h
	46	Sdk/C/Types.h
47	47	UefiLzma.h
48	48	LzmaDecompressLibInternal.h

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/LzmaCustomDecompressLib/LzmaCustomDecompressLib.inf

r58464	r58466
43	43	Sdk/C/LzHash.h
44	44	Sdk/C/LzmaDec.h
45		Sdk/C/Types.h
	45	Sdk/C/Types.h
46	46	GuidedSectionExtraction.c
47	47	UefiLzma.h

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/LzmaCustomDecompressLib/LzmaDecompress.c

-              r58464
+              r58466
 /**
   Given a Lzma compressed source buffer, this function retrieves the size of
   the uncompressed buffer and the size of the scratch buffer required
+  Given a Lzma compressed source buffer, this function retrieves the size of
+  the uncompressed buffer and the size of the scratch buffer required
   to decompress the compressed source buffer.
   Retrieves the size of the uncompressed buffer and the temporary scratch buffer
+  Retrieves the size of the uncompressed buffer and the temporary scratch buffer
   required to decompress the buffer specified by Source and SourceSize.
   The size of the uncompressed buffer is returned in DestinationSize,
+  The size of the uncompressed buffer is returned in DestinationSize,
   the size of the scratch buffer is returned in ScratchSize, and RETURN_SUCCESS is returned.
   This function does not have scratch buffer available to perform a thorough
+  This function does not have scratch buffer available to perform a thorough
   checking of the validity of the source data. It just retrieves the "Original Size"
   field from the LZMA_HEADER_SIZE beginning bytes of the source data and output it as DestinationSize.
 …
                           by Source and SourceSize is decompressed.
   @param  ScratchSize     A pointer to the size, in bytes, of the scratch buffer that
                           is required to decompress the compressed buffer specified
+                          is required to decompress the compressed buffer specified
                           by Source and SourceSize.
   @retval  RETURN_SUCCESS The size of the uncompressed data was returned
                           in DestinationSize and the size of the scratch
+  @retval  RETURN_SUCCESS The size of the uncompressed data was returned
+                          in DestinationSize and the size of the scratch
                           buffer was returned in ScratchSize.
 …
   Extracts decompressed data to its original form.
   If the compressed source data specified by Source is successfully decompressed
   into Destination, then RETURN_SUCCESS is returned.  If the compressed source data
+  If the compressed source data specified by Source is successfully decompressed
+  into Destination, then RETURN_SUCCESS is returned.  If the compressed source data
   specified by Source is not in a valid compressed data format,
   then RETURN_INVALID_PARAMETER is returned.
 …
   @param  Destination The destination buffer to store the decompressed data
   @param  Scratch     A temporary scratch buffer that is used to perform the decompression.
                       This is an optional parameter that may be NULL if the
+                      This is an optional parameter that may be NULL if the
                       required scratch buffer size is 0.
   @retval  RETURN_SUCCESS Decompression completed successfully, and
+  @retval  RETURN_SUCCESS Decompression completed successfully, and
                           the uncompressed buffer is returned in Destination.
   @retval  RETURN_INVALID_PARAMETER
                           The source buffer specified by Source is corrupted
+  @retval  RETURN_INVALID_PARAMETER
+                          The source buffer specified by Source is corrupted
                           (not in a valid compressed format).
 **/
 …
   AllocFuncs.Buffer           = Scratch;
   AllocFuncs.BufferSize       = SCRATCH_BUFFER_REQUEST_SIZE;
   DecodedBufSize = (SizeT)GetDecodedSizeOfBuf((UINT8*)Source);
   EncodedDataSize = (SizeT) (SourceSize - LZMA_HEADER_SIZE);

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/LzmaCustomDecompressLib/LzmaDecompressLibInternal.h

-              r58464
+              r58466
 /**
   Given a Lzma compressed source buffer, this function retrieves the size of
   the uncompressed buffer and the size of the scratch buffer required
+  Given a Lzma compressed source buffer, this function retrieves the size of
+  the uncompressed buffer and the size of the scratch buffer required
   to decompress the compressed source buffer.
   Retrieves the size of the uncompressed buffer and the temporary scratch buffer
+  Retrieves the size of the uncompressed buffer and the temporary scratch buffer
   required to decompress the buffer specified by Source and SourceSize.
   The size of the uncompressed buffer is returned in DestinationSize,
+  The size of the uncompressed buffer is returned in DestinationSize,
   the size of the scratch buffer is returned in ScratchSize, and RETURN_SUCCESS is returned.
   This function does not have scratch buffer available to perform a thorough
+  This function does not have scratch buffer available to perform a thorough
   checking of the validity of the source data. It just retrieves the "Original Size"
   field from the LZMA_HEADER_SIZE beginning bytes of the source data and output it as DestinationSize.
 …
                           by Source and SourceSize is decompressed.
   @param  ScratchSize     A pointer to the size, in bytes, of the scratch buffer that
                           is required to decompress the compressed buffer specified
+                          is required to decompress the compressed buffer specified
                           by Source and SourceSize.
   @retval  RETURN_SUCCESS The size of the uncompressed data was returned
                           in DestinationSize and the size of the scratch
+  @retval  RETURN_SUCCESS The size of the uncompressed data was returned
+                          in DestinationSize and the size of the scratch
                           buffer was returned in ScratchSize.
 …
   Extracts decompressed data to its original form.
   If the compressed source data specified by Source is successfully decompressed
   into Destination, then RETURN_SUCCESS is returned.  If the compressed source data
+  If the compressed source data specified by Source is successfully decompressed
+  into Destination, then RETURN_SUCCESS is returned.  If the compressed source data
   specified by Source is not in a valid compressed data format,
   then RETURN_INVALID_PARAMETER is returned.
 …
   @param  Destination The destination buffer to store the decompressed data
   @param  Scratch     A temporary scratch buffer that is used to perform the decompression.
                       This is an optional parameter that may be NULL if the
+                      This is an optional parameter that may be NULL if the
                       required scratch buffer size is 0.
   @retval  RETURN_SUCCESS Decompression completed successfully, and
+  @retval  RETURN_SUCCESS Decompression completed successfully, and
                           the uncompressed buffer is returned in Destination.
   @retval  RETURN_INVALID_PARAMETER
                           The source buffer specified by Source is corrupted
+  @retval  RETURN_INVALID_PARAMETER
+                          The source buffer specified by Source is corrupted
                           (not in a valid compressed format).
 **/

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/Bra.h

-              r58464
+              r58466
 These functions convert relative addresses to absolute addresses
 in CALL instructions to increase the compression ratio.
   In:
     data     - data buffer
 …
     state    - state variable for x86 converter
     encoding - 0 (for decoding), 1 (for encoding)
   Out:
     state    - state variable for x86 converter
 …
     The number of processed bytes. If you call these functions with multiple calls,
     you must start next call with first byte after block of processed bytes.
   Type   Endian  Alignment  LookAhead
   x86    little      1          4
   ARMT   little      2          2

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzFind.c

-              r58464
+              r58466
   delta2 = p->pos - p->hash[hash2Value];
   curMatch = p->hash[kFix3HashSize + hashValue];
   p->hash[hash2Value] =
   p->hash[kFix3HashSize + hashValue] = p->pos;
 …
   delta3 = p->pos - p->hash[kFix3HashSize + hash3Value];
   curMatch = p->hash[kFix4HashSize + hashValue];
   p->hash[                hash2Value] =
   p->hash[kFix3HashSize + hash3Value] =

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.c

-              r58464
+              r58466
   SizeT dicBufSize = p->dicBufSize;
   SizeT dicPos = p->dicPos;
   UInt32 processedPos = p->processedPos;
   UInt32 checkDicSize = p->checkDicSize;
 …
               NORMALIZE
               range >>= 1;
+              {
                 UInt32 t;
 …
   (*srcLen) = 0;
   LzmaDec_WriteRem(p, dicLimit);
   *status = LZMA_STATUS_NOT_SPECIFIED;
 …
       if (p->needInitState)
         LzmaDec_InitStateReal(p);
       if (p->tempBufSize == 0)
+      {
 …
   UInt32 dicSize;
   Byte d;
   if (size < LZMA_PROPS_SIZE)
     return SZ_ERROR_UNSUPPORTED;
   else
     dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24);
   if (dicSize < LZMA_DIC_MIN)
     dicSize = LZMA_DIC_MIN;
 …
   LzmaDec_Init(&p);
   *srcLen = inSize;
   res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/LzmaCustomDecompressLib/Sdk/C/LzmaDec.h

-              r58464
+              r58466
   SZ_ERROR_UNSUPPORTED - Unsupported properties
 */
 SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc);
 void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc);
 …
 /* LzmaDec_DecodeToDic
    The decoding to internal dictionary buffer (CLzmaDec::dic).
    You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/OemHookStatusCodeLibNull/OemHookStatusCodeLibNull.c

-              r48674
+              r58466
 /**
   Report status code to OEM device.
   @param  CodeType      Indicates the type of status code being reported.
   @param  Value         Describes the current status of a hardware or software entity.
                         This included information about the class and subclass that is used to classify the entity
                         as well as an operation.  For progress codes, the operation is the current activity.
                         For error codes, it is the exception.  For debug codes, it is not defined at this time.
   @param  Instance      The enumeration of a hardware or software entity within the system.
                         A system may contain multiple entities that match a class/subclass pairing.
                         The instance differentiates between them.  An instance of 0 indicates that instance information is unavailable,
+  @param  Value         Describes the current status of a hardware or software entity.
+                        This included information about the class and subclass that is used to classify the entity
+                        as well as an operation.  For progress codes, the operation is the current activity.
+                        For error codes, it is the exception.  For debug codes, it is not defined at this time.
+  @param  Instance      The enumeration of a hardware or software entity within the system.
+                        A system may contain multiple entities that match a class/subclass pairing.
+                        The instance differentiates between them.  An instance of 0 indicates that instance information is unavailable,
                         not meaningful, or not relevant.  Valid instance numbers start with 1.
   @param  CallerId      This optional parameter may be used to identify the caller.
                         This parameter allows the status code driver to apply different rules to different callers.
+  @param  CallerId      This optional parameter may be used to identify the caller.
+                        This parameter allows the status code driver to apply different rules to different callers.
   @param  Data          This optional parameter may be used to pass additional data
   @retval EFI_SUCCESS   Always return EFI_SUCCESS.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/OemHookStatusCodeLibNull/OemHookStatusCodeLibNull.inf

r58459	r58466
21	21	MODULE_TYPE = DXE_DRIVER
22	22	VERSION_STRING = 1.0
23		LIBRARY_CLASS = OemHookStatusCodeLib
	23	LIBRARY_CLASS = OemHookStatusCodeLib
24	24
25	25	#

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PeiCrc32GuidedSectionExtractLib/PeiCrc32GuidedSectionExtractLib.c

-              r58464
+              r58466
 /** @file
   This library registers CRC32 guided section handler
+  This library registers CRC32 guided section handler
   to parse CRC32 encapsulation section and extract raw data.
 Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 which accompanies this distribution.  The full text of the license may be found at
 http://opensource.org/licenses/bsd-license.php
 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 **/
 …
     return EFI_INVALID_PARAMETER;
+  }
   //
   // Initialize CRC32 table.
 …
   GetInfo gets raw data size and attribute of the input guided section.
   It first checks whether the input guid section is supported.
+  It first checks whether the input guid section is supported.
   If not, EFI_INVALID_PARAMETER will return.
 …
   @param SectionAttribute   The attribute of the input guided section.
   @retval EFI_SUCCESS            The size of destination buffer, the size of scratch buffer and
+  @retval EFI_SUCCESS            The size of destination buffer, the size of scratch buffer and
                                  the attribute of the input section are successull retrieved.
   @retval EFI_INVALID_PARAMETER  The GUID in InputSection does not match this instance guid.
 …
   Extraction handler tries to extract raw data from the input guided section.
   It also does authentication check for 32bit CRC value in the input guided section.
   It first checks whether the input guid section is supported.
+  It first checks whether the input guid section is supported.
   If not, EFI_INVALID_PARAMETER will return.
 …
       return EFI_INVALID_PARAMETER;
+    }
     //
     // Get section Crc32 checksum.
 …
       return EFI_INVALID_PARAMETER;
+    }
     //
     // Get section Crc32 checksum.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PeiCrc32GuidedSectionExtractLib/PeiCrc32GuidedSectionExtractLib.inf

r58464	r58466
2	2	# Pei Crc32 Guided Section Extract library.
3	3	#
4		# This library doesn't produce any library class. The constructor function uses
	4	# This library doesn't produce any library class. The constructor function uses
5	5	# ExtractGuidedSectionLib service to register CRC32 guided section handler
6	6	# that parses CRC32 encapsulation section and extracts raw data.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PeiDebugPrintHobLib/PeiDebugPrintHobLib.c

-              r48674
+              r58466
 /**
   The constructor reads variable and sets HOB
   @param  FileHandle   The handle of FFS header the loaded driver.
   @param  PeiServices  The pointer to the PEI services.
 …
   UINT64                          GlobalErrorLevel;
   UINT32                          HobErrorLevel;
   Status = PeiServicesLocatePpi (
              &gEfiPeiReadOnlyVariable2PpiGuid,
 …
   if (!EFI_ERROR (Status)) {
     Size = sizeof (GlobalErrorLevel);
     Status = Variable->GetVariable (
                          Variable,
+    Status = Variable->GetVariable (
+                         Variable,
                          DEBUG_MASK_VARIABLE_NAME,
                          &gEfiGenericVariableGuid,

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PeiDxeDebugLibReportStatusCode/DebugLib.c

-              r58464
+              r58466
   Prints a debug message to the debug output device if the specified error level is enabled.
   If any bit in ErrorLevel is also set in DebugPrintErrorLevelLib function
   GetDebugPrintErrorLevel (), then print the message specified by Format and the
+  If any bit in ErrorLevel is also set in DebugPrintErrorLevelLib function
+  GetDebugPrintErrorLevel (), then print the message specified by Format and the
   associated variable argument list to the debug output device.
 …
   @param  ErrorLevel  The error level of the debug message.
   @param  Format      Format string for the debug message to print.
   @param  ...         Variable argument list whose contents are accessed
+  @param  ...         Variable argument list whose contents are accessed
                       based on the format string specified by Format.
 …
   //
   // Compute the total size of the record.
   // Note that the passing-in format string and variable parameters will be constructed to
+  // Note that the passing-in format string and variable parameters will be constructed to
   // the following layout:
   //
 …
         //
         // Make no output if Format string terminates unexpectedly when
         // looking up for flag, width, precision and type.
+        // looking up for flag, width, precision and type.
         //
         Format--;
 …
       break;
+    }
     //
     // Pack variable arguments into the storage area following EFI_DEBUG_INFO.
 …
     //
     // If the converted BASE_LIST is larger than the 12 * sizeof (UINT64) allocated bytes, then ASSERT()
     // This indicates that the DEBUG() macro is passing in more argument than can be handled by
+    // This indicates that the DEBUG() macro is passing in more argument than can be handled by
     // the EFI_DEBUG_INFO record
     //
 …
 /**
   Prints an assert message containing a filename, line number, and description.
+  Prints an assert message containing a filename, line number, and description.
   This may be followed by a breakpoint or a dead loop.
   Print a message of the form "ASSERT <FileName>(<LineNumber>): <Description>\n"
   to the debug output device.  If DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED bit of
   PcdDebugProperyMask is set then CpuBreakpoint() is called. Otherwise, if
   DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED bit of PcdDebugProperyMask is set then
   CpuDeadLoop() is called.  If neither of these bits are set, then this function
+  to the debug output device.  If DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED bit of
+  PcdDebugProperyMask is set then CpuBreakpoint() is called. Otherwise, if
+  DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED bit of PcdDebugProperyMask is set then
+  CpuDeadLoop() is called.  If neither of these bits are set, then this function
   returns immediately after the message is printed to the debug output device.
   DebugAssert() must actively prevent recursion.  If DebugAssert() is called while
 …
   if (HeaderSize + FileNameSize + DescriptionSize > sizeof (Buffer)) {
     //
     // FileName + Description is too long to be filled into buffer.
+    // FileName + Description is too long to be filled into buffer.
     //
     if (HeaderSize + FileNameSize < sizeof (Buffer)) {
       //
       // Description has enough buffer to be truncated.
+      // Description has enough buffer to be truncated.
       //
       DescriptionSize = sizeof (Buffer) - HeaderSize - FileNameSize;
 …
+    }
+  }
   //
   // Fill in EFI_DEBUG_ASSERT_DATA
 …
   Fills a target buffer with PcdDebugClearMemoryValue, and returns the target buffer.
   This function fills Length bytes of Buffer with the value specified by
+  This function fills Length bytes of Buffer with the value specified by
   PcdDebugClearMemoryValue, and returns Buffer.
   If Buffer is NULL, then ASSERT().
   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
   @param   Buffer  Pointer to the target buffer to be filled with PcdDebugClearMemoryValue.
   @param   Length  Number of bytes in Buffer to fill with zeros PcdDebugClearMemoryValue.
+  @param   Length  Number of bytes in Buffer to fill with zeros PcdDebugClearMemoryValue.
   @return  Buffer  Pointer to the target buffer filled with PcdDebugClearMemoryValue.
 …
   Returns TRUE if ASSERT() macros are enabled.
   This function returns TRUE if the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of
   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 …
 /**
+/**
   Returns TRUE if DEBUG() macros are enabled.
   This function returns TRUE if the DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of
   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 …
 /**
+/**
   Returns TRUE if DEBUG_CODE() macros are enabled.
   This function returns TRUE if the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of
+  This function returns TRUE if the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of
   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 …
 /**
+/**
   Returns TRUE if DEBUG_CLEAR_MEMORY() macro is enabled.
   This function returns TRUE if the DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of
+  This function returns TRUE if the DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of
   PcdDebugProperyMask is set.  Otherwise FALSE is returned.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PeiDxeDebugLibReportStatusCode/PeiDxeDebugLibReportStatusCode.inf

r58464	r58466
37	37	MdePkg/MdePkg.dec
38	38	MdeModulePkg/MdeModulePkg.dec
39
	39
40	40	[LibraryClasses]
41	41	PcdLib

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PeiPerformanceLib/PeiPerformanceLib.c

-              r58459
+              r58466
   performance logging GUIDed HOB on the first performance logging and then logs the
   performance data to the GUIDed HOB. Due to the limitation of temporary RAM, the maximum
   number of performance logging entry is specified by PcdMaxPeiPerformanceLogEntries.
+  number of performance logging entry is specified by PcdMaxPeiPerformanceLogEntries.
 Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
 …
   otherwise, the the number of log entries in the array is returned.
   @param  PeiPerformanceLog       Pointer to the data structure containing PEI
+  @param  PeiPerformanceLog       Pointer to the data structure containing PEI
                                   performance data.
   @param  PeiPerformanceIdArray   Pointer to PEI performance identifier array.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PeiPerformanceLib/PeiPerformanceLib.inf

-              r58459
+              r58466
 ## @file
+## @file
 #  Performance library instance used in PEI phase.
+#
+#
 #  This library provides the performance measurement interfaces in PEI phase, it creates
 #  and consumes GUIDed HOB for performance logging. The GUIDed HOB is passed to DXE phase
 #  so that it can be taken over by DxeCorePerformanceLib.
+#
+#  so that it can be taken over by DxeCorePerformanceLib.
+#
 #  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 …
 #  which accompanies this distribution.  The full text of the license may be found at
 #  http://opensource.org/licenses/bsd-license.php
+#
+#
 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#
 ##

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PeiRecoveryLibNull/PeiRecoveryLibNull.c

-              r48674
+              r58466
   This library instance is no longer used and module using this library
   class should update to directly locate EFI_PEI_RECOVERY_MODULE_PPI defined
   in PI 1.2 specification.
+  in PI 1.2 specification.
 Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
 …
 /**
   Calling this function causes the system do recovery boot path.
   @retval EFI_UNSUPPORTED       Recovery is not supported.
 **/

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PeiRecoveryLibNull/PeiRecoveryLibNull.inf

-              r58459
+              r58466
 ## @file
+## @file
 #  Null Recovery library instance for PEIM module
 #  This library instance is no longer used and module using this library
 #  class should update to directly locate EFI_PEI_RECOVERY_MODULE_PPI defined
 #  in PI 1.2 specification.
+#
+#  in PI 1.2 specification.
+#
 #  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 …
 #  which accompanies this distribution.  The full text of the license may be found at
 #  http://opensource.org/licenses/bsd-license.php
+#
+#
 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#
 ##

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PeiReportStatusCodeLib/PeiReportStatusCodeLib.inf

r58459	r58466
26	26	VERSION_STRING = 1.0
27	27	LIBRARY_CLASS = ReportStatusCodeLib\|SEC PEIM PEI_CORE
28
	28
29	29	#
30	30	# The following information is for reference only and not required by the build tools.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PeiS3LibNull/PeiS3LibNull.c

-              r48674
+              r58466
   This library instance is no longer used and module using this library
   class should update to directly locate EFI_PEI_S3_RESUME_PPI defined
   in PI 1.2 specification.
+  in PI 1.2 specification.
 Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
 …
 /**
   This function is responsible for calling the S3 resume vector in the ACPI Tables.
   @retval EFI_SUCESS   Success to restore config from S3.
   @retval Others       Fail to restore config from S3.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PeiS3LibNull/PeiS3LibNull.inf

-              r58459
+              r58466
 #  This library instance is no longer used and module using this library
 #  class should update to directly locate EFI_PEI_S3_RESUME_PPI defined
 #  in PI 1.2 specification.
+#
+#  in PI 1.2 specification.
+#
 #  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
+#
 …
 #  which accompanies this distribution.  The full text of the license may be found at
 #  http://opensource.org/licenses/bsd-license.php
+#
+#
 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PiDxeS3BootScriptLib/BootScriptExecute.c

-              r58459
+              r58466
 /** @file
   Interpret and execute the S3 data in S3 boot script.
+  Interpret and execute the S3 data in S3 boot script.
   Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 …
   slave devices accept this transaction or that this function returns with error.
   @param  SmbusAddress            Address that encodes the SMBUS Slave Address, SMBUS Command, SMBUS Data Length,
+  @param  SmbusAddress            Address that encodes the SMBUS Slave Address, SMBUS Command, SMBUS Data Length,
                                   and PEC.
   @param  Operation               Signifies which particular SMBus hardware protocol instance that
 …
+  }
   return Status;
+  return Status;
+}
 …
   @param Address        Address of the operation.
   @param AddressStride  Instride for stepping input buffer.
   @param BufferStride   Outstride for stepping output buffer.
+  @param BufferStride   Outstride for stepping output buffer.
   @retval EFI_SUCCESS  Successful translation.
 …
 /**
   Perform IO read operation
   @param[in]  Width   Width of the operation.
   @param[in]  Address Address of the operation.
   @param[in]  Count   Count of the number of accesses to perform.
   @param[out] Buffer  Pointer to the buffer to read from I/O space.
+  @param[out] Buffer  Pointer to the buffer to read from I/O space.
   @retval EFI_SUCCESS The data was written to the EFI System.
 …
                                 Buffer is NULL.
                                 The Buffer is not aligned for the given Width.
                                 Address is outside the legal range of I/O ports.
+                                Address is outside the legal range of I/O ports.
 **/
 EFI_STATUS
 …
 /**
   Perform IO write operation
   @param[in]  Width Width of the operation.
   @param[in]  Address Address of the operation.
   @param[in]  Count Count of the number of accesses to perform.
   @param[in]  Buffer Pointer to the buffer to write to I/O space.
+  @param[in]  Buffer Pointer to the buffer to write to I/O space.
   @retval EFI_SUCCESS The data was written to the EFI System.
 …
                                 Buffer is NULL.
                                 The Buffer is not aligned for the given Width.
                                 Address is outside the legal range of I/O ports.
+                                Address is outside the legal range of I/O ports.
 **/
 EFI_STATUS
 …
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint8 - 0x%08x (0x%02x)\n", (UINTN)Address, (UINTN)*In.Uint8));
         IoWrite8 ((UINTN) Address, *In.Uint8);
         break;
+        break;
       case S3BootScriptWidthFifoUint8:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint8 - 0x%08x (0x%02x)\n", (UINTN)OriginalAddress, (UINTN)*In.Uint8));
         IoWrite8 ((UINTN) OriginalAddress, *In.Uint8);
         break;
+        break;
       case S3BootScriptWidthFillUint8:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint8 - 0x%08x (0x%02x)\n", (UINTN)Address, (UINTN)*OriginalIn.Uint8));
 …
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint16 - 0x%08x (0x%04x)\n", (UINTN)Address, (UINTN)*In.Uint16));
         IoWrite16 ((UINTN) Address, *In.Uint16);
         break;
+        break;
       case S3BootScriptWidthFifoUint16:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint16 - 0x%08x (0x%04x)\n", (UINTN)OriginalAddress, (UINTN)*In.Uint16));
         IoWrite16 ((UINTN) OriginalAddress, *In.Uint16);
         break;
+        break;
       case S3BootScriptWidthFillUint16:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint16 - 0x%08x (0x%04x)\n", (UINTN)Address, (UINTN)*OriginalIn.Uint16));
 …
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint32 - 0x%08x (0x%08x)\n", (UINTN)Address, (UINTN)*In.Uint32));
         IoWrite32 ((UINTN) Address, *In.Uint32);
         break;
+        break;
       case S3BootScriptWidthFifoUint32:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint32 - 0x%08x (0x%08x)\n", (UINTN)OriginalAddress, (UINTN)*In.Uint32));
 …
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint64 - 0x%08x (0x%016lx)\n", (UINTN)Address, *In.Uint64));
         IoWrite64 ((UINTN) Address, *In.Uint64);
         break;
+        break;
       case S3BootScriptWidthFifoUint64:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint64 - 0x%08x (0x%016lx)\n", (UINTN)OriginalAddress, *In.Uint64));
         IoWrite64 ((UINTN) OriginalAddress, *In.Uint64);
         break;
+        break;
       case S3BootScriptWidthFillUint64:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint64 - 0x%08x (0x%016lx)\n", (UINTN)Address, *OriginalIn.Uint64));
 …
+    }
+  }
   return EFI_SUCCESS;
 …
 /**
   Interprete the boot script node with EFI_BOOT_SCRIPT_IO_WRITE OP code.
   @param Script       Pointer to the node which is to be interpreted.
 …
                                 Buffer is NULL.
                                 The Buffer is not aligned for the given Width.
                                 Address is outside the legal range of I/O ports.
+                                Address is outside the legal range of I/O ports.
 **/
 EFI_STATUS
 BootScriptExecuteIoWrite (
   IN UINT8                    *Script
+  IN UINT8                    *Script
+  )
+{
 …
   VOID                      *Buffer;
   EFI_BOOT_SCRIPT_IO_WRITE   IoWrite;
   CopyMem ((VOID*)&IoWrite, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_IO_WRITE));
   Width = (S3_BOOT_SCRIPT_LIB_WIDTH) IoWrite.Width;
 …
 /**
   Perform memory read operation
   @param  Width Width of the operation.
   @param  Address Address of the operation.
   @param  Count Count of the number of accesses to perform.
   @param  Buffer Pointer to the buffer read from memory.
+  @param  Buffer Pointer to the buffer read from memory.
   @retval EFI_SUCCESS The data was written to the EFI System.
 …
                                 Buffer is NULL.
                                 The Buffer is not aligned for the given Width.
   @retval EFI_UNSUPPORTED The address range specified by Address, Width, and Count
                           is not valid for this EFI System.
+  @retval EFI_UNSUPPORTED The address range specified by Address, Width, and Count
+                          is not valid for this EFI System.
 **/
 EFI_STATUS
 …
 /**
   Perform memory write operation
   @param   Width   Width of the operation.
   @param   Address Address of the operation.
   @param   Count   Count of the number of accesses to perform.
   @param   Buffer  Pointer to the buffer write to memory.
+  @param   Buffer  Pointer to the buffer write to memory.
   @retval EFI_SUCCESS The data was written to the EFI System.
 …
                                 Buffer is NULL.
                                 The Buffer is not aligned for the given Width.
   @retval EFI_UNSUPPORTED The address range specified by Address, Width, and Count
                           is not valid for this EFI System.
+  @retval EFI_UNSUPPORTED The address range specified by Address, Width, and Count
+                          is not valid for this EFI System.
 **/
 EFI_STATUS
 …
   EFI_STATUS  Status;
   UINTN       AddressStride;
   UINT64      OriginalAddress;
+  UINT64      OriginalAddress;
   UINTN       BufferStride;
   PTR         In;
 …
   //
   OriginalAddress = Address;
   OriginalIn.Buf = In.Buf;
+  OriginalIn.Buf = In.Buf;
   for (; Count > 0; Count--, Address += AddressStride, In.Buf += BufferStride) {
     switch (Width) {
 …
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint8 - 0x%08x (0x%02x)\n", (UINTN)Address, (UINTN)*In.Uint8));
         MmioWrite8 ((UINTN) Address, *In.Uint8);
         break;
+        break;
       case S3BootScriptWidthFifoUint8:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint8 - 0x%08x (0x%02x)\n", (UINTN)OriginalAddress, (UINTN)*In.Uint8));
         MmioWrite8 ((UINTN) OriginalAddress, *In.Uint8);
         break;
+        break;
       case S3BootScriptWidthFillUint8:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint8 - 0x%08x (0x%02x)\n", (UINTN)Address, (UINTN)*OriginalIn.Uint8));
 …
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint16 - 0x%08x (0x%04x)\n", (UINTN)Address, (UINTN)*In.Uint16));
         MmioWrite16 ((UINTN) Address, *In.Uint16);
         break;
+        break;
       case S3BootScriptWidthFifoUint16:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint16 - 0x%08x (0x%04x)\n", (UINTN)OriginalAddress, (UINTN)*In.Uint16));
         MmioWrite16 ((UINTN) OriginalAddress, *In.Uint16);
         break;
+        break;
       case S3BootScriptWidthFillUint16:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint16 - 0x%08x (0x%04x)\n", (UINTN)Address, (UINTN)*OriginalIn.Uint16));
 …
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint32 - 0x%08x (0x%08x)\n", (UINTN)Address, (UINTN)*In.Uint32));
         MmioWrite32 ((UINTN) Address, *In.Uint32);
         break;
+        break;
       case S3BootScriptWidthFifoUint32:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint32 - 0x%08x (0x%08x)\n", (UINTN)OriginalAddress, (UINTN)*In.Uint32));
         MmioWrite32 ((UINTN) OriginalAddress, *In.Uint32);
         break;
+        break;
       case S3BootScriptWidthFillUint32:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint32 - 0x%08x (0x%08x)\n", (UINTN)Address, (UINTN)*OriginalIn.Uint32));
 …
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint64 - 0x%08x (0x%016lx)\n", (UINTN)Address, *In.Uint64));
         MmioWrite64 ((UINTN) Address, *In.Uint64);
         break;
+        break;
       case S3BootScriptWidthFifoUint64:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint64 - 0x%08x (0x%016lx)\n", (UINTN)OriginalAddress, *In.Uint64));
         MmioWrite64 ((UINTN) OriginalAddress, *In.Uint64);
         break;
+        break;
       case S3BootScriptWidthFillUint64:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint64 - 0x%08x (0x%016lx)\n", (UINTN)Address, *OriginalIn.Uint64));
 …
   @param[in]  Script Pointer to the node which is to be interpreted.
   @retval EFI_SUCCESS The data was written to the EFI System.
   @retval EFI_INVALID_PARAMETER Width is invalid for this EFI System.
                                 Buffer is NULL.
                                 The Buffer is not aligned for the given Width.
   @retval EFI_UNSUPPORTED The address range specified by Address, Width, and Count
                           is not valid for this EFI System.
+  @retval EFI_UNSUPPORTED The address range specified by Address, Width, and Count
+                          is not valid for this EFI System.
 **/
 EFI_STATUS
 …
   UINTN            Count;
   EFI_BOOT_SCRIPT_MEM_WRITE  MemWrite;
   CopyMem((VOID*)&MemWrite, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_MEM_WRITE));
   Width   = (S3_BOOT_SCRIPT_LIB_WIDTH)MemWrite.Width;
 …
   DEBUG ((EFI_D_INFO, "BootScriptExecuteMemoryWrite - 0x%08x, 0x%08x, 0x%08x\n", (UINTN)Address, Count, (UINTN)Width));
   return ScriptMemoryWrite (Width,Address, Count,  Buffer);
+}
+}
 /**
   Performance PCI configuration read operation
 …
   @param  Count   Count of the number of accesses to perform.
   @param  Buffer  Pointer to the buffer read from PCI config space
   @retval EFI_SUCCESS The read succeed.
   @retval EFI_INVALID_PARAMETER if Width is not defined
+  @retval EFI_INVALID_PARAMETER if Width is not defined
   @note  A known Limitations in the implementation which is 64bits operations are not supported.
 …
   @param  Count   Count of the number of accesses to perform.
   @param  Buffer  Pointer to the buffer write to PCI config space
   @retval EFI_SUCCESS The write succeed.
   @retval EFI_INVALID_PARAMETER if Width is not defined
+  @retval EFI_INVALID_PARAMETER if Width is not defined
   @note  A known Limitations in the implementation which is 64bits operations are not supported.
 …
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint8 - 0x%08x (0x%02x)\n", PciAddress, (UINTN)*In.Uint8));
         PciWrite8 (PciAddress, *In.Uint8);
         break;
+        break;
       case S3BootScriptWidthFifoUint8:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint8 - 0x%08x (0x%02x)\n", OriginalPciAddress, (UINTN)*In.Uint8));
         PciWrite8 (OriginalPciAddress, *In.Uint8);
         break;
+        break;
       case S3BootScriptWidthFillUint8:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint8 - 0x%08x (0x%02x)\n", PciAddress, (UINTN)*OriginalIn.Uint8));
 …
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint16 - 0x%08x (0x%04x)\n", PciAddress, (UINTN)*In.Uint16));
         PciWrite16 (PciAddress, *In.Uint16);
         break;
+        break;
       case S3BootScriptWidthFifoUint16:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint16 - 0x%08x (0x%04x)\n", OriginalPciAddress, (UINTN)*In.Uint16));
         PciWrite16 (OriginalPciAddress, *In.Uint16);
         break;
+        break;
       case S3BootScriptWidthFillUint16:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint16 - 0x%08x (0x%04x)\n", PciAddress, (UINTN)*OriginalIn.Uint16));
 …
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint32 - 0x%08x (0x%08x)\n", PciAddress, (UINTN)*In.Uint32));
         PciWrite32 (PciAddress, *In.Uint32);
         break;
+        break;
       case S3BootScriptWidthFifoUint32:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint32 - 0x%08x (0x%08x)\n", OriginalPciAddress, (UINTN)*In.Uint32));
         PciWrite32 (OriginalPciAddress, *In.Uint32);
         break;
+        break;
       case S3BootScriptWidthFillUint32:
         DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint32 - 0x%08x (0x%08x)\n", (UINTN)PciAddress, (UINTN)*OriginalIn.Uint32));
 …
 /**
   Performance PCI configuration 2 read operation
   @param     Width                      Width of the operation.
   @param     Segment                    Pci segment number
 …
                                         The Buffer is not aligned for the given Width.
                                         Address is outside the legal range of I/O ports.
   @note  A known Limitations in the implementation which is the 'Segment' parameter is assumed as
+  @note  A known Limitations in the implementation which is the 'Segment' parameter is assumed as
          Zero, or else, assert.
 **/
 …
 ScriptPciCfg2Read (
   IN  S3_BOOT_SCRIPT_LIB_WIDTH    Width,
   IN  UINT16                   Segment,
+  IN  UINT16                   Segment,
   IN  UINT64                   Address,
   IN  UINTN                    Count,
 …
+{
   ASSERT (Segment==0);
   return ScriptPciCfgRead (Width, Address, Count, Buffer);
+}
 /**
   Performance PCI configuration 2 write operation
   @param     Width                      Width of the operation.
   @param     Segment                    Pci segment number
 …
                                         The Buffer is not aligned for the given Width.
                                         Address is outside the legal range of I/O ports.
   @note  A known Limitations in the implementation which is the 'Segment' parameter is assumed as
+  @note  A known Limitations in the implementation which is the 'Segment' parameter is assumed as
          Zero, or else, assert.
 **/
 EFI_STATUS
 …
 ScriptPciCfg2Write (
   IN  S3_BOOT_SCRIPT_LIB_WIDTH    Width,
   IN  UINT16                   Segment,
+  IN  UINT16                   Segment,
   IN  UINT64                   Address,
   IN  UINTN                    Count,
 …
 /**
   Interprete the boot script node with EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE OP code.
   @param  Script        The pointer of typed node in boot script table
+  @param  Script        The pointer of typed node in boot script table
   @retval EFI_SUCCESS  The operation was executed successfully
 **/
 …
   Interprete the boot script node with EFI_BOOT_SCRIPT_IO_READ_WRITE OP code.
   @param Script   The pointer of typed node in boot script table
+  @param Script   The pointer of typed node in boot script table
   @param AndMask  Mask value for 'and' operation
   @param OrMask   Mask value for 'or' operation
 …
   UINT64      Data;
   EFI_BOOT_SCRIPT_IO_READ_WRITE IoReadWrite;
   Data = 0;
   CopyMem((VOID*)&IoReadWrite, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_IO_READ_WRITE));
 …
   Interprete the boot script node with EFI_BOOT_SCRIPT_MEM_READ_WRITE OP code.
   @param Script    The pointer of typed node in boot script table
+  @param Script    The pointer of typed node in boot script table
   @param AndMask   Mask value for 'and' operation
   @param OrMask    Mask value for 'or' operation
 …
   UINT64      Data;
   EFI_BOOT_SCRIPT_MEM_READ_WRITE  MemReadWrite;
   Data = 0;
   CopyMem((VOID*)&MemReadWrite, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_MEM_READ_WRITE));
   DEBUG ((EFI_D_INFO, "BootScriptExecuteMemoryReadWrite - 0x%08x, 0x%016lx, 0x%016lx\n", (UINTN)MemReadWrite.Address, AndMask, OrMask));
   Status = ScriptMemoryRead (
              (S3_BOOT_SCRIPT_LIB_WIDTH) MemReadWrite.Width,
 …
   Interprete the boot script node with EFI_BOOT_SCRIPT_PCI_CFG_READ_WRITE OP code.
   @param Script   The pointer of typed node in boot script table
+  @param Script   The pointer of typed node in boot script table
   @param AndMask  Mask value for 'and' operation
   @param OrMask   Mask value for 'or' operation
 …
   DEBUG ((EFI_D_INFO, "BootScriptExecutePciCfgReadWrite - 0x%08x, 0x%016lx, 0x%016lx\n", PCI_ADDRESS_ENCODE (PciCfgReadWrite.Address), AndMask, OrMask));
   Status = ScriptPciCfgRead (
              (S3_BOOT_SCRIPT_LIB_WIDTH) PciCfgReadWrite.Width,
 …
   Interprete the boot script node with EFI_BOOT_SCRIPT_SMBUS_EXECUTE OP code.
   @param Script  The pointer of typed node in boot script table
+  @param Script  The pointer of typed node in boot script table
   @retval EFI_SUCCESS      The operation was executed successfully
   @retval EFI_UNSUPPORTED  Cannot locate smbus ppi or occur error of script execution
   @retval Others           Result of script execution
+  @retval Others           Result of script execution
 **/
 EFI_STATUS
 …
   UINTN                    DataSize;
   EFI_BOOT_SCRIPT_SMBUS_EXECUTE SmbusExecuteEntry;
   CopyMem ((VOID*)&SmbusExecuteEntry, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_SMBUS_EXECUTE ));
 …
   Interprete the boot script node with EFI_BOOT_SCRIPT_STALL OP code.
   @param Script      The pointer of typed node in boot script table
+  @param Script      The pointer of typed node in boot script table
   @retval EFI_SUCCESS The operation was executed successfully
 **/
 …
+{
   EFI_BOOT_SCRIPT_STALL    Stall;
   CopyMem ((VOID*)&Stall, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_STALL));
 …
 /**
   Interprete the boot script node with EFI_BOOT_SCRIPT_DISPATCH OP code.
   @param Script  The pointer of typed node in boot script table
+  @param Script  The pointer of typed node in boot script table
   @retval EFI_SUCCESS  The operation was executed successfully
 **/
 …
   DISPATCH_ENTRYPOINT_FUNC  EntryFunc;
   EFI_BOOT_SCRIPT_DISPATCH  ScriptDispatch;
   CopyMem ((VOID*)&ScriptDispatch, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_DISPATCH));
   EntryFunc = (DISPATCH_ENTRYPOINT_FUNC) (UINTN) (ScriptDispatch.EntryPoint);
 …
   Interprete the boot script node with EFI_BOOT_SCRIPT_DISPATCH_2 OP code.
   @param  Script       The pointer of typed node in boot script table
+  @param  Script       The pointer of typed node in boot script table
   @retval EFI_SUCCESS  The operation was executed successfully
 **/
 …
   DISPATCH_ENTRYPOINT_FUNC  EntryFunc;
   EFI_BOOT_SCRIPT_DISPATCH_2  ScriptDispatch2;
   CopyMem ((VOID*)&ScriptDispatch2, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_DISPATCH_2));
   DEBUG ((EFI_D_INFO, "BootScriptExecuteDispatch2 - 0x%08x(0x%08x)\n", (UINTN)ScriptDispatch2.EntryPoint, (UINTN)ScriptDispatch2.Context));
   EntryFunc = (DISPATCH_ENTRYPOINT_FUNC) (UINTN) (ScriptDispatch2.EntryPoint);
 …
   Interprete the boot script node with EFI_BOOT_SCRIPT_MEM_POLL OP code.
   @param  Script  The pointer of typed node in boot script table
+  @param  Script  The pointer of typed node in boot script table
   @param  AndMask  Mask value for 'and' operation
   @param  OrMask   Mask value for 'or' operation
   @retval EFI_DEVICE_ERROR Data polled from memory does not equal to
+  @retval EFI_DEVICE_ERROR Data polled from memory does not equal to
                            the epecting data within the Loop Times.
   @retval EFI_SUCCESS      The operation was executed successfully
 …
   IN UINT8                        *Script,
   IN UINT64                        AndMask,
   IN UINT64                        OrMask
+  )
+{
+  IN UINT64                        OrMask
+  )
+{
   UINT64        Data;
   UINT64        LoopTimes;
   EFI_STATUS    Status;
   EFI_BOOT_SCRIPT_MEM_POLL       MemPoll;
   CopyMem ((VOID*)&MemPoll, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_MEM_POLL));
 …
   This opcode is a no-op on dispatch and is only used for debugging script issues.
   @param Script       The pointer of node in boot script table
+  @param Script       The pointer of node in boot script table
 **/
 VOID
 …
 /**
   Execute the boot script to interpret the Label information.
   @param Script       The pointer of node in boot script table
+  Execute the boot script to interpret the Label information.
+  @param Script       The pointer of node in boot script table
 **/
 VOID
 …
 /**
   calculate the mask value for 'and' and 'or' operation
   @param ScriptHeader   The pointer of header of node in boot script table
+  @param ScriptHeader   The pointer of header of node in boot script table
   @param AndMask  The Mask value for 'and' operation
   @param OrMask   The Mask value for 'or' operation
 …
     Size = sizeof (EFI_BOOT_SCRIPT_MEM_POLL);
     break;
   case EFI_BOOT_SCRIPT_IO_POLL_OPCODE:
     Size = sizeof (EFI_BOOT_SCRIPT_IO_POLL);
     break;
+    break;
   case EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE_OPCODE:
     Size = sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE);
     break;
   case EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE:
     Size = sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL);
     break;
   case EFI_BOOT_SCRIPT_PCI_CONFIG_POLL_OPCODE:
     Size = sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_POLL);
     break;
   default:
     return;
+  }
   DataPtr = Script + Size;
 …
   Interprete the boot script node with EFI_BOOT_SCRIPT_IO_POLL OP code.
   @param  Script  The pointer of typed node in boot script table
+  @param  Script  The pointer of typed node in boot script table
   @param  AndMask  Mask value for 'and' operation
   @param  OrMask   Mask value for 'or' operation
   @retval EFI_DEVICE_ERROR Data polled from memory does not equal to
+  @retval EFI_DEVICE_ERROR Data polled from memory does not equal to
                            the epecting data within the Loop Times.
   @retval EFI_SUCCESS      The operation was executed successfully
 …
   UINT64        LoopTimes;
   EFI_BOOT_SCRIPT_IO_POLL       IoPoll;
   CopyMem ((VOID*)&IoPoll, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_IO_POLL));
 …
     if ((!EFI_ERROR (Status)) &&(Data & AndMask) == OrMask) {
       return EFI_SUCCESS;
+    }
+    }
+  }
 …
   UINTN                             Count;
   EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE PciCfg2Write;
   CopyMem ((VOID*)&PciCfg2Write, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE));
 …
 /**
   Interprete the boot script node with EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE OP code.
   @param     Script                     The pointer of S3 boot script
   @param     AndMask                    Mask value for 'and' operation
 …
   DEBUG ((EFI_D_INFO, "BootScriptExecutePciCfg2ReadWrite - 0x%04x, 0x%08x, 0x%016lx, 0x%016lx\n", PciCfg2ReadWrite.Segment, PCI_ADDRESS_ENCODE (PciCfg2ReadWrite.Address), AndMask, OrMask));
   Status = ScriptPciCfg2Read (
              (S3_BOOT_SCRIPT_LIB_WIDTH) PciCfg2ReadWrite.Width,
 …
 /**
   Interprete the boot script node with EFI_BOOT_SCRIPT_PCI_CONFIG_POLL OP code.
   @param     Script                     The pointer of S3 boot script
   @param     AndMask                    Mask value for 'and' operation
 …
   @retval    EFI_SUCCESS                The operation was executed successfully
   @retval    EFI_DEVICE_ERROR           Data polled from Pci configuration space does not equal to
+  @retval    EFI_DEVICE_ERROR           Data polled from Pci configuration space does not equal to
                                         epecting data within the Loop Times.
 **/
 …
   IN UINT8                         *Script,
   IN UINT64                        AndMask,
   IN UINT64                        OrMask
+  IN UINT64                        OrMask
+  )
+{
 …
   DEBUG ((EFI_D_INFO, "BootScriptPciCfgPoll - 0x%08x, 0x%016lx, 0x%016lx\n", PCI_ADDRESS_ENCODE (PciCfgPoll.Address), AndMask, OrMask));
   Data = 0;
   Status = ScriptPciCfgRead (
 …
 /**
   Interprete the boot script node with EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL OP code.
   @param     Script                     The pointer of S3 Boot Script
   @param     AndMask                    Mask value for 'and' operation
 …
   @retval    EFI_SUCCESS                The operation was executed successfully
   @retval    EFI_DEVICE_ERROR           Data polled from Pci configuration space does not equal to
+  @retval    EFI_DEVICE_ERROR           Data polled from Pci configuration space does not equal to
                                         epecting data within the Loop Times.
 …
   IN UINT8                        *Script,
   IN UINT64                        AndMask,
   IN UINT64                        OrMask
+  IN UINT64                        OrMask
+  )
+{
 …
   DEBUG ((EFI_D_INFO, "BootScriptPciCfg2Poll - 0x%04x, 0x%08x, 0x%016lx, 0x%016lx\n", PciCfg2Poll.Segment, PCI_ADDRESS_ENCODE (PciCfg2Poll.Address), AndMask, OrMask));
   Status = ScriptPciCfg2Read (
              (S3_BOOT_SCRIPT_LIB_WIDTH) PciCfg2Poll.Width,
 …
     Status = ScriptPciCfg2Read (
                (S3_BOOT_SCRIPT_LIB_WIDTH) PciCfg2Poll.Width,
                PciCfg2Poll.Segment,
+               PciCfg2Poll.Segment,
                PciCfg2Poll.Address,
 ,
 …
     return EFI_DEVICE_ERROR;
+  }
+}
 /**
   Executes the S3 boot script table.
   @retval RETURN_SUCCESS           The boot script table was executed successfully.
   @retval RETURN_UNSUPPORTED       Invalid script table or opcode.
+  @retval RETURN_UNSUPPORTED       Invalid script table or opcode.
   @note  A known Limitations in the implementation: When interpreting the opcode  EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE_OPCODE
          EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE_OPCODE and EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE, the 'Segment' parameter is assumed as
+         EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE_OPCODE and EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE, the 'Segment' parameter is assumed as
          Zero, or else, assert.
 **/
 …
   EFI_BOOT_SCRIPT_TABLE_HEADER   TableHeader;
   Script = mS3BootScriptTablePtr->TableBase;
   if (Script != 0) {
+  if (Script != 0) {
     CopyMem ((VOID*)&TableHeader, Script, sizeof(EFI_BOOT_SCRIPT_TABLE_HEADER));
   } else {
 …
   DEBUG ((EFI_D_INFO, "TableHeader - 0x%08x\n", Script));
   StartAddress  = (UINTN) Script;
   TableLength   = TableHeader.TableLength;
 …
   while ((UINTN) Script < (UINTN) (StartAddress + TableLength)) {
     DEBUG ((EFI_D_INFO, "ExecuteBootScript - %08x\n", (UINTN)Script));
     CopyMem ((VOID*)&ScriptHeader, Script, sizeof(EFI_BOOT_SCRIPT_COMMON_HEADER));
     switch (ScriptHeader.OpCode) {
 …
       DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_INFORMATION_OPCODE\n"));
       BootScriptExecuteInformation (Script);
       break;
+      break;
     case S3_BOOT_SCRIPT_LIB_TERMINATE_OPCODE:
 …
       CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
       Status = BootScriptExecuteMemPoll (Script, AndMask, OrMask);
       break;
+      break;
     case EFI_BOOT_SCRIPT_IO_POLL_OPCODE:
       DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_IO_POLL_OPCODE\n"));
 …
       Status = BootScriptExecuteIoPoll (Script, AndMask, OrMask);
       break;
     case EFI_BOOT_SCRIPT_PCI_CONFIG_POLL_OPCODE:
       DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG_POLL_OPCODE\n"));
 …
       Status = BootScriptPciCfgPoll (Script, AndMask, OrMask);
       break;
     case EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE:
      DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE\n"));

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PiDxeS3BootScriptLib/BootScriptInternalFormat.h

r58459	r58466
170	170	UINT32 Width;
171	171	UINT64 Address;
172		UINT16 Segment;
	172	UINT16 Segment;
173	173	UINT64 Delay;
174	174	} EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL;

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PiDxeS3BootScriptLib/BootScriptSave.c

-              r58459
+              r58466
 /** @file
   Save the S3 data to S3 boot script.
+  Save the S3 data to S3 boot script.
   Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
 …
 /**
   This is an internal function to add a terminate node the entry, recalculate the table
   length and fill into the table.
   @return the base address of the boot script table.
+  This is an internal function to add a terminate node the entry, recalculate the table
+  length and fill into the table.
+  @return the base address of the boot script table.
  **/
 UINT8*
 …
   EFI_BOOT_SCRIPT_TABLE_HEADER   *ScriptTableInfo;
   S3TableBase = mS3BootScriptTablePtr->TableBase;
   if (S3TableBase == NULL) {
     //
 …
   ScriptTableInfo                = (EFI_BOOT_SCRIPT_TABLE_HEADER*)(mS3BootScriptTablePtr->TableBase);
   ScriptTableInfo->TableLength = mS3BootScriptTablePtr->TableLength + sizeof (EFI_BOOT_SCRIPT_TERMINATE);
   return S3TableBase;
   //
   // NOTE: Here we did NOT adjust the mS3BootScriptTablePtr->TableLength to
   // mS3BootScriptTablePtr->TableLength + sizeof (EFI_BOOT_SCRIPT_TERMINATE). Because
+  // NOTE: Here we did NOT adjust the mS3BootScriptTablePtr->TableLength to
+  // mS3BootScriptTablePtr->TableLength + sizeof (EFI_BOOT_SCRIPT_TERMINATE). Because
   // maybe in runtime, we still need add entries into the table, and the runtime entry should be
   // added start before this TERMINATE node.
   //
+}
+}
 /**
 …
   This is the Event call back function to notify the Library the system is entering
   run time phase.
   @param  Event   Pointer to this event
   @param  Context Event handler private data
+  @param  Context Event handler private data
  **/
 VOID
 …
   //
   // Here we should tell the library that we are enter into runtime phase. and
+  // Here we should tell the library that we are enter into runtime phase. and
   // the memory page number occupied by the table should not grow anymore.
   //
 …
     SaveBootScriptDataToLockBox ();
+  }
+}
+}
 /**
   This is the Event call back function is triggered in SMM to notify the Library the system is entering
   run time phase and set InSmm flag.
   @param  Protocol   Points to the protocol's unique identifier
   @param  Interface  Points to the interface instance
 …
 /**
   Library Constructor.
   this function just identify it is a smm driver or non-smm driver linked against
   with the library
+  this function just identify it is a smm driver or non-smm driver linked against
+  with the library
   @param  ImageHandle   The firmware allocated handle for the EFI image.
 …
     S3TablePtr = (VOID *) (UINTN) Buffer;
     PcdSet64 (PcdS3BootScriptTablePrivateDataPtr, (UINT64) (UINTN)S3TablePtr);
     ZeroMem (S3TablePtr, sizeof(SCRIPT_TABLE_PRIVATE_DATA));
+    PcdSet64 (PcdS3BootScriptTablePrivateDataPtr, (UINT64) (UINTN)S3TablePtr);
+    ZeroMem (S3TablePtr, sizeof(SCRIPT_TABLE_PRIVATE_DATA));
     //
     // create event to notify the library system enter the runtime phase
 …
                           );
     ASSERT (mEnterRuntimeEvent != NULL);
+  }
+  }
   mS3BootScriptTablePtr = S3TablePtr;
 …
   To get the start address from which a new boot time s3 boot script entry will write into.
   If the table is not exist, the functio will first allocate a buffer for the table
   If the table buffer is not enough for the new entry, in non-smm mode, the funtion will
+  If the table buffer is not enough for the new entry, in non-smm mode, the funtion will
   invoke reallocate to enlarge buffer.
   @param EntryLength      the new entry length.
   @retval the address from which the a new s3 boot script entry will write into
+  @retval the address from which the a new s3 boot script entry will write into
  **/
 UINT8*
 …
    EFI_STATUS                        Status;
    EFI_BOOT_SCRIPT_TABLE_HEADER      *ScriptTableInfo;
    S3TableBase = (EFI_PHYSICAL_ADDRESS)(UINTN)(mS3BootScriptTablePtr->TableBase);
    if (S3TableBase == 0) {
      // The table is not exist. This is the first to add entry.
+     // The table is not exist. This is the first to add entry.
      // Allocate ACPI script table space under 4G memory. We need it to save
      // some settings done by CSM, which runs after normal script table closed
 …
                   (EFI_PHYSICAL_ADDRESS*)&S3TableBase
                   );
      if (EFI_ERROR(Status)) {
        ASSERT_EFI_ERROR (Status);
 …
      mS3BootScriptTablePtr->TableMemoryPageNumber = (UINT16)(2 + PcdGet16(PcdS3BootScriptRuntimeTableReservePageNumber));
+   }
    // Here we do not count the reserved memory for runtime script table.
    PageNumber   = (UINT16)(mS3BootScriptTablePtr->TableMemoryPageNumber - PcdGet16(PcdS3BootScriptRuntimeTableReservePageNumber));
+   PageNumber   = (UINT16)(mS3BootScriptTablePtr->TableMemoryPageNumber - PcdGet16(PcdS3BootScriptRuntimeTableReservePageNumber));
    TableLength =  mS3BootScriptTablePtr->TableLength;
    if ((UINT32)(PageNumber * EFI_PAGE_SIZE) < (TableLength + EntryLength + sizeof (EFI_BOOT_SCRIPT_TERMINATE))) {
      //
+     //
      // The buffer is too small to hold the table, Reallocate the buffer
      //
 …
                   (EFI_PHYSICAL_ADDRESS*)&NewS3TableBase
                   );
      if (EFI_ERROR(Status)) {
        ASSERT_EFI_ERROR (Status);
        return 0;
+     }
      CopyMem ((VOID*)(UINTN)NewS3TableBase, (VOID*)(UINTN)S3TableBase, TableLength);
      gBS->FreePages (S3TableBase, mS3BootScriptTablePtr->TableMemoryPageNumber);
      mS3BootScriptTablePtr->TableBase = (UINT8*)(UINTN)NewS3TableBase;
      mS3BootScriptTablePtr->TableMemoryPageNumber =  (UINT16) (2 + PageNumber + PcdGet16(PcdS3BootScriptRuntimeTableReservePageNumber));
+     mS3BootScriptTablePtr->TableMemoryPageNumber =  (UINT16) (2 + PageNumber + PcdGet16(PcdS3BootScriptRuntimeTableReservePageNumber));
+   }
    //
    // calculate the the start address for the new entry.
+   // calculate the the start address for the new entry.
    //
    NewEntryPtr = mS3BootScriptTablePtr->TableBase + TableLength;
    //
    // update the table lenghth
    //
    mS3BootScriptTablePtr->TableLength =  TableLength + EntryLength;
    //
    // In the boot time, we will not append the termination entry to the boot script
    // table until the callers think there is no boot time data that should be added and
    // it is caller's responsibility to explicit call the CloseTable.
+   // table until the callers think there is no boot time data that should be added and
+   // it is caller's responsibility to explicit call the CloseTable.
    //
    //
    return NewEntryPtr;
+   return NewEntryPtr;
+}
 /**
   To get the start address from which a new runtime s3 boot script entry will write into.
   In this case, it should be ensured that there is enough buffer to hold the entry.
   @param EntryLength      the new entry length.
   @retval the address from which the a new s3 runtime script entry will write into
  **/
 …
+{
    UINT8     *NewEntryPtr;
    NewEntryPtr = NULL;
+   NewEntryPtr = NULL;
    //
    // Check if the memory range reserved for S3 Boot Script table is large enough to hold the node.
+   // Check if the memory range reserved for S3 Boot Script table is large enough to hold the node.
    //
    if (mS3BootScriptTablePtr->TableLength + EntryLength + sizeof (EFI_BOOT_SCRIPT_TERMINATE) <= EFI_PAGES_TO_SIZE((UINT32)(mS3BootScriptTablePtr->TableMemoryPageNumber))) {
      NewEntryPtr = mS3BootScriptTablePtr->TableBase + mS3BootScriptTablePtr->TableLength;
+     NewEntryPtr = mS3BootScriptTablePtr->TableBase + mS3BootScriptTablePtr->TableLength;
      mS3BootScriptTablePtr->TableLength = mS3BootScriptTablePtr->TableLength + EntryLength;
      //
 …
      S3BootScriptInternalCloseTable ();
+   }
    return (UINT8*)NewEntryPtr;
+   return (UINT8*)NewEntryPtr;
+}
 /**
   To get the start address from which a new s3 boot script entry will write into.
   @param EntryLength      the new entry length.
   @retval the address from which the a new s3 runtime script entry will write into
  **/
 UINT8*
+  @retval the address from which the a new s3 runtime script entry will write into
+ **/
+UINT8*
 S3BootScriptGetEntryAddAddress (
   UINT8  EntryLength
 …
       ASSERT_EFI_ERROR (Status);
+    }
   } else {
+  } else {
     NewEntryPtr  = S3BootScriptGetBootTimeEntryAddAddress (EntryLength);
+  }
+  }
   return NewEntryPtr;
+}
+}
 /**
 …
+}
 /**
   This is an function to close the S3 boot script table. The function could only be called in
   BOOT time phase. To comply with the Framework spec definition on
+/**
+  This is an function to close the S3 boot script table. The function could only be called in
+  BOOT time phase. To comply with the Framework spec definition on
   EFI_BOOT_SCRIPT_SAVE_PROTOCOL.CloseTable(), this function will fulfill following things:
 . Closes the specified boot script table
 . It allocates a new memory pool to duplicate all the boot scripts in the specified table.
      Once this function is called, the table maintained by the library will be destroyed
+. It allocates a new memory pool to duplicate all the boot scripts in the specified table.
+     Once this function is called, the table maintained by the library will be destroyed
      after it is copied into the allocated pool.
 . Any attempts to add a script record after calling this function will cause a new table
+. Any attempts to add a script record after calling this function will cause a new table
      to be created by the library.
 . The base address of the allocated pool will be returned in Address. Note that after
+. The base address of the allocated pool will be returned in Address. Note that after
      using the boot script table, the CALLER is responsible for freeing the pool that is allocated
      by this function.
   In Spec PI1.1, this EFI_BOOT_SCRIPT_SAVE_PROTOCOL.CloseTable() is retired. To provides this API for now is
+     by this function.
+  In Spec PI1.1, this EFI_BOOT_SCRIPT_SAVE_PROTOCOL.CloseTable() is retired. To provides this API for now is
   for Framework Spec compatibility.
   If anyone does call CloseTable() on a real platform, then the caller is responsible for figuring out
   how to get the script to run on an S3 resume because the boot script maintained by the lib will be
+  If anyone does call CloseTable() on a real platform, then the caller is responsible for figuring out
+  how to get the script to run on an S3 resume because the boot script maintained by the lib will be
   destroyed.
   @return the base address of the new copy of the boot script table.
+  @return the base address of the new copy of the boot script table.
   @note this function could only called in boot time phase
 …
   EFI_STATUS                      Status;
   EFI_BOOT_SCRIPT_TABLE_HEADER      *ScriptTableInfo;
   S3TableBase =    mS3BootScriptTablePtr->TableBase;
+  S3TableBase =    mS3BootScriptTablePtr->TableBase;
   if (S3TableBase == 0) {
     return 0;
+    return 0;
+  }
   //
 …
   TableLength = mS3BootScriptTablePtr->TableLength + sizeof (EFI_BOOT_SCRIPT_TERMINATE);
   //
   // Allocate the buffer and copy the boot script to the buffer.
+  // Allocate the buffer and copy the boot script to the buffer.
   //
   Status = gBS->AllocatePool (
 …
                   );
   if (EFI_ERROR (Status)) {
         return 0;
+        return 0;
+  }
   CopyMem (Buffer, S3TableBase, TableLength);
   //
   // Destroy the table maintained by the library so that the next write operation
+  //
+  // Destroy the table maintained by the library so that the next write operation
   // will write the record to the first entry of the table.
   //
 …
   ScriptTableInfo->Length      = (UINT8) sizeof (EFI_BOOT_SCRIPT_TABLE_HEADER);
   ScriptTableInfo->TableLength = 0;   // will be calculate at close the table
   mS3BootScriptTablePtr->TableLength = sizeof (EFI_BOOT_SCRIPT_TABLE_HEADER);
   return Buffer;
+}
 /**
   Save I/O write to boot script
+  Save I/O write to boot script
   @param Width   The width of the I/O operations.Enumerated in S3_BOOT_SCRIPT_LIB_WIDTH.
 …
   WidthInByte = (UINT8) (0x01 << (Width & 0x03));
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_IO_WRITE) + (WidthInByte * Count));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
 …
   WidthInByte = (UINT8) (0x01 << (Width & 0x03));
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_IO_READ_WRITE) + (WidthInByte * 2));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
 …
   ScriptIoReadWrite.Width   = Width;
   ScriptIoReadWrite.Address = Address;
   CopyMem ((VOID*)Script, (VOID*)&ScriptIoReadWrite, sizeof(EFI_BOOT_SCRIPT_IO_READ_WRITE));
   CopyMem ((VOID*)(Script + sizeof (EFI_BOOT_SCRIPT_IO_READ_WRITE)), Data, WidthInByte);
 …
   UINT8                 WidthInByte;
   EFI_BOOT_SCRIPT_MEM_WRITE  ScriptMemWrite;
   WidthInByte = (UINT8) (0x01 << (Width & 0x03));
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_MEM_WRITE) + (WidthInByte * Count));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
     return RETURN_OUT_OF_RESOURCES;
+  }
+  }
   //
   // Build script data
 …
   ScriptMemWrite.Address  = Address;
   ScriptMemWrite.Count    = (UINT32) Count;
   CopyMem ((VOID*)Script, (VOID*)&ScriptMemWrite, sizeof(EFI_BOOT_SCRIPT_MEM_WRITE));
   CopyMem ((VOID*)(Script + sizeof (EFI_BOOT_SCRIPT_MEM_WRITE)), Buffer, WidthInByte * Count);
   SyncBootScript (Script);
 …
   UINT8                 WidthInByte;
   EFI_BOOT_SCRIPT_MEM_READ_WRITE  ScriptMemReadWrite;
   WidthInByte = (UINT8) (0x01 << (Width & 0x03));
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_MEM_READ_WRITE) + (WidthInByte * 2));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
     return RETURN_OUT_OF_RESOURCES;
+  }
+  }
   //
   // Build script data
   //
+  //
   ScriptMemReadWrite.OpCode   = EFI_BOOT_SCRIPT_MEM_READ_WRITE_OPCODE;
   ScriptMemReadWrite.Length   = Length;
   ScriptMemReadWrite.Width    = Width;
   ScriptMemReadWrite.Address  = Address;
   CopyMem ((VOID*)Script, (VOID*)&ScriptMemReadWrite , sizeof (EFI_BOOT_SCRIPT_MEM_READ_WRITE));
   CopyMem ((VOID*)(Script + sizeof (EFI_BOOT_SCRIPT_MEM_READ_WRITE)), Data, WidthInByte);
 …
   WidthInByte = (UINT8) (0x01 << (Width & 0x03));
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE) + (WidthInByte * Count));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
     return RETURN_OUT_OF_RESOURCES;
+  }
+  }
   //
   // Build script data
 …
   ScriptPciWrite.Address  = Address;
   ScriptPciWrite.Count    = (UINT32) Count;
   CopyMem ((VOID*)Script, (VOID*)&ScriptPciWrite,  sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE));
   CopyMem ((VOID*)(Script + sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE)), Buffer, WidthInByte * Count);
   SyncBootScript (Script);
 …
   WidthInByte = (UINT8) (0x01 << (Width & 0x03));
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE) + (WidthInByte * 2));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
     return RETURN_OUT_OF_RESOURCES;
+  }
+  }
   //
   // Build script data
   //
+  //
   ScriptPciReadWrite.OpCode   = EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE_OPCODE;
   ScriptPciReadWrite.Length   = Length;
   ScriptPciReadWrite.Width    = Width;
   ScriptPciReadWrite.Address  = Address;
   CopyMem ((VOID*)Script, (VOID*)&ScriptPciReadWrite, sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE));
   CopyMem ((VOID*)(Script + sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE)), Data, WidthInByte);
 …
   WidthInByte = (UINT8) (0x01 << (Width & 0x03));
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE) + (WidthInByte * Count));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
     return RETURN_OUT_OF_RESOURCES;
+  }
+  }
   //
   // Build script data
 …
   ScriptPciWrite2.Segment  = Segment;
   ScriptPciWrite2.Count    = (UINT32)Count;
   CopyMem ((VOID*)Script, (VOID*)&ScriptPciWrite2, sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE));
   CopyMem ((VOID*)(Script + sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE)), Buffer, WidthInByte * Count);
 …
     return EFI_INVALID_PARAMETER;
+  }
   WidthInByte = (UINT8) (0x01 << (Width & 0x03));
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE) + (WidthInByte * 2));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
     return RETURN_OUT_OF_RESOURCES;
+  }
+  }
   //
   // Build script data
 …
   ScriptPciReadWrite2.Segment  = Segment;
   ScriptPciReadWrite2.Address  = Address;
   CopyMem ((VOID*)Script, (VOID*)&ScriptPciReadWrite2, sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE));
   CopyMem ((VOID*)(Script + sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE)), Data, WidthInByte);
 …
     WidthInByte
     );
   SyncBootScript (Script);
 …
   error code based on the input SMBus bus protocol.
   @param  SmBusAddress            Address that encodes the SMBUS Slave Address, SMBUS Command, SMBUS Data Length,
+  @param  SmBusAddress            Address that encodes the SMBUS Slave Address, SMBUS Command, SMBUS Data Length,
                                   and PEC.
   @param  Operation               Signifies which particular SMBus hardware protocol instance that
 …
   @retval EFI_SUCCESS             All the parameters are valid for the corresponding SMBus bus
                                   protocol.
+                                  protocol.
   @retval EFI_INVALID_PARAMETER   Operation is not defined in EFI_SMBUS_OPERATION.
   @retval EFI_INVALID_PARAMETER   Length/Buffer is NULL for operations except for EfiSmbusQuickRead
 …
   EFI_SMBUS_DEVICE_COMMAND Command;
   BOOLEAN                  PecCheck;
   Command      = SMBUS_LIB_COMMAND (SmBusAddress);
   PecCheck     = SMBUS_LIB_PEC (SmBusAddress);
   //
   // Set default value to be 2:
   // for SmbusReadWord, SmbusWriteWord and SmbusProcessCall.
+  // for SmbusReadWord, SmbusWriteWord and SmbusProcessCall.
   //
   RequiredLen = 2;
 …
     case EfiSmbusWriteBlock:
     case EfiSmbusBWBRProcessCall:
       if ((Buffer == NULL) ||
           (Length == NULL) ||
+      if ((Buffer == NULL) ||
+          (Length == NULL) ||
           (*Length < MIN_SMBUS_BLOCK_LEN) ||
           (*Length > MAX_SMBUS_BLOCK_LEN)) {
 …
   @param Length         A pointer to signify the number of bytes that this operation will do.
   @param Buffer         Contains the value of data to execute to the SMBUS slave device.
   @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
   @retval RETURN_SUCCESS           Opcode is added.
 …
 EFIAPI
 S3BootScriptSaveSmbusExecute (
   IN  UINTN                             SmBusAddress,
+  IN  UINTN                             SmBusAddress,
   IN  EFI_SMBUS_OPERATION               Operation,
   IN  UINTN                             *Length,
 …
   DataSize = (UINT8)(sizeof (EFI_BOOT_SCRIPT_SMBUS_EXECUTE) + BufferLength);
   Script = S3BootScriptGetEntryAddAddress (DataSize);
   if (Script == NULL) {
 …
   @param Duration   Duration in microseconds of the stall
   @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
   @retval RETURN_SUCCESS           Opcode is added.
 …
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_STALL));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
     return RETURN_OUT_OF_RESOURCES;
+  }
+  }
   //
   // Build script data
 …
   ScriptStall.Length    = Length;
   ScriptStall.Duration  = Duration;
   CopyMem ((VOID*)Script, (VOID*)&ScriptStall, sizeof (EFI_BOOT_SCRIPT_STALL));
   SyncBootScript (Script);
 …
   @param EntryPoint   Entry point of the code to be dispatched.
   @param Context      Argument to be passed into the EntryPoint of the code to be dispatched.
   @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
   @retval RETURN_SUCCESS           Opcode is added.
 …
   EFI_BOOT_SCRIPT_DISPATCH_2  ScriptDispatch2;
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_DISPATCH_2));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
     return RETURN_OUT_OF_RESOURCES;
+  }
+  }
   //
   // Build script data
 …
   ScriptDispatch2.EntryPoint = (EFI_PHYSICAL_ADDRESS)(UINTN)EntryPoint;
   ScriptDispatch2.Context =   (EFI_PHYSICAL_ADDRESS)(UINTN)Context;
   CopyMem ((VOID*)Script, (VOID*)&ScriptDispatch2, sizeof (EFI_BOOT_SCRIPT_DISPATCH_2));
   SyncBootScript (Script);
 …
   UINT8                 Length;
   UINT8                *Script;
   UINT8                 WidthInByte;
   EFI_BOOT_SCRIPT_MEM_POLL      ScriptMemPoll;
+  UINT8                 WidthInByte;
+  EFI_BOOT_SCRIPT_MEM_POLL      ScriptMemPoll;
   WidthInByte = (UINT8) (0x01 << (Width & 0x03));
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_MEM_POLL) + (WidthInByte * 2));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
 …
   ScriptMemPoll.OpCode   = EFI_BOOT_SCRIPT_MEM_POLL_OPCODE;
   ScriptMemPoll.Length   = Length;
   ScriptMemPoll.Width    = Width;
+  ScriptMemPoll.Width    = Width;
   ScriptMemPoll.Address  = Address;
   ScriptMemPoll.Duration = Duration;
 …
   CopyMem ((UINT8 *) (Script + sizeof (EFI_BOOT_SCRIPT_MEM_POLL)), BitValue, WidthInByte);
   CopyMem ((UINT8 *) (Script + sizeof (EFI_BOOT_SCRIPT_MEM_POLL) + WidthInByte), BitMask, WidthInByte);
   CopyMem ((VOID*)Script, (VOID*)&ScriptMemPoll, sizeof (EFI_BOOT_SCRIPT_MEM_POLL));
+  CopyMem ((VOID*)Script, (VOID*)&ScriptMemPoll, sizeof (EFI_BOOT_SCRIPT_MEM_POLL));
   SyncBootScript (Script);
 …
   Store arbitrary information in the boot script table. This opcode is a no-op on dispatch and is only
   used for debugging script issues.
   @param InformationLength   Length of the data in bytes
   @param Information       Information to be logged in the boot scrpit
   @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
   @retval RETURN_SUCCESS           Opcode is added.
 …
 EFIAPI
 S3BootScriptSaveInformation (
   IN  UINT32                                InformationLength,
+  IN  UINT32                                InformationLength,
   IN  VOID                                 *Information
+  )
 …
   ScriptInformation.InformationLength = InformationLength;
+  ScriptInformation.InformationLength = InformationLength;
   CopyMem ((VOID*)Script, (VOID*)&ScriptInformation, sizeof (EFI_BOOT_SCRIPT_INFORMATION));
 …
   Store a string in the boot script table. This opcode is a no-op on dispatch and is only
   used for debugging script issues.
   @param String            The string to save to boot script table
   @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
   @retval RETURN_SUCCESS           Opcode is added.
 …
+  )
+{
   return S3BootScriptSaveInformation (
            (UINT32) AsciiStrLen (String) + 1,
+  return S3BootScriptSaveInformation (
+           (UINT32) AsciiStrLen (String) + 1,
            (VOID*) String
            );
 …
   @param EntryPoint   Entry point of the code to be dispatched.
   @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
   @retval RETURN_SUCCESS           Opcode is added.
 …
   UINT8                *Script;
   EFI_BOOT_SCRIPT_DISPATCH  ScriptDispatch;
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_DISPATCH));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
     return RETURN_OUT_OF_RESOURCES;
+  }
+  }
   //
   // Build script data
 …
   ScriptDispatch.Length     = Length;
   ScriptDispatch.EntryPoint = (EFI_PHYSICAL_ADDRESS)(UINTN)EntryPoint;
   CopyMem ((VOID*)Script, (VOID*)&ScriptDispatch, sizeof (EFI_BOOT_SCRIPT_DISPATCH));
+  CopyMem ((VOID*)Script, (VOID*)&ScriptDispatch, sizeof (EFI_BOOT_SCRIPT_DISPATCH));
   SyncBootScript (Script);
 …
   Adds a record for I/O reads the I/O location and continues when the exit criteria is satisfied or after a
   defined duration.
   @param  Width                 The width of the I/O operations.
+  @param  Width                 The width of the I/O operations.
   @param  Address               The base address of the I/O operations.
   @param  Data                  The comparison value used for the polling exit criteria.
 …
   IN UINT64                     Address,
   IN VOID                      *Data,
   IN VOID                      *DataMask,
   IN UINT64                     Delay
+  )
+{
   UINT8                 WidthInByte;
+  IN VOID                      *DataMask,
+  IN UINT64                     Delay
+  )
+{
+  UINT8                 WidthInByte;
   UINT8                *Script;
   UINT8                 Length;
   EFI_BOOT_SCRIPT_IO_POLL  ScriptIoPoll;
   WidthInByte = (UINT8) (0x01 << (Width & 0x03));
+  WidthInByte = (UINT8) (0x01 << (Width & 0x03));
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_IO_POLL) + (WidthInByte * 2));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
     return RETURN_OUT_OF_RESOURCES;
+  }
+  }
   //
   // Build script data
 …
   ScriptIoPoll.OpCode   = EFI_BOOT_SCRIPT_IO_POLL_OPCODE;
   ScriptIoPoll.Length   = (UINT8) (sizeof (EFI_BOOT_SCRIPT_IO_POLL) + (WidthInByte * 2));
   ScriptIoPoll.Width    = Width;
+  ScriptIoPoll.Width    = Width;
   ScriptIoPoll.Address  = Address;
   ScriptIoPoll.Delay    = Delay;
   CopyMem ((VOID*)Script, (VOID*)&ScriptIoPoll, sizeof (EFI_BOOT_SCRIPT_IO_POLL));
+  CopyMem ((VOID*)Script, (VOID*)&ScriptIoPoll, sizeof (EFI_BOOT_SCRIPT_IO_POLL));
   CopyMem ((UINT8 *) (Script + sizeof (EFI_BOOT_SCRIPT_IO_POLL)), Data, WidthInByte);
   CopyMem ((UINT8 *) (Script + sizeof (EFI_BOOT_SCRIPT_IO_POLL) + WidthInByte), DataMask, WidthInByte);
   SyncBootScript (Script);
 …
   after a defined duration.
   @param  Width                 The width of the I/O operations.
+  @param  Width                 The width of the I/O operations.
   @param  Address               The address within the PCI configuration space.
   @param  Data                  The comparison value used for the polling exit criteria.
 …
+{
   UINT8                   *Script;
   UINT8                    WidthInByte;
+  UINT8                    WidthInByte;
   UINT8                    Length;
   EFI_BOOT_SCRIPT_PCI_CONFIG_POLL  ScriptPciPoll;
 …
   WidthInByte = (UINT8) (0x01 << (Width & 0x03));
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_POLL) + (WidthInByte * 2));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
 …
   ScriptPciPoll.OpCode   = EFI_BOOT_SCRIPT_PCI_CONFIG_POLL_OPCODE;
   ScriptPciPoll.Length   = (UINT8) (sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_POLL) + (WidthInByte * 2));
   ScriptPciPoll.Width    = Width;
+  ScriptPciPoll.Width    = Width;
   ScriptPciPoll.Address  = Address;
   ScriptPciPoll.Delay    = Delay;
 …
   CopyMem ((UINT8 *) (Script + sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_POLL)), Data, WidthInByte);
   CopyMem ((UINT8 *) (Script + sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_POLL) + WidthInByte), DataMask, WidthInByte);
   SyncBootScript (Script);
 …
   after a defined duration.
   @param  Width                 The width of the I/O operations.
+  @param  Width                 The width of the I/O operations.
   @param  Segment               The PCI segment number for Address.
   @param  Address               The address within the PCI configuration space.
 …
+)
+{
   UINT8                    WidthInByte;
+  UINT8                    WidthInByte;
   UINT8                   *Script;
   UINT8                    Length;
 …
   WidthInByte = (UINT8) (0x01 << (Width & 0x03));
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL) + (WidthInByte * 2));
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
     return RETURN_OUT_OF_RESOURCES;
+  }
+  }
   //
   // Build script data
 …
   ScriptPci2Poll.OpCode   = EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE;
   ScriptPci2Poll.Length   = (UINT8) (sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL) + (WidthInByte * 2));
   ScriptPci2Poll.Width    = Width;
+  ScriptPci2Poll.Width    = Width;
   ScriptPci2Poll.Segment  = Segment;
   ScriptPci2Poll.Address  = Address;
 …
   CopyMem ((UINT8 *) (Script + sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL)), Data, WidthInByte);
   CopyMem ((UINT8 *) (Script + sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL) + WidthInByte), DataMask, WidthInByte);
   SyncBootScript (Script);
 …
 /**
   Do the calculation of start address from which a new s3 boot script entry will write into.
   @param EntryLength      The new entry length.
   @param Position         specifies the position in the boot script table where the opcode will be
                           inserted, either before or after, depending on BeforeOrAfter.
+                          inserted, either before or after, depending on BeforeOrAfter.
   @param BeforeOrAfter    The flag to indicate to insert the nod before or after the position.
                           This parameter is effective when InsertFlag is TRUE
 …
   IN  VOID     *Position OPTIONAL,
   IN  BOOLEAN   BeforeOrAfter OPTIONAL,
   OUT UINT8   **Script
+  OUT UINT8   **Script
+  )
+{
    UINTN                            TableLength;
    UINT8                            *S3TableBase;
    UINTN                            PositionOffset;
+   UINTN                            PositionOffset;
    EFI_BOOT_SCRIPT_COMMON_HEADER     ScriptHeader;
    //
 …
    TableLength =  mS3BootScriptTablePtr->TableLength - EntryLength;
    S3TableBase = mS3BootScriptTablePtr->TableBase ;
    //
+   //
    // calculate the Position offset
    //
    if (Position != NULL) {
      PositionOffset = (UINTN) ((UINT8 *)Position - S3TableBase);
      //
      // If the BeforeOrAfter is FALSE, that means to insert the node right after the node.
      //
      if (!BeforeOrAfter) {
         CopyMem ((VOID*)&ScriptHeader, Position, sizeof(EFI_BOOT_SCRIPT_COMMON_HEADER));
+        CopyMem ((VOID*)&ScriptHeader, Position, sizeof(EFI_BOOT_SCRIPT_COMMON_HEADER));
         PositionOffset += (ScriptHeader.Length);
+     }
      //
+     //
      // Insert the node before the adjusted Position
      //
      CopyMem (S3TableBase+PositionOffset+EntryLength, S3TableBase+PositionOffset, TableLength - PositionOffset);
+     CopyMem (S3TableBase+PositionOffset+EntryLength, S3TableBase+PositionOffset, TableLength - PositionOffset);
      //
      // calculate the the start address for the new entry.
+     // calculate the the start address for the new entry.
      //
      *Script = S3TableBase + PositionOffset;
    } else {
      if (!BeforeOrAfter) {
 …
        //  Insert the node to the end of the table
        //
        *Script = S3TableBase + TableLength;
+       *Script = S3TableBase + TableLength;
      } else {
        //
+       //
        // Insert the node to the beginning of the table
        //
        PositionOffset = (UINTN) sizeof(EFI_BOOT_SCRIPT_TABLE_HEADER);
        CopyMem (S3TableBase+PositionOffset+EntryLength, S3TableBase+PositionOffset, TableLength - PositionOffset);
        *Script = S3TableBase + PositionOffset;
+       CopyMem (S3TableBase+PositionOffset+EntryLength, S3TableBase+PositionOffset, TableLength - PositionOffset);
+       *Script = S3TableBase + PositionOffset;
+     }
+   }
+}
 /**
   Move the last boot script entry to the position
+   }
+}
+/**
+  Move the last boot script entry to the position
   @param  BeforeOrAfter         Specifies whether the opcode is stored before (TRUE) or after (FALSE) the position
 …
+{
   UINT8*                Script;
   VOID                  *TempPosition;
+  VOID                  *TempPosition;
   UINTN                 StartAddress;
   UINT32                TableLength;
 …
   UINT8*                LastOpcode;
   UINT8                 TempBootScriptEntry[BOOT_SCRIPT_NODE_MAX_LENGTH];
   ValidatePosition = FALSE;
   TempPosition = (Position == NULL) ? NULL:(*Position);
 …
   // Find the last boot Script Entry which is not the terminate node
   //
   while ((UINTN) Script < (UINTN) (StartAddress + TableLength)) {
     CopyMem ((VOID*)&ScriptHeader, Script, sizeof(EFI_BOOT_SCRIPT_COMMON_HEADER));
+  while ((UINTN) Script < (UINTN) (StartAddress + TableLength)) {
+    CopyMem ((VOID*)&ScriptHeader, Script, sizeof(EFI_BOOT_SCRIPT_COMMON_HEADER));
     if (TempPosition != NULL && TempPosition == Script) {
       //
       // If the position is specified, the position must be pointed to a boot script entry start address.
+      // If the position is specified, the position must be pointed to a boot script entry start address.
       //
       ValidatePosition = TRUE;
 …
     if (ScriptHeader.OpCode != S3_BOOT_SCRIPT_LIB_TERMINATE_OPCODE) {
       LastOpcode = Script;
+    }
+    }
     Script  = Script + ScriptHeader.Length;
+  }
 …
     return RETURN_INVALID_PARAMETER;
+  }
   CopyMem ((VOID*)&ScriptHeader, LastOpcode, sizeof(EFI_BOOT_SCRIPT_COMMON_HEADER));
   CopyMem((VOID*)TempBootScriptEntry, LastOpcode, ScriptHeader.Length);
+  CopyMem ((VOID*)&ScriptHeader, LastOpcode, sizeof(EFI_BOOT_SCRIPT_COMMON_HEADER));
+  CopyMem((VOID*)TempBootScriptEntry, LastOpcode, ScriptHeader.Length);
   //
   // Find the right position to write the node in
 …
     TempPosition,
     BeforeOrAfter,
     &Script
+    &Script
   );
   //
 …
+}
 /**
   Create a Label node in the boot script table.
+  Create a Label node in the boot script table.
   @param  BeforeOrAfter         Specifies whether the opcode is stored before (TRUE) or after (FALSE) the position
                                 in the boot script table specified by Position. If Position is NULL or points to
 …
   @param  Position              On entry, specifies the position in the boot script table where the opcode will be
                                 inserted, either before or after, depending on BeforeOrAfter. On exit, specifies
                                 the position of the inserted opcode in the boot script table.
+                                the position of the inserted opcode in the boot script table.
   @param InformationLength      Length of the label in bytes
   @param Information            Label to be logged in the boot scrpit
   @retval RETURN_INVALID_PARAMETER The Position is not a valid position in the boot script table.
   @retval RETURN_OUT_OF_RESOURCES  Not enough memory for the table do operation.
 …
 S3BootScriptLabelInternal (
   IN        BOOLEAN                        BeforeOrAfter,
   IN OUT    VOID                         **Position OPTIONAL,
   IN        UINT32                         InformationLength,
+  IN OUT    VOID                         **Position OPTIONAL,
+  IN        UINT32                         InformationLength,
   IN CONST  CHAR8                          *Information
+  )
 …
   UINT8                 *Script;
   EFI_BOOT_SCRIPT_INFORMATION  ScriptInformation;
   Length = (UINT8)(sizeof (EFI_BOOT_SCRIPT_INFORMATION) + InformationLength);
   Script = S3BootScriptGetEntryAddAddress (Length);
   if (Script == NULL) {
 …
   ScriptInformation.InformationLength = InformationLength;
+  ScriptInformation.InformationLength = InformationLength;
   CopyMem ((VOID*)Script, (VOID*)&ScriptInformation, sizeof (EFI_BOOT_SCRIPT_INFORMATION));
 …
   @param  BeforeOrAfter         Specifies whether the opcode is stored before (TRUE)
                                 or after (FALSE) the position in the boot script table
+                                or after (FALSE) the position in the boot script table
                                 specified by Position.
   @param  CreateIfNotFound      Specifies whether the label will be created if the label
+  @param  CreateIfNotFound      Specifies whether the label will be created if the label
                                 does not exists (TRUE) or not (FALSE).
   @param  Position              On entry, specifies the position in the boot script table
 …
                                 specified script table.
   @retval EFI_INVALID_PARAMETER The parameter is illegal or the given boot script is not supported.
                                 If the opcode is unknow or not supported because of the PCD
+                                If the opcode is unknow or not supported because of the PCD
                                 Feature Flags.
   @retval EFI_OUT_OF_RESOURCES  There is insufficient memory to store the boot script.
 …
 **/
 RETURN_STATUS
 EFIAPI
+EFIAPI
 S3BootScriptLabel (
   IN       BOOLEAN                      BeforeOrAfter,
 …
     return EFI_INVALID_PARAMETER;
+  }
   //
   // Check that the script is initialized and synced without adding an entry to the script.
 …
     return RETURN_OUT_OF_RESOURCES;
+  }
   //
   // Check the header and search for existing label.
   //
+  //
   Script = mS3BootScriptTablePtr->TableBase;
   CopyMem ((VOID*)&TableHeader, Script, sizeof(EFI_BOOT_SCRIPT_TABLE_HEADER));
 …
   Script    =     Script + TableHeader.Length;
   while ((UINTN) Script < (UINTN) (StartAddress + TableLength)) {
     CopyMem ((VOID*)&ScriptHeader, Script, sizeof(EFI_BOOT_SCRIPT_COMMON_HEADER));
+    CopyMem ((VOID*)&ScriptHeader, Script, sizeof(EFI_BOOT_SCRIPT_COMMON_HEADER));
     if (ScriptHeader.OpCode == S3_BOOT_SCRIPT_LIB_LABEL_OPCODE) {
       if (AsciiStrCmp ((CHAR8 *)(UINTN)(Script+sizeof(EFI_BOOT_SCRIPT_INFORMATION)), Label) == 0) {
         (*Position) = Script;
+        (*Position) = Script;
         return EFI_SUCCESS;
+      }
+    }
+    }
     Script  = Script + ScriptHeader.Length;
+  }
   if (CreateIfNotFound) {
     LabelLength = (UINT32)AsciiStrSize(Label);
     return S3BootScriptLabelInternal (BeforeOrAfter,Position, LabelLength, Label);
+    return S3BootScriptLabelInternal (BeforeOrAfter,Position, LabelLength, Label);
   } else {
     return EFI_NOT_FOUND;
+  }
+  }
+}
 …
                                 specified script table.
   @retval EFI_INVALID_PARAMETER The parameter is illegal or the given boot script is not supported.
                                 If the opcode is unknow or not supported because of the PCD
+                                If the opcode is unknow or not supported because of the PCD
                                 Feature Flags.
   @retval EFI_OUT_OF_RESOURCES  There is insufficient memory to store the boot script.
 …
 **/
 RETURN_STATUS
 EFIAPI
+EFIAPI
 S3BootScriptCompare (
   IN  UINT8                       *Position1,
 …
+{
   UINT8*                    Script;
   UINT32                    TableLength;
+  UINT32                    TableLength;
   if (RelativePosition == NULL) {
 …
+  }
   *RelativePosition = (Position1 < Position2)?-1:((Position1 == Position2)?0:1);
   return EFI_SUCCESS;
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PiDxeS3BootScriptLib/DxeS3BootScriptLib.inf

r58459	r58466
53	53	SmbusLib
54	54	PciLib
55		IoLib
	55	IoLib
56	56	LockBoxLib
57	57

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PiDxeS3BootScriptLib/InternalBootScriptLib.h

-              r48674
+              r58466
 /** @file
   Support for S3 boot script lib. This file defined some internal macro and internal
+  Support for S3 boot script lib. This file defined some internal macro and internal
   data structure
   Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
 …
         ((((UINTN)(A))& 0xff000000) >> 24), ((((UINTN)(A)) &0x00ff0000) >> 16), ((((UINTN)(A)) & 0xff00) >> 8), ((RShiftU64 ((A), 32) & 0xfff) | ((A)& 0xff)) \
+        )
 …
 typedef struct {
   UINT8           *TableBase;
   UINT32          TableLength;               // Record the actual memory length
   UINT16          TableMemoryPageNumber;     // Record the page number Allocated for the table
+  UINT32          TableLength;               // Record the actual memory length
+  UINT16          TableMemoryPageNumber;     // Record the page number Allocated for the table
   BOOLEAN         AtRuntime;                 // Record if current state is after SmmReadyToLock
   BOOLEAN         InSmm;                     // Record if this library is in SMM.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PiSmmCoreMemoryAllocationLib/MemoryAllocationLib.c

-              r58459
+              r58466
   Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
   which accompanies this distribution.  The full text of the license may be found at
   http://opensource.org/licenses/bsd-license.php
   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 **/
 …
 /**
   This function gets and caches SMRAM ranges that are present in the system.
   It will ASSERT() if SMM Access2 Protocol doesn't exist.
   It will ASSERT() if SMRAM ranges can't be got.
   It will ASSERT() if Resource can't be allocated for cache SMRAM range.
+  It will ASSERT() if Resource can't be allocated for cache SMRAM range.
 **/
 …
   //
   Status = gBS->LocateProtocol (
                   &gEfiSmmAccess2ProtocolGuid,
                   NULL,
+                  &gEfiSmmAccess2ProtocolGuid,
+                  NULL,
                   (VOID **)&SmmAccess
                   );
 …
   for (Index = 0; Index < mSmramRangeCount; Index ++) {
     if (((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer >= mSmramRanges[Index].CpuStart) &&
+    if (((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer >= mSmramRanges[Index].CpuStart) &&
         ((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer < (mSmramRanges[Index].CpuStart + mSmramRanges[Index].PhysicalSize))) {
       return TRUE;
 …
 VOID *
 InternalAllocatePages (
   IN EFI_MEMORY_TYPE  MemoryType,
+  IN EFI_MEMORY_TYPE  MemoryType,
   IN UINTN            Pages
+  )
+{
   EFI_STATUS            Status;
   EFI_PHYSICAL_ADDRESS  Memory;
+  EFI_PHYSICAL_ADDRESS  Memory;
   if (Pages == 0) {
 …
   Allocation Library.  If it is not possible to free allocated pages, then this function will
   perform no actions.
   If Buffer was not allocated with a page allocation function in the Memory Allocation Library,
   then ASSERT().
   If Pages is zero, then ASSERT().
   @param  Buffer                Pointer to the buffer of pages to free.
   @param  Pages                 The number of 4 KB pages to free.
 …
 VOID *
 InternalAllocateAlignedPages (
   IN EFI_MEMORY_TYPE  MemoryType,
+  IN EFI_MEMORY_TYPE  MemoryType,
   IN UINTN            Pages,
   IN UINTN            Alignment
 …
   //
   ASSERT ((Alignment & (Alignment - 1)) == 0);
   if (Pages == 0) {
     return NULL;
 …
     //
     ASSERT (RealPages > Pages);
     Status         = SmmAllocatePages (AllocateAnyPages, MemoryType, RealPages, &Memory);
     if (EFI_ERROR (Status)) {
 …
   returned.  If there is not enough memory at the specified alignment remaining to satisfy the
   request, then NULL is returned.
   If Alignment is not a power of two and Alignment is not zero, then ASSERT().
   If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
 …
   returned.  If there is not enough memory at the specified alignment remaining to satisfy the
   request, then NULL is returned.
   If Alignment is not a power of two and Alignment is not zero, then ASSERT().
   If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
 …
   returned.  If there is not enough memory at the specified alignment remaining to satisfy the
   request, then NULL is returned.
   If Alignment is not a power of two and Alignment is not zero, then ASSERT().
   If Pages plus EFI_SIZE_TO_PAGES (Alignment) overflows, then ASSERT().
 …
   Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  Buffer
   must have been allocated on a previous call to the aligned page allocation services of the Memory
   Allocation Library.  If it is not possible to free allocated pages, then this function will
+  Allocation Library.  If it is not possible to free allocated pages, then this function will
   perform no actions.
   If Buffer was not allocated with an aligned page allocation function in the Memory Allocation
   Library, then ASSERT().
   If Pages is zero, then ASSERT().
   @param  Buffer                Pointer to the buffer of pages to free.
   @param  Pages                 The number of 4 KB pages to free.
 …
 VOID *
 InternalAllocatePool (
   IN EFI_MEMORY_TYPE  MemoryType,
+  IN EFI_MEMORY_TYPE  MemoryType,
   IN UINTN            AllocationSize
+  )
 …
 VOID *
 InternalAllocateZeroPool (
   IN EFI_MEMORY_TYPE  PoolType,
+  IN EFI_MEMORY_TYPE  PoolType,
   IN UINTN            AllocationSize
+  )
+  )
+{
   VOID  *Memory;
 …
   is not enough memory remaining to satisfy the request, then NULL is returned.
   If Buffer is NULL, then ASSERT().
   If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
   @param  PoolType              The type of pool to allocate.
 …
 VOID *
 InternalAllocateCopyPool (
   IN EFI_MEMORY_TYPE  PoolType,
+  IN EFI_MEMORY_TYPE  PoolType,
   IN UINTN            AllocationSize,
   IN CONST VOID       *Buffer
+  )
+  )
+{
   VOID  *Memory;
 …
+  }
   return Memory;
+}
+}
 /**
 …
   allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
   is not enough memory remaining to satisfy the request, then NULL is returned.
   If Buffer is NULL, then ASSERT().
   If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
   @param  AllocationSize        The number of bytes to allocate and zero.
 …
   allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
   is not enough memory remaining to satisfy the request, then NULL is returned.
   If Buffer is NULL, then ASSERT().
   If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
   @param  AllocationSize        The number of bytes to allocate and zero.
 …
   allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
   is not enough memory remaining to satisfy the request, then NULL is returned.
   If Buffer is NULL, then ASSERT().
   If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
+  If AllocationSize is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
   @param  AllocationSize        The number of bytes to allocate and zero.
 …
   Allocates and zeros the number bytes specified by NewSize from memory of the type
   specified by PoolType.  If OldBuffer is not NULL, then the smaller of OldSize and
   NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
   OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
   If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
+  specified by PoolType.  If OldBuffer is not NULL, then the smaller of OldSize and
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
   enough memory remaining to satisfy the request, then NULL is returned.
   If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
   is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
 …
   @param  OldSize        The size, in bytes, of OldBuffer.
   @param  NewSize        The size, in bytes, of the buffer to reallocate.
   @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
                          parameter that may be NULL.
 …
 VOID *
 InternalReallocatePool (
   IN EFI_MEMORY_TYPE  PoolType,
+  IN EFI_MEMORY_TYPE  PoolType,
   IN UINTN            OldSize,
   IN UINTN            NewSize,
 …
   Allocates and zeros the number bytes specified by NewSize from memory of type
   EfiBootServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and
   NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
   OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
   If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
+  EfiBootServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
   enough memory remaining to satisfy the request, then NULL is returned.
   If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
   is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
 …
   @param  OldSize        The size, in bytes, of OldBuffer.
   @param  NewSize        The size, in bytes, of the buffer to reallocate.
   @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
                          parameter that may be NULL.
 …
   Allocates and zeros the number bytes specified by NewSize from memory of type
   EfiRuntimeServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and
   NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
   OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
   If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
+  EfiRuntimeServicesData.  If OldBuffer is not NULL, then the smaller of OldSize and
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
   enough memory remaining to satisfy the request, then NULL is returned.
 …
   @param  OldSize        The size, in bytes, of OldBuffer.
   @param  NewSize        The size, in bytes, of the buffer to reallocate.
   @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
                          parameter that may be NULL.
 …
   Allocates and zeros the number bytes specified by NewSize from memory of type
   EfiReservedMemoryType.  If OldBuffer is not NULL, then the smaller of OldSize and
   NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
   OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
   If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
+  EfiReservedMemoryType.  If OldBuffer is not NULL, then the smaller of OldSize and
+  NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
+  OldBuffer is freed.  A pointer to the newly allocated buffer is returned.
+  If NewSize is 0, then a valid buffer of 0 size is  returned.  If there is not
   enough memory remaining to satisfy the request, then NULL is returned.
 …
   @param  OldSize        The size, in bytes, of OldBuffer.
   @param  NewSize        The size, in bytes, of the buffer to reallocate.
   @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
+  @param  OldBuffer      The buffer to copy to the allocated buffer.  This is an optional
                          parameter that may be NULL.
 …
   pool allocation services of the Memory Allocation Library.  If it is not possible to free pool
   resources, then this function will perform no actions.
   If Buffer was not allocated with a pool allocation function in the Memory Allocation Library,
   then ASSERT().

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PiSmmCoreMemoryAllocationLib/PiSmmCoreMemoryAllocationLib.inf

-              r58459
+              r58466
 # The implementation borrows the SMM Core Memory Allocation services as the primitive
 # for memory allocation instead of using SMM System Table servces in an indirect way.
 # It is assumed that this library instance must be linked with SMM Cre in this package.
+# It is assumed that this library instance must be linked with SMM Cre in this package.
+#
 # Copyright (c) 2010 - 2015, Intel Corporation. All rights reserved.<BR>
 …
 [Protocols]
   gEfiSmmAccess2ProtocolGuid    ## CONSUMES
+  gEfiSmmAccess2ProtocolGuid    ## CONSUMES

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PiSmmCoreMemoryAllocationLib/PiSmmCoreMemoryAllocationServices.h

-              r58459
+              r58466
   This header file borrows the PiSmmCore Memory Allocation services as the primitive
   for memory allocation.
+  for memory allocation.
   Copyright (c) 2008 - 2015, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
   which accompanies this distribution.  The full text of the license may be found at
   http://opensource.org/licenses/bsd-license.php
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 **/

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/RuntimeDxeReportStatusCodeLib/ReportStatusCodeLib.c

-              r58459
+              r58466
     return;
+  }
   if (mHaveExitedBootServices) {
     return;
+  }
   //
   // Check gBS just in case ReportStatusCode is called before gBS is initialized.
 …
   //
   // Locate the report status code service before enter runtime.
   //
+  //
   InternalGetReportStatusCode ();
   mHaveExitedBootServices = TRUE;
+}
 …
   @param  ImageHandle   The firmware allocated handle for the EFI image.
   @param  SystemTable   A pointer to the EFI System Table.
   @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
 …
   //
   // Cache the report status code service
   //
+  //
   InternalGetReportStatusCode ();
   //
   // Register notify function for EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE
   //
+  //
   Status = gBS->CreateEventEx (
                   EVT_NOTIFY_SIGNAL,
 …
   //
   // Register notify function for EVT_SIGNAL_EXIT_BOOT_SERVICES
   //
+  //
   Status = gBS->CreateEventEx (
                   EVT_NOTIFY_SIGNAL,
 …
 /**
   The destructor function of Runtime DXE Report Status Code Lib.
   The destructor function frees memory allocated by constructor, and closes related events.
   It will ASSERT() if that related operation fails and it will always return EFI_SUCCESS.
+  It will ASSERT() if that related operation fails and it will always return EFI_SUCCESS.
   @param  ImageHandle   The firmware allocated handle for the EFI image.
   @param  SystemTable   A pointer to the EFI System Table.
   @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
 …
     return mReportStatusCodeLibStatusCodeProtocol->ReportStatusCode (Type, Value, Instance, (EFI_GUID *)CallerId, Data);
+  }
   return EFI_UNSUPPORTED;
+}
 …
       return EFI_UNSUPPORTED;
+    }
     //
     // Allocate space for the Status Code Header and its buffer

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/RuntimeDxeReportStatusCodeLib/RuntimeDxeReportStatusCodeLib.inf

r58459	r58466
32	32	[Sources]
33	33	ReportStatusCodeLib.c
34
	34
35	35	[Packages]
36	36	MdePkg/MdePkg.dec

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmCorePerformanceLib/SmmCorePerformanceLib.c

-              r58459
+              r58466
 //
 // The current maximum number of logging entries. If current number of
+// The current maximum number of logging entries. If current number of
 // entries exceeds this value, it will re-allocate a larger array and
 // migration the old data to the larger array.
 …
   This SMI handler provides services for the performance wrapper driver.
    Caution: This function may receive untrusted input.
    Communicate buffer and buffer size are external input, so this function will do basic validation.
 …
   @param[in, out] CommBufferSize The size of the CommBuffer.
   @retval EFI_SUCCESS                         The interrupt was handled and quiesced. No other handlers
+  @retval EFI_SUCCESS                         The interrupt was handled and quiesced. No other handlers
                                               should still be called.
   @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED  The interrupt has been quiesced but other handlers should
+  @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED  The interrupt has been quiesced but other handlers should
                                               still be called.
   @retval EFI_WARN_INTERRUPT_SOURCE_PENDING   The interrupt is still pending and other handlers should still
+  @retval EFI_WARN_INTERRUPT_SOURCE_PENDING   The interrupt is still pending and other handlers should still
                                               be called.
   @retval EFI_INTERRUPT_PENDING               The interrupt could not be quiesced.
 …
     return EFI_SUCCESS;
+  }
   SmmPerfCommData = (SMM_PERF_COMMUNICATE_EX *)CommBuffer;
 …
   SmmPerfCommData->ReturnStatus = Status;
   return EFI_SUCCESS;
+}
 …
   @param[in, out] CommBufferSize The size of the CommBuffer.
   @retval EFI_SUCCESS                         The interrupt was handled and quiesced. No other handlers
+  @retval EFI_SUCCESS                         The interrupt was handled and quiesced. No other handlers
                                               should still be called.
   @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED  The interrupt has been quiesced but other handlers should
+  @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED  The interrupt has been quiesced but other handlers should
                                               still be called.
   @retval EFI_WARN_INTERRUPT_SOURCE_PENDING   The interrupt is still pending and other handlers should still
+  @retval EFI_WARN_INTERRUPT_SOURCE_PENDING   The interrupt is still pending and other handlers should still
                                               be called.
   @retval EFI_INTERRUPT_PENDING               The interrupt could not be quiesced.
 …
   SmmPerfCommData->ReturnStatus = Status;
   return EFI_SUCCESS;
+}
 /**
   SmmBase2 protocol notify callback function, when SMST and SMM memory service get initialized
   this function is callbacked to initialize the Smm Performance Lib
+  SmmBase2 protocol notify callback function, when SMST and SMM memory service get initialized
+  this function is callbacked to initialize the Smm Performance Lib
   @param  Event    The event of notify protocol.
 …
   mGaugeData = AllocateZeroPool (sizeof (GAUGE_DATA_HEADER) + (sizeof (GAUGE_DATA_ENTRY_EX) * mMaxGaugeRecords));
   ASSERT (mGaugeData != NULL);
   //
   // Install the protocol interfaces.
 …
 /**
   The constructor function initializes the Performance Measurement Enable flag and
+  The constructor function initializes the Performance Measurement Enable flag and
   registers SmmBase2 protocol notify callback.
   It will ASSERT() if one of these operations fails and it will always return EFI_SUCCESS.
 …
 EFIAPI
 GetPerformanceMeasurementEx (
   IN  UINTN       LogEntryKey,
+  IN  UINTN       LogEntryKey,
   OUT CONST VOID  **Handle,
   OUT CONST CHAR8 **Token,
 …
   GaugeData = NULL;
   ASSERT (Handle != NULL);
   ASSERT (Token != NULL);

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmCorePerformanceLib/SmmCorePerformanceLib.inf

-              r58459
+              r58466
 ## @file
 #  Performance library instance used by SMM Core.
+#
+#
 #  This library provides the performance measurement interfaces and initializes performance
 #  logging for the SMM phase.
 …
 #  This library is mainly used by SMM Core to start performance logging to ensure that
 #  SMM Performance and PerformanceEx Protocol are installed at the very beginning of SMM phase.
+#
+#
 #  Copyright (c) 2011 - 2015, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 …
 #  which accompanies this distribution.  The full text of the license may be found at
 #  http://opensource.org/licenses/bsd-license.php
+#
+#
 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#
 ##

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmCorePerformanceLib/SmmCorePerformanceLibInternal.h

-              r58459
+              r58466
 **/
 #ifndef _SMM_CORE_PERFORMANCE_LIB_INTERNAL_H_
 #define _SMM_CORE_PERFORMANCE_LIB_INTERNAL_H_
 …
 #include <Library/TimerLib.h>
 #include <Library/PcdLib.h>
 #include <Library/UefiLib.h>
+#include <Library/UefiLib.h>
 #include <Library/UefiBootServicesTableLib.h>
 #include <Library/MemoryAllocationLib.h>

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmCorePlatformHookLibNull/SmmCorePlatformHookLibNull.c

-              r48674
+              r58466
 /**
   Performs platform specific tasks before invoking registered SMI handlers.
   This function performs platform specific tasks before invoking registered SMI handlers.
   @retval EFI_SUCCESS       The platform hook completes successfully.
   @retval Other values      The paltform hook cannot complete due to some error.
 …
 /**
   Performs platform specific tasks after invoking registered SMI handlers.
   This function performs platform specific tasks after invoking registered SMI handlers.
   @retval EFI_SUCCESS       The platform hook completes successfully.
   @retval Other values      The paltform hook cannot complete due to some error.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmLockBoxLib/SmmLockBoxDxeLib.c

r48674	r58466
297	297	@retval RETURN_SUCCESS the information is restored successfully.
298	298	@retval RETURN_INVALID_PARAMETER the Guid is NULL, or one of Buffer and Length is NULL.
299		@retval RETURN_WRITE_PROTECTED Buffer and Length are NULL, but the LockBox has no
	299	@retval RETURN_WRITE_PROTECTED Buffer and Length are NULL, but the LockBox has no
300	300	LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE attribute.
301	301	@retval RETURN_BUFFER_TOO_SMALL the Length is too small to hold the confidential information.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmLockBoxLib/SmmLockBoxDxeLib.inf

r58459	r58466
27	27	# The following information is for reference only and not required by the build tools.
28	28	#
29		# VALID_ARCHITECTURES = IA32 X64
	29	# VALID_ARCHITECTURES = IA32 X64
30	30	#
31	31

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmLockBoxLib/SmmLockBoxPeiLib.c

-              r48674
+              r58466
   @retval RETURN_SUCCESS            the information is restored successfully.
   @retval RETURN_WRITE_PROTECTED    Buffer and Length are NULL, but the LockBox has no
+  @retval RETURN_WRITE_PROTECTED    Buffer and Length are NULL, but the LockBox has no
                                     LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE attribute.
   @retval RETURN_BUFFER_TOO_SMALL   the Length is too small to hold the confidential information.
 …
   @retval RETURN_SUCCESS            the information is restored successfully.
   @retval RETURN_INVALID_PARAMETER  the Guid is NULL, or one of Buffer and Length is NULL.
   @retval RETURN_WRITE_PROTECTED    Buffer and Length are NULL, but the LockBox has no
+  @retval RETURN_WRITE_PROTECTED    Buffer and Length are NULL, but the LockBox has no
                                     LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE attribute.
   @retval RETURN_BUFFER_TOO_SMALL   the Length is too small to hold the confidential information.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmLockBoxLib/SmmLockBoxPeiLib.inf

r58459	r58466
27	27	# The following information is for reference only and not required by the build tools.
28	28	#
29		# VALID_ARCHITECTURES = IA32 X64
	29	# VALID_ARCHITECTURES = IA32 X64
30	30	#
31	31

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmLockBoxLib/SmmLockBoxSmmLib.c

-              r58459
+              r58466
   @param[in] SystemTable  A Pointer to the EFI System Table.
   @retval EFI_SUCEESS
+  @retval EFI_SUCEESS
   @return Others          Some error occurs.
 **/
 …
   @retval RETURN_SUCCESS            the information is restored successfully.
   @retval RETURN_INVALID_PARAMETER  the Guid is NULL, or one of Buffer and Length is NULL.
   @retval RETURN_WRITE_PROTECTED    Buffer and Length are NULL, but the LockBox has no
+  @retval RETURN_WRITE_PROTECTED    Buffer and Length are NULL, but the LockBox has no
                                     LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE attribute.
   @retval RETURN_BUFFER_TOO_SMALL   the Length is too small to hold the confidential information.

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmLockBoxLib/SmmLockBoxSmmLib.inf

r58459	r58466
28	28	# The following information is for reference only and not required by the build tools.
29	29	#
30		# VALID_ARCHITECTURES = IA32 X64
	30	# VALID_ARCHITECTURES = IA32 X64
31	31	#
32	32

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmPerformanceLib/SmmPerformanceLib.c

-              r58459
+              r58466
+  )
+{
   mPerformanceMeasurementEnabled =  (BOOLEAN) ((PcdGet8(PcdPerformanceLibraryPropertyMask) & PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED) != 0);
 …
 EFIAPI
 GetPerformanceMeasurementEx (
   IN  UINTN       LogEntryKey,
+  IN  UINTN       LogEntryKey,
   OUT CONST VOID  **Handle,
   OUT CONST CHAR8 **Token,

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmPerformanceLib/SmmPerformanceLib.inf

-              r58459
+              r58466
 ## @file
 #  Performance library instance used in SMM phase.
+#
+#
 #  This library instance provides infrastructure for SMM drivers to log performance
 #  data. It consumes SMM PerformanceEx or Performance Protocol published by SmmCorePerformanceLib
 #  to log performance data. If both SMM PerformanceEx and Performance Protocol are not available,
 #  it does not log any performance information.
+#
+#
 #  Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>
 #  This program and the accompanying materials
 …
 #  which accompanies this distribution.  The full text of the license may be found at
 #  http://opensource.org/licenses/bsd-license.php
+#
+#
 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#
 ##

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmReportStatusCodeLib/ReportStatusCodeLib.c

r48674	r58466
93	93	}
94	94	}
95
	95
96	96	//
97	97	// A status code service is present in system, so pass in all the parameters to the service.
…	…
99	99	return (mReportStatusCode) (mStatusCodeProtocol, Type, Value, Instance, (EFI_GUID )CallerId, Data);
100	100	}
101
	101
102	102	return EFI_UNSUPPORTED;
103	103	}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/UefiHiiLib/HiiLanguage.c

-              r48674
+              r58466
 /**
   Retrieves a pointer to the a Null-terminated ASCII string containing the list
   of languages that an HII handle in the HII Database supports.  The returned
+  Retrieves a pointer to the a Null-terminated ASCII string containing the list
+  of languages that an HII handle in the HII Database supports.  The returned
   string is allocated using AllocatePool().  The caller is responsible for freeing
   the returned string using FreePool().  The format of the returned string follows
   the language format assumed the HII Database.
   If HiiHandle is NULL, then ASSERT().
 …
   @retval NULL   HiiHandle is not registered in the HII database
   @retval NULL   There are not enough resources available to retrieve the suported
+  @retval NULL   There are not enough resources available to retrieve the suported
                  languages.
   @retval NULL   The list of suported languages could not be retrieved.
 …
   //
   // If GetLanguages() returns EFI_SUCCESS for a zero size,
   // then there are no supported languages registered for HiiHandle.  If GetLanguages()
+  // If GetLanguages() returns EFI_SUCCESS for a zero size,
+  // then there are no supported languages registered for HiiHandle.  If GetLanguages()
   // returns an error other than EFI_BUFFER_TOO_SMALL, then HiiHandle is not present
   // in the HII Database

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/UefiHiiLib/HiiLib.c

-              r58459
+              r58466
 //
 // Template used to mark the end of a list of packages
+// Template used to mark the end of a list of packages
 //
 GLOBAL_REMOVE_IF_UNREFERENCED CONST EFI_HII_PACKAGE_HEADER  mEndOfPakageList = {
 …
   Status = gHiiDatabase->ExportPackageLists (gHiiDatabase, Handle, &BufferSize, HiiPackageList);
   ASSERT (Status != EFI_NOT_FOUND);
   if (Status == EFI_BUFFER_TOO_SMALL) {
     HiiPackageList = AllocatePool (BufferSize);
 …
   the list of package is 0, then NULL is returned.
   The variable arguments are pointers which point to package header that defined
+  The variable arguments are pointers which point to package header that defined
   by UEFI VFR compiler and StringGather tool.
 …
   } EDKII_AUTOGEN_PACKAGES_HEADER;
   #pragma pack (pop)
   @param[in]  PackageListGuid  The GUID of the package list.
   @param[in]  DeviceHandle     If not NULL, the Device Handle on which
+  @param[in]  DeviceHandle     If not NULL, the Device Handle on which
                                an instance of DEVICE_PATH_PROTOCOL is installed.
                                This Device Handle uniquely defines the device that
+                               This Device Handle uniquely defines the device that
                                the added packages are associated with.
   @param[in]  ...              The variable argument list that contains pointers
+  @param[in]  ...              The variable argument list that contains pointers
                                to packages terminated by a NULL.
 …
   //
   // If there are no packages in the variable argument list or all the packages
+  // If there are no packages in the variable argument list or all the packages
   // are empty, then return a NULL HII Handle
   //
 …
   //
   // Add the length of the Package List Header and the terminating Package Header
+  // Add the length of the Package List Header and the terminating Package Header
   //
   Length += sizeof (EFI_HII_PACKAGE_LIST_HEADER) + sizeof (EFI_HII_PACKAGE_HEADER);
 …
   //
   Status = gHiiDatabase->NewPackageList (
                            gHiiDatabase,
                            PackageListHeader,
                            DeviceHandle,
+                           gHiiDatabase,
+                           PackageListHeader,
+                           DeviceHandle,
                            &HiiHandle
                            );
 …
   The caller is responsible for freeing the array with FreePool().
   @param[in]  PackageListGuid  An optional parameter that is used to request
+  @param[in]  PackageListGuid  An optional parameter that is used to request
                                HII Handles associated with a specific
                                Package List GUID.  If this parameter is NULL,
                                then all the HII Handles in the HII Database
                                are returned.  If this parameter is not NULL,
                                then zero or more HII Handles associated with
+                               then zero or more HII Handles associated with
                                PackageListGuid are returned.
 …
   //
   // If ListPackageLists() returns EFI_SUCCESS for a zero size,
   // then there are no HII handles in the HII database.  If ListPackageLists()
   // returns an error other than EFI_BUFFER_TOO_SMALL, then there are no HII
+  // If ListPackageLists() returns EFI_SUCCESS for a zero size,
+  // then there are no HII handles in the HII database.  If ListPackageLists()
+  // returns an error other than EFI_BUFFER_TOO_SMALL, then there are no HII
   // handles in the HII database.
   //
   if (Status != EFI_BUFFER_TOO_SMALL) {
     //
     // Return NULL if the size can not be retrieved, or if there are no HII
+    // Return NULL if the size can not be retrieved, or if there are no HII
     // handles in the HII Database
     //
 …
       ASSERT_EFI_ERROR (Status);
       if (CompareGuid (&Guid, PackageListGuid)) {
         HiiHandleBuffer[Index2++] = HiiHandleBuffer[Index1];
+        HiiHandleBuffer[Index2++] = HiiHandleBuffer[Index1];
+      }
+    }
 …
 /**
   Converts all hex dtring characters in range ['A'..'F'] to ['a'..'f'] for
+  Converts all hex dtring characters in range ['A'..'F'] to ['a'..'f'] for
   hex digits that appear between a '=' and a '&' in a config string.
 …
 /**
   Uses the BlockToConfig() service of the Config Routing Protocol to
+  Uses the BlockToConfig() service of the Config Routing Protocol to
   convert <ConfigRequest> and a buffer to a <ConfigResp>
 …
 /**
   Uses the BrowserCallback() service of the Form Browser Protocol to retrieve
   or set uncommitted data.  If sata i being retrieved, then the buffer is
   allocated using AllocatePool().  The caller is then responsible for freeing
+  Uses the BrowserCallback() service of the Form Browser Protocol to retrieve
+  or set uncommitted data.  If sata i being retrieved, then the buffer is
+  allocated using AllocatePool().  The caller is then responsible for freeing
   the buffer using FreePool().
   @param[in]  VariableGuid    Pointer to an EFI_GUID structure.  This is an optional
+  @param[in]  VariableGuid    Pointer to an EFI_GUID structure.  This is an optional
                               parameter that may be NULL.
   @param[in]  VariableName    Pointer to a Null-terminated Unicode string.  This
+  @param[in]  VariableName    Pointer to a Null-terminated Unicode string.  This
                               is an optional parameter that may be NULL.
   @param[in]  SetResultsData  If not NULL, then this parameter specified the buffer
 …
                               VariableName
                               );
     if (!EFI_ERROR (Status)) {
       //
 …
 /**
   Allocates and returns a Null-terminated Unicode <ConfigHdr> string using routing
+  Allocates and returns a Null-terminated Unicode <ConfigHdr> string using routing
   information that includes a GUID, an optional Unicode string name, and a device
   path.  The string returned is allocated with AllocatePool().  The caller is
+  path.  The string returned is allocated with AllocatePool().  The caller is
   responsible for freeing the allocated string with FreePool().
   The format of a <ConfigHdr> is as follows:
 …
   @param[in]  Guid          Pointer to an EFI_GUID that is the routing information
                             GUID.  Each of the 16 bytes in Guid is converted to
                             a 2 Unicode character hexidecimal string.  This is
+                            GUID.  Each of the 16 bytes in Guid is converted to
+                            a 2 Unicode character hexidecimal string.  This is
                             an optional parameter that may be NULL.
   @param[in]  Name          Pointer to a Null-terminated Unicode string that is
                             the routing information NAME.  This is an optional
                             parameter that may be NULL.  Each 16-bit Unicode
                             character in Name is converted to a 4 character Unicode
                             hexidecimal string.
+  @param[in]  Name          Pointer to a Null-terminated Unicode string that is
+                            the routing information NAME.  This is an optional
+                            parameter that may be NULL.  Each 16-bit Unicode
+                            character in Name is converted to a 4 character Unicode
+                            hexidecimal string.
   @param[in]  DriverHandle  The driver handle which supports a Device Path Protocol
                             that is the routing information PATH.  Each byte of
 …
   //
   // Compute the length of Name in Unicode characters.
+  // Compute the length of Name in Unicode characters.
   // If Name is NULL, then the length is 0.
   //
 …
+    }
+  }
   //
   // Append L"&NAME="
 …
 /**
   Convert the hex UNICODE encoding string of UEFI GUID, NAME or device path
+  Convert the hex UNICODE encoding string of UEFI GUID, NAME or device path
   to binary buffer from <ConfigHdr>.
 …
     return EFI_INVALID_PARAMETER;
+  }
   DataBuffer = NULL;
   StringPtr  = NULL;
 …
+      }
+    }
     *Buffer = DataBuffer;
     break;
 …
     //
     // Convert Config String to Unicode String, e.g. "0041004200430044" => "ABCD"
     //
+    //
     //
 …
   This function checks VarOffset and VarWidth is in the block range.
   @param  BlockArray         The block array is to be checked.
+  @param  BlockArray         The block array is to be checked.
   @param  VarOffset          Offset of var to the structure
   @param  VarWidth           Width of var.
   @retval TRUE   This Var is in the block range.
   @retval FALSE  This Var is not in the block range.
 …
   LIST_ENTRY          *Link;
   IFR_BLOCK_DATA      *BlockData;
   //
   // No Request Block array, all vars are got.
 …
     return TRUE;
+  }
   //
   // Check the input var is in the request block range.
 …
+  }
   Length = StringPtr - ValueString;
   //
   // Allocate buffer to store the value
 …
     return EFI_OUT_OF_RESOURCES;
+  }
   //
   // Convert character one by one to the value buffer
 …
+    }
+  }
   //
   // Set the converted value and string length.
 …
   @param VarName                 The variable name which need to get value.
   @param VarValue                The return value.
   @retval EFI_SUCCESS            Get the value for the VarName
   @retval EFI_OUT_OF_RESOURCES   The memory is not enough.
 …
   @param HiiHandle          The HiiHandle for this formset.
   @param NameValueType      Whether current storage is name/value varstore or not.
   @retval EFI_SUCCESS            The current setting is valid.
   @retval EFI_OUT_OF_RESOURCES   The memory is not enough.
 …
           //
           // If the length is small than the structure, this is from old efi
           // varstore definition. Old efi varstore get config directly from
+          // If the length is small than the structure, this is from old efi
+          // varstore definition. Old efi varstore get config directly from
           // GetVariable function.
           //
 …
           //
           // OneOf question is not in IFR Form. This IFR form is not valid.
+          // OneOf question is not in IFR Form. This IFR form is not valid.
           //
           if (VarStoreData.VarStoreId == 0) {
             return EFI_INVALID_PARAMETER;
+          }
           //
+          //
           // Check whether this question is for the requested varstore.
           //
 …
+            }
             //
             // Check this var question is in the var storage
+            // Check this var question is in the var storage
             //
             if ((Offset + Width) > VarStoreData.Size) {
               //
               // This question exceeds the var store size.
+              // This question exceeds the var store size.
               //
               return EFI_INVALID_PARAMETER;
 …
           //
           // Numeric question is not in IFR Form. This IFR form is not valid.
+          // Numeric question is not in IFR Form. This IFR form is not valid.
           //
           if (VarStoreData.VarStoreId == 0) {
 …
               break;
+            }
             Status = GetValueFromRequest (RequestElement, QuestionName, &VarValue);
             if (EFI_ERROR (Status)) {
 …
+            }
             //
             // Check this var question is in the var storage
+            // Check this var question is in the var storage
             //
             if ((Offset + Width) > VarStoreData.Size) {
               //
               // This question exceeds the var store size.
+              // This question exceeds the var store size.
               //
               return EFI_INVALID_PARAMETER;
 …
           //
           // CheckBox question is not in IFR Form. This IFR form is not valid.
+          // CheckBox question is not in IFR Form. This IFR form is not valid.
           //
           if (VarStoreData.VarStoreId == 0) {
 …
               break;
+            }
             Status = GetValueFromRequest (RequestElement, QuestionName, &VarValue);
             if (EFI_ERROR (Status)) {
 …
+            }
             //
             // Check this var question is in the var storage
+            // Check this var question is in the var storage
             //
             if ((Offset + Width) > VarStoreData.Size) {
               //
               // This question exceeds the var store size.
+              // This question exceeds the var store size.
               //
               return EFI_INVALID_PARAMETER;
 …
           //
           // CheckBox question is not in IFR Form. This IFR form is not valid.
+          // CheckBox question is not in IFR Form. This IFR form is not valid.
           //
           if (VarStoreData.VarStoreId == 0) {
 …
             //
             // Skip the "=".
             //
+            //
             StringPtr += 1;
             //
             // Check current string length is less than maxsize
 …
+            }
             //
             // Check this var question is in the var storage
+            // Check this var question is in the var storage
             //
             if ((Offset + Width) > VarStoreData.Size) {
               //
               // This question exceeds the var store size.
+              // This question exceeds the var store size.
               //
               return EFI_INVALID_PARAMETER;
 …
         case EFI_IFR_ONE_OF_OPTION_OP:
           //
           // Opcode Scope is zero. This one of option is not to be checked.
+          // Opcode Scope is zero. This one of option is not to be checked.
           //
           if (VarBlockData.Scope == 0) {
 …
           //
           // OneOf value doesn't belong to one of option value.
+          // OneOf value doesn't belong to one of option value.
           //
           if ((VarBlockData.Scope == 0) && (VarBlockData.OpCode == EFI_IFR_ONE_OF_OP)) {
 …
   @param CurrentBlockArray     Current block array.
   @param VarBuffer             Data buffer for this varstore.
   @retval EFI_SUCCESS            The current setting is valid.
   @retval EFI_OUT_OF_RESOURCES   The memory is not enough.
 …
   IFR_BLOCK_DATA               *BlockArray;
   UINT8                        *DataBuffer;
   //
   // Initialize the local variables.
 …
     //
     // Skip the &OFFSET= string
     //
+    //
     StringPtr += StrLen (L"&OFFSET=");
 …
     //
     // If '\0', parsing is finished.
+    // If '\0', parsing is finished.
     //
     if (*StringPtr == 0) {
 …
+    }
     //
     // Go to next ConfigBlock
+    // Go to next ConfigBlock
     //
+  }
 …
     FreePool (DataBuffer);
+  }
   if (BlockArray != NULL) {
     //
 …
   @param VarName            Name of the buffer storage.
   @param HiiHandle          The HiiHandle for this package.
   @retval EFI_SUCCESS            The current setting is valid.
   @retval EFI_OUT_OF_RESOURCES   The memory is not enough.
 …
     FreePool (VarBuffer);
+  }
   if (CurrentBlockArray != NULL) {
     //
 …
   @retval  TRUE              The input include config request elements.
   @retval  FALSE             The input string not includes.
 **/
 BOOLEAN
 …
   string for setting default value and validating current setting.
 . For setting default action, Reset the default value specified by DefaultId
+. For setting default action, Reset the default value specified by DefaultId
   to the driver configuration got by Request string.
 . For validating current setting, Validate the current configuration
+. For validating current setting, Validate the current configuration
   by parsing HII form IFR opcode.
   NULL request string support depends on the ExportConfig interface of
   HiiConfigRouting protocol in UEFI specification.
   @param Request    A null-terminated Unicode string in
+  @param Request    A null-terminated Unicode string in
                     <MultiConfigRequest> format. It can be NULL.
                     If it is NULL, all current configuration for the
 …
   @param DefaultId  Specifies the type of defaults to retrieve only for setting default action.
   @param ActionType Action supports setting defaults and validate current setting.
   @retval TURE    Action runs successfully.
   @retval FALSE   Action is not valid or Action can't be executed successfully..
 …
   HiiHandle        = NULL;
   HiiPackageList   = NULL;
   //
   // Only support set default and validate setting action.
 …
                                 );
+  }
   if (EFI_ERROR (Status)) {
     return FALSE;
+  }
   StringPtr = ConfigAltResp;
   while (StringPtr != L'\0') {
     //
 …
       goto Done;
+    }
     //
     // Get Path value DevicePath
 …
       goto Done;
+    }
     //
     // Find the matched Hii Handle for the found Driver handle
 …
       // This request string has no its Hii package.
       // Its default value and validating can't execute by parsing IFR data.
       // Directly jump into the next ConfigAltResp string for another pair Guid, Name, and Path.
+      // Directly jump into the next ConfigAltResp string for another pair Guid, Name, and Path.
       //
       Status = EFI_SUCCESS;
 …
     HiiPackageList     = NULL;
     Status = gHiiDatabase->ExportPackageLists (gHiiDatabase, HiiHandle, &PackageListLength, HiiPackageList);
     //
     // The return status should always be EFI_BUFFER_TOO_SMALL as input buffer's size is 0.
 …
       goto Done;
+    }
     HiiPackageList = AllocatePool (PackageListLength);
     if (HiiPackageList == NULL) {
 …
       goto Done;
+    }
     //
     // Get PackageList on HiiHandle
 …
       goto Done;
+    }
     //
     // 3. Call ConfigRouting GetAltCfg(ConfigRoute, <ConfigResponse>, Guid, Name, DevicePath, AltCfgId, AltCfgResp)
 …
                                   &ConfigResp
                                 );
     //
     // The required setting can't be found. So, it is not required to be validated and set.
 …
       goto NextConfigAltResp;
+    }
     //
     // 4. Set the default configuration information or Validate current setting by parse IFR code.
 …
       HiiPackageList = NULL;
+    }
     if (ConfigResp != NULL) {
       FreePool (ConfigResp);
 …
     FreePool (VarGuid);
     VarGuid = NULL;
     FreePool (VarName);
     VarName = NULL;
     FreePool (DevicePath);
     DevicePath = NULL;
 …
       break;
+    }
     //
     // Construct ConfigAltHdr string  "&<ConfigHdr>&ALTCFG=\0"
+    //
+    // Construct ConfigAltHdr string  "&<ConfigHdr>&ALTCFG=\0"
     //                               | 1 | StrLen (ConfigHdr) | 8 | 1 |
     //
 …
     StrnCat (ConfigAltHdr, StringHdr, StringPtr - StringHdr);
     StrCat (ConfigAltHdr, L"&ALTCFG=");
     //
     // Skip all AltResp (AltConfigHdr ConfigBody) for the same ConfigHdr
 …
+      }
+    }
     //
     // Free the allocated ConfigAltHdr string
 …
       break;
+    }
     //
     // Find &GUID as the next ConfigHdr
 …
     StringPtr ++;
+  }
 Done:
   if (VarGuid != NULL) {
 …
     FreePool (ConfigAltResp);
+  }
   if (HiiPackageList != NULL) {
     FreePool (HiiPackageList);
+  }
   if (EFI_ERROR (Status)) {
     return FALSE;
 …
   NULL request string support depends on the ExportConfig interface of
   HiiConfigRouting protocol in UEFI specification.
   @param  Request   A null-terminated Unicode string in
+  @param  Request   A null-terminated Unicode string in
                     <MultiConfigRequest> format. It can be NULL.
                     If it is NULL, all current configuration for the
                     entirety of the current HII database will be validated.
   @retval TRUE    Current configuration is valid.
   @retval FALSE   Current configuration is invalid.
 **/
 BOOLEAN
 EFIAPI
+EFIAPI
 HiiValidateSettings (
   IN CONST EFI_STRING Request  OPTIONAL
 …
 /**
   Reset the default value specified by DefaultId to the driver
   configuration got by Request string.
+  configuration got by Request string.
   NULL request string support depends on the ExportConfig interface of
   HiiConfigRouting protocol in UEFI specification.
   @param Request    A null-terminated Unicode string in
+  @param Request    A null-terminated Unicode string in
                     <MultiConfigRequest> format. It can be NULL.
                     If it is NULL, all configuration for the
                     entirety of the current HII database will be reset.
   @param DefaultId  Specifies the type of defaults to retrieve.
   @retval TURE    The default value is set successfully.
   @retval FALSE   The default value can't be found and set.
 …
   Determines if two values in config strings match.
   Compares the substring between StartSearchString and StopSearchString in
   FirstString to the substring between StartSearchString and StopSearchString
+  Compares the substring between StartSearchString and StopSearchString in
+  FirstString to the substring between StartSearchString and StopSearchString
   in SecondString.  If the two substrings match, then TRUE is returned.  If the
   two substrings do not match, then FALSE is returned.
 …
   @param FirstString        Pointer to the first Null-terminated Unicode string.
   @param SecondString       Pointer to the second Null-terminated Unicode string.
   @param StartSearchString  Pointer to the Null-terminated Unicode string that
+  @param StartSearchString  Pointer to the Null-terminated Unicode string that
                             marks the start of the value string to compare.
   @param StopSearchString   Pointer to the Null-terminated Unicode string that
+  @param StopSearchString   Pointer to the Null-terminated Unicode string that
                             marks the end of the value string to compare.
   @retval FALSE             StartSearchString is not present in FirstString.
+  @retval FALSE             StartSearchString is not present in FirstString.
   @retval FALSE             StartSearchString is not present in SecondString.
   @retval FALSE             StopSearchString is not present in FirstString.
+  @retval FALSE             StopSearchString is not present in FirstString.
   @retval FALSE             StopSearchString is not present in SecondString.
   @retval FALSE             The length of the substring in FirstString is not the
+  @retval FALSE             The length of the substring in FirstString is not the
                             same length as the substring in SecondString.
   @retval FALSE             The value string in FirstString does not matche the
+  @retval FALSE             The value string in FirstString does not matche the
                             value string in SecondString.
   @retval TRUE              The value string in FirstString matches the value
+  @retval TRUE              The value string in FirstString matches the value
                             string in SecondString.
 …
   buffer.
   @param[in]  VariableGuid  Pointer to an EFI_GUID structure.  This is an optional
+  @param[in]  VariableGuid  Pointer to an EFI_GUID structure.  This is an optional
                             parameter that may be NULL.
   @param[in]  VariableName  Pointer to a Null-terminated Unicode string.  This
+  @param[in]  VariableName  Pointer to a Null-terminated Unicode string.  This
                             is an optional parameter that may be NULL.
   @param[in]  BufferSize    Length in bytes of buffer to hold retrieved data.
+  @param[in]  BufferSize    Length in bytes of buffer to hold retrieved data.
   @param[out] Buffer        Buffer of data to be updated.
 …
   ConfigResp = AllocateZeroPool (Size);
   UnicodeSPrint (ConfigResp, Size, L"%s&%s", mConfigHdrTemplate, ResultsData);
   //
   // Free the allocated buffer
 …
                               buffer data will be send back to Browser. If NULL,
                               the whole buffer of data will be committed to
                               Browser.
+                              Browser.
                               <RequestElement> ::= &OFFSET=<Number>&WIDTH=<Number>*
 …
   if (RequestElement == NULL) {
     //
     // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
+    // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
     // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator
     //
 …
   } else {
     //
     // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
+    // Allocate and fill a buffer large enough to hold the <ConfigHdr> template
     // followed by <RequestElement> followed by a Null-terminator
     //
 …
 /**
   Allocates and returns a new OpCode Handle.  OpCode Handles must be freed with
+  Allocates and returns a new OpCode Handle.  OpCode Handles must be freed with
   HiiFreeOpCodeHandle().
 …
 /**
   Internal function gets the current position of opcode buffer.
   @param[in]  OpCodeHandle   Handle to the buffer of opcodes.
 …
 /**
   Internal function gets the start pointer of opcode buffer.
   @param[in]  OpCodeHandle   Handle to the buffer of opcodes.
 …
   Internal function reserves the enough buffer for current opcode.
   When the buffer is not enough, Opcode buffer will be extended.
   @param[in]  OpCodeHandle   Handle to the buffer of opcodes.
   @param[in]  Size           Size of current opcode.
 …
   if (OpCodeBuffer->Position + Size > OpCodeBuffer->BufferSize) {
     Buffer = ReallocatePool (
               OpCodeBuffer->BufferSize,
+              OpCodeBuffer->BufferSize,
               OpCodeBuffer->BufferSize + (Size + HII_LIB_OPCODE_ALLOCATION_SIZE),
               OpCodeBuffer->Buffer
 …
 /**
   Internal function creates opcode based on the template opcode.
   @param[in]  OpCodeHandle    Handle to the buffer of opcodes.
   @param[in]  OpCodeTemplate  Pointer to the template buffer of opcode.
 …
 /**
   Internal function creates opcode based on the template opcode for the normal opcode.
   @param[in]  OpCodeHandle    Handle to the buffer of opcodes.
   @param[in]  OpCodeTemplate  Pointer to the template buffer of opcode.
 …
   @param[in]  OpCodeHandle  Handle to the buffer of opcodes.
   @param[in]  Guid          Pointer to EFI_GUID of this guided opcode.
   @param[in]  GuidOpCode    Pointer to an EFI_IFR_GUID opcode.  This is an
+  @param[in]  GuidOpCode    Pointer to an EFI_IFR_GUID opcode.  This is an
                             optional parameter that may be NULL.  If this
                             parameter is NULL, then the GUID extension
+                            parameter is NULL, then the GUID extension
                             region of the created opcode is filled with zeros.
                             If this parameter is not NULL, then the GUID
                             extension region of GuidData will be copied to
+                            If this parameter is not NULL, then the GUID
+                            extension region of GuidData will be copied to
                             the GUID extension region of the created opcode.
   @param[in]  OpCodeSize    The size, in bytes, of created opcode.  This value
+  @param[in]  OpCodeSize    The size, in bytes, of created opcode.  This value
                             must be >= sizeof(EFI_IFR_GUID).
 …
   OpCodePointer = (EFI_IFR_GUID *)InternalHiiCreateOpCodeExtended (
                                     OpCodeHandle,
+                                    OpCodeHandle,
                                     &OpCode,
                                     EFI_IFR_GUID_OP,
 …
   return InternalHiiCreateOpCodeExtended (
            OpCodeHandle,
+           OpCodeHandle,
            &OpCode,
            EFI_IFR_SUBTITLE_OP,
            sizeof (OpCode),
 ,
+           EFI_IFR_SUBTITLE_OP,
+           sizeof (OpCode),
+,
            Scope
            );
 …
   Create EFI_IFR_REF_OP, EFI_IFR_REF2_OP, EFI_IFR_REF3_OP and EFI_IFR_REF4_OP opcode.
   When RefDevicePath is not zero, EFI_IFR_REF4 opcode will be created.
+  When RefDevicePath is not zero, EFI_IFR_REF4 opcode will be created.
   When RefDevicePath is zero and RefFormSetId is not NULL, EFI_IFR_REF3 opcode will be created.
   When RefDevicePath is zero, RefFormSetId is NULL and RefQuestionId is not zero, EFI_IFR_REF2 opcode will be created.
 …
   @param[in]  QuestionFlags  The flags in Question Header
   @param[in]  QuestionId     Question ID.
   @param[in]  RefQuestionId  The question on the form to which this link is referring.
+  @param[in]  RefQuestionId  The question on the form to which this link is referring.
                              If its value is zero, then the link refers to the top of the form.
   @param[in]  RefFormSetId   The form set to which this link is referring. If its value is NULL, and RefDevicePath is
+  @param[in]  RefFormSetId   The form set to which this link is referring. If its value is NULL, and RefDevicePath is
                              zero, then the link is to the current form set.
   @param[in]  RefDevicePath  The string identifier that specifies the string containing the text representation of
+  @param[in]  RefDevicePath  The string identifier that specifies the string containing the text representation of
                              the device path to which the form set containing the form specified by FormId.
                              If its value is zero, then the link refers to the current page.
 …
   @param[in] FormId            The Form ID.
   @param[in] Package           The package header.
   @param[in] OpCodeBufferStart An OpCode buffer that contains the set of IFR
+  @param[in] OpCodeBufferStart An OpCode buffer that contains the set of IFR
                                opcodes to be inserted or replaced in the form.
   @param[in] OpCodeBufferEnd   An OpCcode buffer that contains the IFR opcode
 …
     BufferPos           += IfrOpHdr->Length;
     UpdatePackageLength += IfrOpHdr->Length;
     //
     // Find the matched FormSet and Form
 …
+      }
+    }
     //
     // The matched Form is found, and Update data in this form
 …
             IfrOpHdr       = (EFI_IFR_OP_HEADER *) ((UINT8 *) (IfrOpHdr) + IfrOpHdr->Length);
+          }
           if (Offset >= PackageHeader.Length) {
             //
 …
     IfrOpHdr = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (IfrOpHdr) + IfrOpHdr->Length);
+  }
   if (!Updated) {
     //
 …
 /**
   This function updates a form that has previously been registered with the HII
+  This function updates a form that has previously been registered with the HII
   Database.  This function will perform at most one update operation.
   The form to update is specified by Handle, FormSetGuid, and FormId.  Binary
   comparisons of IFR opcodes are performed from the beginning of the form being
   updated until an IFR opcode is found that exactly matches the first IFR opcode
+  The form to update is specified by Handle, FormSetGuid, and FormId.  Binary
+  comparisons of IFR opcodes are performed from the beginning of the form being
+  updated until an IFR opcode is found that exactly matches the first IFR opcode
   specified by StartOpCodeHandle.  The following rules are used to determine if
   an insert, replace, or delete operation is performed.
 ) If no matches are found, then NULL is returned.
+) If no matches are found, then NULL is returned.
 ) If a match is found, and EndOpCodeHandle is NULL, then all of the IFR opcodes
      from StartOpCodeHandle except the first opcode are inserted immediately after
+     from StartOpCodeHandle except the first opcode are inserted immediately after
      the matching IFR opcode in the form to be updated.
 ) If a match is found, and EndOpCodeHandle is not NULL, then a search is made
      from the matching IFR opcode until an IFR opcode exactly matches the first
+) If a match is found, and EndOpCodeHandle is not NULL, then a search is made
+     from the matching IFR opcode until an IFR opcode exactly matches the first
      IFR opcode specified by EndOpCodeHandle.  If no match is found for the first
      IFR opcode specified by EndOpCodeHandle, then NULL is returned.  If a match
      is found, then all of the IFR opcodes between the start match and the end
+     is found, then all of the IFR opcodes between the start match and the end
      match are deleted from the form being updated and all of the IFR opcodes
      from StartOpCodeHandle except the first opcode are inserted immediately after
+     from StartOpCodeHandle except the first opcode are inserted immediately after
      the matching start IFR opcode.  If StartOpCcodeHandle only contains one
      IFR instruction, then the result of this operation will delete all of the IFR
 …
                                  If it is NULL, all FormSet will be updated.
   @param[in]  FormId             The ID of the form to update.
   @param[in]  StartOpCodeHandle  An OpCode Handle that contains the set of IFR
+  @param[in]  StartOpCodeHandle  An OpCode Handle that contains the set of IFR
                                  opcodes to be inserted or replaced in the form.
                                  The first IFR instruction in StartOpCodeHandle
                                  is used to find matching IFR opcode in the
                                  form.
+                                 The first IFR instruction in StartOpCodeHandle
+                                 is used to find matching IFR opcode in the
+                                 form.
   @param[in]  EndOpCodeHandle    An OpCcode Handle that contains the IFR opcode
                                  that marks the end of a replace operation in
                                  the form.  This is an optional parameter that
                                  may be NULL.  If it is NULL, then an the IFR
                                  opcodes specified by StartOpCodeHandle are
+                                 opcodes specified by StartOpCodeHandle are
                                  inserted into the form.
   @retval EFI_OUT_OF_RESOURCES   No enough memory resource is allocated.
   @retval EFI_NOT_FOUND          The following cases will return EFI_NOT_FOUND.
 ) The form specified by HiiHandle, FormSetGuid,
+) The form specified by HiiHandle, FormSetGuid,
                                  and FormId could not be found in the HII Database.
 ) No IFR opcodes in the target form match the first
                                  IFR opcode in StartOpCodeHandle.
 ) EndOpCOde is not NULL, and no IFR opcodes in the
                                  target form following a matching start opcode match
+) EndOpCOde is not NULL, and no IFR opcodes in the
+                                 target form following a matching start opcode match
                                  the first IFR opcode in EndOpCodeHandle.
   @retval EFI_SUCCESS            The matched form is updated by StartOpcode.
 …
 EFIAPI
 HiiUpdateForm (
   IN EFI_HII_HANDLE  HiiHandle,
+  IN EFI_HII_HANDLE  HiiHandle,
   IN EFI_GUID        *FormSetGuid,        OPTIONAL
   IN EFI_FORM_ID     FormId,
 …
   EFI_STATUS                   Status;
   EFI_HII_PACKAGE_LIST_HEADER  *HiiPackageList;
   UINT32                       PackageListLength;
+  UINT32                       PackageListLength;
   UINT32                       Offset;
   EFI_HII_PACKAGE_LIST_HEADER  *UpdatePackageList;
 …
   HII_LIB_OPCODE_BUFFER        *OpCodeBufferStart;
   HII_LIB_OPCODE_BUFFER        *OpCodeBufferEnd;
   //
   // Input update data can't be NULL.
 …
   TempPacakge       = NULL;
   HiiPackageList    = NULL;
   //
   // Retrieve buffer data from Opcode Handle
 …
   OpCodeBufferStart = (HII_LIB_OPCODE_BUFFER *) StartOpCodeHandle;
   OpCodeBufferEnd   = (HII_LIB_OPCODE_BUFFER *) EndOpCodeHandle;
   //
   // Get the original package list
 …
     goto Finish;
+  }
   //
   // Allocate temp buffer to store the temp updated package buffer
 …
   CopyMem (UpdateBufferPos, HiiPackageList, sizeof (EFI_HII_PACKAGE_LIST_HEADER));
   UpdateBufferPos += sizeof (EFI_HII_PACKAGE_LIST_HEADER);
   //
   // Go through each package to find the matched package and update one by one
 …
         //
         // Set Update Flag
         //
+        //
         Updated = TRUE;
         //
 …
     UpdateBufferPos += PackageHeader.Length;
+  }
   if (Updated) {
     //
 …
     BufferSize = UpdateBufferPos - (UINT8 *) UpdatePackageList;
     WriteUnaligned32 (&UpdatePackageList->PackageLength, (UINT32) BufferSize);
     //
     // Update Package to show form
 …
     FreePool (HiiPackageList);
+  }
   if (UpdatePackageList != NULL) {
     FreePool (UpdatePackageList);
+  }
   if (TempPacakge != NULL) {
     FreePool (TempPacakge);
+  }
   return Status;
+}
+  return Status;
+}

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/UefiHiiLib/HiiString.c

-              r58459
+              r58466
 /**
   This function create a new string in String Package or updates an existing
+  This function create a new string in String Package or updates an existing
   string in a String Package.  If StringId is 0, then a new string is added to
   a String Package.  If StringId is not zero, then a string in String Package is
   updated.  If SupportedLanguages is NULL, then the string is added or updated
   for all the languages that the String Package supports.  If SupportedLanguages
   is not NULL, then the string is added or updated for the set of languages
+  is not NULL, then the string is added or updated for the set of languages
   specified by SupportedLanguages.
   If HiiHandle is NULL, then ASSERT().
   If String is NULL, then ASSERT().
   @param[in]  HiiHandle           A handle that was previously registered in the
+  @param[in]  HiiHandle           A handle that was previously registered in the
                                   HII Database.
+  @param[in]  StringId            If zero, then a new string is created in the
+                                  String Package associated with HiiHandle.  If
+                                  non-zero, then the string specified by StringId
+                                  is updated in the String Package  associated
+                                  with HiiHandle.
+  @param[in]  String              A pointer to the Null-terminated Unicode string
+                                  to add or update in the String Package associated
+  @param[in]  StringId            If zero, then a new string is created in the
+                                  String Package associated with HiiHandle.  If
+                                  non-zero, then the string specified by StringId
+                                  is updated in the String Package  associated
                                   with HiiHandle.
+  @param[in]  SupportedLanguages  A pointer to a Null-terminated ASCII string of
+                                  language codes.  If this parameter is NULL, then
+                                  String is added or updated in the String Package
+                                  associated with HiiHandle for all the languages
+                                  that the String Package supports.  If this
+                                  parameter is not NULL, then then String is added
+                                  or updated in the String Package associated with
+                                  HiiHandle for the set oflanguages specified by
+                                  SupportedLanguages.  The format of
+                                  SupportedLanguages must follow the language
+  @param[in]  String              A pointer to the Null-terminated Unicode string
+                                  to add or update in the String Package associated
+                                  with HiiHandle.
+  @param[in]  SupportedLanguages  A pointer to a Null-terminated ASCII string of
+                                  language codes.  If this parameter is NULL, then
+                                  String is added or updated in the String Package
+                                  associated with HiiHandle for all the languages
+                                  that the String Package supports.  If this
+                                  parameter is not NULL, then then String is added
+                                  or updated in the String Package associated with
+                                  HiiHandle for the set oflanguages specified by
+                                  SupportedLanguages.  The format of
+                                  SupportedLanguages must follow the language
                                   format assumed the HII Database.
 …
 /**
   Retrieves a string from a string package names by GUID in a specific language.
   If the language is not specified, then a string from a string package in the
   current platform  language is retrieved.  If the string can not be retrieved
   using the specified language or the current platform language, then the string
   is retrieved from the string package in the first language the string package
   supports.  The returned string is allocated using AllocatePool().  The caller
+  Retrieves a string from a string package names by GUID in a specific language.
+  If the language is not specified, then a string from a string package in the
+  current platform  language is retrieved.  If the string can not be retrieved
+  using the specified language or the current platform language, then the string
+  is retrieved from the string package in the first language the string package
+  supports.  The returned string is allocated using AllocatePool().  The caller
   is responsible for freeing the allocated buffer using FreePool().
   If PackageListGuid is NULL, then ASSERT().
   If StringId is 0, then ASSERT.
   @param[in]  PackageListGuid  The GUID of a package list that was previously
+  @param[in]  PackageListGuid  The GUID of a package list that was previously
                                registered in the HII Database.
   @param[in]  StringId         The identifier of the string to retrieved from the
+  @param[in]  StringId         The identifier of the string to retrieved from the
                                string package associated with PackageListGuid.
   @param[in]  Language         The language of the string to retrieve.  If this
                                parameter is NULL, then the current platform
                                language is used.  The format of Language must
+  @param[in]  Language         The language of the string to retrieve.  If this
+                               parameter is NULL, then the current platform
+                               language is used.  The format of Language must
                                follow the language format assumed the HII Database.
 …
 /**
   Retrieves a string from a string package in a specific language.  If the language
   is not specified, then a string from a string package in the current platform
   language is retrieved.  If the string can not be retrieved using the specified
   language or the current platform language, then the string is retrieved from
   the string package in the first language the string package supports.  The
   returned string is allocated using AllocatePool().  The caller is responsible
+  is not specified, then a string from a string package in the current platform
+  language is retrieved.  If the string can not be retrieved using the specified
+  language or the current platform language, then the string is retrieved from
+  the string package in the first language the string package supports.  The
+  returned string is allocated using AllocatePool().  The caller is responsible
   for freeing the allocated buffer using FreePool().
   If HiiHandle is NULL, then ASSERT().
   If StringId is 0, then ASSET.
   @param[in]  HiiHandle  A handle that was previously registered in the HII Database.
   @param[in]  StringId   The identifier of the string to retrieved from the string
+  @param[in]  StringId   The identifier of the string to retrieved from the string
                          package associated with HiiHandle.
   @param[in]  Language   The language of the string to retrieve.  If this parameter
                          is NULL, then the current platform language is used.  The
                          format of Language must follow the language format assumed
+  @param[in]  Language   The language of the string to retrieve.  If this parameter
+                         is NULL, then the current platform language is used.  The
+                         format of Language must follow the language format assumed
                          the HII Database.
 …
   //
   // Initialize all allocated buffers to NULL
   //
+  //
   SupportedLanguages = NULL;
   PlatformLanguage   = NULL;
 …
   //
   // If Languag is NULL, then set it to an empty string, so it will be
+  // If Languag is NULL, then set it to an empty string, so it will be
   // skipped by GetBestLanguage()
   //
 …
   //
   BestLanguage = GetBestLanguage (
                    SupportedLanguages,
+                   SupportedLanguages,
                    FALSE,                                             // RFC 4646 mode
                    Language,                                          // Highest priority
+                   Language,                                          // Highest priority
                    PlatformLanguage != NULL ? PlatformLanguage : "",  // Next highest priority
                    SupportedLanguages,                                // Lowest priority
+                   SupportedLanguages,                                // Lowest priority
                    NULL
                    );
 …
                          );
   //
   // If GetString() returns EFI_SUCCESS for a zero size,
   // then there are no supported languages registered for HiiHandle.  If GetString()
+  // If GetString() returns EFI_SUCCESS for a zero size,
+  // then there are no supported languages registered for HiiHandle.  If GetString()
   // returns an error other than EFI_BUFFER_TOO_SMALL, then HiiHandle is not present
   // in the HII Database

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/UefiHiiLib/InternalHiiLib.h

-              r48674
+              r58466
   Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
   which accompanies this distribution.  The full text of the license may be found at
   http://opensource.org/licenses/bsd-license.php
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 **/

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/UefiHiiServicesLib/UefiHiiServicesLib.c

-              r48674
+              r58466
 /** @file
   This library retrieves pointers to the UEFI HII Protocol instances in the
   library's constructor.  All of the UEFI HII related protocols are optional,
   so the consumers of this library class must verify that the global variable
   pointers are not NULL before use.
+  This library retrieves pointers to the UEFI HII Protocol instances in the
+  library's constructor.  All of the UEFI HII related protocols are optional,
+  so the consumers of this library class must verify that the global variable
+  pointers are not NULL before use.
   Copyright (c) 2006 - 2009, Intel Corporation. All rights reserved.<BR>
 …
 /**
   The constructor function retrieves pointers to the UEFI HII protocol instances
   The constructor function retrieves pointers to the four UEFI HII protocols from the
   handle database.  These include the UEFI HII Font Protocol, the UEFI HII String
   Protocol, the UEFI HII Image Protocol, the UEFI HII Database Protocol, and the
+  The constructor function retrieves pointers to the four UEFI HII protocols from the
+  handle database.  These include the UEFI HII Font Protocol, the UEFI HII String
+  Protocol, the UEFI HII Image Protocol, the UEFI HII Database Protocol, and the
   UEFI HII Config Routing Protocol.  This function always return EFI_SUCCESS.
   All of these protocols are optional if the platform does not support configuration
   and the UEFI HII Image Protocol and the UEFI HII Font Protocol are optional if
+  and the UEFI HII Image Protocol and the UEFI HII Font Protocol are optional if
   the platform does not support a graphical console.  As a result, the consumers
   of this library much check the protocol pointers againt NULL before using them,
 …
   //
   // Retrieve the pointer to the UEFI HII String Protocol
+  // Retrieve the pointer to the UEFI HII String Protocol
   //
   Status = gBS->LocateProtocol (&gEfiHiiStringProtocolGuid, NULL, (VOID **) &gHiiString);
 …
   //
   // Retrieve the pointer to the UEFI HII Database Protocol
+  // Retrieve the pointer to the UEFI HII Database Protocol
   //
   Status = gBS->LocateProtocol (&gEfiHiiDatabaseProtocolGuid, NULL, (VOID **) &gHiiDatabase);
 …
   //
   // Retrieve the pointer to the UEFI HII Config Routing Protocol
+  // Retrieve the pointer to the UEFI HII Config Routing Protocol
   //
   Status = gBS->LocateProtocol (&gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID **) &gHiiConfigRouting);
 …
   //
   // Retrieve the pointer to the optional UEFI HII Font Protocol
+  // Retrieve the pointer to the optional UEFI HII Font Protocol
   //
   gBS->LocateProtocol (&gEfiHiiFontProtocolGuid, NULL, (VOID **) &gHiiFont);
   //
   // Retrieve the pointer to the optional UEFI HII Image Protocol
+  // Retrieve the pointer to the optional UEFI HII Image Protocol
   //
   gBS->LocateProtocol (&gEfiHiiImageProtocolGuid, NULL, (VOID **) &gHiiImage);

trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/UefiHiiServicesLib/UefiHiiServicesLib.inf

-              r58459
+              r58466
 ## @file
 # UEFI HII Services Library implementation.
+#
+#
 # Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
+#
 …
   MODULE_TYPE                    = UEFI_DRIVER
   VERSION_STRING                 = 1.0
   LIBRARY_CLASS                  = UefiHiiServicesLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
+  LIBRARY_CLASS                  = UefiHiiServicesLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
   CONSTRUCTOR                    = UefiHiiServicesLibConstructor
 …
   UefiBootServicesTableLib
   DebugLib
 [Protocols]
   gEfiHiiFontProtocolGuid             ## SOMETIMES_CONSUMES
+  gEfiHiiFontProtocolGuid             ## SOMETIMES_CONSUMES
   gEfiHiiStringProtocolGuid           ## CONSUMES
   gEfiHiiImageProtocolGuid            ## SOMETIMES_CONSUMES

Changeset 58466 in vbox for trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library

Legend:

Download in other formats: