EdkGenericPlatformBdsLib added

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2368 6f19259b-4bc3-4df7-8a09-765794883524

EdkModulePkg/Include/Library/EdkGenericPlatformBdsLib.h

@@ -0,0 +1,140 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name: 
+
+  BdsPlatform.h
+
+Abstract:
+
+  Head file for BDS Platform specific code
+
+--*/
+
+#ifndef _BDS_PLATFORM_LIB_H
+#define _BDS_PLATFORM_LIB_H
+
+extern BDS_CONSOLE_CONNECT_ENTRY  gPlatformConsole[];
+extern EFI_DEVICE_PATH_PROTOCOL   *gPlatformConnectSequence[];
+extern EFI_DEVICE_PATH_PROTOCOL   *gPlatformDriverOption[];
+//
+// Bds AP Context data
+//
+#define EFI_BDS_ARCH_PROTOCOL_INSTANCE_SIGNATURE  EFI_SIGNATURE_32 ('B', 'd', 's', 'A')
+typedef struct {
+  UINTN                     Signature;
+
+  EFI_HANDLE                Handle;
+
+  EFI_BDS_ARCH_PROTOCOL     Bds;
+
+  //
+  // Save the current boot mode
+  //
+  EFI_BOOT_MODE             BootMode;
+
+  //
+  // Set true if boot with default settings
+  //
+  BOOLEAN                   DefaultBoot;
+
+  //
+  // The system default timeout for choose the boot option
+  //
+  UINT16                    TimeoutDefault;
+
+  //
+  // Memory Test Level
+  //
+  EXTENDMEM_COVERAGE_LEVEL  MemoryTestLevel;
+
+} EFI_BDS_ARCH_PROTOCOL_INSTANCE;
+
+#define EFI_BDS_ARCH_PROTOCOL_INSTANCE_FROM_THIS(_this) \
+  CR (_this, \
+      EFI_BDS_ARCH_PROTOCOL_INSTANCE, \
+      Bds, \
+      EFI_BDS_ARCH_PROTOCOL_INSTANCE_SIGNATURE \
+      )
+
+
+#define gEndEntire \
+  { \
+    END_DEVICE_PATH_TYPE,\
+    END_ENTIRE_DEVICE_PATH_SUBTYPE,\
+    {\
+      END_DEVICE_PATH_LENGTH,\
+      0\
+    }\
+  }
+
+//
+// Platform BDS Functions
+//
+VOID
+PlatformBdsInit (
+  IN EFI_BDS_ARCH_PROTOCOL_INSTANCE  *PrivateData
+  )
+;
+
+VOID
+PlatformBdsPolicyBehavior (
+  IN EFI_BDS_ARCH_PROTOCOL_INSTANCE  *PrivateData,
+  IN LIST_ENTRY                      *DriverOptionList,
+  IN LIST_ENTRY                      *BootOptionList
+  )
+;
+
+EFI_STATUS
+BdsMemoryTest (
+  EXTENDMEM_COVERAGE_LEVEL Level
+  )
+;
+
+EFI_STATUS
+PlatformBdsShowProgress (
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL TitleForeground,
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL TitleBackground,
+  CHAR16                        *Title,
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL ProgressColor,
+  UINTN                         Progress,
+  UINTN                         PreviousValue
+  )
+;
+
+VOID
+PlatformBdsBootFail (
+  IN  BDS_COMMON_OPTION  *Option,
+  IN  EFI_STATUS         Status,
+  IN  CHAR16             *ExitData,
+  IN  UINTN              ExitDataSize
+  )
+;
+
+VOID
+PlatformBdsBootSuccess (
+  IN  BDS_COMMON_OPTION *Option
+  )
+;
+
+EFI_STATUS
+ProcessCapsules (
+  EFI_BOOT_MODE BootMode
+  )
+;
+
+VOID
+PlatformBdsEnterFrontPage (
+  IN UINT16                 TimeoutDefault,
+  IN BOOLEAN                ConnectAllHappened
+  );
+
+#endif // _BDS_PLATFORM_LIB_H

EdkModulePkg/Library/EdkGenericPlatformBdsLib/Bds.dxs

@@ -0,0 +1,27 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  Bds.dxs
+
+Abstract:
+
+  Dependency expression source file.  This driver produces an arch protocol, so
+  must dipatch early.
+  
+--*/
+#include <AutoGen.h>
+#include <DxeDepex.h>
+
+DEPENDENCY_START
+  EFI_HII_PROTOCOL_GUID
+DEPENDENCY_END

EdkModulePkg/Library/EdkGenericPlatformBdsLib/Bds.h

@@ -0,0 +1,44 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  Bds.h
+
+Abstract:
+
+  Head file for BDS Architectural Protocol implementation
+
+Revision History
+
+--*/
+
+#ifndef _BDS_H
+#define _BDS_H
+
+
+//
+// Prototypes
+//
+EFI_STATUS
+EFIAPI
+BdsInitialize (
+  IN EFI_HANDLE                     ImageHandle,
+  IN EFI_SYSTEM_TABLE               *SystemTable
+  );
+
+VOID
+EFIAPI
+BdsEntry (
+  IN  EFI_BDS_ARCH_PROTOCOL *This
+  );
+
+#endif

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BdsBoot.c

@@ -0,0 +1,103 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  BdsPlatform.c
+
+Abstract:
+
+  This file include all platform action which can be customized
+  by IBV/OEM.
+
+--*/
+
+#include "String.h"
+
+VOID
+PlatformBdsBootSuccess (
+  IN  BDS_COMMON_OPTION *Option
+  )
+/*++
+
+Routine Description:
+  
+  Hook point after a boot attempt succeeds. We don't expect a boot option to
+  return, so the EFI 1.0 specification defines that you will default to an
+  interactive mode and stop processing the BootOrder list in this case. This
+  is alos a platform implementation and can be customized by IBV/OEM.
+
+Arguments:
+
+  Option - Pointer to Boot Option that succeeded to boot.
+
+Returns:
+  
+  None.
+
+--*/
+{
+  CHAR16  *TmpStr;
+
+  //
+  // If Boot returned with EFI_SUCCESS and there is not in the boot device
+  // select loop then we need to pop up a UI and wait for user input.
+  //
+  TmpStr = GetStringById (STRING_TOKEN (STR_BOOT_SUCCEEDED));
+  if (TmpStr != NULL) {
+    BdsLibOutputStrings (gST->ConOut, TmpStr, Option->Description, L"\n\r", NULL);
+    gBS->FreePool (TmpStr);
+  }
+}
+
+VOID
+PlatformBdsBootFail (
+  IN  BDS_COMMON_OPTION  *Option,
+  IN  EFI_STATUS         Status,
+  IN  CHAR16             *ExitData,
+  IN  UINTN              ExitDataSize
+  )
+/*++
+
+Routine Description:
+  
+  Hook point after a boot attempt fails.
+
+Arguments:
+  
+  Option - Pointer to Boot Option that failed to boot.
+
+  Status - Status returned from failed boot.
+
+  ExitData - Exit data returned from failed boot.
+
+  ExitDataSize - Exit data size returned from failed boot.
+
+Returns:
+  
+  None.
+
+--*/
+{
+  CHAR16  *TmpStr;
+
+  //
+  // If Boot returned with failed status then we need to pop up a UI and wait
+  // for user input.
+  //
+  TmpStr = GetStringById (STRING_TOKEN (STR_BOOT_FAILED));
+  if (TmpStr != NULL) {
+    BdsLibOutputStrings (gST->ConOut, TmpStr, Option->Description, L"\n\r", NULL);
+    gBS->FreePool (TmpStr);
+  }
+
+}
+

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BdsEntry.c

@@ -0,0 +1,363 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  BdsEntry.c
+
+Abstract:
+
+  The entry of the bds
+
+--*/
+
+#include "Bds.h"
+#include "FrontPage.h"
+#include "Language.h"
+
+EFI_BDS_ARCH_PROTOCOL_INSTANCE  gBdsInstanceTemplate = {
+  EFI_BDS_ARCH_PROTOCOL_INSTANCE_SIGNATURE,
+  NULL,
+  {
+    BdsEntry
+  },
+  0xFFFF,
+  TRUE,
+  EXTENSIVE
+};
+
+UINT16                          *mBootNext = NULL;
+
+EFI_HANDLE                      mBdsImageHandle;
+
+EFI_STATUS
+EFIAPI
+BdsInitialize (
+  IN EFI_HANDLE                            ImageHandle,
+  IN EFI_SYSTEM_TABLE                      *SystemTable
+  )
+/*++
+
+Routine Description:
+
+  Install Boot Device Selection Protocol
+
+Arguments:
+  
+  (Standard EFI Image entry - EFI_IMAGE_ENTRY_POINT)
+
+Returns:
+
+  EFI_SUCEESS - BDS has finished initializing.
+                Rerun the 
+                dispatcher and recall BDS.Entry
+
+  Other       - Return value from EfiLibAllocatePool()
+                or gBS->InstallProtocolInterface
+
+--*/
+{
+  EFI_STATUS  Status;
+
+  mBdsImageHandle = ImageHandle;
+
+  //
+  // Install protocol interface
+  //
+  Status = gBS->InstallProtocolInterface (
+                  &gBdsInstanceTemplate.Handle,
+                  &gEfiBdsArchProtocolGuid,
+                  EFI_NATIVE_INTERFACE,
+                  &gBdsInstanceTemplate.Bds
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
+
+VOID
+BdsBootDeviceSelect (
+  VOID
+  )
+/*++
+
+Routine Description:
+
+  In the loop of attempt to boot for the boot order
+
+Arguments:
+  
+  None.
+
+Returns:
+
+  None.
+  
+--*/
+{
+  EFI_STATUS        Status;
+  LIST_ENTRY        *Link;
+  BDS_COMMON_OPTION *BootOption;
+  UINTN             ExitDataSize;
+  CHAR16            *ExitData;
+  UINT16            Timeout;
+  LIST_ENTRY        BootLists;
+  CHAR16            Buffer[20];
+  BOOLEAN           BootNextExist;
+  LIST_ENTRY        *LinkBootNext;
+
+  //
+  // Got the latest boot option
+  //
+  BootNextExist = FALSE;
+  LinkBootNext  = NULL;
+  InitializeListHead (&BootLists);
+
+  //
+  // First check the boot next option
+  //
+  ZeroMem (Buffer, sizeof (Buffer));
+
+  if (mBootNext != NULL) {
+    //
+    // Indicate we have the boot next variable, so this time
+    // boot will always have this boot option
+    //
+    BootNextExist = TRUE;
+
+    //
+    // Clear the this variable so it's only exist in this time boot
+    //
+    gRT->SetVariable (
+          L"BootNext",
+          &gEfiGlobalVariableGuid,
+          EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
+          0,
+          mBootNext
+          );
+
+    //
+    // Add the boot next boot option
+    //
+    UnicodeSPrint (Buffer, sizeof (Buffer), L"Boot%04x", *mBootNext);
+    BootOption = BdsLibVariableToOption (&BootLists, Buffer);
+  }
+  //
+  // Parse the boot order to get boot option
+  //
+  BdsLibBuildOptionFromVar (&BootLists, L"BootOrder");
+  Link = BootLists.ForwardLink;
+
+  //
+  // Parameter check, make sure the loop will be valid
+  //
+  if (Link == NULL) {
+    return ;
+  }
+  //
+  // Here we make the boot in a loop, every boot success will
+  // return to the front page
+  //
+  for (;;) {
+    //
+    // Check the boot option list first
+    //
+    if (Link == &BootLists) {
+      //
+      // There are two ways to enter here:
+      // 1. There is no active boot option, give user chance to
+      //    add new boot option
+      // 2. All the active boot option processed, and there is no
+      //    one is success to boot, then we back here to allow user
+      //    add new active boot option
+      //
+      Timeout = 0xffff;
+      PlatformBdsEnterFrontPage (Timeout, FALSE);
+      InitializeListHead (&BootLists);
+      BdsLibBuildOptionFromVar (&BootLists, L"BootOrder");
+      Link = BootLists.ForwardLink;
+      continue;
+    }
+    //
+    // Get the boot option from the link list
+    //
+    BootOption = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE);
+
+    //
+    // According to EFI Specification, if a load option is not marked
+    // as LOAD_OPTION_ACTIVE, the boot manager will not automatically
+    // load the option.
+    //
+    if (!IS_LOAD_OPTION_TYPE (BootOption->Attribute, LOAD_OPTION_ACTIVE)) {
+      //
+      // skip the header of the link list, becuase it has no boot option
+      //
+      Link = Link->ForwardLink;
+      continue;
+    }
+    //
+    // Make sure the boot option device path connected,
+    // but ignore the BBS device path
+    //
+    if (DevicePathType (BootOption->DevicePath) != BBS_DEVICE_PATH) {
+      //
+      // Notes: the internal shell can not been connected with device path
+      // so we do not check the status here
+      //
+      BdsLibConnectDevicePath (BootOption->DevicePath);
+    }
+    //
+    // All the driver options should have been processed since
+    // now boot will be performed.
+    //
+    PERF_END (0, BDS_TOK, NULL, 0);
+    Status = BdsLibBootViaBootOption (BootOption, BootOption->DevicePath, &ExitDataSize, &ExitData);
+    if (EFI_ERROR (Status)) {
+      //
+      // Call platform action to indicate the boot fail
+      //
+      PlatformBdsBootFail (BootOption, Status, ExitData, ExitDataSize);
+
+      //
+      // Check the next boot option
+      //
+      Link = Link->ForwardLink;
+
+    } else {
+      //
+      // Call platform action to indicate the boot success
+      //
+      PlatformBdsBootSuccess (BootOption);
+
+      //
+      // Boot success, then stop process the boot order, and
+      // present the boot manager menu, front page
+      //
+      Timeout = 0xffff;
+      PlatformBdsEnterFrontPage (Timeout, FALSE);
+
+      //
+      // Rescan the boot option list, avoid pertential risk of the boot
+      // option change in front page
+      //
+      if (BootNextExist) {
+        LinkBootNext = BootLists.ForwardLink;
+      }
+
+      InitializeListHead (&BootLists);
+      if (LinkBootNext != NULL) {
+        //
+        // Reserve the boot next option
+        //
+        InsertTailList (&BootLists, LinkBootNext);
+      }
+
+      BdsLibBuildOptionFromVar (&BootLists, L"BootOrder");
+      Link = BootLists.ForwardLink;
+    }
+  }
+
+  return ;
+
+}
+
+VOID
+EFIAPI
+BdsEntry (
+  IN EFI_BDS_ARCH_PROTOCOL  *This
+  )
+/*++
+
+Routine Description:
+
+  Service routine for BdsInstance->Entry(). Devices are connected, the 
+  consoles are initialized, and the boot options are tried. 
+
+Arguments:
+
+  This - Protocol Instance structure.
+
+Returns:
+
+  EFI_SUCEESS - BDS->Entry has finished executing. 
+                
+--*/
+{
+  EFI_BDS_ARCH_PROTOCOL_INSTANCE  *PrivateData;
+  LIST_ENTRY                      DriverOptionList;
+  LIST_ENTRY                      BootOptionList;
+  UINTN                           BootNextSize;
+
+  //
+  // Insert the performance probe
+  //
+  PERF_END (0, DXE_TOK, NULL, 0);
+  PERF_START (0, BDS_TOK, NULL, 0);
+
+  //
+  // Initialize the global system boot option and driver option
+  //
+  InitializeListHead (&DriverOptionList);
+  InitializeListHead (&BootOptionList);
+
+  //
+  // Get the BDS private data
+  //
+  PrivateData = EFI_BDS_ARCH_PROTOCOL_INSTANCE_FROM_THIS (This);
+
+  //
+  // Do the platform init, can be customized by OEM/IBV
+  //
+  PERF_START (0, "PlatformBds", "BDS", 0);
+  PlatformBdsInit (PrivateData);
+
+  //
+  // Initialize the platform specific string and language
+  //
+  InitializeStringSupport ();
+  InitializeLanguage (TRUE);
+  InitializeFrontPage (FALSE);
+  //
+  // Set up the device list based on EFI 1.1 variables
+  // process Driver#### and Load the driver's in the
+  // driver option list
+  //
+  BdsLibBuildOptionFromVar (&DriverOptionList, L"DriverOrder");
+  if (!IsListEmpty (&DriverOptionList)) {
+    BdsLibLoadDrivers (&DriverOptionList);
+  }
+  //
+  // Check if we have the boot next option
+  //
+  mBootNext = BdsLibGetVariableAndSize (
+                L"BootNext",
+                &gEfiGlobalVariableGuid,
+                &BootNextSize
+                );
+
+  //
+  // Setup some platform policy here
+  //
+  PlatformBdsPolicyBehavior (PrivateData, &DriverOptionList, &BootOptionList);
+  PERF_END (0, "PlatformBds", "BDS", 0);
+
+  //
+  // BDS select the boot device to load OS
+  //
+  BdsBootDeviceSelect ();
+
+  //
+  // Only assert here since this is the right behavior, we should never
+  // return back to DxeCore.
+  //
+  ASSERT (FALSE);
+}
+

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/BBSsupport.h

@@ -0,0 +1,83 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  BBSsupport.h
+
+Abstract:
+
+  declares interface functions
+
+Revision History
+
+--*/
+
+#ifndef _EFI_BDS_BBS_SUPPORT_H
+#define _EFI_BDS_BBS_SUPPORT_H
+
+#include "BootMaint/BootMaint.h"
+
+#ifdef EFI32
+#define REFRESH_LEGACY_BOOT_OPTIONS \
+        BdsDeleteAllInvalidLegacyBootOptions ();\
+        BdsAddNonExistingLegacyBootOptions (); \
+        BdsUpdateLegacyDevOrder ()
+#else
+#define REFRESH_LEGACY_BOOT_OPTIONS
+#endif
+
+VOID
+BdsBuildLegacyDevNameString (
+  IN BBS_TABLE                     *CurBBSEntry,
+  IN UINTN                         Index,
+  IN UINTN                         BufSize,
+  OUT CHAR16                       *BootString
+  );
+
+EFI_STATUS
+BdsDeleteAllInvalidLegacyBootOptions (
+  VOID
+  );
+
+EFI_STATUS
+BdsAddNonExistingLegacyBootOptions (
+  VOID
+  )
+/*++
+
+Routine Description:
+
+  Add the legacy boot options from BBS table if they do not exist.
+
+Arguments:
+
+  None.
+
+Returns:
+
+  EFI_SUCCESS       - The boot options are added successfully or they are already in boot options.
+  others            - An error occurred when creating legacy boot options.
+
+--*/
+;
+
+EFI_STATUS
+BdsUpdateLegacyDevOrder (
+  VOID
+  );
+
+EFI_STATUS
+BdsRefreshBbsTableForBoot (
+  IN BDS_COMMON_OPTION        *Entry
+  );
+
+#endif

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/Bm.vfr

@@ -0,0 +1,495 @@
+// *++
+//
+// Copyright (c) 2006, Intel Corporation                                                         
+// All rights reserved. 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.             
+// 
+// Module Name:
+//
+//   bm.vfr 
+// 
+// Abstract:
+// 
+//   Boot Maintenance Utility Formset
+// 
+// Revision History: 
+// 
+// --*/
+
+#include "EdkGenericPlatformBdsLibStrDefs.h" 
+#include "FormGuid.h"
+
+#pragma pack(1)
+
+//
+// This is the structure that will be used to store the 
+// question's current value. Use it at initialize time to 
+// set default value for each question. When using at run
+// time, this map is returned by the callback function,
+// so dynamically changing the question's value will be
+// possible through this mechanism
+//
+typedef struct {
+
+//
+// Three questions displayed at the main page
+// for Timeout, BootNext Variables respectively
+//
+  UINT16                    BootTimeOut;
+  UINT16                    BootNext;
+
+//
+// This is the COM1 Attributes value storage
+//
+  UINT8                     COM1BaudRate;
+  UINT8                     COM1DataRate;
+  UINT8                     COM1StopBits;
+  UINT8                     COM1Parity;
+  UINT8                     COM1TerminalType;
+  
+//
+// This is the COM2 Attributes value storage
+//
+  UINT8                     COM2BaudRate;
+  UINT8                     COM2DataRate;
+  UINT8                     COM2StopBits;
+  UINT8                     COM2Parity;
+  UINT8                     COM2TerminalType;
+
+// 
+// Driver Option Add Handle page storage
+//
+  UINT16                    DriverAddHandleDesc[100];
+  UINT16                    DriverAddHandleOptionalData[100];
+  UINT8                     DriverAddActive;
+  UINT8                     DriverAddForceReconnect;
+  
+//
+// Console Input/Output/Errorout using COM port check storage
+//
+  UINT8                     ConsoleInputCOM1;
+  UINT8                     ConsoleInputCOM2;
+  UINT8                     ConsoleOutputCOM1;
+  UINT8                     ConsoleOutputCOM2;
+  UINT8                     ConsoleErrorCOM1;
+  UINT8                     ConsoleErrorCOM2;
+
+//
+// At most 100 input/output/errorout device for console storage
+//
+  UINT8                     ConsoleCheck[100];
+
+//
+// Boot or Driver Option Order storage
+//
+  UINT8                     OptionOrder[100];
+  UINT8                     DriverOptionToBeDeleted[100];
+
+//
+// Boot Option Delete storage
+// 
+  UINT8                     BootOptionDel[100];
+  UINT8                     DriverOptionDel[100];
+  
+//
+// This is the Terminal Attributes value storage
+//
+  UINT8                     COMBaudRate;
+  UINT8                     COMDataRate;
+  UINT8                     COMStopBits;
+  UINT8                     COMParity;
+  UINT8                     COMTerminalType;
+  
+//
+// Legacy Device Order Selection Storage
+//
+  UINT8                     LegacyFD[100];
+  UINT8                     LegacyHD[100];
+  UINT8                     LegacyCD[100];
+  UINT8                     LegacyNET[100];
+  UINT8                     LegacyBEV[100];
+} BMM_FAKE_NV_DATA;
+#pragma pack()
+
+
+#define FORM_MAIN_ID                         0x0001
+#define FORM_BOOT_ADD_ID                     0x0002
+#define FORM_BOOT_DEL_ID                     0x0003
+#define FORM_BOOT_CHG_ID                     0x0004
+#define FORM_DRV_ADD_ID                      0x0005
+#define FORM_DRV_DEL_ID                      0x0006
+#define FORM_DRV_CHG_ID                      0x0007
+#define FORM_CON_MAIN_ID                     0x0008
+#define FORM_CON_IN_ID                       0x0009
+#define FORM_CON_OUT_ID                      0x000A
+#define FORM_CON_ERR_ID                      0x000B
+#define FORM_FILE_SEEK_ID                    0x000C
+#define FORM_FILE_NEW_SEEK_ID                0x000D
+#define FORM_DRV_ADD_FILE_ID                 0x000E
+#define FORM_DRV_ADD_HANDLE_ID               0x000F
+#define FORM_DRV_ADD_HANDLE_DESC_ID          0x0010
+#define FORM_BOOT_NEXT_ID                    0x0011
+#define FORM_TIME_OUT_ID                     0x0012
+#define FORM_RESET                           0x0013
+#define FORM_BOOT_SETUP_ID                   0x0014
+#define FORM_DRIVER_SETUP_ID                 0x0015
+#define FORM_BOOT_LEGACY_DEVICE_ID           0x0016
+#define FORM_CON_COM_ID                      0x0017
+#define FORM_CON_COM_SETUP_ID                0x0018
+#define FORM_SET_FD_ORDER_ID                 0x0019
+#define FORM_SET_HD_ORDER_ID                 0x001A
+#define FORM_SET_CD_ORDER_ID                 0x001B
+#define FORM_SET_NET_ORDER_ID                0x001C
+#define FORM_SET_BEV_ORDER_ID                0x001D
+									
+#define KEY_VALUE_BOOT_FROM_FILE             0x0092
+
+formset 
+  guid = MAIN_FORMSET_GUID,
+  title = STRING_TOKEN(STR_FORM_MAIN_TITLE),  // uint8 opcode, uint8 length, guid Handle, uint16 Title
+  help = STRING_TOKEN(STR_NULL_STRING),
+  class = 0,      
+  subclass = 0,
+
+  form formid = FORM_MAIN_ID,
+       title = STRING_TOKEN(STR_FORM_MAIN_TITLE);
+
+    goto FORM_BOOT_SETUP_ID,
+         prompt = STRING_TOKEN(STR_FORM_BOOT_SETUP_TITLE),
+         help = STRING_TOKEN(STR_FORM_BOOT_SETUP_HELP),
+         flags = INTERACTIVE | NV_ACCESS,
+         key = FORM_BOOT_SETUP_ID;
+
+    subtitle text = STRING_TOKEN(STR_NULL_STRING);
+
+    goto FORM_DRIVER_SETUP_ID,
+         prompt = STRING_TOKEN(STR_FORM_DRIVER_SETUP_TITLE),
+         help = STRING_TOKEN(STR_FORM_DRIVER_SETUP_HELP),
+         flags = INTERACTIVE | NV_ACCESS,
+         key = FORM_DRIVER_SETUP_ID;
+
+    subtitle text = STRING_TOKEN(STR_NULL_STRING);
+
+    goto FORM_CON_MAIN_ID,
+         prompt = STRING_TOKEN(STR_FORM_CON_MAIN_TITLE),
+         help = STRING_TOKEN(STR_FORM_CON_MAIN_HELP),
+         flags = INTERACTIVE | NV_ACCESS,
+         key = FORM_CON_MAIN_ID;
+   
+    subtitle text = STRING_TOKEN(STR_NULL_STRING);
+
+    text 
+         help   = STRING_TOKEN(STR_BOOT_FROM_FILE_HELP),  
+         text   = STRING_TOKEN(STR_BOOT_FROM_FILE),
+         text   = STRING_TOKEN(STR_NULL_STRING),
+         flags  = INTERACTIVE | NV_ACCESS,
+         key    = KEY_VALUE_BOOT_FROM_FILE;
+
+    subtitle text = STRING_TOKEN(STR_NULL_STRING);
+
+//    label FORM_MAIN_ID;
+
+    goto FORM_BOOT_NEXT_ID,
+         prompt = STRING_TOKEN(STR_FORM_BOOT_NEXT_TITLE),
+         help = STRING_TOKEN(STR_FORM_BOOT_NEXT_HELP),
+         flags = INTERACTIVE | NV_ACCESS,
+         key = FORM_BOOT_NEXT_ID;            
+
+    goto FORM_TIME_OUT_ID,
+         prompt = STRING_TOKEN(STR_FORM_TIME_OUT_TITLE),
+         help = STRING_TOKEN(STR_FORM_TIME_OUT_HELP),
+         flags = INTERACTIVE | NV_ACCESS,
+         key = FORM_TIME_OUT_ID;
+         
+    subtitle text = STRING_TOKEN(STR_NULL_STRING);
+
+    goto FORM_MAIN_ID,
+         prompt = STRING_TOKEN(STR_RESET),
+         help = STRING_TOKEN(STR_RESET),
+         flags = INTERACTIVE | NV_ACCESS,
+         key = FORM_RESET;
+         
+  endform;       
+
+  form formid = FORM_BOOT_SETUP_ID,
+       title = STRING_TOKEN(STR_FORM_BOOT_SETUP_TITLE);
+
+       goto FORM_MAIN_ID,
+            prompt = STRING_TOKEN(STR_FORM_GOTO_MAIN),
+            help = STRING_TOKEN(STR_FORM_GOTO_MAIN),
+            flags = INTERACTIVE | NV_ACCESS,
+            key = FORM_MAIN_ID;
+
+       goto FORM_BOOT_ADD_ID,
+            prompt = STRING_TOKEN(STR_FORM_BOOT_ADD_TITLE),
+            help = STRING_TOKEN(STR_FORM_BOOT_ADD_HELP),
+            flags = INTERACTIVE | NV_ACCESS,
+            key = FORM_BOOT_ADD_ID;
+      
+       goto FORM_BOOT_DEL_ID,
+            prompt = STRING_TOKEN(STR_FORM_BOOT_DEL_TITLE),
+            help = STRING_TOKEN(STR_FORM_NEXT_BOOT_HELP),
+            flags = INTERACTIVE | NV_ACCESS,
+            key = FORM_BOOT_DEL_ID;
+       
+       goto FORM_BOOT_CHG_ID,
+            prompt = STRING_TOKEN(STR_FORM_BOOT_CHG_TITLE),
+            help = STRING_TOKEN(STR_FORM_NEXT_BOOT_HELP),
+            flags = INTERACTIVE | NV_ACCESS,
+            key = FORM_BOOT_CHG_ID;
+
+       subtitle text = STRING_TOKEN(STR_NULL_STRING);
+       //
+	   // We will add "Select Legacy Boot Floppy Drive" and "Select Legacy Boot Hard Drive" 
+	   // here dynamically
+	   //
+       label FORM_BOOT_LEGACY_DEVICE_ID;
+
+  endform;       
+
+  form formid = FORM_DRIVER_SETUP_ID,
+       title = STRING_TOKEN(STR_FORM_DRIVER_SETUP_TITLE);
+
+       goto FORM_MAIN_ID,
+            prompt = STRING_TOKEN(STR_FORM_GOTO_MAIN),
+            help = STRING_TOKEN(STR_FORM_GOTO_MAIN),
+            flags = INTERACTIVE | NV_ACCESS,
+            key = FORM_MAIN_ID;
+
+       goto FORM_DRV_ADD_ID,
+            prompt = STRING_TOKEN(STR_FORM_DRV_ADD_TITLE),
+            help = STRING_TOKEN(STR_FORM_DRV_ADD_HELP),
+            flags = INTERACTIVE | NV_ACCESS,
+            key = FORM_DRV_ADD_ID;
+     
+       goto FORM_DRV_DEL_ID,
+            prompt = STRING_TOKEN(STR_FORM_DRV_DEL_TITLE),
+            help = STRING_TOKEN(STR_FORM_NEXT_BOOT_HELP),
+            flags = INTERACTIVE | NV_ACCESS,
+            key = FORM_DRV_DEL_ID;
+       
+       goto FORM_DRV_CHG_ID,
+            prompt = STRING_TOKEN(STR_FORM_DRV_CHG_TITLE),
+            help = STRING_TOKEN(STR_FORM_NEXT_BOOT_HELP),
+            flags = INTERACTIVE | NV_ACCESS,
+            key = FORM_DRV_CHG_ID;
+  endform;       
+
+  form formid = FORM_BOOT_ADD_ID,
+       title = STRING_TOKEN(STR_FORM_BOOT_ADD_TITLE);
+
+       label FORM_BOOT_ADD_ID;
+  endform;
+
+  form formid = FORM_BOOT_DEL_ID,
+       title = STRING_TOKEN(STR_FORM_BOOT_DEL_TITLE);
+
+       label FORM_BOOT_DEL_ID;
+  endform;
+
+  form formid = FORM_BOOT_CHG_ID,
+       title = STRING_TOKEN(STR_FORM_BOOT_CHG_TITLE);
+
+       label FORM_BOOT_CHG_ID;
+       
+       //
+       // This tag is added for bypassing issue of setup browser
+       // setup browser could not support dynamic form very well.
+       //
+       checkbox varid    = BMM_FAKE_NV_DATA.OptionOrder[0],
+           prompt   = STRING_TOKEN(STR_FORM_BOOT_CHG_TITLE),
+           help     = STRING_TOKEN(STR_FORM_BOOT_CHG_TITLE),  
+           flags    = 1,
+           key      = 0,
+       endcheckbox;
+      
+  endform;
+
+  form formid = FORM_BOOT_NEXT_ID,
+       title = STRING_TOKEN(STR_FORM_BOOT_NEXT_TITLE);
+
+       label FORM_BOOT_NEXT_ID;
+  endform;
+  
+  form formid = FORM_TIME_OUT_ID,
+       title = STRING_TOKEN(STR_FORM_TIME_OUT_TITLE);
+       
+       label FORM_TIME_OUT_ID;
+  endform;
+  
+  form formid = FORM_DRV_ADD_ID,
+       title = STRING_TOKEN(STR_FORM_DRV_ADD_TITLE);
+
+       goto FORM_MAIN_ID,
+            prompt = STRING_TOKEN(STR_FORM_GOTO_MAIN),
+            help = STRING_TOKEN(STR_FORM_GOTO_MAIN),
+            flags = INTERACTIVE | NV_ACCESS,
+            key = FORM_MAIN_ID;
+              
+       goto FORM_DRV_ADD_FILE_ID,
+            prompt = STRING_TOKEN(STR_FORM_DRV_ADD_FILE_TITLE),
+            help = STRING_TOKEN(STR_FORM_DRV_ADD_FILE_TITLE),
+            flags = INTERACTIVE | NV_ACCESS,
+            key = FORM_DRV_ADD_FILE_ID;
+
+  endform;
+
+  form formid = FORM_DRV_DEL_ID,
+       title = STRING_TOKEN(STR_FORM_DRV_DEL_TITLE);
+
+       label FORM_DRV_DEL_ID;
+
+  endform;
+
+  form formid = FORM_DRV_CHG_ID,
+       title = STRING_TOKEN(STR_FORM_DRV_CHG_TITLE);
+
+       label FORM_DRV_CHG_ID;
+      
+       //
+       // This tag is added for bypassing issue of setup browser
+       // setup browser could not support dynamic form very well.
+       //
+       checkbox varid    = BMM_FAKE_NV_DATA.OptionOrder[0],
+           prompt   = STRING_TOKEN(STR_FORM_DRV_CHG_TITLE),
+           help     = STRING_TOKEN(STR_FORM_DRV_CHG_TITLE),  
+           flags    = 1,
+           key      = 0,
+       endcheckbox;
+       
+  endform;
+
+  form formid = FORM_CON_MAIN_ID,
+       title = STRING_TOKEN(STR_FORM_CON_MAIN_TITLE);
+
+       goto FORM_MAIN_ID,
+       prompt = STRING_TOKEN(STR_FORM_GOTO_MAIN),
+       help = STRING_TOKEN(STR_FORM_GOTO_MAIN),
+       flags = INTERACTIVE | NV_ACCESS,
+       key = FORM_MAIN_ID;
+
+       goto FORM_CON_IN_ID,
+       prompt = STRING_TOKEN(STR_FORM_CON_IN_TITLE),
+       help = STRING_TOKEN(STR_FORM_CON_IN_HELP),
+       flags = INTERACTIVE | NV_ACCESS,
+       key = FORM_CON_IN_ID;
+
+       goto FORM_CON_OUT_ID,
+       prompt = STRING_TOKEN(STR_FORM_CON_OUT_TITLE),
+       help = STRING_TOKEN(STR_FORM_CON_OUT_HELP),
+       flags = INTERACTIVE | NV_ACCESS,
+       key = FORM_CON_OUT_ID;
+  
+       goto FORM_CON_ERR_ID,
+       prompt = STRING_TOKEN(STR_FORM_STD_ERR_TITLE),
+       help = STRING_TOKEN(STR_FORM_STD_ERR_HELP),
+       flags = INTERACTIVE | NV_ACCESS,
+       key = FORM_CON_ERR_ID;
+
+       goto FORM_CON_COM_ID,
+       prompt = STRING_TOKEN(STR_FORM_COM_TITLE),
+       help = STRING_TOKEN(STR_FORM_COM_HELP),
+       flags = INTERACTIVE | NV_ACCESS,
+       key = FORM_CON_COM_ID;
+  endform;
+
+  form formid = FORM_CON_COM_ID,
+       title = STRING_TOKEN(STR_FORM_COM_TITLE);
+
+       label FORM_CON_COM_ID;
+  endform;
+
+  form formid = FORM_CON_COM_SETUP_ID,
+       title = STRING_TOKEN(STR_CON_COM_SETUP);
+
+       label FORM_CON_COM_SETUP_ID;
+  endform;
+
+  form formid = FORM_FILE_SEEK_ID,
+       title = STRING_TOKEN(STR_FORM_BOOT_ADD_TITLE);
+
+       label FORM_FILE_SEEK_ID;
+  endform;
+
+  form formid = FORM_FILE_NEW_SEEK_ID,
+       title = STRING_TOKEN(STR_FORM_BOOT_ADD_TITLE);
+
+       label FORM_FILE_NEW_SEEK_ID;
+  endform;
+
+  form formid = FORM_DRV_ADD_FILE_ID,
+       title = STRING_TOKEN(STR_FORM_DRV_ADD_FILE_TITLE);
+
+       label FORM_DRV_ADD_FILE_ID;
+  endform;
+
+  form formid = FORM_DRV_ADD_HANDLE_ID,
+       title = STRING_TOKEN(STR_FORM_DRV_ADD_HANDLE_TITLE);
+
+       label FORM_DRV_ADD_HANDLE_ID;
+  endform;     
+
+  form formid = FORM_DRV_ADD_HANDLE_DESC_ID,
+       title = STRING_TOKEN(STR_FORM_DRV_ADD_DESC_TITLE);
+
+       label FORM_DRV_ADD_HANDLE_DESC_ID;
+
+  endform;
+
+  form formid = FORM_CON_IN_ID,
+       title = STRING_TOKEN(STR_FORM_CON_IN_TITLE);
+
+       label FORM_CON_IN_ID;
+
+  endform;
+
+  form formid = FORM_CON_OUT_ID,
+       title = STRING_TOKEN(STR_FORM_CON_OUT_TITLE);
+
+       label FORM_CON_OUT_ID;
+
+  endform;
+
+  form formid = FORM_CON_ERR_ID,
+       title = STRING_TOKEN(STR_FORM_STD_ERR_TITLE);
+
+       label FORM_CON_ERR_ID;
+
+  endform;
+
+  form formid = FORM_SET_FD_ORDER_ID,
+       title = STRING_TOKEN(STR_FORM_SET_FD_ORDER_TITLE);
+
+       label FORM_SET_FD_ORDER_ID;
+  endform;
+  
+  form formid = FORM_SET_HD_ORDER_ID,
+       title = STRING_TOKEN(STR_FORM_SET_HD_ORDER_TITLE);
+
+       label FORM_SET_HD_ORDER_ID;
+  endform;
+
+  form formid = FORM_SET_CD_ORDER_ID,
+       title = STRING_TOKEN(STR_FORM_SET_CD_ORDER_TITLE);
+
+       label FORM_SET_CD_ORDER_ID;
+  endform;
+
+  form formid = FORM_SET_NET_ORDER_ID,
+       title = STRING_TOKEN(STR_FORM_SET_NET_ORDER_TITLE);
+
+       label FORM_SET_NET_ORDER_ID;
+  endform;
+
+  form formid = FORM_SET_BEV_ORDER_ID,
+       title = STRING_TOKEN(STR_FORM_SET_BEV_ORDER_TITLE);
+
+       label FORM_SET_BEV_ORDER_ID;
+  endform;
+
+endformset;

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/BmLib.c

@@ -0,0 +1,627 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  BmLib.c
+    
+AgBStract:
+
+  Boot Maintainence Helper functions
+
+--*/
+
+#include "BootMaint.h"
+
+EFI_STATUS
+EfiLibLocateProtocol (
+  IN  EFI_GUID    *ProtocolGuid,
+  OUT VOID        **Interface
+  )
+/*++
+
+Routine Description:
+
+  Find the first instance of this Protocol 
+  in the system and return it's interface
+
+Arguments:
+
+  ProtocolGuid    - Provides the protocol to search for
+  Interface       - On return, a pointer to the first interface 
+                    that matches ProtocolGuid
+
+Returns:
+
+  EFI_SUCCESS     - A protocol instance matching ProtocolGuid was found
+
+  EFI_NOT_FOUND   - No protocol instances were found that match ProtocolGuid
+
+--*/
+{
+  EFI_STATUS  Status;
+
+  Status = gBS->LocateProtocol (
+                  ProtocolGuid,
+                  NULL,
+                  Interface
+                  );
+  return Status;
+}
+
+EFI_FILE_HANDLE
+EfiLibOpenRoot (
+  IN EFI_HANDLE                   DeviceHandle
+  )
+/*++
+
+Routine Description:
+
+  Function opens and returns a file handle to the root directory of a volume.
+
+Arguments:
+
+  DeviceHandle         - A handle for a device
+
+Returns:
+  
+  A valid file handle or NULL is returned
+
+--*/
+{
+  EFI_STATUS                      Status;
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume;
+  EFI_FILE_HANDLE                 File;
+
+  File = NULL;
+
+  //
+  // File the file system interface to the device
+  //
+  Status = gBS->HandleProtocol (
+                  DeviceHandle,
+                  &gEfiSimpleFileSystemProtocolGuid,
+                  (VOID *) &Volume
+                  );
+
+  //
+  // Open the root directory of the volume
+  //
+  if (!EFI_ERROR (Status)) {
+    Status = Volume->OpenVolume (
+                      Volume,
+                      &File
+                      );
+  }
+  //
+  // Done
+  //
+  return EFI_ERROR (Status) ? NULL : File;
+}
+
+BOOLEAN
+EfiGrowBuffer (
+  IN OUT EFI_STATUS   *Status,
+  IN OUT VOID         **Buffer,
+  IN UINTN            BufferSize
+  )
+/*++
+
+Routine Description:
+
+    Helper function called as part of the code needed
+    to allocate the proper sized buffer for various 
+    EFI interfaces.
+
+Arguments:
+
+    Status      - Current status
+
+    Buffer      - Current allocated buffer, or NULL
+
+    BufferSize  - Current buffer size needed
+    
+Returns:
+    
+    TRUE - if the buffer was reallocated and the caller 
+    should try the API again.
+
+--*/
+{
+  BOOLEAN TryAgain;
+
+  //
+  // If this is an initial request, buffer will be null with a new buffer size
+  //
+  if (!*Buffer && BufferSize) {
+    *Status = EFI_BUFFER_TOO_SMALL;
+  }
+  //
+  // If the status code is "buffer too small", resize the buffer
+  //
+  TryAgain = FALSE;
+  if (*Status == EFI_BUFFER_TOO_SMALL) {
+
+    SafeFreePool (*Buffer);
+
+    *Buffer = AllocateZeroPool (BufferSize);
+
+    if (*Buffer) {
+      TryAgain = TRUE;
+    } else {
+      *Status = EFI_OUT_OF_RESOURCES;
+    }
+  }
+  //
+  // If there's an error, free the buffer
+  //
+  if (!TryAgain && EFI_ERROR (*Status) && *Buffer) {
+    SafeFreePool (*Buffer);
+    *Buffer = NULL;
+  }
+
+  return TryAgain;
+}
+
+VOID *
+EfiLibGetVariable (
+  IN CHAR16               *Name,
+  IN EFI_GUID             *VendorGuid
+  )
+/*++
+
+Routine Description:
+  Function returns the value of the specified variable.
+
+Arguments:
+  Name                - A Null-terminated Unicode string that is 
+                        the name of the vendor's variable.
+
+  VendorGuid          - A unique identifier for the vendor.
+
+Returns:
+
+  None
+
+--*/
+{
+  UINTN VarSize;
+
+  return BdsLibGetVariableAndSize (Name, VendorGuid, &VarSize);
+}
+
+EFI_STATUS
+EfiLibDeleteVariable (
+  IN CHAR16   *VarName,
+  IN EFI_GUID *VarGuid
+  )
+/*++
+
+Routine Description:
+  Function deletes the variable specified by VarName and VarGuid.
+
+Arguments:
+  VarName              - A Null-terminated Unicode string that is 
+                         the name of the vendor's variable.
+
+  VendorGuid           - A unique identifier for the vendor.
+
+Returns:
+
+  EFI_SUCCESS          - The variable was found and removed
+
+  EFI_UNSUPPORTED      - The variable store was inaccessible
+
+  EFI_OUT_OF_RESOURCES - The temporary buffer was not available
+
+  EFI_NOT_FOUND        - The variable was not found
+
+--*/
+{
+  VOID        *VarBuf;
+  EFI_STATUS  Status;
+
+  VarBuf  = EfiLibGetVariable (VarName, VarGuid);
+  Status  = EFI_NOT_FOUND;
+
+  if (VarBuf) {
+    //
+    // Delete variable from Storage
+    //
+    Status = gRT->SetVariable (VarName, VarGuid, VAR_FLAG, 0, NULL);
+    ASSERT (!EFI_ERROR (Status));
+    SafeFreePool (VarBuf);
+  }
+
+  return Status;
+}
+
+EFI_FILE_SYSTEM_VOLUME_LABEL_INFO *
+EfiLibFileSystemVolumeLabelInfo (
+  IN EFI_FILE_HANDLE      FHand
+  )
+/*++
+
+Routine Description:
+
+  Function gets the file system information from an open file descriptor, 
+  and stores it in a buffer allocated from pool.
+
+Arguments:
+
+  Fhand         - A file handle
+
+Returns:
+  
+  A pointer to a buffer with file information or NULL is returned
+
+--*/
+{
+  EFI_STATUS                        Status;
+  EFI_FILE_SYSTEM_VOLUME_LABEL_INFO *Buffer;
+  UINTN                             BufferSize;
+  //
+  // Initialize for GrowBuffer loop
+  //
+  Buffer      = NULL;
+  BufferSize  = SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL_INFO + 200;
+
+  //
+  // Call the real function
+  //
+  while (EfiGrowBuffer (&Status, (VOID **) &Buffer, BufferSize)) {
+    Status = FHand->GetInfo (
+                      FHand,
+                      &gEfiFileSystemVolumeLabelInfoIdGuid,
+                      &BufferSize,
+                      Buffer
+                      );
+  }
+
+  return Buffer;
+}
+
+CHAR16 *
+EfiStrDuplicate (
+  IN CHAR16   *Src
+  )
+{
+  CHAR16  *Dest;
+  UINTN   Size;
+
+  Size  = StrSize (Src);
+  Dest  = AllocateZeroPool (Size);
+  ASSERT (Dest != NULL);
+  if (Dest) {
+    CopyMem (Dest, Src, Size);
+  }
+
+  return Dest;
+}
+
+EFI_FILE_INFO *
+EfiLibFileInfo (
+  IN EFI_FILE_HANDLE      FHand
+  )
+/*++
+
+Routine Description:
+
+  Function gets the file information from an open file descriptor, and stores it 
+  in a buffer allocated from pool.
+
+Arguments:
+
+  Fhand         - A file handle
+
+Returns:
+  
+  A pointer to a buffer with file information or NULL is returned
+
+--*/
+{
+  EFI_STATUS    Status;
+  EFI_FILE_INFO *Buffer;
+  UINTN         BufferSize;
+
+  //
+  // Initialize for GrowBuffer loop
+  //
+  Buffer      = NULL;
+  BufferSize  = SIZE_OF_EFI_FILE_INFO + 200;
+
+  //
+  // Call the real function
+  //
+  while (EfiGrowBuffer (&Status, (VOID **) &Buffer, BufferSize)) {
+    Status = FHand->GetInfo (
+                      FHand,
+                      &gEfiFileInfoGuid,
+                      &BufferSize,
+                      Buffer
+                      );
+  }
+
+  return Buffer;
+}
+
+UINTN
+EfiDevicePathInstanceCount (
+  IN EFI_DEVICE_PATH_PROTOCOL      *DevicePath
+  )
+/*++
+
+Routine Description:
+  Function is used to determine the number of device path instances 
+  that exist in a device path.
+
+Arguments:
+  DevicePath           - A pointer to a device path data structure.
+
+Returns:
+
+  This function counts and returns the number of device path instances 
+  in DevicePath.
+
+--*/
+{
+  UINTN Count;
+  UINTN Size;
+
+  Count = 0;
+  while (GetNextDevicePathInstance (&DevicePath, &Size)) {
+    Count += 1;
+  }
+
+  return Count;
+}
+
+VOID *
+EfiReallocatePool (
+  IN VOID                 *OldPool,
+  IN UINTN                OldSize,
+  IN UINTN                NewSize
+  )
+/*++
+
+Routine Description:
+  Adjusts the size of a previously allocated buffer.
+
+Arguments:
+  OldPool               - A pointer to the buffer whose size is being adjusted.
+  OldSize               - The size of the current buffer.
+  NewSize               - The size of the new buffer.
+
+Returns:
+
+  EFI_SUCEESS           - The requested number of bytes were allocated.
+
+  EFI_OUT_OF_RESOURCES  - The pool requested could not be allocated.
+
+  EFI_INVALID_PARAMETER - The buffer was invalid.
+
+--*/
+{
+  VOID  *NewPool;
+
+  NewPool = NULL;
+  if (NewSize) {
+    NewPool = AllocateZeroPool (NewSize);
+  }
+
+  if (OldPool) {
+    if (NewPool) {
+      CopyMem (NewPool, OldPool, OldSize < NewSize ? OldSize : NewSize);
+    }
+
+    SafeFreePool (OldPool);
+  }
+
+  return NewPool;
+}
+
+EFI_STATUS
+EfiLibGetStringFromToken (
+  IN      EFI_GUID                  *ProducerGuid,
+  IN      STRING_REF                Token,
+  OUT     CHAR16                    **String
+  )
+/*++
+
+Routine Description:
+  
+  Acquire the string associated with the ProducerGuid and return it.
+
+Arguments:
+  
+  ProducerGuid - The Guid to search the HII database for
+  Token        - The token value of the string to extract
+  String       - The string that is extracted
+  
+Returns:
+
+  EFI_SUCCESS           -  Buffer filled with the requested forms. BufferLength
+                           was updated.
+  EFI_BUFFER_TOO_SMALL  -  The buffer provided was not large enough to allow the form to be stored.
+
+--*/
+{
+  EFI_STATUS        Status;
+  UINT16            HandleBufferLength;
+  EFI_HII_HANDLE    *HiiHandleBuffer;
+  UINTN             StringBufferLength;
+  UINTN             NumberOfHiiHandles;
+  UINTN             Index;
+  UINT16            Length;
+  EFI_GUID          HiiGuid;
+  EFI_HII_PROTOCOL  *Hii;
+
+  //
+  // Initialize params.
+  //
+  HandleBufferLength  = 0;
+  HiiHandleBuffer     = NULL;
+  
+  Status = gBS->LocateProtocol (
+                  &gEfiHiiProtocolGuid,
+                  NULL,
+                  (VOID**) &Hii
+                  );
+  if (EFI_ERROR (Status)) {
+    *String = NULL;
+    return Status;
+  }
+  //
+  // Get all the Hii handles
+  //
+  Status = BdsLibGetHiiHandles (Hii, &HandleBufferLength, &HiiHandleBuffer);
+  ASSERT_EFI_ERROR (Status);
+  
+  //
+  // Get the Hii Handle that matches the StructureNode->ProducerName
+  //
+  NumberOfHiiHandles = HandleBufferLength / sizeof (EFI_HII_HANDLE);
+  for (Index = 0; Index < NumberOfHiiHandles; Index++) {
+    Length = 0;
+    Status = ExtractDataFromHiiHandle (
+              HiiHandleBuffer[Index],
+              &Length,
+              NULL,
+              &HiiGuid
+              );
+    if (CompareGuid (ProducerGuid, &HiiGuid)) {
+      break;
+    }
+  }
+  //
+  // Find the string based on the current language
+  //
+  StringBufferLength  = 0x100;
+  *String             = AllocateZeroPool (0x100);
+  ASSERT (*String != NULL);
+
+  Status = Hii->GetString (
+                  Hii,
+                  HiiHandleBuffer[Index],
+                  Token,
+                  FALSE,
+                  NULL,
+                  &StringBufferLength,
+                  *String
+                  );
+
+  gBS->FreePool (HiiHandleBuffer);
+
+  return Status;
+}
+
+BOOLEAN
+TimeCompare (
+  IN EFI_TIME               *FirstTime,
+  IN EFI_TIME               *SecondTime
+  )
+/*++
+
+Routine Description:
+  Compare two EFI_TIME data.
+
+Arguments:
+
+  FirstTime         - A pointer to the first EFI_TIME data.
+  SecondTime        - A pointer to the second EFI_TIME data.
+
+Returns:
+  TRUE              The FirstTime is not later than the SecondTime.
+  FALSE             The FirstTime is later than the SecondTime.
+  
+--*/
+{
+  if (FirstTime->Year != SecondTime->Year) {
+    return (BOOLEAN) (FirstTime->Year < SecondTime->Year);
+  } else if (FirstTime->Month != SecondTime->Month) {
+    return (BOOLEAN) (FirstTime->Month < SecondTime->Month);
+  } else if (FirstTime->Day != SecondTime->Day) {
+    return (BOOLEAN) (FirstTime->Day < SecondTime->Day);
+  } else if (FirstTime->Hour != SecondTime->Hour) {
+    return (BOOLEAN) (FirstTime->Hour < SecondTime->Hour);
+  } else if (FirstTime->Minute != SecondTime->Minute) {
+    return (BOOLEAN) (FirstTime->Minute < FirstTime->Minute);
+  } else if (FirstTime->Second != SecondTime->Second) {
+    return (BOOLEAN) (FirstTime->Second < SecondTime->Second);
+  }
+
+  return (BOOLEAN) (FirstTime->Nanosecond <= SecondTime->Nanosecond);
+}
+
+UINT16 *
+EfiLibStrFromDatahub (
+  IN EFI_DEVICE_PATH_PROTOCOL                 *DevPath
+  )
+{
+  EFI_STATUS                                  Status;
+  UINT16                                      *Desc;
+  EFI_DATA_HUB_PROTOCOL                       *Datahub;
+  UINT64                                      Count;
+  EFI_DATA_RECORD_HEADER                      *Record;
+  EFI_SUBCLASS_TYPE1_HEADER                   *DataHdr;
+  EFI_GUID                                    MiscGuid = EFI_MISC_SUBCLASS_GUID;
+  EFI_MISC_ONBOARD_DEVICE_DATA                *ob;
+  EFI_MISC_PORT_INTERNAL_CONNECTOR_DESIGNATOR_DATA *Port;
+  EFI_TIME                                    CurTime;
+
+  Status = gBS->LocateProtocol (
+                  &gEfiDataHubProtocolGuid,
+                  NULL,
+                  (VOID**) &Datahub
+                  );
+  if (EFI_ERROR (Status)) {
+    return NULL;
+  }
+
+  Status = gRT->GetTime (&CurTime, NULL);
+  if (EFI_ERROR (Status)) {
+    return NULL;
+  }
+
+  Count = 0;
+  do {
+    Status = Datahub->GetNextRecord (Datahub, &Count, NULL, &Record);
+
+    if (EFI_ERROR (Status)) {
+      break;
+    }
+
+    if (Record->DataRecordClass == EFI_DATA_RECORD_CLASS_DATA && CompareGuid (&Record->DataRecordGuid, &MiscGuid)) {
+      //
+      // This record is what we need
+      //
+      DataHdr = (EFI_SUBCLASS_TYPE1_HEADER *) (Record + 1);
+      if (EFI_MISC_ONBOARD_DEVICE_RECORD_NUMBER == DataHdr->RecordType) {
+        ob = (EFI_MISC_ONBOARD_DEVICE_DATA *) (DataHdr + 1);
+        if (BdsLibMatchDevicePaths ((EFI_DEVICE_PATH_PROTOCOL *) &ob->OnBoardDevicePath, DevPath)) {
+          EfiLibGetStringFromToken (&Record->ProducerName, ob->OnBoardDeviceDescription, &Desc);
+          return Desc;
+        }
+      }
+
+      if (EFI_MISC_PORT_INTERNAL_CONNECTOR_DESIGNATOR_RECORD_NUMBER == DataHdr->RecordType) {
+        Port = (EFI_MISC_PORT_INTERNAL_CONNECTOR_DESIGNATOR_DATA *) (DataHdr + 1);
+        if (BdsLibMatchDevicePaths ((EFI_DEVICE_PATH_PROTOCOL *) &Port->PortPath, DevPath)) {
+          EfiLibGetStringFromToken (&Record->ProducerName, Port->PortExternalConnectorDesignator, &Desc);
+          return Desc;
+        }
+      }
+    }
+
+  } while (TimeCompare (&Record->LogTime, &CurTime) && Count != 0);
+
+  return NULL;
+}

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/ConsoleOption.c

@@ -0,0 +1,840 @@
+/*++
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+    ConsoleOption.c
+    
+Abstract:
+
+    handles console redirection from boot manager
+
+
+Revision History
+
+--*/
+
+#include "BootMaint.h"
+
+EFI_DEVICE_PATH_PROTOCOL  *
+DevicePathInstanceDup (
+  IN EFI_DEVICE_PATH_PROTOCOL  *DevPath
+  );
+
+EFI_STATUS
+UpdateComAttributeFromVariable (
+  EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  );
+
+EFI_STATUS
+ChangeTerminalDevicePath (
+  EFI_DEVICE_PATH_PROTOCOL  *DevicePath,
+  BOOLEAN                   ChangeTerminal
+  )
+{
+  EFI_DEVICE_PATH_PROTOCOL  *Node;
+  EFI_DEVICE_PATH_PROTOCOL  *Node1;
+  ACPI_HID_DEVICE_PATH      *Acpi;
+  UART_DEVICE_PATH          *Uart;
+  UART_DEVICE_PATH          *Uart1;
+  UINTN                     Com;
+  UINT32                    Match;
+  BM_TERMINAL_CONTEXT       *NewTerminalContext;
+  BM_MENU_ENTRY             *NewMenuEntry;
+
+  Match = EISA_PNP_ID (0x0501);
+  Node  = DevicePath;
+  Node  = NextDevicePathNode (Node);
+  Com   = 0;
+  while (!IsDevicePathEnd (Node)) {
+    if ((DevicePathType (Node) == ACPI_DEVICE_PATH) && (DevicePathSubType (Node) == ACPI_DP)) {
+      Acpi = (ACPI_HID_DEVICE_PATH *) Node;
+      if (CompareMem (&Acpi->HID, &Match, sizeof (UINT32)) == 0) {
+        CopyMem (&Com, &Acpi->UID, sizeof (UINT32));
+      }
+    }
+
+    NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Com);
+    if (NULL == NewMenuEntry) {
+      return EFI_NOT_FOUND;
+    }
+
+    NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
+    if ((DevicePathType (Node) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (Node) == MSG_UART_DP)) {
+      Uart = (UART_DEVICE_PATH *) Node;
+      CopyMem (
+        &Uart->BaudRate,
+        &NewTerminalContext->BaudRate,
+        sizeof (UINT64)
+        );
+
+      CopyMem (
+        &Uart->DataBits,
+        &NewTerminalContext->DataBits,
+        sizeof (UINT8)
+        );
+
+      CopyMem (
+        &Uart->Parity,
+        &NewTerminalContext->Parity,
+        sizeof (UINT8)
+        );
+
+      CopyMem (
+        &Uart->StopBits,
+        &NewTerminalContext->StopBits,
+        sizeof (UINT8)
+        );
+      //
+      // Change the device path in the ComPort
+      //
+      if (ChangeTerminal) {
+        Node1 = NewTerminalContext->DevicePath;
+        Node1 = NextDevicePathNode (Node1);
+        while (!IsDevicePathEnd (Node1)) {
+          if ((DevicePathType (Node1) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (Node1) == MSG_UART_DP)) {
+            Uart1 = (UART_DEVICE_PATH *) Node1;
+            CopyMem (
+              &Uart1->BaudRate,
+              &NewTerminalContext->BaudRate,
+              sizeof (UINT64)
+              );
+
+            CopyMem (
+              &Uart1->DataBits,
+              &NewTerminalContext->DataBits,
+              sizeof (UINT8)
+              );
+
+            CopyMem (
+              &Uart1->Parity,
+              &NewTerminalContext->Parity,
+              sizeof (UINT8)
+              );
+
+            CopyMem (
+              &Uart1->StopBits,
+              &NewTerminalContext->StopBits,
+              sizeof (UINT8)
+              );
+            break;
+          }
+          //
+          // end if
+          //
+          Node1 = NextDevicePathNode (Node1);
+        }
+        //
+        // end while
+        //
+        break;
+      }
+    }
+
+    Node = NextDevicePathNode (Node);
+  }
+
+  return EFI_SUCCESS;
+
+}
+
+VOID
+ChangeVariableDevicePath (
+  EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  )
+{
+  EFI_DEVICE_PATH_PROTOCOL  *Node;
+  ACPI_HID_DEVICE_PATH      *Acpi;
+  UART_DEVICE_PATH          *Uart;
+  UINTN                     Com;
+  UINT32                    Match;
+  BM_TERMINAL_CONTEXT       *NewTerminalContext;
+  BM_MENU_ENTRY             *NewMenuEntry;
+
+  Match = EISA_PNP_ID (0x0501);
+  Node  = DevicePath;
+  Node  = NextDevicePathNode (Node);
+  Com   = 0;
+  while (!IsDevicePathEnd (Node)) {
+    if ((DevicePathType (Node) == ACPI_DEVICE_PATH) && (DevicePathSubType (Node) == ACPI_DP)) {
+      Acpi = (ACPI_HID_DEVICE_PATH *) Node;
+      if (CompareMem (&Acpi->HID, &Match, sizeof (UINT32)) == 0) {
+        CopyMem (&Com, &Acpi->UID, sizeof (UINT32));
+      }
+    }
+
+    if ((DevicePathType (Node) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (Node) == MSG_UART_DP)) {
+      NewMenuEntry = BOpt_GetMenuEntry (
+                      &TerminalMenu,
+                      Com
+                      );
+      NewTerminalContext  = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
+      Uart                = (UART_DEVICE_PATH *) Node;
+      CopyMem (
+        &Uart->BaudRate,
+        &NewTerminalContext->BaudRate,
+        sizeof (UINT64)
+        );
+
+      CopyMem (
+        &Uart->DataBits,
+        &NewTerminalContext->DataBits,
+        sizeof (UINT8)
+        );
+
+      CopyMem (
+        &Uart->Parity,
+        &NewTerminalContext->Parity,
+        sizeof (UINT8)
+        );
+
+      CopyMem (
+        &Uart->StopBits,
+        &NewTerminalContext->StopBits,
+        sizeof (UINT8)
+        );
+    }
+
+    Node = NextDevicePathNode (Node);
+  }
+
+  return ;
+}
+
+BOOLEAN
+IsTerminalDevicePath (
+  IN  EFI_DEVICE_PATH_PROTOCOL *DevicePath,
+  OUT TYPE_OF_TERMINAL         *Termi,
+  OUT UINTN                    *Com
+  );
+
+EFI_STATUS
+LocateSerialIo (
+  VOID
+  )
+/*++
+
+Routine Description:
+  Build a list containing all serial devices 
+  
+Arguments:
+  
+Returns:
+  
+--*/
+{
+  UINT8                     *Ptr;
+  UINTN                     Index;
+  UINTN                     Index2;
+  UINTN                     NoHandles;
+  EFI_HANDLE                *Handles;
+  EFI_STATUS                Status;
+  ACPI_HID_DEVICE_PATH      *Acpi;
+  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
+  UINT32                    Match;
+  EFI_SERIAL_IO_PROTOCOL    *SerialIo;
+  EFI_DEVICE_PATH_PROTOCOL  *OutDevicePath;
+  EFI_DEVICE_PATH_PROTOCOL  *InpDevicePath;
+  EFI_DEVICE_PATH_PROTOCOL  *ErrDevicePath;
+  BM_MENU_ENTRY             *NewMenuEntry;
+  BM_TERMINAL_CONTEXT       *NewTerminalContext;
+  EFI_DEVICE_PATH_PROTOCOL  *NewDevicePath;
+  VENDOR_DEVICE_PATH        Vendor;
+  //
+  // Get all handles that have SerialIo protocol installed
+  //
+  InitializeListHead (&TerminalMenu.Head);
+  TerminalMenu.MenuNumber = 0;
+  Status = gBS->LocateHandleBuffer (
+                  ByProtocol,
+                  &gEfiSerialIoProtocolGuid,
+                  NULL,
+                  &NoHandles,
+                  &Handles
+                  );
+  if (EFI_ERROR (Status)) {
+    //
+    // No serial ports present
+    //
+    return EFI_UNSUPPORTED;
+  }
+
+  for (Index = 0; Index < NoHandles; Index++) {
+    //
+    // Check to see whether the handle has DevicePath Protocol installed
+    //
+    gBS->HandleProtocol (
+          Handles[Index],
+          &gEfiDevicePathProtocolGuid,
+          (VOID**) &DevicePath
+          );
+    Ptr = (UINT8 *) DevicePath;
+    while (*Ptr != END_DEVICE_PATH_TYPE) {
+      Ptr++;
+    }
+
+    Ptr   = Ptr - sizeof (UART_DEVICE_PATH) - sizeof (ACPI_HID_DEVICE_PATH);
+    Acpi  = (ACPI_HID_DEVICE_PATH *) Ptr;
+    Match = EISA_PNP_ID (0x0501);
+
+    if (CompareMem (&Acpi->HID, &Match, sizeof (UINT32)) == 0) {
+      NewMenuEntry = BOpt_CreateMenuEntry (BM_TERMINAL_CONTEXT_SELECT);
+      if (!NewMenuEntry) {
+        return EFI_OUT_OF_RESOURCES;
+      }
+
+      NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
+      CopyMem (&NewMenuEntry->OptionNumber, &Acpi->UID, sizeof (UINT32));
+      NewTerminalContext->DevicePath = DevicePathInstanceDup (DevicePath);
+      //
+      // BugBug: I have no choice, calling EfiLibStrFromDatahub will hang the system!
+      // coz' the misc data for each platform is not correct, actually it's the device path stored in
+      // datahub which is not completed, so a searching for end of device path will enter a
+      // dead-loop.
+      //
+      NewMenuEntry->DisplayString = EfiLibStrFromDatahub (DevicePath);
+      if (NULL == NewMenuEntry->DisplayString) {
+        NewMenuEntry->DisplayString = DevicePathToStr (DevicePath);
+      }
+
+      NewMenuEntry->HelpString = NULL;
+
+      gBS->HandleProtocol (
+            Handles[Index],
+            &gEfiSerialIoProtocolGuid,
+            (VOID**) &SerialIo
+            );
+
+      CopyMem (
+        &NewTerminalContext->BaudRate,
+        &SerialIo->Mode->BaudRate,
+        sizeof (UINT64)
+        );
+
+      CopyMem (
+        &NewTerminalContext->DataBits,
+        &SerialIo->Mode->DataBits,
+        sizeof (UINT8)
+        );
+
+      CopyMem (
+        &NewTerminalContext->Parity,
+        &SerialIo->Mode->Parity,
+        sizeof (UINT8)
+        );
+
+      CopyMem (
+        &NewTerminalContext->StopBits,
+        &SerialIo->Mode->StopBits,
+        sizeof (UINT8)
+        );
+      InsertTailList (&TerminalMenu.Head, &NewMenuEntry->Link);
+      TerminalMenu.MenuNumber++;
+    }
+  }
+  //
+  // Get L"ConOut", L"ConIn" and L"ErrOut" from the Var
+  //
+  OutDevicePath = EfiLibGetVariable (L"ConOut", &gEfiGlobalVariableGuid);
+  InpDevicePath = EfiLibGetVariable (L"ConIn", &gEfiGlobalVariableGuid);
+  ErrDevicePath = EfiLibGetVariable (L"ErrOut", &gEfiGlobalVariableGuid);
+  if (OutDevicePath) {
+    UpdateComAttributeFromVariable (OutDevicePath);
+  }
+
+  if (InpDevicePath) {
+    UpdateComAttributeFromVariable (InpDevicePath);
+  }
+
+  if (ErrDevicePath) {
+    UpdateComAttributeFromVariable (ErrDevicePath);
+  }
+
+  for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
+    NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
+    if (NULL == NewMenuEntry) {
+      return EFI_NOT_FOUND;
+    }
+
+    NewTerminalContext                = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
+
+    NewTerminalContext->TerminalType  = 0;
+    NewTerminalContext->IsConIn       = FALSE;
+    NewTerminalContext->IsConOut      = FALSE;
+    NewTerminalContext->IsStdErr      = FALSE;
+
+    Vendor.Header.Type                = MESSAGING_DEVICE_PATH;
+    Vendor.Header.SubType             = MSG_VENDOR_DP;
+
+    for (Index2 = 0; Index2 < 4; Index2++) {
+      CopyMem (&Vendor.Guid, &Guid[Index2], sizeof (EFI_GUID));
+      SetDevicePathNodeLength (&Vendor.Header, sizeof (VENDOR_DEVICE_PATH));
+      NewDevicePath = AppendDevicePathNode (
+                        NewTerminalContext->DevicePath,
+                        (EFI_DEVICE_PATH_PROTOCOL *) &Vendor
+                        );
+      SafeFreePool (NewMenuEntry->HelpString);
+      //
+      // NewMenuEntry->HelpString = DevicePathToStr (NewDevicePath);
+      // NewMenuEntry->DisplayString = NewMenuEntry->HelpString;
+      //
+      NewMenuEntry->HelpString = NULL;
+
+      if (BdsLibMatchDevicePaths (OutDevicePath, NewDevicePath)) {
+        NewTerminalContext->IsConOut      = TRUE;
+        NewTerminalContext->TerminalType  = (UINT8) Index2;
+      }
+
+      if (BdsLibMatchDevicePaths (InpDevicePath, NewDevicePath)) {
+        NewTerminalContext->IsConIn       = TRUE;
+        NewTerminalContext->TerminalType  = (UINT8) Index2;
+      }
+
+      if (BdsLibMatchDevicePaths (ErrDevicePath, NewDevicePath)) {
+        NewTerminalContext->IsStdErr      = TRUE;
+        NewTerminalContext->TerminalType  = (UINT8) Index2;
+      }
+    }
+  }
+
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+UpdateComAttributeFromVariable (
+  EFI_DEVICE_PATH_PROTOCOL  *DevicePath
+  )
+/*++
+
+Routine Description:
+  Update Com Ports attributes from DevicePath
+  
+Arguments:
+  DevicePath  -   DevicePath that contains Com ports
+  
+Returns:
+  
+--*/
+{
+  EFI_DEVICE_PATH_PROTOCOL  *Node;
+  EFI_DEVICE_PATH_PROTOCOL  *SerialNode;
+  ACPI_HID_DEVICE_PATH      *Acpi;
+  UART_DEVICE_PATH          *Uart;
+  UART_DEVICE_PATH          *Uart1;
+  UINT32                    Match;
+  UINTN                     TerminalNumber;
+  BM_MENU_ENTRY             *NewMenuEntry;
+  BM_TERMINAL_CONTEXT       *NewTerminalContext;
+  UINTN                     Index;
+
+  Match           = EISA_PNP_ID (0x0501);
+  Node            = DevicePath;
+  Node            = NextDevicePathNode (Node);
+  TerminalNumber  = 0;
+  for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
+    while (!IsDevicePathEnd (Node)) {
+      if ((DevicePathType (Node) == ACPI_DEVICE_PATH) && (DevicePathSubType (Node) == ACPI_DP)) {
+        Acpi = (ACPI_HID_DEVICE_PATH *) Node;
+        if (CompareMem (&Acpi->HID, &Match, sizeof (UINT32)) == 0) {
+          CopyMem (&TerminalNumber, &Acpi->UID, sizeof (UINT32));
+        }
+      }
+
+      if ((DevicePathType (Node) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (Node) == MSG_UART_DP)) {
+        Uart          = (UART_DEVICE_PATH *) Node;
+        NewMenuEntry  = BOpt_GetMenuEntry (&TerminalMenu, TerminalNumber);
+        if (NULL == NewMenuEntry) {
+          return EFI_NOT_FOUND;
+        }
+
+        NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
+        CopyMem (
+          &NewTerminalContext->BaudRate,
+          &Uart->BaudRate,
+          sizeof (UINT64)
+          );
+
+        CopyMem (
+          &NewTerminalContext->DataBits,
+          &Uart->DataBits,
+          sizeof (UINT8)
+          );
+
+        CopyMem (
+          &NewTerminalContext->Parity,
+          &Uart->Parity,
+          sizeof (UINT8)
+          );
+
+        CopyMem (
+          &NewTerminalContext->StopBits,
+          &Uart->StopBits,
+          sizeof (UINT8)
+          );
+
+        SerialNode  = NewTerminalContext->DevicePath;
+        SerialNode  = NextDevicePathNode (SerialNode);
+        while (!IsDevicePathEnd (SerialNode)) {
+          if ((DevicePathType (SerialNode) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (SerialNode) == MSG_UART_DP)) {
+            //
+            // Update following device paths according to
+            // previous acquired uart attributes
+            //
+            Uart1 = (UART_DEVICE_PATH *) SerialNode;
+            CopyMem (
+              &Uart1->BaudRate,
+              &NewTerminalContext->BaudRate,
+              sizeof (UINT64)
+              );
+
+            CopyMem (
+              &Uart1->DataBits,
+              &NewTerminalContext->DataBits,
+              sizeof (UINT8)
+              );
+            CopyMem (
+              &Uart1->Parity,
+              &NewTerminalContext->Parity,
+              sizeof (UINT8)
+              );
+            CopyMem (
+              &Uart1->StopBits,
+              &NewTerminalContext->StopBits,
+              sizeof (UINT8)
+              );
+
+            break;
+          }
+
+          SerialNode = NextDevicePathNode (SerialNode);
+        }
+        //
+        // end while
+        //
+      }
+
+      Node = NextDevicePathNode (Node);
+    }
+    //
+    // end while
+    //
+  }
+
+  return EFI_SUCCESS;
+}
+
+EFI_DEVICE_PATH_PROTOCOL *
+DevicePathInstanceDup (
+  IN EFI_DEVICE_PATH_PROTOCOL  *DevPath
+  )
+/*++
+
+Routine Description:
+  Function creates a device path data structure that identically matches the 
+  device path passed in.
+
+Arguments:
+  DevPath      - A pointer to a device path data structure.
+
+Returns:
+
+  The new copy of DevPath is created to identically match the input.  
+  Otherwise, NULL is returned.
+
+--*/
+{
+  EFI_DEVICE_PATH_PROTOCOL  *NewDevPath;
+  EFI_DEVICE_PATH_PROTOCOL  *DevicePathInst;
+  EFI_DEVICE_PATH_PROTOCOL  *Temp;
+  UINT8                     *Ptr;
+  UINTN                     Size;
+
+  //
+  // get the size of an instance from the input
+  //
+  Temp            = DevPath;
+  DevicePathInst  = GetNextDevicePathInstance (&Temp, &Size);
+
+  //
+  // Make a copy and set proper end type
+  //
+  NewDevPath = NULL;
+  if (Size) {
+    NewDevPath = AllocateZeroPool (Size);
+    ASSERT (NewDevPath != NULL);
+  }
+
+  if (NewDevPath) {
+    CopyMem (NewDevPath, DevicePathInst, Size);
+    Ptr = (UINT8 *) NewDevPath;
+    Ptr += Size - sizeof (EFI_DEVICE_PATH_PROTOCOL);
+    Temp = (EFI_DEVICE_PATH_PROTOCOL *) Ptr;
+    SetDevicePathEndNode (Temp);
+  }
+
+  return NewDevPath;
+}
+
+EFI_STATUS
+GetConsoleMenu (
+  IN UINTN              ConsoleMenuType
+  )
+{
+  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
+  EFI_DEVICE_PATH_PROTOCOL  *AllDevicePath;
+  EFI_DEVICE_PATH_PROTOCOL  *MultiDevicePath;
+  EFI_DEVICE_PATH_PROTOCOL  *DevicePathInst;
+  UINTN                     Size;
+  UINTN                     AllCount;
+  UINTN                     Index;
+  UINTN                     Index2;
+  BM_MENU_ENTRY             *NewMenuEntry;
+  BM_CONSOLE_CONTEXT        *NewConsoleContext;
+  BM_TERMINAL_CONTEXT       *NewTerminalContext;
+  TYPE_OF_TERMINAL          Terminal;
+  BM_MENU_ENTRY             *NewTerminalMenuEntry;
+  UINTN                     Com;
+  BM_MENU_OPTION            *ConsoleMenu;
+
+  DevicePath    = NULL;
+  AllDevicePath = NULL;
+  AllCount      = 0;
+  switch (ConsoleMenuType) {
+  case BM_CONSOLE_IN_CONTEXT_SELECT:
+    ConsoleMenu = &ConsoleInpMenu;
+    DevicePath = EfiLibGetVariable (
+                  L"ConIn",
+                  &gEfiGlobalVariableGuid
+                  );
+
+    AllDevicePath = EfiLibGetVariable (
+                      L"ConInDev",
+                      &gEfiGlobalVariableGuid
+                      );
+    break;
+
+  case BM_CONSOLE_OUT_CONTEXT_SELECT:
+    ConsoleMenu = &ConsoleOutMenu;
+    DevicePath = EfiLibGetVariable (
+                  L"ConOut",
+                  &gEfiGlobalVariableGuid
+                  );
+
+    AllDevicePath = EfiLibGetVariable (
+                      L"ConOutDev",
+                      &gEfiGlobalVariableGuid
+                      );
+    break;
+
+  case BM_CONSOLE_ERR_CONTEXT_SELECT:
+    ConsoleMenu = &ConsoleErrMenu;
+    DevicePath = EfiLibGetVariable (
+                  L"ErrOut",
+                  &gEfiGlobalVariableGuid
+                  );
+
+    AllDevicePath = EfiLibGetVariable (
+                      L"ErrOutDev",
+                      &gEfiGlobalVariableGuid
+                      );
+    break;
+
+  default:
+    return EFI_UNSUPPORTED;
+  }
+
+  if (NULL == AllDevicePath) {
+    return EFI_NOT_FOUND;
+  }
+
+  InitializeListHead (&ConsoleMenu->Head);
+
+  AllCount                = EfiDevicePathInstanceCount (AllDevicePath);
+  ConsoleMenu->MenuNumber = 0;
+  //
+  // Following is menu building up for Console Out Devices
+  //
+  MultiDevicePath = AllDevicePath;
+  Index2          = 0;
+  for (Index = 0; Index < AllCount; Index++) {
+    DevicePathInst  = GetNextDevicePathInstance (&MultiDevicePath, &Size);
+
+    NewMenuEntry    = BOpt_CreateMenuEntry (BM_CONSOLE_CONTEXT_SELECT);
+    if (NULL == NewMenuEntry) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+
+    NewConsoleContext             = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
+    NewMenuEntry->OptionNumber    = Index2;
+
+    NewConsoleContext->DevicePath = DevicePathInstanceDup (DevicePathInst);
+    NewMenuEntry->DisplayString   = EfiLibStrFromDatahub (NewConsoleContext->DevicePath);
+    if (NULL == NewMenuEntry->DisplayString) {
+      NewMenuEntry->DisplayString = DevicePathToStr (NewConsoleContext->DevicePath);
+    }
+
+    NewConsoleContext->IsTerminal = IsTerminalDevicePath (
+                                      NewConsoleContext->DevicePath,
+                                      &Terminal,
+                                      &Com
+                                      );
+
+    NewConsoleContext->IsActive = BdsLibMatchDevicePaths (
+                                    DevicePath,
+                                    NewConsoleContext->DevicePath
+                                    );
+    NewTerminalMenuEntry  = NULL;
+    NewTerminalContext    = NULL;
+
+    if (NewConsoleContext->IsTerminal) {
+      BOpt_DestroyMenuEntry (NewMenuEntry);
+    } else {
+      Index2++;
+      ConsoleMenu->MenuNumber++;
+      InsertTailList (&ConsoleMenu->Head, &NewMenuEntry->Link);
+    }
+  }
+
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+GetAllConsoles (
+  VOID
+  )
+/*++
+
+Routine Description:
+  Build up ConsoleOutMenu, ConsoleInpMenu and ConsoleErrMenu
+
+Arguments:
+  
+Returns:
+  EFI_SUCCESS 
+  Others
+  
+--*/
+{
+  GetConsoleMenu (BM_CONSOLE_IN_CONTEXT_SELECT);
+  GetConsoleMenu (BM_CONSOLE_OUT_CONTEXT_SELECT);
+  GetConsoleMenu (BM_CONSOLE_ERR_CONTEXT_SELECT);
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+FreeAllConsoles (
+  VOID
+  )
+/*++
+
+Routine Description:
+  Free ConsoleOutMenu, ConsoleInpMenu and ConsoleErrMenu
+
+Arguments:
+  
+Returns:
+  EFI_SUCCESS 
+  Others
+  
+--*/
+{
+  BOpt_FreeMenu (&ConsoleOutMenu);
+  BOpt_FreeMenu (&ConsoleInpMenu);
+  BOpt_FreeMenu (&ConsoleErrMenu);
+  BOpt_FreeMenu (&TerminalMenu);
+  return EFI_SUCCESS;
+}
+
+BOOLEAN
+IsTerminalDevicePath (
+  IN  EFI_DEVICE_PATH_PROTOCOL *DevicePath,
+  OUT TYPE_OF_TERMINAL         *Termi,
+  OUT UINTN                    *Com
+  )
+/*++
+
+Routine Description:
+  Test whether DevicePath is a valid Terminal
+
+Arguments:
+  DevicePath  -   DevicePath to be checked
+  Termi       -   If is terminal, give its type
+  Com         -   If is Com Port, give its type
+  
+Returns:
+  TRUE        -   If DevicePath point to a Terminal
+  FALSE
+  
+--*/
+{
+  UINT8                 *Ptr;
+  BOOLEAN               IsTerminal;
+  VENDOR_DEVICE_PATH    *Vendor;
+  ACPI_HID_DEVICE_PATH  *Acpi;
+  UINT32                Match;
+  EFI_GUID              TempGuid;
+
+  IsTerminal = FALSE;
+
+  //
+  // Parse the Device Path, should be change later!!!
+  //
+  Ptr = (UINT8 *) DevicePath;
+  while (*Ptr != END_DEVICE_PATH_TYPE) {
+    Ptr++;
+  }
+
+  Ptr     = Ptr - sizeof (VENDOR_DEVICE_PATH);
+  Vendor  = (VENDOR_DEVICE_PATH *) Ptr;
+
+  //
+  // There are four kinds of Terminal types
+  // check to see whether this devicepath
+  // is one of that type
+  //
+  CopyMem (&TempGuid, &Vendor->Guid, sizeof (EFI_GUID));
+
+  if (CompareGuid (&TempGuid, &Guid[0])) {
+    *Termi      = PC_ANSI;
+    IsTerminal  = TRUE;
+  } else {
+    if (CompareGuid (&TempGuid, &Guid[1])) {
+      *Termi      = VT_100;
+      IsTerminal  = TRUE;
+    } else {
+      if (CompareGuid (&TempGuid, &Guid[2])) {
+        *Termi      = VT_100_PLUS;
+        IsTerminal  = TRUE;
+      } else {
+        if (CompareGuid (&TempGuid, &Guid[3])) {
+          *Termi      = VT_UTF8;
+          IsTerminal  = TRUE;
+        } else {
+          IsTerminal = FALSE;
+        }
+      }
+    }
+  }
+
+  if (!IsTerminal) {
+    return FALSE;
+  }
+
+  Ptr   = Ptr - sizeof (UART_DEVICE_PATH) - sizeof (ACPI_HID_DEVICE_PATH);
+  Acpi  = (ACPI_HID_DEVICE_PATH *) Ptr;
+  Match = EISA_PNP_ID (0x0501);
+  if (CompareMem (&Acpi->HID, &Match, sizeof (UINT32)) == 0) {
+    CopyMem (Com, &Acpi->UID, sizeof (UINT32));
+  } else {
+    return FALSE;
+  }
+
+  return TRUE;
+}

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/Data.c

@@ -0,0 +1,324 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  Data.c
+    
+Abstract:
+
+  Define some data used for Boot Maint
+
+Revision History
+
+--*/
+
+#include "BootMaint.h"
+
+EFI_HII_UPDATE_DATA *UpdateData;
+STRING_DEPOSITORY   *FileOptionStrDepository;
+STRING_DEPOSITORY   *ConsoleOptionStrDepository;
+STRING_DEPOSITORY   *BootOptionStrDepository;
+STRING_DEPOSITORY   *BootOptionHelpStrDepository;
+STRING_DEPOSITORY   *DriverOptionStrDepository;
+STRING_DEPOSITORY   *DriverOptionHelpStrDepository;
+STRING_DEPOSITORY   *TerminalStrDepository;
+
+//
+// Terminal type string token storage
+//
+UINT16              TerminalType[] = {
+  STRING_TOKEN(STR_COM_TYPE_0),
+  STRING_TOKEN(STR_COM_TYPE_1),
+  STRING_TOKEN(STR_COM_TYPE_2),
+  STRING_TOKEN(STR_COM_TYPE_3),
+};
+
+//
+// File system selection menu
+//
+BM_MENU_OPTION      FsOptionMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Console Input Device Selection Menu
+//
+BM_MENU_OPTION      ConsoleInpMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Console Output Device Selection Menu
+//
+BM_MENU_OPTION      ConsoleOutMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Error Output Device Selection Menu
+//
+BM_MENU_OPTION      ConsoleErrMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Boot Option from variable Menu
+//
+BM_MENU_OPTION      BootOptionMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Driver Option from variable menu
+//
+BM_MENU_OPTION      DriverOptionMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Legacy FD Info from LegacyBios.GetBbsInfo()
+//
+BM_MENU_OPTION      LegacyFDMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Legacy HD Info from LegacyBios.GetBbsInfo()
+//
+BM_MENU_OPTION      LegacyHDMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Legacy CD Info from LegacyBios.GetBbsInfo()
+//
+BM_MENU_OPTION      LegacyCDMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Legacy NET Info from LegacyBios.GetBbsInfo()
+//
+BM_MENU_OPTION      LegacyNETMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Legacy NET Info from LegacyBios.GetBbsInfo()
+//
+BM_MENU_OPTION      LegacyBEVMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Files and sub-directories in current directory menu
+//
+BM_MENU_OPTION      DirectoryMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Handles in current system selection menu
+//
+BM_MENU_OPTION      DriverMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+BM_MENU_OPTION      TerminalMenu = {
+  BM_MENU_OPTION_SIGNATURE,
+  { NULL, NULL},
+  0
+};
+
+//
+// Value and string token correspondency for BaudRate
+//
+COM_ATTR            BaudRateList[19] = {
+  {
+    115200,
+    STRING_TOKEN(STR_COM_BAUD_RATE_0)
+  },
+  {
+    57600,
+    STRING_TOKEN(STR_COM_BAUD_RATE_1)
+  },
+  {
+    38400,
+    STRING_TOKEN(STR_COM_BAUD_RATE_2)
+  },
+  {
+    19200,
+    STRING_TOKEN(STR_COM_BAUD_RATE_3)
+  },
+  {
+    9600,
+    STRING_TOKEN(STR_COM_BAUD_RATE_4)
+  },
+  {
+    7200,
+    STRING_TOKEN(STR_COM_BAUD_RATE_5)
+  },
+  {
+    4800,
+    STRING_TOKEN(STR_COM_BAUD_RATE_6)
+  },
+  {
+    3600,
+    STRING_TOKEN(STR_COM_BAUD_RATE_7)
+  },
+  {
+    2400,
+    STRING_TOKEN(STR_COM_BAUD_RATE_8)
+  },
+  {
+    2000,
+    STRING_TOKEN(STR_COM_BAUD_RATE_9)
+  },
+  {
+    1800,
+    STRING_TOKEN(STR_COM_BAUD_RATE_10)
+  },
+  {
+    1200,
+    STRING_TOKEN(STR_COM_BAUD_RATE_11)
+  },
+  {
+    600,
+    STRING_TOKEN(STR_COM_BAUD_RATE_12)
+  },
+  {
+    300,
+    STRING_TOKEN(STR_COM_BAUD_RATE_13)
+  },
+  {
+    150,
+    STRING_TOKEN(STR_COM_BAUD_RATE_14)
+  },
+  {
+    134,
+    STRING_TOKEN(STR_COM_BAUD_RATE_15)
+  },
+  {
+    110,
+    STRING_TOKEN(STR_COM_BAUD_RATE_16)
+  },
+  {
+    75,
+    STRING_TOKEN(STR_COM_BAUD_RATE_17)
+  },
+  {
+    50,
+    STRING_TOKEN(STR_COM_BAUD_RATE_18)
+  }
+};
+
+//
+// Value and string token correspondency for DataBits
+//
+COM_ATTR            DataBitsList[4] = {
+  {
+    5,
+    STRING_TOKEN(STR_COM_DATA_BITS_0)
+  },
+  {
+    6,
+    STRING_TOKEN(STR_COM_DATA_BITS_1)
+  },
+  {
+    7,
+    STRING_TOKEN(STR_COM_DATA_BITS_2)
+  },
+  {
+    8,
+    STRING_TOKEN(STR_COM_DATA_BITS_3)
+  }
+};
+
+//
+// Value and string token correspondency for Parity
+//
+COM_ATTR            ParityList[5] = {
+  {
+    NoParity,
+    STRING_TOKEN(STR_COM_PAR_0)
+  },
+  {
+    EvenParity,
+    STRING_TOKEN(STR_COM_PAR_1)
+  },
+  {
+    OddParity,
+    STRING_TOKEN(STR_COM_PAR_2)
+  },
+  {
+    MarkParity,
+    STRING_TOKEN(STR_COM_PAR_3)
+  },
+  {
+    SpaceParity,
+    STRING_TOKEN(STR_COM_PAR_4)
+  }
+};
+
+//
+// Value and string token correspondency for Baudreate
+//
+COM_ATTR            StopBitsList[3] = {
+  {
+    OneStopBit,
+    STRING_TOKEN(STR_COM_STOP_BITS_0)
+  },
+  {
+    OneFiveStopBits,
+    STRING_TOKEN(STR_COM_STOP_BITS_1)
+  },
+  {
+    TwoStopBits,
+    STRING_TOKEN(STR_COM_STOP_BITS_2)
+  }
+};
+
+//
+// Guid for messaging path, used in Serial port setting.
+//
+EFI_GUID            Guid[4] = {
+  DEVICE_PATH_MESSAGING_PC_ANSI,
+  DEVICE_PATH_MESSAGING_VT_100,
+  DEVICE_PATH_MESSAGING_VT_100_PLUS,
+  DEVICE_PATH_MESSAGING_VT_UTF8
+};

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/FE.vfr

@@ -0,0 +1,138 @@
+// *++
+//
+// Copyright (c) 2006, Intel Corporation                                                         
+// All rights reserved. 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.             
+// 
+// Module Name:
+//
+//   FE.vfr 
+// 
+// Abstract:
+// 
+//   File Explorer Formset
+// 
+// Revision History: 
+// 
+// --*/
+
+#include "EdkGenericPlatformBdsLibStrDefs.h" 
+#include "FormGuid.h"
+
+#pragma pack(1)
+typedef struct {
+  UINT16                    DescriptionData[75];
+  UINT16                    OptionalData[127];
+  UINT8                     Active;
+  UINT8                     ForceReconnect;  
+} FILE_EXPLORER_NV_DATA;
+#pragma pack()
+
+#define FORM_FILE_EXPLORER_ID                 0x001E
+#define FORM_BOOT_ADD_DESCRIPTION_ID          0x001F
+#define FORM_DRIVER_ADD_FILE_DESCRIPTION_ID   0x0020
+#define KEY_VALUE_SAVE_AND_EXIT               0x0090
+#define KEY_VALUE_NO_SAVE_AND_EXIT            0x0091
+
+
+
+formset 
+  guid = FILE_EXPLORE_FORMSET_GUID,
+  title = STRING_TOKEN(STR_FILE_EXPLORER_TITLE),
+  help = STRING_TOKEN(STR_NULL_STRING),
+  class = 0,
+  subclass = 0,
+
+  form formid = FORM_FILE_EXPLORER_ID,
+       title = STRING_TOKEN(STR_FILE_EXPLORER_TITLE);
+
+       label FORM_FILE_EXPLORER_ID;
+  endform;
+  
+  form formid = FORM_BOOT_ADD_DESCRIPTION_ID,
+       title = STRING_TOKEN(STR_FORM_BOOT_ADD_DESC_TITLE);
+       
+       label FORM_BOOT_ADD_DESCRIPTION_ID;
+
+       subtitle  text = STRING_TOKEN(STR_NULL_STRING);
+       
+       string    varid    = FILE_EXPLORER_NV_DATA.DescriptionData,
+                 prompt   = STRING_TOKEN(STR_LOAD_OPTION_DESC),
+                 help     = STRING_TOKEN(STR_NULL_STRING),
+                 minsize  = 6,
+                 maxsize  = 75,
+       endstring;
+
+       string    varid    = FILE_EXPLORER_NV_DATA.OptionalData,
+       		prompt   = STRING_TOKEN(STR_OPTIONAL_DATA),
+       		help     = STRING_TOKEN(STR_NULL_STRING),
+       		minsize  = 0,
+       		maxsize  = 120,
+       endstring;
+
+       text 
+         help   = STRING_TOKEN(STR_SAVE_AND_EXIT),  
+         text   = STRING_TOKEN(STR_SAVE_AND_EXIT), 
+         text   = STRING_TOKEN(STR_NULL_STRING),
+         flags  = INTERACTIVE | NV_ACCESS,
+         key    = KEY_VALUE_SAVE_AND_EXIT;
+             
+       text 
+         help   = STRING_TOKEN(STR_NO_SAVE_AND_EXIT),  
+         text   = STRING_TOKEN(STR_NO_SAVE_AND_EXIT), 
+         text   = STRING_TOKEN(STR_NULL_STRING),
+         flags  = INTERACTIVE | NV_ACCESS,
+         key    = KEY_VALUE_NO_SAVE_AND_EXIT;
+    
+  endform;
+
+  form formid = FORM_DRIVER_ADD_FILE_DESCRIPTION_ID,
+       title = STRING_TOKEN(STR_FORM_DRV_ADD_DESC_TITLE);
+       
+       label FORM_DRIVER_ADD_FILE_DESCRIPTION_ID;
+       
+       subtitle  text = STRING_TOKEN(STR_NULL_STRING);
+
+       string    varid    = FILE_EXPLORER_NV_DATA.DescriptionData,
+                 prompt   = STRING_TOKEN(STR_LOAD_OPTION_DESC),
+                 help     = STRING_TOKEN(STR_NULL_STRING),
+                 minsize  = 6,
+                 maxsize  = 75,
+       endstring;
+
+       string    varid    = FILE_EXPLORER_NV_DATA.OptionalData,
+                 prompt   = STRING_TOKEN(STR_OPTIONAL_DATA),
+                 help     = STRING_TOKEN(STR_NULL_STRING),
+                 minsize  = 0,
+                 maxsize  = 120,
+       endstring; 
+       
+       checkbox varid    = FILE_EXPLORER_NV_DATA.ForceReconnect,
+               prompt   = STRING_TOKEN(STR_LOAD_OPTION_FORCE_RECON),
+               help     = STRING_TOKEN(STR_LOAD_OPTION_FORCE_RECON),  
+               flags    = 1,
+               key      = 0,
+       endcheckbox;
+
+       text 
+         help   = STRING_TOKEN(STR_SAVE_AND_EXIT),  
+         text   = STRING_TOKEN(STR_SAVE_AND_EXIT), 
+         text   = STRING_TOKEN(STR_NULL_STRING),
+         flags  = INTERACTIVE | NV_ACCESS,
+         key    = KEY_VALUE_SAVE_AND_EXIT;
+      
+       text 
+         help   = STRING_TOKEN(STR_NO_SAVE_AND_EXIT),  
+         text   = STRING_TOKEN(STR_NO_SAVE_AND_EXIT), 
+         text   = STRING_TOKEN(STR_NULL_STRING),
+         flags  = INTERACTIVE | NV_ACCESS,
+         key    = KEY_VALUE_NO_SAVE_AND_EXIT;
+               
+  endform;
+  
+endformset;

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/FileExplorer.c

@@ -0,0 +1,339 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  FileExplorer.c
+    
+AgBStract:
+
+  File explorer related functions.
+
+--*/
+
+#include "Bds.h"
+#include "BootMaint.h"
+
+VOID
+UpdateFileExplorePage (
+  IN BMM_CALLBACK_DATA            *CallbackData,
+  BM_MENU_OPTION                  *MenuOption
+  )
+/*++
+Routine Description:
+  Update the File Explore page.
+
+Arguments:
+  MenuOption      - Pointer to menu options to display.
+
+Returns:
+  None.
+
+--*/
+{
+  UINT8           *Location;
+  UINTN           Index;
+  BM_MENU_ENTRY   *NewMenuEntry;
+  BM_FILE_CONTEXT *NewFileContext;
+  FORM_ID         FormId;
+
+  NewMenuEntry    = NULL;
+  NewFileContext  = NULL;
+  FormId          = 0;
+
+  //
+  // Clean up file explore page.
+  //
+  RefreshUpdateData (FALSE, 0, FALSE, 0, 0xff);
+
+  //
+  // Remove all op-codes from dynamic page
+  //
+  CallbackData->Hii->UpdateForm (
+                      CallbackData->Hii,
+                      CallbackData->FeHiiHandle,
+                      FORM_FILE_EXPLORER_ID,
+                      FALSE,
+                      UpdateData
+                      );
+
+  RefreshUpdateData (TRUE, (EFI_PHYSICAL_ADDRESS) (UINTN) CallbackData->FeCallbackHandle, FALSE, 0, 0);
+
+  Location = (UINT8 *) &UpdateData->Data;
+
+  for (Index = 0; Index < MenuOption->MenuNumber; Index++) {
+    NewMenuEntry    = BOpt_GetMenuEntry (MenuOption, Index);
+    NewFileContext  = (BM_FILE_CONTEXT *) NewMenuEntry->VariableContext;
+
+    if (NewFileContext->IsBootLegacy) {
+      continue;
+    }
+
+    if ((NewFileContext->IsDir) || (BOOT_FROM_FILE_STATE == CallbackData->FeCurrentState)) {
+      //
+      // Create Text opcode for directory, also create Text opcode for file in BOOT_FROM_FILE_STATE.
+      //
+      CreateTextOpCode (
+        NewMenuEntry->DisplayStringToken,
+        STR_NULL_STRING,
+        STR_NULL_STRING,
+        EFI_IFR_FLAG_INTERACTIVE | EFI_IFR_FLAG_NV_ACCESS,
+        (UINT16) (FILE_OPTION_OFFSET + Index),
+        Location
+        );
+    } else {
+      //
+      // Create Goto opcode for file in ADD_BOOT_OPTION_STATE or ADD_DRIVER_OPTION_STATE.
+      //
+      if (ADD_BOOT_OPTION_STATE == CallbackData->FeCurrentState) {
+        FormId = FORM_BOOT_ADD_DESCRIPTION_ID;
+      } else if (ADD_DRIVER_OPTION_STATE == CallbackData->FeCurrentState) {
+        FormId = FORM_DRIVER_ADD_FILE_DESCRIPTION_ID;
+      }
+
+      CreateGotoOpCode (
+        FormId,
+        NewMenuEntry->DisplayStringToken,
+        STRING_TOKEN (STR_NULL_STRING),
+        EFI_IFR_FLAG_INTERACTIVE | EFI_IFR_FLAG_NV_ACCESS,
+        (UINT16) (FILE_OPTION_OFFSET + Index),
+        Location
+        );
+    }
+
+    UpdateData->DataCount++;
+    Location = Location + ((EFI_IFR_OP_HEADER *) Location)->Length;
+  }
+
+  CallbackData->Hii->UpdateForm (
+                      CallbackData->Hii,
+                      CallbackData->FeHiiHandle,
+                      FORM_FILE_EXPLORER_ID,
+                      TRUE,
+                      UpdateData
+                      );
+}
+
+BOOLEAN
+UpdateFileExplorer (
+  IN BMM_CALLBACK_DATA            *CallbackData,
+  IN UINT16                       KeyValue
+  )
+/*++
+
+Routine Description:
+  Update the file explower page with the refershed file system.
+
+Arguments:
+  CallbackData  -   BMM context data
+  KeyValue        - Key value to identify the type of data to expect.
+
+Returns:
+  TRUE          - Inform the caller to create a callback packet to exit file explorer.
+  FALSE         - Indicate that there is no need to exit file explorer.
+
+--*/
+{
+  UINT16          FileOptionMask;
+  BM_MENU_ENTRY   *NewMenuEntry;
+  BM_FILE_CONTEXT *NewFileContext;
+  FORM_ID         FormId;
+  BOOLEAN         ExitFileExplorer;
+  EFI_STATUS      Status;
+  
+  NewMenuEntry      = NULL;
+  NewFileContext    = NULL;
+  ExitFileExplorer  = FALSE;
+
+  FileOptionMask    = (UINT16) (FILE_OPTION_MASK & KeyValue);
+
+  if (UNKNOWN_CONTEXT == CallbackData->FeDisplayContext) {
+    //
+    // First in, display file system.
+    //
+    BOpt_FreeMenu (&FsOptionMenu);
+    BOpt_FindFileSystem (CallbackData);
+    CreateMenuStringToken (CallbackData, CallbackData->FeHiiHandle, &FsOptionMenu);
+
+    UpdateFileExplorePage (CallbackData, &FsOptionMenu);
+
+    CallbackData->FeDisplayContext = FILE_SYSTEM;
+  } else {
+    if (FILE_SYSTEM == CallbackData->FeDisplayContext) {
+      NewMenuEntry = BOpt_GetMenuEntry (&FsOptionMenu, FileOptionMask);
+    } else if (DIRECTORY == CallbackData->FeDisplayContext) {
+      NewMenuEntry = BOpt_GetMenuEntry (&DirectoryMenu, FileOptionMask);
+    }
+
+    CallbackData->FeDisplayContext  = DIRECTORY;
+
+    NewFileContext                  = (BM_FILE_CONTEXT *) NewMenuEntry->VariableContext;
+
+    if (NewFileContext->IsDir ) {
+      RemoveEntryList (&NewMenuEntry->Link);
+      BOpt_FreeMenu (&DirectoryMenu);
+      Status = BOpt_FindFiles (CallbackData, NewMenuEntry);
+       if (EFI_ERROR (Status)) {
+         ExitFileExplorer = TRUE;
+         goto exit;
+       }
+      CreateMenuStringToken (CallbackData, CallbackData->FeHiiHandle, &DirectoryMenu);
+      BOpt_DestroyMenuEntry (NewMenuEntry);
+
+      UpdateFileExplorePage (CallbackData, &DirectoryMenu);
+
+    } else {
+      switch (CallbackData->FeCurrentState) {
+      case BOOT_FROM_FILE_STATE:
+        //
+        // Here boot from file
+        //
+        BootThisFile (NewFileContext);
+        ExitFileExplorer = TRUE;
+        break;
+
+      case ADD_BOOT_OPTION_STATE:
+      case ADD_DRIVER_OPTION_STATE:
+        if (ADD_BOOT_OPTION_STATE == CallbackData->FeCurrentState) {
+          FormId = FORM_BOOT_ADD_DESCRIPTION_ID;
+        } else {
+          FormId = FORM_DRIVER_ADD_FILE_DESCRIPTION_ID;
+        }
+
+        CallbackData->MenuEntry = NewMenuEntry;
+        CallbackData->LoadContext->FilePathList = ((BM_FILE_CONTEXT *) (CallbackData->MenuEntry->VariableContext))->DevicePath;
+
+        //
+        // Clean up file explore page.
+        //
+        RefreshUpdateData (FALSE, 0, FALSE, 0, 1);
+
+        //
+        // Remove the Subtitle op-code.
+        //
+        CallbackData->Hii->UpdateForm (
+                            CallbackData->Hii,
+                            CallbackData->FeHiiHandle,
+                            FormId,
+                            FALSE,
+                            UpdateData
+                            );
+
+        //
+        // Create Subtitle op-code for the display string of the option.
+        //
+        RefreshUpdateData (TRUE, (EFI_PHYSICAL_ADDRESS) (UINTN) CallbackData->FeCallbackHandle, FALSE, 0, 1);
+
+        CreateSubTitleOpCode (
+          NewMenuEntry->DisplayStringToken,
+          &UpdateData->Data
+          );
+
+        CallbackData->Hii->UpdateForm (
+                            CallbackData->Hii,
+                            CallbackData->FeHiiHandle,
+                            FormId,
+                            TRUE,
+                            UpdateData
+                            );
+        break;
+
+      default:
+        break;
+      }
+    }
+  }
+exit:
+  return ExitFileExplorer;
+}
+
+EFI_STATUS
+EFIAPI
+FileExplorerCallback (
+  IN EFI_FORM_CALLBACK_PROTOCOL       *This,
+  IN UINT16                           KeyValue,
+  IN EFI_IFR_DATA_ARRAY               *Data,
+  OUT EFI_HII_CALLBACK_PACKET         **Packet
+  )
+/*++
+Routine Description:
+  Callback Function for file exploration and file interaction.
+
+Arguments:
+  This            - File explorer callback protocol pointer.     
+  KeyValue        - Key value to identify the type of data to expect.
+  Data            - A pointer to the data being sent to the original exporting driver.
+  Packet          - A pointer to a packet of information which a driver passes back to the browser.
+
+Returns:
+  EFI_SUCCESS     - Callback ended successfully.
+  Others          - Contain some errors.
+  
+--*/
+{
+  BMM_CALLBACK_DATA     *Private;
+  FILE_EXPLORER_NV_DATA *NvRamMap;
+  EFI_STATUS            Status;
+
+  Status                          = EFI_SUCCESS;
+  Private                         = FE_CALLBACK_DATA_FROM_THIS (This);
+  UpdateData->FormCallbackHandle  = (EFI_PHYSICAL_ADDRESS) (UINTN) Private->FeCallbackHandle;
+  NvRamMap                        = (FILE_EXPLORER_NV_DATA *) Data->NvRamMap;
+
+  if (KEY_VALUE_SAVE_AND_EXIT == KeyValue) {
+    //
+    // Apply changes and exit formset.
+    //
+    if (ADD_BOOT_OPTION_STATE == Private->FeCurrentState) {
+      Status = Var_UpdateBootOption (Private, NvRamMap);
+      if (EFI_ERROR (Status)) {
+        return Status;
+      }
+
+      BOpt_GetBootOptions (Private);
+      CreateMenuStringToken (Private, Private->FeHiiHandle, &BootOptionMenu);
+    } else if (ADD_DRIVER_OPTION_STATE == Private->FeCurrentState) {
+      Status = Var_UpdateDriverOption (
+                Private,
+                Private->FeHiiHandle,
+                NvRamMap->DescriptionData,
+                NvRamMap->OptionalData,
+                NvRamMap->ForceReconnect
+                );
+      if (EFI_ERROR (Status)) {
+        return Status;
+      }
+
+      BOpt_GetDriverOptions (Private);
+      CreateMenuStringToken (Private, Private->FeHiiHandle, &DriverOptionMenu);
+    }
+
+    CreateCallbackPacket (Packet, EXIT_REQUIRED | NV_NOT_CHANGED);
+  } else if (KEY_VALUE_NO_SAVE_AND_EXIT == KeyValue) {
+    //
+    // Discard changes and exit formset.
+    //
+    NvRamMap->OptionalData[0]     = 0x0000;
+    NvRamMap->DescriptionData[0]  = 0x0000;
+    CreateCallbackPacket (Packet, EXIT_REQUIRED | NV_NOT_CHANGED);
+  } else if (KeyValue < FILE_OPTION_OFFSET) {
+    //
+    // Exit File Explorer formset.
+    //
+    CreateCallbackPacket (Packet, EXIT_REQUIRED);
+  } else {
+    if (UpdateFileExplorer (Private, KeyValue)) {
+      CreateCallbackPacket (Packet, EXIT_REQUIRED);
+    }
+  }
+
+  return Status;
+}

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/FormGuid.h

@@ -0,0 +1,32 @@
+// *++
+//
+// Copyright (c) 2006, Intel Corporation
+// All rights reserved. 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.
+//
+// Module Name:
+//
+//   FormGuid.h
+//
+// Abstract:
+//
+//   Formset guids for Boot Maintenance Manager
+//
+// Revision History:
+//
+// --*/
+//
+#define MAIN_FORMSET_GUID \
+  { \
+    0x642237c7, 0x35d4, 0x472d, { 0x83, 0x65, 0x12, 0xe0, 0xcc, 0xf2, 0x7a, 0x22 } \
+  }
+
+#define FILE_EXPLORE_FORMSET_GUID \
+  { \
+    0x1f2d63e1, 0xfebd, 0x4dc7, { 0x9c, 0xc5, 0xba, 0x2b, 0x1c, 0xef, 0x9c, 0x5b } \
+  }

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMngr/BootManager.c

@@ -0,0 +1,355 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name: 
+
+  BootManager.c
+
+Abstract:
+
+  The platform boot manager reference implement
+
+--*/
+#include "BootManager.h"
+
+UINT16                            mKeyInput;
+LIST_ENTRY                        *mBootOptionsList;
+BDS_COMMON_OPTION                 *gOption;
+EFI_HII_HANDLE                    gBootManagerHandle;
+EFI_HANDLE                        BootManagerCallbackHandle;
+EFI_FORM_CALLBACK_PROTOCOL        BootManagerCallback;
+EFI_GUID                          gBmGuid = BOOT_MANAGER_GUID;
+
+extern EFI_FORM_BROWSER_PROTOCOL  *gBrowser;
+extern UINT8                      BootManagerVfrBin[];
+extern UINT8                      EdkGenericPlatformBdsLibStrings[];
+extern BOOLEAN                    gConnectAllHappened;
+
+EFI_STATUS
+EFIAPI
+BootManagerCallbackRoutine (
+  IN EFI_FORM_CALLBACK_PROTOCOL       *This,
+  IN UINT16                           KeyValue,
+  IN EFI_IFR_DATA_ARRAY               *DataArray,
+  OUT EFI_HII_CALLBACK_PACKET         **Packet
+  )
+/*++
+
+Routine Description:
+
+  This is the function that is called to provide results data to the driver.  This data
+  consists of a unique key which is used to identify what data is either being passed back
+  or being asked for. 
+
+Arguments:
+
+  KeyValue -        A unique value which is sent to the original exporting driver so that it
+                    can identify the type of data to expect.  The format of the data tends to
+                    vary based on the op-code that geerated the callback.
+
+  Data -            A pointer to the data being sent to the original exporting driver.
+
+Returns: 
+
+--*/
+{
+  BDS_COMMON_OPTION       *Option;
+  LIST_ENTRY              *Link;
+  UINT16                  KeyCount;
+  EFI_HII_CALLBACK_PACKET *DataPacket;
+
+  //
+  // Initialize the key count
+  //
+  KeyCount = 0;
+
+  for (Link = mBootOptionsList->ForwardLink; Link != mBootOptionsList; Link = Link->ForwardLink) {
+    Option = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE);
+
+    KeyCount++;
+
+    gOption = Option;
+
+    //
+    // Is this device the one chosen?
+    //
+    if (KeyCount == KeyValue) {
+      //
+      // Assigning the returned Key to a global allows the original routine to know what was chosen
+      //
+      mKeyInput = KeyValue;
+
+      *Packet   = AllocateZeroPool (sizeof (EFI_HII_CALLBACK_PACKET) + 2);
+      ASSERT (*Packet != NULL);
+
+      //
+      // Assign the buffer address to DataPacket
+      //
+      DataPacket                        = *Packet;
+
+      DataPacket->DataArray.EntryCount  = 1;
+      DataPacket->DataArray.NvRamMap    = NULL;
+      ((EFI_IFR_DATA_ENTRY *) (((EFI_IFR_DATA_ARRAY *)DataPacket) + 1))->Flags = EXIT_REQUIRED | NV_NOT_CHANGED;
+      return EFI_SUCCESS;
+    } else {
+      continue;
+    }
+  }
+
+  return EFI_SUCCESS;
+}
+
+VOID
+CallBootManager (
+  VOID
+  )
+/*++
+
+Routine Description:
+  Hook to enable UI timeout override behavior.
+
+Arguments:
+  BdsDeviceList - Device List that BDS needs to connect.
+
+  Entry - Pointer to current Boot Entry.
+
+Returns:
+  NONE
+
+--*/
+{
+  EFI_STATUS          Status;
+  EFI_HII_PACKAGES    *PackageList;
+  BDS_COMMON_OPTION   *Option;
+  LIST_ENTRY          *Link;
+  EFI_HII_UPDATE_DATA *UpdateData;
+  CHAR16              *ExitData;
+  UINTN               ExitDataSize;
+  STRING_REF          Token;
+  STRING_REF          LastToken;
+  EFI_INPUT_KEY       Key;
+  UINT8               *Location;
+  EFI_GUID            BmGuid;
+  LIST_ENTRY          BdsBootOptionList;
+  BOOLEAN	          BootMngrMenuResetRequired;
+
+  gOption = NULL;
+  InitializeListHead (&BdsBootOptionList);
+
+  //
+  // Connect all prior to entering the platform setup menu.
+  //
+  if (!gConnectAllHappened) {
+    BdsLibConnectAllDriversToAllControllers ();
+    gConnectAllHappened = TRUE;
+  }
+  //
+  // BugBug: Here we can not remove the legacy refresh macro, so we need
+  // get the boot order every time from "BootOrder" variable.
+  // Recreate the boot option list base on the BootOrder variable
+  //
+  BdsLibEnumerateAllBootOption (&BdsBootOptionList);
+
+  //
+  // This GUID must be the same as what is defined in BootManagerVfr.vfr
+  //
+  BmGuid            = gBmGuid;
+
+  mBootOptionsList  = &BdsBootOptionList;
+
+  //
+  // Post our VFR to the HII database
+  //
+  PackageList = PreparePackages (2, &BmGuid, BootManagerVfrBin, EdkGenericPlatformBdsLibStrings);
+  Status      = Hii->NewPack (Hii, PackageList, &gBootManagerHandle);
+  gBS->FreePool (PackageList);
+
+  //
+  // This example does not implement worker functions
+  // for the NV accessor functions.  Only a callback evaluator
+  //
+  BootManagerCallback.NvRead    = NULL;
+  BootManagerCallback.NvWrite   = NULL;
+  BootManagerCallback.Callback  = BootManagerCallbackRoutine;
+
+  //
+  // Install protocol interface
+  //
+  BootManagerCallbackHandle = NULL;
+  Status = gBS->InstallProtocolInterface (
+                  &BootManagerCallbackHandle,
+                  &gEfiFormCallbackProtocolGuid,
+                  EFI_NATIVE_INTERFACE,
+                  &BootManagerCallback
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  LastToken = 0;
+  Hii->NewString (Hii, NULL, gBootManagerHandle, &LastToken, L" ");
+
+  //
+  // Allocate space for creation of UpdateData Buffer
+  //
+  UpdateData = AllocateZeroPool (0x1000);
+  ASSERT (UpdateData != NULL);
+
+  //
+  // Flag update pending in FormSet
+  //
+  UpdateData->FormSetUpdate = TRUE;
+  //
+  // Register CallbackHandle data for FormSet
+  //
+  UpdateData->FormCallbackHandle = (EFI_PHYSICAL_ADDRESS) (UINTN) BootManagerCallbackHandle;
+  UpdateData->FormUpdate  = FALSE;
+  UpdateData->FormTitle   = 0;
+  UpdateData->DataCount   = 1;
+
+  //
+  // Create blank space.  Since when we update the contents of IFR data at a label, it is
+  // inserted at the location of the label.  So if you want to add a string with an empty
+  // space afterwards, you need to add the space first and then the string like below.
+  //
+  Status = CreateSubTitleOpCode (
+            LastToken,        // Token Value for the string
+            &UpdateData->Data // Buffer containing created op-code
+            );
+
+  Hii->UpdateForm (Hii, gBootManagerHandle, (EFI_FORM_LABEL) 0x0000, TRUE, UpdateData);
+
+  //
+  // Create "Boot Option Menu" title
+  //
+  Status = CreateSubTitleOpCode (
+            STRING_TOKEN (STR_BOOT_OPTION_BANNER),  // Token Value for the string
+            &UpdateData->Data                       // Buffer containing created op-code
+            );
+
+  Hii->UpdateForm (Hii, gBootManagerHandle, (EFI_FORM_LABEL) 0x0000, TRUE, UpdateData);
+
+  Token                 = LastToken;
+  mKeyInput             = 0;
+
+  UpdateData->DataCount = 0;
+  Location              = (UINT8 *) &UpdateData->Data;
+
+  for (Link = BdsBootOptionList.ForwardLink; Link != &BdsBootOptionList; Link = Link->ForwardLink) {
+    Option = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE);
+
+    //
+    // At this stage we are creating a menu entry, thus the Keys are reproduceable
+    //
+    mKeyInput++;
+    Token++;
+
+    Status = Hii->NewString (Hii, NULL, gBootManagerHandle, &Token, Option->Description);
+
+    //
+    // If we got an error it is almost certainly due to the token value being invalid.
+    // Therefore we will set the Token to 0 to automatically add a token.
+    //
+    if (EFI_ERROR (Status)) {
+      Token   = 0;
+      Status  = Hii->NewString (Hii, NULL, gBootManagerHandle, &Token, Option->Description);
+    }
+
+    Status = CreateGotoOpCode (
+              0x1000, // Form ID
+              Token,  // Token Value for the string
+              0,      // Help String (none)
+              EFI_IFR_FLAG_INTERACTIVE | EFI_IFR_FLAG_NV_ACCESS,  // The Op-Code flags
+              mKeyInput,                                          // The Key to get a callback on
+              Location  // Buffer containing created op-code
+              );
+
+    UpdateData->DataCount++;
+    Location = Location + ((EFI_IFR_OP_HEADER *) Location)->Length;
+
+  }
+
+  Hii->UpdateForm (Hii, gBootManagerHandle, (EFI_FORM_LABEL) 0x0001, TRUE, UpdateData);
+
+  UpdateData->DataCount = 1;
+
+  //
+  // Create "Boot Option Menu" title
+  //
+  Status = CreateSubTitleOpCode (
+            STRING_TOKEN (STR_HELP_FOOTER), // Token Value for the string
+            &UpdateData->Data               // Buffer containing created op-code
+            );
+
+  Hii->UpdateForm (Hii, gBootManagerHandle, (EFI_FORM_LABEL) 0x0002, TRUE, UpdateData);
+
+  Status = CreateSubTitleOpCode (
+            LastToken,                      // Token Value for the string
+            &UpdateData->Data               // Buffer containing created op-code
+            );
+
+  Hii->UpdateForm (Hii, gBootManagerHandle, (EFI_FORM_LABEL) 0x0002, TRUE, UpdateData);
+
+  gBS->FreePool (UpdateData);
+
+  ASSERT (gBrowser);
+
+  BootMngrMenuResetRequired = FALSE;
+  gBrowser->SendForm (
+              gBrowser, 
+              TRUE, 
+              &gBootManagerHandle, 
+              1, 
+              NULL, 
+              NULL, 
+              NULL, 
+              NULL, 
+              &BootMngrMenuResetRequired
+              );
+
+  if (BootMngrMenuResetRequired) {
+    EnableResetRequired ();
+  }
+
+  Hii->ResetStrings (Hii, gBootManagerHandle);
+
+  if (gOption == NULL) {
+    return ;
+  }
+  
+  //
+  //Will leave browser, check any reset required change is applied? if yes, reset system
+  //
+  SetupResetReminder ();
+  
+  //
+  // BugBug: This code looks repeated from the BDS. Need to save code space.
+  //
+
+  //
+  // parse the selected option
+  //
+  Status = BdsLibBootViaBootOption (gOption, gOption->DevicePath, &ExitDataSize, &ExitData);
+
+  if (!EFI_ERROR (Status)) {
+    PlatformBdsBootSuccess (gOption);
+  } else {
+    PlatformBdsBootFail (gOption, Status, ExitData, ExitDataSize);
+    gST->ConOut->OutputString (
+                  gST->ConOut,
+                  GetStringById (STRING_TOKEN (STR_ANY_KEY_CONTINUE))
+                  );
+
+    //
+    // BdsLibUiWaitForSingleEvent (gST->ConIn->WaitForKey, 0);
+    //
+
+    gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
+  }
+}

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMngr/BootManager.h

@@ -0,0 +1,50 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name: 
+
+  BootManager.h
+
+Abstract:
+
+  The platform boot manager reference implement
+
+Revision History
+
+--*/
+
+#ifndef _EFI_BOOT_MANAGER_H
+#define _EFI_BOOT_MANAGER_H
+
+#include "Bds.h"
+//#include "EdkGenericPlatformBdsLib.h"
+#include "String.h"
+
+EFI_STATUS
+EFIAPI
+BootManagerCallbackRoutine (
+  IN EFI_FORM_CALLBACK_PROTOCOL       *This,
+  IN UINT16                           KeyValue,
+  IN EFI_IFR_DATA_ARRAY               *DataArray,
+  OUT EFI_HII_CALLBACK_PACKET         **Packet
+  );
+
+VOID
+CallBootManager (
+  VOID
+);
+
+#define BOOT_MANAGER_GUID \
+  { \
+    0x847bc3fe, 0xb974, 0x446d, {0x94, 0x49, 0x5a, 0xd5, 0x41, 0x2e, 0x99, 0x3b } \
+  }
+
+#endif

EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMngr/BootManagerVfr.Vfr

@@ -0,0 +1,55 @@
+// *++
+//
+// Copyright (c) 2006, Intel Corporation                                                         
+// All rights reserved. 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.             
+// 
+// Module Name:
+//
+//   BootManager.vfr 
+// 
+// Abstract:
+// 
+//   Browser formset.
+// 
+// Revision History: 
+// 
+// --*/
+
+#include "EdkGenericPlatformBdsLibStrDefs.h"
+
+#define FORMSET_GUID  { 0x847bc3fe, 0xb974, 0x446d, { 0x94, 0x49, 0x5a, 0xd5, 0x41, 0x2e, 0x99, 0x3b } } 
+
+#define BOOT_MANAGER_HEADER		 0x00
+#define BOOT_MANAGER_LABEL		 0x01
+#define BOOT_MANAGER_TAIL		 0x02
+
+
+#define BOOT_MANAGER_CLASS       0x00
+#define BOOT_MANAGER_SUBCLASS    0x01
+
+formset 
+  guid     = FORMSET_GUID,
+  title    = STRING_TOKEN(STR_BM_BANNER),  
+  help     = STRING_TOKEN(STR_LAST_STRING),
+  class    = BOOT_MANAGER_CLASS,      
+  subclass = BOOT_MANAGER_SUBCLASS,
+
+  form formid = 0x1000,
+       title  = STRING_TOKEN(STR_BM_BANNER);
+
+    label BOOT_MANAGER_HEADER;
+    label BOOT_MANAGER_LABEL;
+    //
+    // This is where we will dynamically add choices for the Boot Manager
+    //
+
+    label BOOT_MANAGER_TAIL;
+  endform;
+
+endformset;

EdkModulePkg/Library/EdkGenericPlatformBdsLib/Capsules.c

@@ -0,0 +1,213 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  Capsules.c
+
+Abstract:
+
+  BDS routines to handle capsules.
+
+--*/
+
+
+#include <Common/FlashMap.h>
+
+VOID
+BdsLockFv (
+  IN EFI_CPU_IO_PROTOCOL          *CpuIo,
+  IN EFI_FLASH_SUBAREA_ENTRY      *FlashEntry
+  );
+
+VOID
+BdsLockFv (
+  IN EFI_CPU_IO_PROTOCOL          *CpuIo,
+  IN EFI_FLASH_SUBAREA_ENTRY      *FlashEntry
+  )
+{
+  EFI_FV_BLOCK_MAP_ENTRY      *BlockMap;
+  EFI_FIRMWARE_VOLUME_HEADER  *FvHeader;
+  UINT64                      BaseAddress;
+  UINT8                       Data;
+  UINT32                      BlockLength;
+  UINTN                       Index;
+
+  BaseAddress = FlashEntry->Base - 0x400000 + 2;
+  FvHeader    = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) (FlashEntry->Base));
+  BlockMap    = &(FvHeader->FvBlockMap[0]);
+
+  while ((BlockMap->NumBlocks != 0) && (BlockMap->BlockLength != 0)) {
+    BlockLength = BlockMap->BlockLength;
+    for (Index = 0; Index < BlockMap->NumBlocks; Index++) {
+      CpuIo->Mem.Read (
+                  CpuIo,
+                  EfiCpuIoWidthUint8,
+                  BaseAddress,
+                  1,
+                  &Data
+                  );
+      Data = (UINT8) (Data | 0x3);
+      CpuIo->Mem.Write (
+                  CpuIo,
+                  EfiCpuIoWidthUint8,
+                  BaseAddress,
+                  1,
+                  &Data
+                  );
+      BaseAddress += BlockLength;
+    }
+
+    BlockMap++;
+  }
+}
+
+VOID
+BdsLockNonUpdatableFlash (
+  VOID
+  )
+{
+  EFI_FLASH_MAP_ENTRY_DATA  *FlashMapEntryData;
+  EFI_PEI_HOB_POINTERS      GuidHob;
+  EFI_STATUS                Status;
+  EFI_CPU_IO_PROTOCOL       *CpuIo;
+
+  Status = gBS->LocateProtocol (&gEfiCpuIoProtocolGuid, NULL, (VOID**)&CpuIo);
+  ASSERT_EFI_ERROR (Status);
+  
+  GuidHob.Raw = GetHobList ();
+  while ((GuidHob.Raw = GetNextGuidHob (&gEfiFlashMapHobGuid, GuidHob.Raw)) != NULL) {
+    FlashMapEntryData = (EFI_FLASH_MAP_ENTRY_DATA *) GET_GUID_HOB_DATA (GuidHob.Guid);
+
+    //
+    // Get the variable store area
+    //
+    if ((FlashMapEntryData->AreaType == EFI_FLASH_AREA_RECOVERY_BIOS) ||
+        (FlashMapEntryData->AreaType == EFI_FLASH_AREA_MAIN_BIOS)
+        ) {
+      BdsLockFv (CpuIo, &(FlashMapEntryData->Entries[0]));
+    }
+    GuidHob.Raw = GET_NEXT_HOB (GuidHob);
+  }
+
+  return ;
+}
+
+EFI_STATUS
+ProcessCapsules (
+  EFI_BOOT_MODE BootMode
+  )
+/*++
+
+Routine Description:
+
+  This routine is called to see if there are any capsules we need to process.
+  If the boot mode is not UPDATE, then we do nothing. Otherwise find the
+  capsule HOBS and produce firmware volumes for them via the DXE service.
+  Then call the dispatcher to dispatch drivers from them. Finally, check
+  the status of the updates.
+
+Arguments:
+
+  BootMode - the current boot mode
+
+Returns:
+  
+  EFI_INVALID_PARAMETER - boot mode is not correct for an update
+
+Note:
+ 
+ This function should be called by BDS in case we need to do some
+ sort of processing even if there is no capsule to process. We
+ need to do this if an earlier update went awry and we need to
+ clear the capsule variable so on the next reset PEI does not see it and 
+ think there is a capsule available.
+
+--*/
+{
+  EFI_STATUS                  Status;
+  EFI_HOB_CAPSULE_VOLUME      *CvHob;
+  EFI_PHYSICAL_ADDRESS        BaseAddress;
+  UINT64                      Length;
+  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;
+  EFI_HANDLE                  FvProtocolHandle;
+
+  //
+  // We don't do anything else if the boot mode is not flash-update
+  //
+  if (BootMode != BOOT_ON_FLASH_UPDATE) {
+    return EFI_INVALID_PARAMETER;
+  }
+  //
+  // Only one capsule HOB allowed.
+  //
+  CvHob = GetFirstHob (EFI_HOB_TYPE_CV);
+  if (CvHob == NULL) {
+    //
+    // We didn't find a hob, so had no errors.
+    //
+    BdsLockNonUpdatableFlash ();
+    return EFI_SUCCESS;
+  }
+  
+  BaseAddress = CvHob->BaseAddress;
+  Length      = CvHob->Length;
+
+  Status      = EFI_SUCCESS;
+  //
+  // Now walk the capsule and call the core to process each
+  // firmware volume in it.
+  //
+  while (Length != 0) {
+    //
+    // Point to the next firmware volume header, and then
+    // call the DXE service to process it.
+    //
+    FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) BaseAddress;
+    if (FwVolHeader->FvLength > Length) {
+      //
+      // Notes: need to stuff this status somewhere so that the
+      // error can be detected at OS runtime
+      //
+      Status = EFI_VOLUME_CORRUPTED;
+      break;
+    }
+
+    Status = gDS->ProcessFirmwareVolume (
+                    (VOID *) (UINTN) BaseAddress,
+                    (UINTN) FwVolHeader->FvLength,
+                    &FvProtocolHandle
+                    );
+    if (EFI_ERROR (Status)) {
+      break;
+    }
+    //
+    // Call the dispatcher to dispatch any drivers from the produced firmware volume
+    //
+    gDS->Dispatch ();
+    //
+    // On to the next FV in the capsule
+    //
+    Length -= FwVolHeader->FvLength;
+    BaseAddress = (EFI_PHYSICAL_ADDRESS) ((UINTN) BaseAddress + FwVolHeader->FvLength);
+    //
+    // Notes: when capsule spec is finalized, if the requirement is made to
+    // have each FV in a capsule aligned, then we will need to align the
+    // BaseAddress and Length here.
+    //
+  }
+   
+
+  BdsLockNonUpdatableFlash ();
+
+  return Status;
+}
+

EdkModulePkg/Library/EdkGenericPlatformBdsLib/DeviceMngr/DeviceManager.c

@@ -0,0 +1,497 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name: 
+
+  DeviceManager.c
+
+Abstract:
+
+  The platform device manager reference implement
+
+--*/
+#include "DeviceManager.h"
+
+STATIC UINT16                     mTokenCount;
+EFI_FRONTPAGE_CALLBACK_INFO       FPCallbackInfo;
+extern UINTN                      gCallbackKey;
+extern EFI_FORM_BROWSER_PROTOCOL  *gBrowser;
+extern EFI_GUID                   gBdsStringPackGuid;
+extern BOOLEAN                    gConnectAllHappened;
+
+STRING_REF                        gStringTokenTable[] = {
+  STR_VIDEO_DEVICE,
+  STR_NETWORK_DEVICE,
+  STR_INPUT_DEVICE,
+  STR_ON_BOARD_DEVICE,
+  STR_OTHER_DEVICE,
+  STR_EMPTY_STRING,
+  0xFFFF
+};
+
+EFI_STATUS
+EFIAPI
+DeviceManagerCallbackRoutine (
+  IN EFI_FORM_CALLBACK_PROTOCOL       *This,
+  IN UINT16                           KeyValue,
+  IN EFI_IFR_DATA_ARRAY               *DataArray,
+  OUT EFI_HII_CALLBACK_PACKET         **Packet
+  )
+/*++
+
+Routine Description:
+
+  This is the function that is called to provide results data to the driver.  This data
+  consists of a unique key which is used to identify what data is either being passed back
+  or being asked for. 
+
+Arguments:
+
+  KeyValue -        A unique value which is sent to the original exporting driver so that it
+                    can identify the type of data to expect.  The format of the data tends to
+                    vary based on the op-code that geerated the callback.
+
+  Data -            A pointer to the data being sent to the original exporting driver.
+
+Returns: 
+
+--*/
+{
+  //
+  // The KeyValue corresponds in this case to the handle which was requested to be displayed
+  //
+  EFI_FRONTPAGE_CALLBACK_INFO *CallbackInfo;
+
+  CallbackInfo = EFI_FP_CALLBACK_DATA_FROM_THIS (This);
+  switch (KeyValue) {
+  case 0x2000:
+    CallbackInfo->Data.VideoBIOS = (UINT8) (UINTN) (((EFI_IFR_DATA_ENTRY *)(DataArray + 1))->Data);
+    gRT->SetVariable (
+          L"VBIOS",
+          &gEfiGlobalVariableGuid,
+          EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
+          sizeof (UINT8),
+          &CallbackInfo->Data.VideoBIOS
+          );
+    break;
+
+  default:
+    break;
+  }
+
+  gCallbackKey = KeyValue;
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+InitializeDeviceManager (
+  VOID
+  )
+/*++
+
+Routine Description:
+
+  Initialize HII information for the FrontPage
+
+Arguments:
+  None
+            
+Returns:
+
+--*/
+{
+  EFI_STATUS          Status;
+  EFI_HII_PACKAGES    *PackageList;
+  EFI_HII_UPDATE_DATA *UpdateData;
+
+  //
+  // Allocate space for creation of UpdateData Buffer
+  //
+  UpdateData = AllocateZeroPool (0x1000);
+  ASSERT (UpdateData != NULL);
+
+  PackageList = PreparePackages (1, &gBdsStringPackGuid, DeviceManagerVfrBin);
+  Status      = Hii->NewPack (Hii, PackageList, &FPCallbackInfo.DevMgrHiiHandle);
+  gBS->FreePool (PackageList);
+
+  //
+  // This example does not implement worker functions for the NV accessor functions.  Only a callback evaluator
+  //
+  FPCallbackInfo.Signature                = EFI_FP_CALLBACK_DATA_SIGNATURE;
+  FPCallbackInfo.DevMgrCallback.NvRead    = NULL;
+  FPCallbackInfo.DevMgrCallback.NvWrite   = NULL;
+  FPCallbackInfo.DevMgrCallback.Callback  = DeviceManagerCallbackRoutine;
+
+  //
+  // Install protocol interface
+  //
+  FPCallbackInfo.CallbackHandle = NULL;
+
+  Status = gBS->InstallProtocolInterface (
+                  &FPCallbackInfo.CallbackHandle,
+                  &gEfiFormCallbackProtocolGuid,
+                  EFI_NATIVE_INTERFACE,
+                  &FPCallbackInfo.DevMgrCallback
+                  );
+
+  ASSERT_EFI_ERROR (Status);
+
+  //
+  // Flag update pending in FormSet
+  //
+  UpdateData->FormSetUpdate = TRUE;
+  //
+  // Register CallbackHandle data for FormSet
+  //
+  UpdateData->FormCallbackHandle = (EFI_PHYSICAL_ADDRESS) (UINTN) FPCallbackInfo.CallbackHandle;
+  //
+  // Simply registering the callback handle
+  //
+  Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) 0x0000, TRUE, UpdateData);
+
+  gBS->FreePool (UpdateData);
+  return Status;
+}
+
+EFI_STATUS
+CallDeviceManager (
+  VOID
+  )
+/*++
+
+Routine Description:
+  
+  Call the browser and display the device manager
+
+Arguments:
+  
+  None
+  
+Returns:
+  EFI_SUCCESS            - Operation is successful.
+  EFI_INVALID_PARAMETER  - If the inputs to SendForm function is not valid.
+  
+--*/
+{
+  EFI_STATUS          Status;
+  UINTN               BufferSize;
+  UINTN               Count;
+  EFI_HII_HANDLE      Index;
+  UINT8               *Buffer;
+  EFI_IFR_FORM_SET    *FormSetData;
+  CHAR16              *String;
+  UINTN               StringLength;
+  EFI_HII_UPDATE_DATA *UpdateData;
+  STRING_REF          Token;
+  STRING_REF          TokenHelp;
+  IFR_OPTION          *IfrOptionList;
+  UINT8               *VideoOption;
+  UINTN               VideoOptionSize;
+  EFI_HII_HANDLE      *HiiHandles;
+  UINT16              HandleBufferLength;
+  BOOLEAN	          BootDeviceMngrMenuResetRequired;
+
+  IfrOptionList       = NULL;
+  VideoOption         = NULL;
+  HiiHandles          = NULL;
+  HandleBufferLength  = 0;
+
+  //
+  // Connect all prior to entering the platform setup menu.
+  //
+  if (!gConnectAllHappened) {
+    BdsLibConnectAllDriversToAllControllers ();
+    gConnectAllHappened = TRUE;
+  }
+  //
+  // Allocate space for creation of UpdateData Buffer
+  //
+  UpdateData = AllocateZeroPool (0x1000);
+  ASSERT (UpdateData != NULL);
+
+  Status        = EFI_SUCCESS;
+  Buffer        = NULL;
+  FormSetData   = NULL;
+  gCallbackKey  = 0;
+  if (mTokenCount == 0) {
+    Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &mTokenCount, L" ");
+  }
+
+  Token     = mTokenCount;
+  TokenHelp = (UINT16) (Token + 1);
+
+  //
+  // Reset the menu
+  //
+  for (Index = 0, Count = 1; Count < 0x10000; Count <<= 1, Index++) {
+    //
+    // We will strip off all previous menu entries
+    //
+    UpdateData->DataCount = 0xFF;
+
+    //
+    // Erase entries on this label
+    //
+    Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) Count, FALSE, UpdateData);
+
+    //
+    // Did we reach the end of the Token Table?
+    //
+    if (gStringTokenTable[Index] == 0xFFFF) {
+      break;
+    }
+
+    CreateSubTitleOpCode (gStringTokenTable[Index], &UpdateData->Data);
+    //
+    // Add a single menu item - in this case a subtitle for the device type
+    //
+    UpdateData->DataCount = 1;
+
+    //
+    // Add default title for this label
+    //
+    Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) Count, TRUE, UpdateData);
+  }
+  //
+  // Add a space and an exit string.  Remember since we add things at the label and push other things beyond the
+  // label down, we add this in reverse order
+  //
+  CreateSubTitleOpCode (STRING_TOKEN (STR_EXIT_STRING), &UpdateData->Data);
+  Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) Count, TRUE, UpdateData);
+  CreateSubTitleOpCode (STR_EMPTY_STRING, &UpdateData->Data);
+  Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) Count, TRUE, UpdateData);
+
+  //
+  // Get all the Hii handles
+  //
+  Status = BdsLibGetHiiHandles (Hii, &HandleBufferLength, &HiiHandles);
+  ASSERT_EFI_ERROR (Status);
+
+  for (Index = 1, BufferSize = 0; Index < HandleBufferLength; Index++) {
+    //
+    // Am not initializing Buffer since the first thing checked is the size
+    // this way I can get the real buffersize in the smallest code size
+    //
+    Status = Hii->GetForms (Hii, Index, 0, &BufferSize, Buffer);
+
+    if (Status != EFI_NOT_FOUND) {
+      //
+      // BufferSize should have the real size of the forms now
+      //
+      Buffer = AllocateZeroPool (BufferSize);
+      ASSERT (Buffer != NULL);
+
+      //
+      // Am not initializing Buffer since the first thing checked is the size
+      // this way I can get the real buffersize in the smallest code size
+      //
+      Status = Hii->GetForms (Hii, Index, 0, &BufferSize, Buffer);
+
+      //
+      // Skip EFI_HII_PACK_HEADER, advance to EFI_IFR_FORM_SET data.
+      //
+      FormSetData = (EFI_IFR_FORM_SET *) (Buffer + sizeof (EFI_HII_PACK_HEADER));
+
+      //
+      // If this formset belongs in the device manager, add it to the menu
+      //
+      if (FormSetData->Class != EFI_NON_DEVICE_CLASS) {
+
+        StringLength  = 0x1000;
+        String        = AllocateZeroPool (StringLength);
+        ASSERT (String != NULL);
+
+        Status  = Hii->GetString (Hii, Index, FormSetData->FormSetTitle, TRUE, NULL, &StringLength, String);
+        Status  = Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &Token, String);
+
+        //
+        // If token value exceeded real token value - we need to add a new token values
+        //
+        if (Status == EFI_INVALID_PARAMETER) {
+          Token     = 0;
+          TokenHelp = 0;
+          Status    = Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &Token, String);
+        }
+
+        StringLength = 0x1000;
+        if (FormSetData->Help == 0) {
+          TokenHelp = 0;
+        } else {
+          Status = Hii->GetString (Hii, Index, FormSetData->Help, TRUE, NULL, &StringLength, String);
+          if (StringLength == 0x02) {
+            TokenHelp = 0;
+          } else {
+            Status = Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &TokenHelp, String);
+            if (Status == EFI_INVALID_PARAMETER) {
+              TokenHelp = 0;
+              Status    = Hii->NewString (Hii, NULL, FPCallbackInfo.DevMgrHiiHandle, &TokenHelp, String);
+            }
+          }
+        }
+
+        gBS->FreePool (String);
+
+        CreateGotoOpCode (
+          0x1000,     // Device Manager Page
+          Token,      // Description String Token
+          TokenHelp,  // Description Help String Token
+          EFI_IFR_FLAG_INTERACTIVE | EFI_IFR_FLAG_NV_ACCESS,  // Flag designating callback is active
+          (UINT16) Index,                                     // Callback key value
+          &UpdateData->Data                                   // Buffer to fill with op-code
+          );
+
+        //
+        // In the off-chance that we have lots of extra tokens allocated to the DeviceManager
+        // this ensures we are fairly re-using the tokens instead of constantly growing the token
+        // storage for this one handle.  If we incremented the token value beyond what it normally
+        // would use, we will fall back into the error path which seeds the token value with a 0
+        // so that we can correctly add a token value.
+        //
+        if (TokenHelp == 0) {
+          //
+          // Since we didn't add help, only advance Token by 1
+          //
+          Token++;
+        } else {
+          Token     = (UINT16) (Token + 2);
+          TokenHelp = (UINT16) (TokenHelp + 2);
+        }
+        //
+        // This for loop basically will take the Class value which is a bitmask and
+        // update the form for every active bit.  There will be a label at each bit
+        // location.  So if someone had a device which a class of EFI_DISK_DEVICE_CLASS |
+        // EFI_ON_BOARD_DEVICE_CLASS, this routine will unwind that mask and drop the menu entry
+        // on each corresponding label.
+        //
+        for (Count = 1; Count < 0x10000; Count <<= 1) {
+          //
+          // This is an active bit, so update the form
+          //
+          if (FormSetData->Class & Count) {
+            Hii->UpdateForm (
+                  Hii,
+                  FPCallbackInfo.DevMgrHiiHandle,
+                  (EFI_FORM_LABEL) (FormSetData->Class & Count),
+                  TRUE,
+                  UpdateData
+                  );
+          }
+        }
+      }
+
+      BufferSize = 0;
+      //
+      // Reset Buffer pointer to original location
+      //
+      gBS->FreePool (Buffer);
+    }
+  }
+  //
+  // Add oneof for video BIOS selection
+  //
+  VideoOption = BdsLibGetVariableAndSize (
+                  L"VBIOS",
+                  &gEfiGlobalVariableGuid,
+                  &VideoOptionSize
+                  );
+  if (NULL == VideoOption) {
+    FPCallbackInfo.Data.VideoBIOS = 0;
+  } else {
+    FPCallbackInfo.Data.VideoBIOS = VideoOption[0];
+    gBS->FreePool (VideoOption);
+  }
+
+  ASSERT (FPCallbackInfo.Data.VideoBIOS <= 1);
+
+  Status = gBS->AllocatePool (EfiBootServicesData, 2 * sizeof (IFR_OPTION), (VOID**) &IfrOptionList);
+  if (IfrOptionList != NULL) {
+    IfrOptionList[0].Flags        = EFI_IFR_FLAG_INTERACTIVE;
+    IfrOptionList[0].Key          = SET_VIDEO_BIOS_TYPE_QUESTION_ID + 0x2000;
+    IfrOptionList[0].StringToken  = STRING_TOKEN (STR_ONE_OF_PCI);
+    IfrOptionList[0].Value        = 0;
+    IfrOptionList[0].OptionString = NULL;
+    IfrOptionList[1].Flags        = EFI_IFR_FLAG_INTERACTIVE;
+    IfrOptionList[1].Key          = SET_VIDEO_BIOS_TYPE_QUESTION_ID + 0x2000;
+    IfrOptionList[1].StringToken  = STRING_TOKEN (STR_ONE_OF_AGP);
+    IfrOptionList[1].Value        = 1;
+    IfrOptionList[1].OptionString = NULL;
+    IfrOptionList[FPCallbackInfo.Data.VideoBIOS].Flags |= EFI_IFR_FLAG_DEFAULT;
+
+    CreateOneOfOpCode (
+      SET_VIDEO_BIOS_TYPE_QUESTION_ID,
+      (UINT8) 1,
+      STRING_TOKEN (STR_ONE_OF_VBIOS),
+      STRING_TOKEN (STR_ONE_OF_VBIOS_HELP),
+      IfrOptionList,
+      2,
+      &UpdateData->Data
+      );
+
+    UpdateData->DataCount = 4;
+    Hii->UpdateForm (Hii, FPCallbackInfo.DevMgrHiiHandle, (EFI_FORM_LABEL) EFI_VBIOS_CLASS, TRUE, UpdateData);
+    gBS->FreePool (IfrOptionList);
+  }
+
+  BootDeviceMngrMenuResetRequired = FALSE;
+  Status = gBrowser->SendForm (
+                      gBrowser,
+                      TRUE,                             // Use the database
+                      &FPCallbackInfo.DevMgrHiiHandle,  // The HII Handle
+                      1,
+                      NULL,
+                      FPCallbackInfo.CallbackHandle,
+                      (UINT8 *) &FPCallbackInfo.Data,
+                      NULL,
+                      &BootDeviceMngrMenuResetRequired
+                      );
+
+  if (BootDeviceMngrMenuResetRequired) {
+    EnableResetRequired ();
+  }
+
+  Hii->ResetStrings (Hii, FPCallbackInfo.DevMgrHiiHandle);
+
+  //
+  // We will have returned from processing a callback - user either hit ESC to exit, or selected
+  // a target to display
+  //
+  if (gCallbackKey != 0 && gCallbackKey < 0x2000) {
+    BootDeviceMngrMenuResetRequired = FALSE;
+    Status = gBrowser->SendForm (
+                        gBrowser,
+                        TRUE,                             // Use the database
+                        (EFI_HII_HANDLE *) &gCallbackKey, // The HII Handle
+                        1,
+                        NULL,
+                        NULL,                             // This is the handle that the interface to the callback was installed on
+                        NULL,
+                        NULL,
+                        &BootDeviceMngrMenuResetRequired
+                        );
+
+    if (BootDeviceMngrMenuResetRequired) {
+      EnableResetRequired ();
+    }
+    //
+    // Force return to Device Manager
+    //
+    gCallbackKey = 4;
+  }
+
+  if (gCallbackKey >= 0x2000) {
+    gCallbackKey = 4;
+  }
+
+  gBS->FreePool (UpdateData);
+  gBS->FreePool (HiiHandles);
+
+  return Status;
+}

EdkModulePkg/Library/EdkGenericPlatformBdsLib/DeviceMngr/DeviceManager.h

@@ -0,0 +1,59 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name: 
+
+  DeviceManager.c
+
+Abstract:
+
+  The platform device manager reference implement
+
+Revision History
+
+--*/
+
+#ifndef _DEVICE_MANAGER_H
+#define _DEVICE_MANAGER_H
+
+#include "FrontPage.h"
+
+#define EFI_NON_DEVICE_CLASS              0x00  // Useful when you do not want something in the Device Manager
+#define EFI_DISK_DEVICE_CLASS             0x01
+#define EFI_VIDEO_DEVICE_CLASS            0x02
+#define EFI_NETWORK_DEVICE_CLASS          0x04
+#define EFI_INPUT_DEVICE_CLASS            0x08
+#define EFI_ON_BOARD_DEVICE_CLASS         0x10
+#define EFI_OTHER_DEVICE_CLASS            0x20
+
+EFI_STATUS
+EFIAPI
+DeviceManagerCallbackRoutine (
+  IN EFI_FORM_CALLBACK_PROTOCOL       *This,
+  IN UINT16                           KeyValue,
+  IN EFI_IFR_DATA_ARRAY               *DataArray,
+  OUT EFI_HII_CALLBACK_PACKET         **Packet
+  )
+;
+
+EFI_STATUS
+InitializeDeviceManager (
+  VOID
+  )
+;
+
+EFI_STATUS
+CallDeviceManager (
+  VOID
+  )
+;
+
+#endif

EdkModulePkg/Library/EdkGenericPlatformBdsLib/DeviceMngr/DeviceManagerVfr.Vfr

@@ -0,0 +1,75 @@
+// *++
+//
+// Copyright (c) 2006, Intel Corporation                                                         
+// All rights reserved. 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.             
+// 
+// Module Name:
+//
+//   DeviceManagerVfr.vfr 
+// 
+// Abstract:
+// 
+//   Device Manager formset.
+// 
+// Revision History: 
+// 
+// --*/
+
+#include "EdkGenericPlatformBdsLibStrDefs.h"
+
+#define FORMSET_GUID  { 0x3ebfa8e6, 0x511d, 0x4b5b, { 0xa9, 0x5f, 0xfb, 0x38, 0x26, 0xf, 0x1c, 0x27 } }
+
+#define EFI_DISK_DEVICE_CLASS              0x01
+#define EFI_VIDEO_DEVICE_CLASS             0x02
+#define EFI_NETWORK_DEVICE_CLASS           0x04
+#define EFI_INPUT_DEVICE_CLASS             0x08
+#define EFI_ON_BOARD_DEVICE_CLASS          0x10
+#define EFI_OTHER_DEVICE_CLASS             0x20
+#define EFI_VBIOS_CLASS                    0x40
+
+#define DEVICE_MANAGER_CLASS               0x0000
+#define FRONT_PAGE_SUBCLASS		             0x0003
+
+formset 
+  guid     = FORMSET_GUID,
+  title    = STRING_TOKEN(STR_DEVICE_MANAGER_TITLE),  
+  help     = STRING_TOKEN(STR_EMPTY_STRING),
+  class    = DEVICE_MANAGER_CLASS,      
+  subclass = FRONT_PAGE_SUBCLASS,
+
+  form formid = 0x1000,
+       title  = STRING_TOKEN(STR_DEVICE_MANAGER_TITLE);
+
+    //
+    // This is where devices get added to the device manager hierarchy
+    //
+    subtitle text = STRING_TOKEN(STR_DISK_DEVICE);
+    label EFI_DISK_DEVICE_CLASS;
+
+    subtitle text = STRING_TOKEN(STR_VIDEO_DEVICE);
+    label EFI_VIDEO_DEVICE_CLASS;
+
+    subtitle text = STRING_TOKEN(STR_NETWORK_DEVICE);
+    label EFI_NETWORK_DEVICE_CLASS;
+
+    subtitle text = STRING_TOKEN(STR_INPUT_DEVICE);
+    label EFI_INPUT_DEVICE_CLASS;
+
+    subtitle text = STRING_TOKEN(STR_ON_BOARD_DEVICE);
+    label EFI_ON_BOARD_DEVICE_CLASS;
+
+    subtitle text = STRING_TOKEN(STR_OTHER_DEVICE);
+    label EFI_OTHER_DEVICE_CLASS;
+    
+    subtitle text = STRING_TOKEN(STR_EMPTY_STRING);
+    label EFI_VBIOS_CLASS;
+    
+  endform;
+endformset;
+

EdkModulePkg/Library/EdkGenericPlatformBdsLib/EdkGenericPlatformBdsLib.msa

@@ -0,0 +1,230 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <MsaHeader>
+    <ModuleName>EdkPlatformGenericBdsLib</ModuleName>
+    <ModuleType>DXE_DRIVER</ModuleType>
+    <GuidValue>f392b762-8985-11db-be87-0040d02b1835</GuidValue>
+    <Version>1.0</Version>
+    <Abstract>Generic BDS library</Abstract>
+    <Description>Do generic action.</Description>
+    <Copyright>Copyright (c) 2006, Intel Corporation</Copyright>
+    <License>All rights reserved. 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.</License>
+    <Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION   0x00000052</Specification>
+  </MsaHeader>
+  <ModuleDefinitions>
+    <SupportedArchitectures>IA32 X64 IPF EBC</SupportedArchitectures>
+    <BinaryModule>false</BinaryModule>
+    <OutputFileBasename>EdkGenericPlatformBdsLib</OutputFileBasename>
+  </ModuleDefinitions>
+  <LibraryClassDefinitions>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>DebugLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>UefiLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>UefiDriverEntryPoint</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>BaseLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>EdkGraphicsLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>DxeServicesTableLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>PerformanceLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>PrintLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>EdkIfrSupportLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>ReportStatusCodeLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>HobLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>EdkGenericBdsLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>MemoryAllocationLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>BaseMemoryLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>UefiBootServicesTableLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>UefiRuntimeServicesTableLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>DevicePathLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>HiiLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_PRODUCED">
+      <Keyword>EdkGenericPlatformBdsLib</Keyword>
+    </LibraryClass>
+    <LibraryClass Usage="ALWAYS_CONSUMED">
+      <Keyword>PeCoffLib</Keyword>
+    </LibraryClass>
+  </LibraryClassDefinitions>
+  <SourceFiles>
+    <Filename>Bds.h</Filename>
+    <Filename>BdsEntry.c</Filename>
+    <Filename>BdsBoot.c</Filename>
+    <Filename>FrontPage.h</Filename>
+    <Filename>FrontPage.c</Filename>
+    <Filename>FrontPageStrings.uni</Filename>
+    <Filename>FrontPageVfr.Vfr</Filename>
+    <Filename>Language.h</Filename>
+    <Filename>Language.c</Filename>
+    <Filename>String.h</Filename>
+    <Filename>String.c</Filename>
+    <Filename>Strings.uni</Filename>
+    <Filename>Capsules.c</Filename>
+    <Filename>MemoryTest.c</Filename>
+    <Filename>BootMaint/BmString.uni</Filename>
+    <Filename>BootMaint/Bm.vfr</Filename>
+    <Filename>BootMaint/BBSsupport.h</Filename>
+    <Filename>BootMaint/BootMaint.h</Filename>
+    <Filename>BootMaint/FormGuid.h</Filename>
+    <Filename>BootMaint/BmLib.c</Filename>
+    <Filename>BootMaint/BootOption.c</Filename>
+    <Filename>BootMaint/ConsoleOption.c</Filename>
+    <Filename>BootMaint/Data.c</Filename>
+    <Filename>BootMaint/Variable.c</Filename>
+    <Filename>BootMaint/UpdatePage.c</Filename>
+    <Filename>BootMaint/BBSsupport.c</Filename>
+    <Filename>BootMaint/BootMaint.c</Filename>
+    <Filename>BootMaint/FileExplorer.c</Filename>
+    <Filename>BootMaint/FE.vfr</Filename>
+    <Filename>BootMngr/BootManager.h</Filename>
+    <Filename>BootMngr/BootManager.c</Filename>
+    <Filename>BootMngr/BootManagerStrings.uni</Filename>
+    <Filename>BootMngr/BootManagerVfr.Vfr</Filename>
+    <Filename>DeviceMngr/DeviceManager.h</Filename>
+    <Filename>DeviceMngr/DeviceManager.c</Filename>
+    <Filename>DeviceMngr/DeviceManagerStrings.uni</Filename>
+    <Filename>DeviceMngr/DeviceManagerVfr.Vfr</Filename>
+    <!--<Filename>Bds.dxs</Filename>-->
+  </SourceFiles>
+  <PackageDependencies>
+    <Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>
+    <Package PackageGuid="68169ab0-d41b-4009-9060-292c253ac43d"/>
+  </PackageDependencies>
+  <Protocols>
+    <Protocol Usage="ALWAYS_PRODUCED">
+      <ProtocolCName>gEfiBdsArchProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiLegacyBiosProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiUgaSplashProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiHiiProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiFormCallbackProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiDataHubProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiFormBrowserProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiConsoleControlProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiCpuIoProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiUgaDrawProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiLoadFileProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiSimpleFileSystemProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiDevicePathProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiBlockIoProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiSerialIoProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="ALWAYS_CONSUMED">
+      <ProtocolCName>gEfiGenericMemTestProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="SOMETIMES_CONSUMED">
+      <ProtocolCName>gEfiCpuArchProtocolGuid</ProtocolCName>
+    </Protocol>
+    <Protocol Usage="SOMETIMES_CONSUMED">
+      <ProtocolCName>gEfiDriverBindingProtocolGuid</ProtocolCName>
+    </Protocol>
+  </Protocols>
+  <DataHubs>
+    <DataHubRecord Usage="SOMETIMES_CONSUMED">
+      <DataHubCName>BiosVendor</DataHubCName>
+    </DataHubRecord>
+    <DataHubRecord Usage="SOMETIMES_CONSUMED">
+      <DataHubCName>SystemManufacturer</DataHubCName>
+    </DataHubRecord>
+    <DataHubRecord Usage="SOMETIMES_CONSUMED">
+      <DataHubCName>ProcessorVersion</DataHubCName>
+    </DataHubRecord>
+    <DataHubRecord Usage="SOMETIMES_CONSUMED">
+      <DataHubCName>ProcessorFrequency</DataHubCName>
+    </DataHubRecord>
+    <DataHubRecord Usage="SOMETIMES_CONSUMED">
+      <DataHubCName>MemoryArray</DataHubCName>
+    </DataHubRecord>
+    <DataHubRecord Usage="SOMETIMES_CONSUMED">
+      <DataHubCName>SerialIoDevice</DataHubCName>
+    </DataHubRecord>
+    <DataHubRecord Usage="SOMETIMES_CONSUMED">
+      <DataHubCName>SerialIoPort</DataHubCName>
+    </DataHubRecord>
+  </DataHubs>
+  <Guids>
+    <GuidCNames Usage="ALWAYS_CONSUMED">
+      <GuidCName>gEfiBootStateGuid</GuidCName>
+    </GuidCNames>
+    <GuidCNames Usage="ALWAYS_CONSUMED">
+      <GuidCName>gEfiGlobalVariableGuid</GuidCName>
+    </GuidCNames>
+    <GuidCNames Usage="ALWAYS_CONSUMED">
+      <GuidCName>gEfiFlashMapHobGuid</GuidCName>
+    </GuidCNames>
+    <GuidCNames Usage="ALWAYS_CONSUMED">
+      <GuidCName>gEfiFileSystemVolumeLabelInfoIdGuid</GuidCName>
+    </GuidCNames>
+    <GuidCNames Usage="ALWAYS_CONSUMED">
+      <GuidCName>gEfiFileInfoGuid</GuidCName>
+    </GuidCNames>
+  </Guids>
+  <Externs>
+    <Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>
+    <Specification>EDK_RELEASE_VERSION 0x00020000</Specification>
+  </Externs>
+</ModuleSurfaceArea>

EdkModulePkg/Library/EdkGenericPlatformBdsLib/FrontPage.c

@@ -0,0 +1,901 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  FrontPage.c
+
+Abstract:
+
+  FrontPage routines to handle the callbacks and browser calls
+  
+--*/
+
+#include "Bds.h"
+#include "FrontPage.h"
+#include "String.h"
+
+EFI_GUID                    mProcessorSubClass  = EFI_PROCESSOR_SUBCLASS_GUID;
+EFI_GUID                    mMemorySubClass     = EFI_MEMORY_SUBCLASS_GUID;
+EFI_GUID                    mMiscSubClass       = EFI_MISC_SUBCLASS_GUID;
+
+UINT16                      mLastSelection;
+EFI_HII_HANDLE              gFrontPageHandle;
+EFI_HANDLE                  FrontPageCallbackHandle;
+EFI_FORM_CALLBACK_PROTOCOL  FrontPageCallback;
+EFI_FORM_BROWSER_PROTOCOL   *gBrowser;
+UINTN                       gCallbackKey;
+BOOLEAN                     gConnectAllHappened = FALSE;
+
+extern EFI_HII_HANDLE       gFrontPageHandle;
+extern EFI_GUID             gBdsStringPackGuid;
+
+EFI_STATUS
+EFIAPI
+FrontPageCallbackRoutine (
+  IN EFI_FORM_CALLBACK_PROTOCOL       *This,
+  IN UINT16                           KeyValue,
+  IN EFI_IFR_DATA_ARRAY               *DataArray,
+  OUT EFI_HII_CALLBACK_PACKET         **Packet
+  )
+/*++
+
+Routine Description:
+
+  This is the function that is called to provide results data to the driver.  This data
+  consists of a unique key which is used to identify what data is either being passed back
+  or being asked for. 
+
+Arguments:
+
+  KeyValue -        A unique value which is sent to the original exporting driver so that it
+                    can identify the type of data to expect.  The format of the data tends to
+                    vary based on the op-code that geerated the callback.
+
+  Data -            A pointer to the data being sent to the original exporting driver.
+
+Returns: 
+
+--*/
+{
+  CHAR16        *LanguageString;
+  UINTN         Count;
+  CHAR16        UnicodeLang[3];
+  CHAR8         Lang[3];
+  EFI_STATUS    Status;
+  UINTN         Index;
+  CHAR16        *TmpStr;
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground;
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background;
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL Color;
+
+  SetMem (&Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
+  SetMem (&Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);
+  SetMem (&Color, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
+
+  Count = 0;
+
+  //
+  // The first 4 entries in the Front Page are to be GUARANTEED to remain constant so IHV's can
+  // describe to their customers in documentation how to find their setup information (namely
+  // under the device manager and specific buckets)
+  //
+  switch (KeyValue) {
+  case 0x0001:
+    //
+    // This is the continue - clear the screen and return an error to get out of FrontPage loop
+    //
+    gCallbackKey = 1;
+    break;
+
+  case 0x1234:
+    //
+    // Collect the languages from what our current Language support is based on our VFR
+    //
+    Hii->GetPrimaryLanguages (Hii, gFrontPageHandle, &LanguageString);
+
+    //
+    // Based on the DataArray->Data->Data value, we can determine
+    // which language was chosen by the user
+    //
+    for (Index = 0; Count != (UINTN) (((EFI_IFR_DATA_ENTRY *) (DataArray + 1))->Data); Index += 3) {
+      Count++;
+    }
+    //
+    // Preserve the choice the user made
+    //
+    mLastSelection = (UINT16) Count;
+
+    //
+    // The Language (in Unicode format) the user chose
+    //
+    CopyMem (UnicodeLang, &LanguageString[Index], 6);
+
+    //
+    // Convert Unicode to ASCII (Since the ISO standard assumes ASCII equivalent abbreviations
+    // we can be safe in converting this Unicode stream to ASCII without any loss in meaning.
+    //
+    for (Index = 0; Index < 3; Index++) {
+      Lang[Index] = (CHAR8) UnicodeLang[Index];
+    }
+
+    Status = gRT->SetVariable (
+                    L"Lang",
+                    &gEfiGlobalVariableGuid,
+                    EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
+                    3,
+                    Lang
+                    );
+
+    gBS->FreePool (LanguageString);
+    gCallbackKey = 2;
+    break;
+
+  case 0x1064:
+    //
+    // Boot Manager
+    //
+    gCallbackKey = 3;
+    break;
+
+  case 0x8567:
+    //
+    // Device Manager
+    //
+    gCallbackKey = 4;
+    break;
+
+  case 0x9876:
+    //
+    // Boot Maintenance Manager
+    //
+    gCallbackKey = 5;
+    break;
+
+  case 0xFFFE:
+
+    break;
+
+  case 0xFFFF:
+    //
+    // FrontPage TimeOut Callback
+    //
+    TmpStr = GetStringById (STRING_TOKEN (STR_START_BOOT_OPTION));
+    if (TmpStr != NULL) {
+      PlatformBdsShowProgress (
+        Foreground,
+        Background,
+        TmpStr,
+        Color,
+        (UINTN) (((EFI_IFR_DATA_ENTRY *) (DataArray+1))->Data),
+        0
+        );
+      gBS->FreePool (TmpStr);
+    }
+    break;
+
+  default:
+    gCallbackKey = 0;
+    break;
+  }
+
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+InitializeFrontPage (
+  BOOLEAN                         ReInitializeStrings
+  )
+/*++
+
+Routine Description:
+  
+  Initialize HII information for the FrontPage
+
+Arguments:
+  None
+            
+Returns:
+  EFI_SUCCESS       - The operation is successful.
+  EFI_DEVICE_ERROR  - If the dynamic opcode creation failed.
+
+--*/
+{
+  EFI_STATUS          Status;
+  EFI_HII_PACKAGES    *PackageList;
+  EFI_HII_UPDATE_DATA *UpdateData;
+  IFR_OPTION          *OptionList;
+  CHAR16              *LanguageString;
+  UINTN               OptionCount;
+  UINTN               Index;
+  STRING_REF          Token;
+  UINT16              Key;
+  CHAR8               AsciiLang[4];
+  CHAR16              UnicodeLang[4];
+  CHAR16              Lang[4];
+  CHAR16              *StringBuffer;
+  UINTN               BufferSize;
+  UINT8               *TempBuffer;
+
+  UpdateData  = NULL;
+  OptionList  = NULL;
+
+  if (ReInitializeStrings) {
+    //
+    // BugBug: Dont' use a goto
+    //
+    goto ReInitStrings;
+  }
+  //
+  // Go ahead and initialize the Device Manager
+  //
+  InitializeDeviceManager ();
+
+  //
+  // BugBug: if FrontPageVfrBin is generated by a tool, why are we patching it here
+  //
+  TempBuffer    = (UINT8 *) FrontPageVfrBin;
+  TempBuffer    = TempBuffer + sizeof (EFI_HII_PACK_HEADER);
+  TempBuffer    = (UINT8 *) &((EFI_IFR_FORM_SET *) TempBuffer)->NvDataSize;
+  *TempBuffer   = 1;
+
+  gCallbackKey  = 0;
+
+  PackageList   = PreparePackages (1, &gBdsStringPackGuid, FrontPageVfrBin);
+
+  Status        = Hii->NewPack (Hii, PackageList, &gFrontPageHandle);
+
+  gBS->FreePool (PackageList);
+
+  //
+  // There will be only one FormConfig in the system
+  // If there is another out there, someone is trying to install us
+  // again.  Fail that scenario.
+  //
+  Status = gBS->LocateProtocol (
+                  &gEfiFormBrowserProtocolGuid,
+                  NULL,
+                  (VOID**)&gBrowser
+                  );
+
+  //
+  // This example does not implement worker functions
+  // for the NV accessor functions.  Only a callback evaluator
+  //
+  FrontPageCallback.NvRead    = NULL;
+  FrontPageCallback.NvWrite   = NULL;
+  FrontPageCallback.Callback  = FrontPageCallbackRoutine;
+
+  //
+  // Install protocol interface
+  //
+  FrontPageCallbackHandle = NULL;
+  Status = gBS->InstallProtocolInterface (
+                  &FrontPageCallbackHandle,
+                  &gEfiFormCallbackProtocolGuid,
+                  EFI_NATIVE_INTERFACE,
+                  &FrontPageCallback
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+ReInitStrings:
+  //
+  // BugBug: This logic is in BdsInitLanguage. It should not be in two places!
+  //
+  BufferSize = 4;
+  Status = gRT->GetVariable (
+                  L"Lang",
+                  &gEfiGlobalVariableGuid,
+                  NULL,
+                  &BufferSize,
+                  AsciiLang
+                  );
+
+  for (Index = 0; Index < 3; Index++) {
+    UnicodeLang[Index] = (CHAR16) AsciiLang[Index];
+  }
+
+  UnicodeLang[3] = 0;
+
+  //
+  // Allocate space for creation of UpdateData Buffer
+  //
+  UpdateData = AllocateZeroPool (0x1000);
+  ASSERT (UpdateData != NULL);
+
+  OptionList = AllocateZeroPool (0x1000);
+  ASSERT (OptionList != NULL);
+
+  //
+  // Flag update pending in FormSet
+  //
+  UpdateData->FormSetUpdate = TRUE;
+  //
+  // Register CallbackHandle data for FormSet
+  //
+  UpdateData->FormCallbackHandle = (EFI_PHYSICAL_ADDRESS) (UINTN) FrontPageCallbackHandle;
+  UpdateData->FormUpdate  = FALSE;
+  UpdateData->FormTitle   = 0;
+  UpdateData->DataCount   = 1;
+
+  //
+  // Collect the languages from what our current Language support is based on our VFR
+  //
+  Hii->GetPrimaryLanguages (Hii, gFrontPageHandle, &LanguageString);
+
+  OptionCount = 0;
+
+  //
+  // Try for a 512 byte Buffer
+  //
+  BufferSize = 0x200;
+
+  //
+  // Allocate memory for our Form binary
+  //
+  StringBuffer = AllocateZeroPool (BufferSize);
+  ASSERT (StringBuffer != NULL);
+
+  for (Index = 0; LanguageString[Index] != 0; Index += 3) {
+    Token = 0;
+    CopyMem (Lang, &LanguageString[Index], 6);
+    Lang[3] = 0;
+
+    if (!StrCmp (Lang, UnicodeLang)) {
+      mLastSelection = (UINT16) OptionCount;
+    }
+
+    Status = Hii->GetString (Hii, gStringPackHandle, 1, TRUE, Lang, &BufferSize, StringBuffer);
+    Hii->NewString (Hii, NULL, gStringPackHandle, &Token, StringBuffer);
+    CopyMem (&OptionList[OptionCount].StringToken, &Token, sizeof (UINT16));
+    CopyMem (&OptionList[OptionCount].Value, &OptionCount, sizeof (UINT16));
+    Key = 0x1234;
+    CopyMem (&OptionList[OptionCount].Key, &Key, sizeof (UINT16));
+    OptionList[OptionCount].Flags = EFI_IFR_FLAG_INTERACTIVE | EFI_IFR_FLAG_NV_ACCESS;
+    OptionCount++;
+  }
+
+  gBS->FreePool (LanguageString);
+
+  if (ReInitializeStrings) {
+    gBS->FreePool (StringBuffer);
+    gBS->FreePool (OptionList);
+    return EFI_SUCCESS;
+  }
+
+  Status = CreateOneOfOpCode (
+            FRONT_PAGE_QUESTION_ID,                               // Question ID
+            FRONT_PAGE_DATA_WIDTH,                                // Data Width
+            (STRING_REF) STRING_TOKEN (STR_LANGUAGE_SELECT),      // Prompt Token
+            (STRING_REF) STRING_TOKEN (STR_LANGUAGE_SELECT_HELP), // Help Token
+            OptionList,       // List of Options
+            OptionCount,      // Number of Options
+            &UpdateData->Data // Data Buffer
+            );
+
+  //
+  // Assign the number of options and the oneof and endoneof op-codes to count
+  //
+  UpdateData->DataCount = (UINT8) (OptionCount + 2);
+
+  Hii->UpdateForm (Hii, gFrontPageHandle, (EFI_FORM_LABEL) 0x0002, TRUE, UpdateData);
+
+  gBS->FreePool (UpdateData);
+  //
+  // gBS->FreePool (OptionList);
+  //
+  gBS->FreePool (StringBuffer);
+  return Status;
+}
+
+EFI_STATUS
+CallFrontPage (
+  VOID
+  )
+/*++
+
+Routine Description:
+  
+  Call the browser and display the front page
+
+Arguments:
+  
+  None
+  
+Returns:
+
+--*/
+{
+  EFI_STATUS  Status;
+  UINT8       FakeNvRamMap[1];
+  BOOLEAN     FrontPageMenuResetRequired;
+
+  //
+  // Begin waiting for USER INPUT
+  //
+  REPORT_STATUS_CODE (
+        EFI_PROGRESS_CODE,
+        (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_PC_INPUT_WAIT)
+        );
+
+  FakeNvRamMap[0] = (UINT8) mLastSelection;
+  FrontPageMenuResetRequired = FALSE;
+  Status = gBrowser->SendForm (
+                      gBrowser,
+                      TRUE,                     // Use the database
+                      &gFrontPageHandle,        // The HII Handle
+                      1,
+                      NULL,
+                      FrontPageCallbackHandle,  // This is the handle that the interface to the callback was installed on
+                      FakeNvRamMap,
+                      NULL,
+                      &FrontPageMenuResetRequired
+                      );
+  //
+  // Check whether user change any option setting which needs a reset to be effective
+  //                      
+  if (FrontPageMenuResetRequired) {
+    EnableResetRequired ();
+  }
+
+  Hii->ResetStrings (Hii, gFrontPageHandle);
+
+  return Status;
+}
+
+EFI_STATUS
+GetStringFromToken (
+  IN      EFI_GUID                  *ProducerGuid,
+  IN      STRING_REF                Token,
+  OUT     CHAR16                    **String
+  )
+/*++
+
+Routine Description:
+  
+  Acquire the string associated with the ProducerGuid and return it.
+
+Arguments:
+  
+  ProducerGuid - The Guid to search the HII database for
+  Token - The token value of the string to extract
+  String - The string that is extracted
+  
+Returns:
+
+  EFI_SUCCESS - The function returns EFI_SUCCESS always.
+
+--*/
+{
+  EFI_STATUS      Status;
+  UINT16          HandleBufferLength;
+  EFI_HII_HANDLE  *HiiHandleBuffer;
+  UINTN           StringBufferLength;
+  UINTN           NumberOfHiiHandles;
+  UINTN           Index;
+  UINT16          Length;
+  EFI_GUID        HiiGuid;
+
+  //
+  // Initialize params.
+  //
+  HandleBufferLength  = 0;
+  HiiHandleBuffer     = NULL;
+
+  //
+  // Get all the Hii handles
+  //
+  Status = BdsLibGetHiiHandles (Hii, &HandleBufferLength, &HiiHandleBuffer);
+  ASSERT_EFI_ERROR (Status);
+
+  //
+  // Get the Hii Handle that matches the StructureNode->ProducerName
+  //
+  NumberOfHiiHandles = HandleBufferLength / sizeof (EFI_HII_HANDLE);
+  for (Index = 0; Index < NumberOfHiiHandles; Index++) {
+    Length = 0;
+    Status = ExtractDataFromHiiHandle (
+              HiiHandleBuffer[Index],
+              &Length,
+              NULL,
+              &HiiGuid
+              );
+    if (CompareGuid (ProducerGuid, &HiiGuid)) {
+      break;
+    }
+  }
+  //
+  // Find the string based on the current language
+  //
+  StringBufferLength  = 0x100;
+  *String             = AllocateZeroPool (0x100);
+  Status = Hii->GetString (
+                  Hii,
+                  HiiHandleBuffer[Index],
+                  Token,
+                  FALSE,
+                  NULL,
+                  &StringBufferLength,
+                  *String
+                  );
+
+  if (EFI_ERROR (Status)) {
+    gBS->FreePool (*String);
+    *String = GetStringById (STRING_TOKEN (STR_MISSING_STRING));
+  }
+
+  gBS->FreePool (HiiHandleBuffer);
+  return EFI_SUCCESS;
+}
+
+VOID
+ConvertProcessorToString (
+  IN  EFI_PROCESSOR_CORE_FREQUENCY_DATA *ProcessorFrequency,
+  OUT CHAR16                            **String
+  )
+/*++
+
+Routine Description:
+  
+  Convert Processor Frequency Data to a string
+
+Arguments:
+  
+  ProcessorFrequency - The frequency data to process
+  String - The string that is created
+  
+Returns:
+
+--*/
+{
+  CHAR16  *StringBuffer;
+  UINTN   Index;
+  UINT32  FreqMhz;
+
+  if (ProcessorFrequency->Exponent >= 6) {
+    FreqMhz = ProcessorFrequency->Value;
+    for (Index = 0; Index < (UINTN) (ProcessorFrequency->Exponent - 6); Index++) {
+      FreqMhz *= 10;
+    }
+  } else {
+    FreqMhz = 0;
+  }
+
+  StringBuffer = AllocateZeroPool (0x20);
+  ASSERT (StringBuffer != NULL);
+  Index = UnicodeValueToString (StringBuffer, LEFT_JUSTIFY, FreqMhz / 1000, 3);
+  StrCat (StringBuffer, L".");
+  UnicodeValueToString (StringBuffer + Index + 1, PREFIX_ZERO, (FreqMhz % 1000) / 10, 2);
+  StrCat (StringBuffer, L" GHz");
+
+  *String = (CHAR16 *) StringBuffer;
+
+  return ;
+}
+
+VOID
+ConvertMemorySizeToString (
+  IN  UINT32          MemorySize,
+  OUT CHAR16          **String
+  )
+/*++
+
+Routine Description:
+  
+  Convert Memory Size to a string
+
+Arguments:
+  
+  MemorySize - The size of the memory to process
+  String - The string that is created
+  
+Returns:
+
+--*/
+{
+  CHAR16  *StringBuffer;
+
+  StringBuffer = AllocateZeroPool (0x20);
+  ASSERT (StringBuffer != NULL);
+  UnicodeValueToString (StringBuffer, LEFT_JUSTIFY, MemorySize, 6);
+  StrCat (StringBuffer, L" MB RAM");
+
+  *String = (CHAR16 *) StringBuffer;
+
+  return ;
+}
+
+VOID
+UpdateFrontPageStrings (
+  VOID
+  )
+/*++
+
+Routine Description:
+  
+  Update the banner information for the Front Page based on DataHub information
+
+Arguments:
+  
+  None
+  
+Returns:
+
+--*/
+{
+  EFI_STATUS                        Status;
+  STRING_REF                        TokenToUpdate;
+  CHAR16                            *NewString;
+  UINT64                            MonotonicCount;
+  EFI_DATA_HUB_PROTOCOL             *DataHub;
+  EFI_DATA_RECORD_HEADER            *Record;
+  EFI_SUBCLASS_TYPE1_HEADER         *DataHeader;
+  EFI_MISC_BIOS_VENDOR_DATA         *BiosVendor;
+  EFI_MISC_SYSTEM_MANUFACTURER_DATA *SystemManufacturer;
+  EFI_PROCESSOR_VERSION_DATA        *ProcessorVersion;
+  EFI_PROCESSOR_CORE_FREQUENCY_DATA *ProcessorFrequency;
+  EFI_MEMORY_ARRAY_START_ADDRESS_DATA *MemoryArray;
+  CHAR8                             LangCode[3];
+  CHAR16                            Lang[3];
+  UINTN                             Size;
+  UINTN                             Index;
+  BOOLEAN                           Find[5];
+
+  ZeroMem (Find, sizeof (Find));
+
+  //
+  // Update Front Page strings
+  //
+  Status = gBS->LocateProtocol (
+                  &gEfiDataHubProtocolGuid,
+                  NULL,
+                  (VOID**)&DataHub
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  Size = 3;
+
+  Status = gRT->GetVariable (
+                  L"Lang",
+                  &gEfiGlobalVariableGuid,
+                  NULL,
+                  &Size,
+                  LangCode
+                  );
+
+  for (Index = 0; Index < 3; Index++) {
+    Lang[Index] = (CHAR16) LangCode[Index];
+  }
+
+  MonotonicCount  = 0;
+  Record          = NULL;
+  do {
+    Status = DataHub->GetNextRecord (DataHub, &MonotonicCount, NULL, &Record);
+    if (Record->DataRecordClass == EFI_DATA_RECORD_CLASS_DATA) {
+      DataHeader = (EFI_SUBCLASS_TYPE1_HEADER *) (Record + 1);
+      if (CompareGuid (&Record->DataRecordGuid, &mMiscSubClass) &&
+          (DataHeader->RecordType == EFI_MISC_BIOS_VENDOR_RECORD_NUMBER)
+          ) {
+        BiosVendor = (EFI_MISC_BIOS_VENDOR_DATA *) (DataHeader + 1);
+        GetStringFromToken (&Record->ProducerName, BiosVendor->BiosVersion, &NewString);
+        TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_BIOS_VERSION;
+        Hii->NewString (Hii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
+        gBS->FreePool (NewString);
+        Find[0] = TRUE;
+      }
+
+      if (CompareGuid (&Record->DataRecordGuid, &mMiscSubClass) &&
+          (DataHeader->RecordType == EFI_MISC_SYSTEM_MANUFACTURER_RECORD_NUMBER)
+          ) {
+        SystemManufacturer = (EFI_MISC_SYSTEM_MANUFACTURER_DATA *) (DataHeader + 1);
+        GetStringFromToken (&Record->ProducerName, SystemManufacturer->SystemProductName, &NewString);
+        TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_COMPUTER_MODEL;
+        Hii->NewString (Hii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
+        gBS->FreePool (NewString);
+        Find[1] = TRUE;
+      }
+
+      if (CompareGuid (&Record->DataRecordGuid, &mProcessorSubClass) &&
+          (DataHeader->RecordType == ProcessorVersionRecordType)
+          ) {
+        ProcessorVersion = (EFI_PROCESSOR_VERSION_DATA *) (DataHeader + 1);
+        GetStringFromToken (&Record->ProducerName, *ProcessorVersion, &NewString);
+        TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_CPU_MODEL;
+        Hii->NewString (Hii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
+        gBS->FreePool (NewString);
+        Find[2] = TRUE;
+      }
+
+      if (CompareGuid (&Record->DataRecordGuid, &mProcessorSubClass) &&
+          (DataHeader->RecordType == ProcessorCoreFrequencyRecordType)
+          ) {
+        ProcessorFrequency = (EFI_PROCESSOR_CORE_FREQUENCY_DATA *) (DataHeader + 1);
+        ConvertProcessorToString (ProcessorFrequency, &NewString);
+        TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_CPU_SPEED;
+        Hii->NewString (Hii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
+        gBS->FreePool (NewString);
+        Find[3] = TRUE;
+      }
+
+      if (CompareGuid (&Record->DataRecordGuid, &mMemorySubClass) &&
+          (DataHeader->RecordType == EFI_MEMORY_ARRAY_START_ADDRESS_RECORD_NUMBER)
+          ) {
+        MemoryArray = (EFI_MEMORY_ARRAY_START_ADDRESS_DATA *) (DataHeader + 1);
+        ConvertMemorySizeToString((UINT32)(RShiftU64((MemoryArray->MemoryArrayEndAddress - 
+                                  MemoryArray->MemoryArrayStartAddress + 1), 20)),
+                                  &NewString);
+        TokenToUpdate = (STRING_REF) STR_FRONT_PAGE_MEMORY_SIZE;
+        Hii->NewString (Hii, Lang, gFrontPageHandle, &TokenToUpdate, NewString);
+        gBS->FreePool (NewString);
+        Find[4] = TRUE;
+      }
+    }
+  } while (!EFI_ERROR (Status) && (MonotonicCount != 0) && !(Find[0] && Find[1] && Find[2] && Find[3] && Find[4]));
+
+  return ;
+}
+
+VOID
+PlatformBdsEnterFrontPage (
+  IN UINT16                       TimeoutDefault,
+  IN BOOLEAN                      ConnectAllHappened
+  )
+/*++
+
+Routine Description:
+  This function is the main entry of the platform setup entry.
+  The function will present the main menu of the system setup, 
+  this is the platform reference part and can be customize.
+  
+Arguments:
+  TimeoutDefault     - The fault time out value before the system
+                       continue to boot.
+  ConnectAllHappened - The indicater to check if the connect all have
+                       already happended.
+  
+Returns:
+  None
+
+--*/
+{
+  EFI_STATUS                    Status;
+  EFI_HII_UPDATE_DATA           *UpdateData;
+  EFI_CONSOLE_CONTROL_PROTOCOL  *ConsoleControl;
+
+  //
+  // Indicate if we need connect all in the platform setup
+  //
+  if (ConnectAllHappened) {
+    gConnectAllHappened = TRUE;
+  }
+  //
+  // Allocate space for creation of Buffer
+  //
+  UpdateData = AllocateZeroPool (0x1000);
+  ASSERT (UpdateData != NULL);
+
+  UpdateData->FormSetUpdate       = FALSE;
+  UpdateData->FormCallbackHandle  = 0;
+  UpdateData->FormUpdate          = FALSE;
+  UpdateData->FormTitle           = 0;
+  UpdateData->DataCount           = 1;
+
+  //
+  // Remove Banner Op-code if any at this label
+  //
+  Hii->UpdateForm (Hii, gFrontPageHandle, (EFI_FORM_LABEL) 0xFFFF, FALSE, UpdateData);
+
+  //
+  // Create Banner Op-code which reflects correct timeout value
+  //
+  CreateBannerOpCode (
+    STRING_TOKEN (STR_TIME_OUT_PROMPT),
+    TimeoutDefault,
+    (UINT8) EFI_IFR_BANNER_TIMEOUT,
+    &UpdateData->Data
+    );
+
+  //
+  // Add Banner Op-code at this label
+  //
+  Hii->UpdateForm (Hii, gFrontPageHandle, (EFI_FORM_LABEL) 0xFFFF, TRUE, UpdateData);
+
+  do {
+
+    InitializeFrontPage (TRUE);
+
+    //
+    // Update Front Page strings
+    //
+    UpdateFrontPageStrings ();
+
+    gCallbackKey = 0;
+    PERF_START (0, "BdsTimeOut", "BDS", 0);
+    Status = CallFrontPage ();
+    PERF_END (0, "BdsTimeOut", "BDS", 0);
+
+    //
+    // If gCallbackKey is greater than 1 and less or equal to 5,
+    // it will lauch configuration utilities.
+    // 2 = set language
+    // 3 = boot manager
+    // 4 = device manager
+    // 5 = boot maintainenance manager
+    //
+    if ((gCallbackKey > 0x0001) && (gCallbackKey <= 0x0005)) {
+      REPORT_STATUS_CODE (
+            EFI_PROGRESS_CODE,
+            (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_PC_USER_SETUP)
+            );
+    }
+    //
+    // Based on the key that was set, we can determine what to do
+    //
+    switch (gCallbackKey) {
+    //
+    // The first 4 entries in the Front Page are to be GUARANTEED to remain constant so IHV's can
+    // describe to their customers in documentation how to find their setup information (namely
+    // under the device manager and specific buckets)
+    //
+    // These entries consist of the Continue, Select language, Boot Manager, and Device Manager
+    //
+    case 0x0001:
+      //
+      // User hit continue
+      //
+      break;
+
+    case 0x0002:
+      //
+      // User made a language setting change - display front page again
+      //
+      break;
+
+    case 0x0003:
+      //
+      // User chose to run the Boot Manager
+      //
+      CallBootManager ();
+      break;
+
+    case 0x0004:
+      //
+      // Display the Device Manager
+      //
+      do {
+        CallDeviceManager();
+      } while (gCallbackKey == 4);
+      break;
+
+    case 0x0005:
+      //
+      // Display the Boot Maintenance Manager
+      //
+      BdsStartBootMaint ();
+      break;
+    }
+
+  } while ((Status == EFI_SUCCESS) && (gCallbackKey != 1));
+
+  //
+  //Will leave browser, check any reset required change is applied? if yes, reset system
+  //
+  SetupResetReminder ();
+  
+  //
+  // Automatically load current entry
+  // Note: The following lines of code only execute when Auto boot
+  // takes affect
+  //
+  Status = gBS->LocateProtocol (&gEfiConsoleControlProtocolGuid, NULL, (VOID**)&ConsoleControl);
+  ConsoleControl->SetMode (ConsoleControl, EfiConsoleControlScreenText);
+
+}

EdkModulePkg/Library/EdkGenericPlatformBdsLib/FrontPage.h

@@ -0,0 +1,94 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  FrontPage.h
+
+Abstract:
+
+  FrontPage routines to handle the callbacks and browser calls
+
+Revision History
+
+--*/
+
+#ifndef _FRONT_PAGE_H
+#define _FRONT_PAGE_H
+
+#include "DeviceMngr/DeviceManager.h"
+#include "BootMaint/BootMaint.h"
+#include "BootMngr/BootManager.h"
+
+//
+// This is the VFR compiler generated header file which defines the
+// string identifiers.
+//
+#include "EdkGenericPlatformBdsLibStrDefs.h"
+#define EFI_DISK_DEVICE_CLASS           0x01
+#define EFI_VIDEO_DEVICE_CLASS          0x02
+#define EFI_NETWORK_DEVICE_CLASS        0x04
+#define EFI_INPUT_DEVICE_CLASS          0x08
+#define EFI_ON_BOARD_DEVICE_CLASS       0x10
+#define EFI_OTHER_DEVICE_CLASS          0x20
+#define EFI_VBIOS_CLASS                 0x40
+
+#define SET_VIDEO_BIOS_TYPE_QUESTION_ID 0x00
+
+#pragma pack(1)
+typedef struct {
+  UINT8 VideoBIOS;
+} MyDevMgrIfrNVData;
+#pragma pack()
+
+#define EFI_FP_CALLBACK_DATA_SIGNATURE  EFI_SIGNATURE_32 ('F', 'P', 'C', 'B')
+#define EFI_FP_CALLBACK_DATA_FROM_THIS(a) \
+  CR (a, \
+      EFI_FRONTPAGE_CALLBACK_INFO, \
+      DevMgrCallback, \
+      EFI_FP_CALLBACK_DATA_SIGNATURE \
+      )
+
+typedef struct {
+  UINTN                       Signature;
+  MyDevMgrIfrNVData           Data;
+  EFI_HII_HANDLE              DevMgrHiiHandle;
+  EFI_HANDLE                  CallbackHandle;
+  EFI_FORM_CALLBACK_PROTOCOL  DevMgrCallback;
+} EFI_FRONTPAGE_CALLBACK_INFO;
+
+//
+// These are the VFR compiler generated data representing our VFR data.
+//
+// BugBug: we should put g in front of these tool generated globals.
+//         maybe even gVrf would be a better prefix
+//
+extern UINT8  FrontPageVfrBin[];
+extern UINT8  FrontPageStringsStr[];
+extern UINT8  DeviceManagerVfrBin[];
+extern UINT8  DeviceManagerStringsStr[];
+
+#define FRONT_PAGE_QUESTION_ID  0x0000
+#define FRONT_PAGE_DATA_WIDTH   0x01
+
+EFI_STATUS
+InitializeFrontPage (
+  IN BOOLEAN    ReInitializeStrings
+  );
+
+BOOLEAN
+TimeCompare (
+  IN EFI_TIME               *FirstTime,
+  IN EFI_TIME               *SecondTime
+  );
+
+#endif // _FRONT_PAGE_H_
+

EdkModulePkg/Library/EdkGenericPlatformBdsLib/FrontPageVfr.Vfr

@@ -0,0 +1,159 @@
+// *++
+//
+// Copyright (c) 2006, Intel Corporation                                                         
+// All rights reserved. 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.             
+// 
+// Module Name:
+//
+//   FrontPageVfr.vfr 
+// 
+// Abstract:
+// 
+//   Browser formset.
+// 
+// Revision History: 
+// 
+// --*/
+
+#include "EdkGenericPlatformBdsLibStrDefs.h"
+
+#define FORMSET_GUID  { 0x9e0c30bc, 0x3f06, 0x4ba6, { 0x82, 0x88, 0x9, 0x17, 0x9b, 0x85, 0x5d, 0xbe } }
+
+#define FRONT_PAGE_ITEM_ONE    0x0001
+#define FRONT_PAGE_ITEM_TWO    0x0002
+#define FRONT_PAGE_ITEM_THREE  0x0003
+#define FRONT_PAGE_ITEM_FOUR   0x0004
+#define FRONT_PAGE_ITEM_FIVE   0x0005
+
+#define FRONT_PAGE_TIMEOUT     0xFFFF
+#define FRONT_PAGE_CLASS       0x0000
+#define FRONT_PAGE_SUBCLASS    0x0002
+
+formset 
+  guid     = FORMSET_GUID,
+  title    = STRING_TOKEN(STR_FRONT_PAGE_TITLE),  
+  help     = STRING_TOKEN(STR_NULL_STRING),
+  class    = FRONT_PAGE_CLASS,      
+  subclass = FRONT_PAGE_SUBCLASS,
+
+  form formid = 0x1000,
+       title  = STRING_TOKEN(STR_FRONT_PAGE_TITLE);
+
+    banner 
+      title = STRING_TOKEN(STR_FRONT_PAGE_COMPUTER_MODEL),
+      line  0,
+      align left;
+    
+    banner 
+      title = STRING_TOKEN(STR_FRONT_PAGE_CPU_MODEL),
+      line  1,
+      align left;
+    
+    banner 
+      title = STRING_TOKEN(STR_FRONT_PAGE_CPU_SPEED),
+      line  1,
+      align right;
+    
+    banner 
+      title = STRING_TOKEN(STR_FRONT_PAGE_BIOS_VERSION),
+      line  2,
+      align left;
+    
+    banner 
+      title = STRING_TOKEN(STR_FRONT_PAGE_MEMORY_SIZE),
+      line  2,
+      align right;
+
+//    banner 
+//      title = STRING_TOKEN(STR_FRONT_PAGE_BANNER_0_LEFT),
+//      line  0,
+//      align left;
+    
+//    banner 
+//      title = STRING_TOKEN(STR_FRONT_PAGE_BANNER_0_RIGHT),
+//      line  0,
+//      align right;
+    
+//    banner 
+//      title = STRING_TOKEN(STR_FRONT_PAGE_BANNER_1_LEFT),
+//      line  1,
+//      align left;
+    
+//    banner 
+//      title = STRING_TOKEN(STR_FRONT_PAGE_BANNER_1_RIGHT),
+//      line  1,
+//      align right;
+    
+//    banner 
+//      title = STRING_TOKEN(STR_FRONT_PAGE_BANNER_2_LEFT),
+//      line  2,
+//      align left;
+    
+//    banner 
+//      title = STRING_TOKEN(STR_FRONT_PAGE_BANNER_3_LEFT),
+//      line  3,
+//      align left;
+
+    goto FRONT_PAGE_ITEM_ONE, 
+      prompt  = STRING_TOKEN(STR_CONTINUE_PROMPT), 
+      help    = STRING_TOKEN(STR_CONTINUE_HELP),
+      flags   = INTERACTIVE | NV_ACCESS, 
+      key     = 0x0001;
+
+    label FRONT_PAGE_ITEM_TWO;
+    //
+    // This is where we will dynamically add a OneOf type op-code to select Languages from the
+    // currently available choices
+    //
+
+    goto FRONT_PAGE_ITEM_THREE, 
+      prompt  = STRING_TOKEN(STR_BOOT_MANAGER), 
+      help    = STRING_TOKEN(STR_BOOT_MANAGER_HELP),
+      flags   = INTERACTIVE | NV_ACCESS, 
+      key     = 0x1064;
+
+    goto FRONT_PAGE_ITEM_FOUR, 
+      prompt  = STRING_TOKEN(STR_DEVICE_MANAGER), 
+      help    = STRING_TOKEN(STR_DEVICE_MANAGER_HELP),
+      flags   = INTERACTIVE | NV_ACCESS, 
+      key     = 0x8567;
+
+    goto FRONT_PAGE_ITEM_FIVE, 
+      prompt  = STRING_TOKEN(STR_BOOT_MAINT_MANAGER), 
+      help    = STRING_TOKEN(STR_BOOT_MAINT_MANAGER_HELP),
+      flags   = INTERACTIVE | NV_ACCESS, 
+      key     = 0x9876;
+
+    label FRONT_PAGE_TIMEOUT;
+//  If one wanted to hard-code a value one could do it below, but our implementation follows EFI architecture
+//  and honors the TimeOut NV variable
+//
+//    banner
+//      title = STRING_TOKEN(STR_TIME_OUT_PROMPT),
+//      timeout = 0x000A;
+    
+  endform;
+
+  form formid = FRONT_PAGE_ITEM_ONE,
+       title  = STRING_TOKEN(STR_FRONT_PAGE_TITLE);  
+  endform;
+
+  form formid = FRONT_PAGE_ITEM_THREE,
+       title  = STRING_TOKEN(STR_FRONT_PAGE_TITLE);  
+  endform;
+
+  form formid = FRONT_PAGE_ITEM_FOUR,
+       title  = STRING_TOKEN(STR_FRONT_PAGE_TITLE);  
+  endform;
+
+  form formid = FRONT_PAGE_ITEM_FIVE,
+       title  = STRING_TOKEN(STR_FRONT_PAGE_TITLE);  
+  endform;
+
+endformset;

EdkModulePkg/Library/EdkGenericPlatformBdsLib/Language.c

@@ -0,0 +1,435 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  language.c
+
+Abstract:
+
+ Language settings
+  
+Revision History
+
+--*/
+
+#include "String.h"
+#include "Language.h"
+
+#define NARROW_GLYPH_NUMBER 8
+#define WIDE_GLYPH_NUMBER   75
+
+//
+// Default language code, currently is English
+//
+CHAR8 *mDefaultLangCode = "eng";
+
+typedef struct {
+  EFI_HII_FONT_PACK FixedLength;
+  EFI_NARROW_GLYPH  NarrowArray[NARROW_GLYPH_NUMBER];
+  EFI_WIDE_GLYPH    WideArray[WIDE_GLYPH_NUMBER];
+} FONT_PACK;
+
+FONT_PACK mFontPack = {
+  {
+    {
+      sizeof (EFI_HII_FONT_PACK) + (NARROW_GLYPH_NUMBER * sizeof (EFI_NARROW_GLYPH)) + (WIDE_GLYPH_NUMBER * sizeof (EFI_WIDE_GLYPH)),
+      EFI_HII_FONT
+    },
+    NARROW_GLYPH_NUMBER,
+    WIDE_GLYPH_NUMBER
+  },
+  {     // Narrow Glyphs
+    {
+      0x05d0,
+      0x00,
+      {
+        0x00,
+        0x00,
+        0x00,
+        0x4E,
+        0x6E,
+        0x62,
+        0x32,
+        0x32,
+        0x3C,
+        0x68,
+        0x4C,
+        0x4C,
+        0x46,
+        0x76,
+        0x72,
+        0x00,
+        0x00,
+        0x00,
+        0x00
+      }
+    },
+    {
+      0x05d1,
+      0x00,
+      {
+        0x00,
+        0x00,
+        0x00,
+        0x78,
+        0x7C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x7E,
+        0x7E,
+        0x00,
+        0x00,
+        0x00,
+        0x00
+      }
+    },
+    {
+      0x05d2,
+      0x00,
+      {
+        0x00,
+        0x00,
+        0x00,
+        0x78,
+        0x7C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x1C,
+        0x3E,
+        0x66,
+        0x66,
+        0x00,
+        0x00,
+        0x00,
+        0x00
+      }
+    },
+    {
+      0x05d3,
+      0x00,
+      {
+        0x00,
+        0x00,
+        0x00,
+        0x7E,
+        0x7E,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x00,
+        0x00,
+        0x00,
+        0x00
+      }
+    },
+    {
+      0x05d4,
+      0x00,
+      {
+        0x00,
+        0x00,
+        0x00,
+        0x7C,
+        0x7E,
+        0x06,
+        0x06,
+        0x06,
+        0x06,
+        0x66,
+        0x66,
+        0x66,
+        0x66,
+        0x66,
+        0x66,
+        0x00,
+        0x00,
+        0x00,
+        0x00
+      }
+    },
+    {
+      0x05d5,
+      0x00,
+      {
+        0x00,
+        0x00,
+        0x00,
+        0x3C,
+        0x3C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x0C,
+        0x00,
+        0x00,
+        0x00,
+        0x00
+      }
+    },
+    {
+      0x05d6,
+      0x00,
+      {
+        0x00,
+        0x00,
+        0x00,
+        0x38,
+        0x38,
+        0x1E,
+        0x1E,
+        0x18,
+        0x18,
+        0x18,
+        0x18,
+        0x18,
+        0x18,
+        0x18,
+        0x18,
+        0x00,
+        0x00,
+        0x00,
+        0x00
+      }
+    },
+    {
+      0x0000,
+      0x00,
+      {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00
+      }
+    }
+  },
+  {     // Wide Glyphs
+    {
+      0x0020,
+      0x00,
+      {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00
+      },
+      {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00
+      },
+      {
+        0x00,
+        0x00,
+        0x00
+      }
+    },  //
+  }
+};
+
+VOID
+ExportFonts (
+  VOID
+  )
+/*++
+
+Routine Description:
+  Routine to export glyphs to the HII database.  This is in addition to whatever is defined in the Graphics Console driver.
+
+Arguments:
+  None
+            
+Returns:
+
+--*/
+{
+  EFI_HII_HANDLE    HiiHandle;
+  EFI_HII_PACKAGES  *PackageList;
+
+  PackageList = PreparePackages (1, NULL, &mFontPack);
+  //
+  // Register our Fonts into the global database
+  //
+  HiiHandle = 0;
+  Hii->NewPack (Hii, PackageList, &HiiHandle);
+
+  gBS->FreePool (PackageList);
+}
+
+VOID
+InitializeLanguage (
+  BOOLEAN LangCodesSettingRequired
+  )
+/*++
+
+Routine Description:
+  Determine the current language that will be used 
+  based on language related EFI Variables
+
+Arguments:
+  LangCodesSettingRequired - If required to set LangCode variable
+            
+Returns:
+
+--*/
+{
+  EFI_STATUS  Status;
+  UINTN       Index;
+  UINTN       Size;
+  CHAR8       LangCode[ISO_639_2_ENTRY_SIZE];
+  CHAR8       *LangCodes;
+  CHAR16      *LanguageString;
+
+  LanguageString  = NULL;
+  LangCodes       = NULL;
+
+  ExportFonts ();
+
+  //
+  // Collect the languages from what our current Language support is based on our VFR
+  //
+  Hii->GetPrimaryLanguages (Hii, gStringPackHandle, &LanguageString);
+
+  LangCodes = AllocatePool (StrLen (LanguageString));
+  ASSERT (LangCodes);
+
+  //
+  // Convert LanguageString from Unicode to EFI defined ASCII LangCodes
+  //
+  for (Index = 0; LanguageString[Index] != 0x0000; Index++) {
+    LangCodes[Index] = (CHAR8) LanguageString[Index];
+  }
+
+  LangCodes[Index] = 0;
+
+  if (LangCodesSettingRequired) {
+    Status = gRT->SetVariable (
+                    L"LangCodes",
+                    &gEfiGlobalVariableGuid,
+                    EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
+                    AsciiStrLen (LangCodes),
+                    LangCodes
+                    );
+  }
+  //
+  // Find current LangCode from Lang NV Variable
+  //
+  Size = ISO_639_2_ENTRY_SIZE;
+  Status = gRT->GetVariable (
+                  L"Lang",
+                  &gEfiGlobalVariableGuid,
+                  NULL,
+                  &Size,
+                  &LangCode
+                  );
+
+  if (!EFI_ERROR (Status)) {
+    Status = EFI_NOT_FOUND;
+    for (Index = 0; LangCodes[Index] != 0; Index += ISO_639_2_ENTRY_SIZE) {
+      if (CompareMem (&LangCodes[Index], LangCode, ISO_639_2_ENTRY_SIZE) == 0) {
+        Status = EFI_SUCCESS;
+        break;
+      }
+    }
+  }
+  //
+  // If we cannot get language code from Lang variable,
+  // or LangCode cannot be found from language table,
+  // set the mDefaultLangCode to Lang variable.
+  //
+  if (EFI_ERROR (Status)) {
+    Status = gRT->SetVariable (
+                    L"Lang",
+                    &gEfiGlobalVariableGuid,
+                    EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
+                    ISO_639_2_ENTRY_SIZE,
+                    mDefaultLangCode
+                    );
+  }
+
+  if (LangCodes) {
+    gBS->FreePool (LangCodes);
+  }
+
+  if (LanguageString != NULL) {
+    gBS->FreePool (LanguageString);
+  }
+
+}

EdkModulePkg/Library/EdkGenericPlatformBdsLib/Language.h

@@ -0,0 +1,36 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  Language.h
+
+Abstract:
+  
+  Language setting
+
+Revision History
+
+--*/
+
+#ifndef _LANGUAGE_H
+#define _LANGUAGE_H
+
+#ifndef ISO_639_2_ENTRY_SIZE
+#define ISO_639_2_ENTRY_SIZE  3
+#endif
+
+VOID
+InitializeLanguage (
+  BOOLEAN LangCodesSettingRequired
+  );
+
+#endif // _LANGUAGE_H_

EdkModulePkg/Library/EdkGenericPlatformBdsLib/MemoryTest.c

@@ -0,0 +1,430 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  MemoryTest.c
+
+Abstract:
+
+  Perform the platform memory test
+
+--*/
+
+#include "Bds.h"
+#include "String.h"
+
+//
+// BDS Platform Functions
+//
+EFI_STATUS
+PlatformBdsShowProgress (
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL TitleForeground,
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL TitleBackground,
+  IN CHAR16        *Title,
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL ProgressColor,
+  IN UINTN         Progress,
+  IN UINTN         PreviousValue
+  )
+/*++
+
+Routine Description:
+  
+  Show progress bar with title above it. It only works in UGA mode.
+
+Arguments:
+  
+  TitleForeground - Foreground color for Title.
+  TitleBackground - Background color for Title.
+  Title           - Title above progress bar.
+  ProgressColor   - Progress bar color.
+  Progress        - Progress (0-100)
+
+Returns: 
+  
+  EFI_STATUS      - Success update the progress bar
+
+--*/
+{
+  EFI_STATUS            Status;
+  EFI_GRAPHICS_OUTPUT_PROTOCOL   *GraphicsOutput;
+  EFI_UGA_DRAW_PROTOCOL *UgaDraw;
+  UINT32                SizeOfX;
+  UINT32                SizeOfY;
+  UINT32                ColorDepth;
+  UINT32                RefreshRate;
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL  Color;
+  UINTN                 BlockHeight;
+  UINTN                 BlockWidth;
+  UINTN                 BlockNum;
+  UINTN                 PosX;
+  UINTN                 PosY;
+  UINTN                 Index;
+
+  if (Progress > 100) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  UgaDraw = NULL;
+  Status = gBS->HandleProtocol (
+                  gST->ConsoleOutHandle,
+                  &gEfiGraphicsOutputProtocolGuid,
+                  (VOID**)&GraphicsOutput
+                  );
+  if (EFI_ERROR (Status)) {
+    GraphicsOutput = NULL;
+
+    Status = gBS->HandleProtocol (
+                    gST->ConsoleOutHandle,
+                    &gEfiUgaDrawProtocolGuid,
+                    (VOID**)&UgaDraw
+                    );
+    if (EFI_ERROR (Status)) {
+      return EFI_UNSUPPORTED;
+    }
+  }
+
+  if (GraphicsOutput != NULL) {
+    SizeOfX = GraphicsOutput->Mode->Info->HorizontalResolution;
+    SizeOfY = GraphicsOutput->Mode->Info->VerticalResolution;
+  } else {
+    Status = UgaDraw->GetMode (
+                        UgaDraw,
+                        &SizeOfX,
+                        &SizeOfY,
+                        &ColorDepth,
+                        &RefreshRate
+                        );
+    if (EFI_ERROR (Status)) {
+      return EFI_UNSUPPORTED;
+    }
+  }
+
+  BlockWidth  = SizeOfX / 100;
+  BlockHeight = SizeOfY / 50;
+
+  BlockNum    = Progress;
+
+  PosX        = 0;
+  PosY        = SizeOfY * 48 / 50;
+
+  if (BlockNum == 0) {
+    //
+    // Clear progress area
+    //
+    SetMem (&Color, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);
+
+    if (GraphicsOutput != NULL) {
+      Status = GraphicsOutput->Blt (
+                          GraphicsOutput,
+                          &Color,
+                          EfiBltVideoFill,
+                          0,
+                          0,
+                          0,
+                          PosY - GLYPH_HEIGHT - 1,
+                          SizeOfX,
+                          SizeOfY - (PosY - GLYPH_HEIGHT - 1),
+                          SizeOfX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
+                          );
+    } else {
+      Status = UgaDraw->Blt (
+                          UgaDraw,
+                          (EFI_UGA_PIXEL *) &Color,
+                          EfiUgaVideoFill,
+                          0,
+                          0,
+                          0,
+                          PosY - GLYPH_HEIGHT - 1,
+                          SizeOfX,
+                          SizeOfY - (PosY - GLYPH_HEIGHT - 1),
+                          SizeOfX * sizeof (EFI_UGA_PIXEL)
+                          );
+    }
+  }
+  //
+  // Show progress by drawing blocks
+  //
+  for (Index = PreviousValue; Index < BlockNum; Index++) {
+    PosX = Index * BlockWidth;
+    if (GraphicsOutput != NULL) {
+      Status = GraphicsOutput->Blt (
+                          GraphicsOutput,
+                          &ProgressColor,
+                          EfiBltVideoFill,
+                          0,
+                          0,
+                          PosX,
+                          PosY,
+                          BlockWidth - 1,
+                          BlockHeight,
+                          (BlockWidth) * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
+                          );
+    } else {
+      Status = UgaDraw->Blt (
+                          UgaDraw,
+                          (EFI_UGA_PIXEL *) &ProgressColor,
+                          EfiUgaVideoFill,
+                          0,
+                          0,
+                          PosX,
+                          PosY,
+                          BlockWidth - 1,
+                          BlockHeight,
+                          (BlockWidth) * sizeof (EFI_UGA_PIXEL)
+                          );
+    }
+  }
+
+  PrintXY (
+    (SizeOfX - StrLen (Title) * GLYPH_WIDTH) / 2,
+    PosY - GLYPH_HEIGHT - 1,
+    &TitleForeground,
+    &TitleBackground,
+    Title
+    );
+
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+BdsMemoryTest (
+  IN EXTENDMEM_COVERAGE_LEVEL Level
+  )
+/*++
+
+Routine Description:
+  
+  Perform the memory test base on the memory test intensive level, 
+  and update the memory resource.
+
+Arguments:
+  
+  Level  - The memory test intensive level.
+
+Returns: 
+  
+  EFI_STATUS      - Success test all the system memory and update
+                    the memory resource
+                    
+--*/
+{
+  EFI_STATUS                        Status;
+  EFI_STATUS                        InitStatus;
+  EFI_STATUS                        KeyStatus;
+  EFI_STATUS                        ReturnStatus;
+  BOOLEAN                           RequireSoftECCInit;
+  EFI_GENERIC_MEMORY_TEST_PROTOCOL  *GenMemoryTest;
+  UINT64                            TestedMemorySize;
+  UINT64                            TotalMemorySize;
+  UINTN                             TestPercent;
+  UINT64                            PreviousValue;
+  BOOLEAN                           ErrorOut;
+  BOOLEAN                           TestAbort;
+  EFI_INPUT_KEY                     Key;
+  CHAR16                            StrPercent[16];
+  CHAR16                            *StrTotalMemory;
+  CHAR16                            *Pos;
+  CHAR16                            *TmpStr;
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL     Foreground;
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL     Background;
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL     Color;
+  UINT8                             Value;
+  UINTN                             DataSize;
+
+  ReturnStatus = EFI_SUCCESS;
+  ZeroMem (&Key, sizeof (EFI_INPUT_KEY));
+
+  Pos = AllocatePool (128);
+
+  if (Pos == NULL) {
+    return ReturnStatus;
+  }
+
+  StrTotalMemory    = Pos;
+
+  TestedMemorySize  = 0;
+  TotalMemorySize   = 0;
+  PreviousValue     = 0;
+  ErrorOut          = FALSE;
+  TestAbort         = FALSE;
+
+  SetMem (&Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
+  SetMem (&Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);
+  SetMem (&Color, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
+
+  RequireSoftECCInit = FALSE;
+
+  gST->ConOut->ClearScreen (gST->ConOut);
+  gST->ConOut->SetAttribute (gST->ConOut, EFI_YELLOW | EFI_BRIGHT);
+  gST->ConOut->EnableCursor (gST->ConOut, FALSE);
+
+  Status = gBS->LocateProtocol (
+                  &gEfiGenericMemTestProtocolGuid,
+                  NULL,
+                  (VOID**)&GenMemoryTest
+                  );
+  if (EFI_ERROR (Status)) {
+    gBS->FreePool (Pos);
+    return EFI_SUCCESS;
+  }
+
+  InitStatus = GenMemoryTest->MemoryTestInit (
+                                GenMemoryTest,
+                                Level,
+                                &RequireSoftECCInit
+                                );
+  if (InitStatus == EFI_NO_MEDIA) {
+    //
+    // The PEI codes also have the relevant memory test code to check the memory,
+    // it can select to test some range of the memory or all of them. If PEI code
+    // checks all the memory, this BDS memory test will has no not-test memory to
+    // do the test, and then the status of EFI_NO_MEDIA will be returned by
+    // "MemoryTestInit". So it does not need to test memory again, just return.
+    //
+    gBS->FreePool (Pos);
+    return EFI_SUCCESS;
+  }
+
+  gST->ConOut->SetCursorPosition (gST->ConOut, 0, 2);
+  TmpStr = GetStringById (STRING_TOKEN (STR_ESC_TO_SKIP_MEM_TEST));
+
+  if (TmpStr != NULL) {
+    gST->ConOut->OutputString (gST->ConOut, TmpStr);
+    gBS->FreePool (TmpStr);
+  }
+
+  do {
+    Status = GenMemoryTest->PerformMemoryTest (
+                              GenMemoryTest,
+                              &TestedMemorySize,
+                              &TotalMemorySize,
+                              &ErrorOut,
+                              TestAbort
+                              );
+    if (ErrorOut && (Status == EFI_DEVICE_ERROR)) {
+      TmpStr = GetStringById (STRING_TOKEN (STR_SYSTEM_MEM_ERROR));
+      if (TmpStr != NULL) {
+        PrintXY (10, 10, NULL, NULL, TmpStr);
+        gST->ConOut->SetCursorPosition (gST->ConOut, 0, 4);
+        gST->ConOut->OutputString (gST->ConOut, TmpStr);
+        gBS->FreePool (TmpStr);
+      }
+
+      ASSERT (0);
+    }
+
+    TestPercent = (UINTN) DivU64x32 (
+                            DivU64x32 (MultU64x32 (TestedMemorySize, 100), 16),
+                            (UINTN)DivU64x32 (TotalMemorySize, 16)
+                            );
+    if (TestPercent != PreviousValue) {
+      UnicodeValueToString (StrPercent, 0, TestPercent, 0);
+      gST->ConOut->SetCursorPosition (gST->ConOut, 0, 0);
+      TmpStr = GetStringById (STRING_TOKEN (STR_MEMORY_TEST_PERCENT));
+      if (TmpStr != NULL) {
+        BdsLibOutputStrings (gST->ConOut, StrPercent, TmpStr, NULL);
+        gBS->FreePool (TmpStr);
+      }
+
+      TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST));
+      if (TmpStr != NULL) {
+        PlatformBdsShowProgress (
+          Foreground,
+          Background,
+          TmpStr,
+          Color,
+          TestPercent,
+          (UINTN) PreviousValue
+          );
+        gBS->FreePool (TmpStr);
+      }
+    }
+
+    PreviousValue = TestPercent;
+
+    KeyStatus     = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
+    if (Key.ScanCode == SCAN_ESC) {
+      if (!RequireSoftECCInit) {
+        TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST));
+        if (TmpStr != NULL) {
+          PlatformBdsShowProgress (
+            Foreground,
+            Background,
+            TmpStr,
+            Color,
+            100,
+            (UINTN) PreviousValue
+            );
+          gBS->FreePool (TmpStr);
+        }
+
+        gST->ConOut->SetCursorPosition (gST->ConOut, 0, 0);
+        gST->ConOut->OutputString (gST->ConOut, L"100");
+        Status = GenMemoryTest->Finished (GenMemoryTest);
+        goto Done;
+      }
+
+      TestAbort = TRUE;
+    }
+  } while (Status != EFI_NOT_FOUND);
+
+  Status = GenMemoryTest->Finished (GenMemoryTest);
+
+Done:
+  UnicodeValueToString (StrTotalMemory, COMMA_TYPE, (UINTN) TotalMemorySize, 0);
+  if (StrTotalMemory[0] == L',') {
+    StrTotalMemory++;
+  }
+
+  TmpStr = GetStringById (STRING_TOKEN (STR_MEM_TEST_COMPLETED));
+  if (TmpStr != NULL) {
+    StrCat (StrTotalMemory, TmpStr);
+    gBS->FreePool (TmpStr);
+  }
+
+  gST->ConOut->ClearScreen (gST->ConOut);
+  gST->ConOut->SetAttribute (gST->ConOut, EFI_YELLOW | EFI_BRIGHT);
+  gST->ConOut->EnableCursor (gST->ConOut, FALSE);
+  gST->ConOut->OutputString (gST->ConOut, StrTotalMemory);
+  PlatformBdsShowProgress (
+    Foreground,
+    Background,
+    StrTotalMemory,
+    Color,
+    100,
+    (UINTN) PreviousValue
+    );
+
+  gBS->FreePool (Pos);
+
+  DataSize = sizeof (Value);
+  Status = gRT->GetVariable (
+                  L"BootState",
+                  &gEfiBootStateGuid,
+                  NULL,
+                  &DataSize,
+                  &Value
+                  );
+
+  if (EFI_ERROR (Status)) {
+    Value = 1;
+    gRT->SetVariable (
+          L"BootState",
+          &gEfiBootStateGuid,
+          EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
+          sizeof (Value),
+          &Value
+          );
+  }
+
+  return ReturnStatus;
+}

EdkModulePkg/Library/EdkGenericPlatformBdsLib/String.c

@@ -0,0 +1,136 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  string.c
+
+Abstract:
+
+  String support
+
+Revision History
+
+--*/
+
+#include "Bds.h"
+#include "String.h"
+#include "Language.h"
+
+extern UINT8  EdkGenericPlatformBdsLibStrings[];
+
+EFI_GUID      gBdsStringPackGuid = { 0x7bac95d3, 0xddf, 0x42f3, {0x9e, 0x24, 0x7c, 0x64, 0x49, 0x40, 0x37, 0x9a} };
+
+EFI_HII_HANDLE    gStringPackHandle;
+EFI_HII_PROTOCOL  *Hii;
+
+EFI_STATUS
+InitializeStringSupport (
+  VOID
+  )
+/*++
+
+Routine Description:
+  
+  Initialize HII global accessor for string support
+
+Arguments:
+  None
+
+Returns:
+  String from ID.
+
+--*/
+{
+  EFI_STATUS        Status;
+  EFI_HII_PACKAGES  *PackageList;
+  //
+  // There should only ever be one HII protocol
+  //
+  Status = gBS->LocateProtocol (
+                  &gEfiHiiProtocolGuid,
+                  NULL,
+                  (VOID**)&Hii
+                  );
+  if (!EFI_ERROR (Status)) {
+    PackageList = PreparePackages (1, &gBdsStringPackGuid, EdkGenericPlatformBdsLibStrings);
+    Status      = Hii->NewPack (Hii, PackageList, &gStringPackHandle);
+    gBS->FreePool (PackageList);
+  }
+
+  return Status;
+}
+
+CHAR16 *
+GetStringById (
+  IN  STRING_REF   Id
+  )
+/*++
+
+Routine Description:
+
+  Get string by string id from HII Interface
+
+Arguments:
+
+  Id       - String ID.
+           
+Returns:
+
+  CHAR16 * - String from ID.
+  NULL     - If error occurs.
+
+--*/
+{
+  CHAR16      *String;
+  UINTN       StringLength;
+  EFI_STATUS  Status;
+
+  //
+  // Set default string size assumption at no more than 256 bytes
+  //
+  StringLength  = 0x100;
+
+  String        = AllocateZeroPool (StringLength);
+  if (String == NULL) {
+    //
+    // If this happens, we are oh-so-dead, but return a NULL in any case.
+    //
+    return NULL;
+  }
+  //
+  // Get the current string for the current Language
+  //
+  Status = Hii->GetString (Hii, gStringPackHandle, Id, FALSE, NULL, &StringLength, String);
+  if (EFI_ERROR (Status)) {
+    if (Status == EFI_BUFFER_TOO_SMALL) {
+      //
+      // Free the old pool
+      //
+      gBS->FreePool (String);
+
+      //
+      // Allocate new pool with correct value
+      //
+      String = AllocatePool (StringLength);
+      ASSERT (String != NULL);
+
+      Status = Hii->GetString (Hii, gStringPackHandle, Id, FALSE, NULL, &StringLength, String);
+      if (!EFI_ERROR (Status)) {
+        return String;
+      }
+    }
+
+    return NULL;
+  }
+
+  return String;
+}

EdkModulePkg/Library/EdkGenericPlatformBdsLib/String.h

@@ -0,0 +1,59 @@
+/*++
+
+Copyright (c) 2006, Intel Corporation                                                         
+All rights reserved. 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.             
+
+Module Name:
+
+  string.h
+
+Abstract:
+  
+  String support
+
+Revision History
+
+--*/
+
+#ifndef _STRING_H_
+#define _STRING_H_
+
+//
+// This is the VFR compiler generated header file which defines the
+// string identifiers.
+//
+#include "EdkGenericPlatformBdsLibStrDefs.h"
+
+//
+// String Definition Guid for BDS Platform
+//
+#define EFI_BDS_PLATFORM_GUID \
+  { \
+    0x7777E939, 0xD57E, 0x4DCB, {0xA0, 0x8E, 0x64, 0xD7, 0x98, 0x57, 0x1E, 0x0F } \
+  }
+
+extern EFI_HII_HANDLE    gStringPackHandle;
+extern EFI_HII_PROTOCOL  *Hii;
+
+CHAR16            *
+GetStringById (
+  IN  STRING_REF   Id
+  );
+
+EFI_STATUS
+InitializeStringSupport (
+  VOID
+  );
+
+EFI_STATUS
+CallFrontPage (
+  VOID
+  );
+
+#endif // _STRING_H_