tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

EdkGenericPlatformBdsLib added 

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2368 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
tgingold 2007-02-12 23:40:29 +00:00
parent 8033e93148
commit 52657feb15
40 changed files with 15657 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
EdkModulePkg/Include/Library/EdkGenericPlatformBdsLib.h Normal file
View File

@ -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

27
EdkModulePkg/Library/EdkGenericPlatformBdsLib/Bds.dxs Normal file
View File

@ -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

44
EdkModulePkg/Library/EdkGenericPlatformBdsLib/Bds.h Normal file
View File

@ -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

103
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BdsBoot.c Normal file
View File

@ -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);
}
}

363
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BdsEntry.c Normal file
View File

@ -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);
}

1605
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/BBSsupport.c Normal file
View File

File diff suppressed because it is too large Load Diff

83
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/BBSsupport.h Normal file
View File

@ -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

495
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/Bm.vfr Normal file
View File

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

627
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/BmLib.c Normal file
View File

@ -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;
}

BIN
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/BmString.uni Normal file
View File

Binary file not shown.

1315
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/BootMaint.c Normal file
View File

File diff suppressed because it is too large Load Diff

1161
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/BootMaint.h Normal file
View File

File diff suppressed because it is too large Load Diff

1685
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/BootOption.c Normal file
View File

File diff suppressed because it is too large Load Diff

840
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/ConsoleOption.c Normal file
View File

@ -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;
}

324
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/Data.c Normal file
View File

@ -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
};

138
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/FE.vfr Normal file
View File

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

339
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/FileExplorer.c Normal file
View File

@ -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;
}

32
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/FormGuid.h Normal file
View File

@ -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 } \
}

1274
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/UpdatePage.c Normal file
View File

File diff suppressed because it is too large Load Diff

1278
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMaint/Variable.c Normal file
View File

File diff suppressed because it is too large Load Diff

355
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMngr/BootManager.c Normal file
View File

@ -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);
}
}

50
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMngr/BootManager.h Normal file
View File

@ -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

BIN
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMngr/BootManagerStrings.uni Normal file
View File

Binary file not shown.

55
EdkModulePkg/Library/EdkGenericPlatformBdsLib/BootMngr/BootManagerVfr.Vfr Normal file
View File

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

213
EdkModulePkg/Library/EdkGenericPlatformBdsLib/Capsules.c Normal file
View File

@ -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;
}

497
EdkModulePkg/Library/EdkGenericPlatformBdsLib/DeviceMngr/DeviceManager.c Normal file
View File

@ -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;
}

59
EdkModulePkg/Library/EdkGenericPlatformBdsLib/DeviceMngr/DeviceManager.h Normal file
View File

@ -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

BIN
EdkModulePkg/Library/EdkGenericPlatformBdsLib/DeviceMngr/DeviceManagerStrings.uni Normal file
View File

Binary file not shown.

75
EdkModulePkg/Library/EdkGenericPlatformBdsLib/DeviceMngr/DeviceManagerVfr.Vfr Normal file
View File

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

230
EdkModulePkg/Library/EdkGenericPlatformBdsLib/EdkGenericPlatformBdsLib.msa Normal file
View File

@ -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>

901
EdkModulePkg/Library/EdkGenericPlatformBdsLib/FrontPage.c Normal file
View File

@ -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);
}

94
EdkModulePkg/Library/EdkGenericPlatformBdsLib/FrontPage.h Normal file
View File

@ -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_

BIN
EdkModulePkg/Library/EdkGenericPlatformBdsLib/FrontPageStrings.uni Normal file
View File

Binary file not shown.

159
EdkModulePkg/Library/EdkGenericPlatformBdsLib/FrontPageVfr.Vfr Normal file
View File

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

435
EdkModulePkg/Library/EdkGenericPlatformBdsLib/Language.c Normal file
View File

@ -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);
}
}

36
EdkModulePkg/Library/EdkGenericPlatformBdsLib/Language.h Normal file
View File

@ -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_

430
EdkModulePkg/Library/EdkGenericPlatformBdsLib/MemoryTest.c Normal file
View File

@ -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;
}

136
EdkModulePkg/Library/EdkGenericPlatformBdsLib/String.c Normal file
View File

@ -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;
}

59
EdkModulePkg/Library/EdkGenericPlatformBdsLib/String.h Normal file
View File

@ -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_

BIN
EdkModulePkg/Library/EdkGenericPlatformBdsLib/Strings.uni Normal file
View File

Binary file not shown.