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

EdkGenericBdsLib and Logo removed, use EdkGenericPlatformBdsLib 

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2374 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
tgingold 2007-02-13 00:05:13 +00:00
parent d5c918e7e3
commit e8a5c66f4b
54 changed files with 207 additions and 22374 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
EdkUnixPkg/Dxe/PlatformBds/Generic/Bds.dxs → EdkUnixPkg/Dxe/PlatformBds/Bds.dxs
View File

90
EdkUnixPkg/Dxe/PlatformBds/BdsPlatform.c
View File

@ -20,11 +20,7 @@ Abstract:
--*/
#include "Generic/Bds.h"
#include "BdsPlatform.h"
#include "Generic/String.h"
#include "Generic/Language.h"
#include "Generic/FrontPage.h"
CHAR16 mFirmwareVendor[] = L"TianoCore.org";
@ -68,13 +64,6 @@ Returns:
//
gBS->CalculateCrc32 ((VOID *) gST, sizeof (EFI_SYSTEM_TABLE), &gST->Hdr.CRC32);
//
// Initialize the platform specific string and language
//
InitializeStringSupport ();
InitializeLanguage (TRUE);
InitializeFrontPage (FALSE);
}
EFI_STATUS
@ -413,85 +402,6 @@ Returns:
}
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);
}
}
EFI_STATUS
PlatformBdsNoConsoleAction (
VOID

83
EdkUnixPkg/Dxe/PlatformBds/Generic/Bds.h
View File

@ -1,83 +0,0 @@
/*++
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
//
// 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 \
)
//
// Prototypes
//
EFI_STATUS
EFIAPI
BdsInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
);
VOID
EFIAPI
BdsEntry (
IN EFI_BDS_ARCH_PROTOCOL *This
);
#endif

357
EdkUnixPkg/Dxe/PlatformBds/Generic/BdsEntry.c
View File

@ -1,357 +0,0 @@
/*++
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 "BdsPlatform.h"
#include "FrontPage.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);
//
// 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
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/BBSsupport.c
View File

File diff suppressed because it is too large Load Diff

83
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/BBSsupport.h
View File

@ -1,83 +0,0 @@
/*++
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 "Generic/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
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/Bm.vfr
View File

@ -1,495 +0,0 @@
// *++
//
// 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 "BdsStrDefs.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
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/BmLib.c
View File

@ -1,627 +0,0 @@
/*++
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
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/BmString.uni
View File

Binary file not shown.

1319
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/BootMaint.c
View File

File diff suppressed because it is too large Load Diff

1161
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/BootMaint.h
View File

File diff suppressed because it is too large Load Diff

1685
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/BootOption.c
View File

File diff suppressed because it is too large Load Diff

841
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/ConsoleOption.c
View File

@ -1,841 +0,0 @@
/*++
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
);
ASSERT (NewMenuEntry != NULL);
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
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/Data.c
View File

@ -1,324 +0,0 @@
/*++
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
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/FE.vfr
View File

@ -1,138 +0,0 @@
// *++
//
// 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 "BdsStrDefs.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;

340
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/FileExplorer.c
View File

@ -1,340 +0,0 @@
/*++
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 "Generic/Bds.h"
#include "BootMaint.h"
#include "BdsPlatform.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
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/FormGuid.h
View File

@ -1,32 +0,0 @@
// *++
//
// 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 } \
}

1275
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/UpdatePage.c
View File

File diff suppressed because it is too large Load Diff

1280
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMaint/Variable.c
View File

File diff suppressed because it is too large Load Diff

355
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMngr/BootManager.c
View File

@ -1,355 +0,0 @@
/*++
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 BdsStrings[];
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, BdsStrings);
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
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMngr/BootManager.h
View File

@ -1,50 +0,0 @@
/*++
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 "Generic/Bds.h"
#include "BdsPlatform.h"
#include "Generic/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
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMngr/BootManagerStrings.uni
View File

Binary file not shown.

55
EdkUnixPkg/Dxe/PlatformBds/Generic/BootMngr/BootManagerVfr.Vfr
View File

@ -1,55 +0,0 @@
// *++
//
// 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 "BdsStrDefs.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
EdkUnixPkg/Dxe/PlatformBds/Generic/Capsules.c
View File

@ -1,213 +0,0 @@
/*++
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
EdkUnixPkg/Dxe/PlatformBds/Generic/DeviceMngr/DeviceManager.c
View File

@ -1,497 +0,0 @@
/*++
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
EdkUnixPkg/Dxe/PlatformBds/Generic/DeviceMngr/DeviceManager.h
View File

@ -1,59 +0,0 @@
/*++
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 "Generic/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
EdkUnixPkg/Dxe/PlatformBds/Generic/DeviceMngr/DeviceManagerStrings.uni
View File

Binary file not shown.

75
EdkUnixPkg/Dxe/PlatformBds/Generic/DeviceMngr/DeviceManagerVfr.Vfr
View File

@ -1,75 +0,0 @@
// *++
//
// 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 "BdsStrDefs.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;

902
EdkUnixPkg/Dxe/PlatformBds/Generic/FrontPage.c
View File

@ -1,902 +0,0 @@
/*++
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 "BdsPlatform.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);
}

100
EdkUnixPkg/Dxe/PlatformBds/Generic/FrontPage.h
View File

@ -1,100 +0,0 @@
/*++
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 "Generic/DeviceMngr/DeviceManager.h"
#include "Generic/BootMaint/BootMaint.h"
#include "Generic/BootMngr/BootManager.h"
//
// This is the VFR compiler generated header file which defines the
// string identifiers.
//
#include "BdsStrDefs.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
);
VOID
PlatformBdsEnterFrontPage (
IN UINT16 TimeoutDefault,
IN BOOLEAN ConnectAllHappened
);
#endif // _FRONT_PAGE_H_

BIN
EdkUnixPkg/Dxe/PlatformBds/Generic/FrontPageStrings.uni
View File

Binary file not shown.

159
EdkUnixPkg/Dxe/PlatformBds/Generic/FrontPageVfr.Vfr
View File

@ -1,159 +0,0 @@
// *++
//
// 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 "BdsStrDefs.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
EdkUnixPkg/Dxe/PlatformBds/Generic/Language.c
View File

@ -1,435 +0,0 @@
/*++
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
EdkUnixPkg/Dxe/PlatformBds/Generic/Language.h
View File

@ -1,36 +0,0 @@
/*++
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_

431
EdkUnixPkg/Dxe/PlatformBds/Generic/MemoryTest.c
View File

@ -1,431 +0,0 @@
/*++
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 "BdsPlatform.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
EdkUnixPkg/Dxe/PlatformBds/Generic/String.c
View File

@ -1,136 +0,0 @@
/*++
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 BdsStrings[];
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, BdsStrings);
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
EdkUnixPkg/Dxe/PlatformBds/Generic/String.h
View File

@ -1,59 +0,0 @@
/*++
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 "BdsStrDefs.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
EdkUnixPkg/Dxe/PlatformBds/Generic/Strings.uni
View File

Binary file not shown.

56
EdkUnixPkg/Dxe/PlatformBds/PlatformBds.msa
View File

@ -1,14 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0">
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<MsaHeader>
<ModuleName>Bds</ModuleName>
<ModuleType>DXE_DRIVER</ModuleType>
<GuidValue>f392b762-8985-11db-be87-0040d02b1835</GuidValue>
<Version>1.0</Version>
<Abstract>Platfrom BDS driver</Abstract>
<Description>
Do platform action customized by IBV/OEM.
</Description>
<Description>Do platform action customized by IBV/OEM.</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
@ -78,48 +76,15 @@
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>HiiLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>EdkGenericPlatformBdsLib</Keyword>
</LibraryClass>
</LibraryClassDefinitions>
<SourceFiles>
<Filename>PlatformData.c</Filename>
<Filename>BdsPlatform.h</Filename>
<Filename>BdsPlatform.c</Filename>
<Filename>Generic/Bds.h</Filename>
<Filename>Generic/BdsEntry.c</Filename>
<Filename>Generic/FrontPage.h</Filename>
<Filename>Generic/FrontPage.c</Filename>
<Filename>Generic/FrontPageStrings.uni</Filename>
<Filename>Generic/FrontPageVfr.Vfr</Filename>
<Filename>Generic/Language.h</Filename>
<Filename>Generic/Language.c</Filename>
<Filename>Generic/String.h</Filename>
<Filename>Generic/String.c</Filename>
<Filename>Generic/Strings.uni</Filename>
<Filename>Generic/Capsules.c</Filename>
<Filename>Generic/MemoryTest.c</Filename>
<Filename>Generic/BootMaint/BmString.uni</Filename>
<Filename>Generic/BootMaint/Bm.vfr</Filename>
<Filename>Generic/BootMaint/BBSsupport.h</Filename>
<Filename>Generic/BootMaint/BootMaint.h</Filename>
<Filename>Generic/BootMaint/FormGuid.h</Filename>
<Filename>Generic/BootMaint/BmLib.c</Filename>
<Filename>Generic/BootMaint/BootOption.c</Filename>
<Filename>Generic/BootMaint/ConsoleOption.c</Filename>
<Filename>Generic/BootMaint/Data.c</Filename>
<Filename>Generic/BootMaint/Variable.c</Filename>
<Filename>Generic/BootMaint/UpdatePage.c</Filename>
<Filename>Generic/BootMaint/BBSsupport.c</Filename>
<Filename>Generic/BootMaint/BootMaint.c</Filename>
<Filename>Generic/BootMaint/FileExplorer.c</Filename>
<Filename>Generic/BootMaint/FE.vfr</Filename>
<Filename>Generic/BootMngr/BootManager.h</Filename>
<Filename>Generic/BootMngr/BootManager.c</Filename>
<Filename>Generic/BootMngr/BootManagerStrings.uni</Filename>
<Filename>Generic/BootMngr/BootManagerVfr.Vfr</Filename>
<Filename>Generic/DeviceMngr/DeviceManager.h</Filename>
<Filename>Generic/DeviceMngr/DeviceManager.c</Filename>
<Filename>Generic/DeviceMngr/DeviceManagerStrings.uni</Filename>
<Filename>Generic/DeviceMngr/DeviceManagerVfr.Vfr</Filename>
<Filename>Generic/Bds.dxs</Filename>
<Filename>Bds.dxs</Filename>
</SourceFiles>
<PackageDependencies>
<Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>
@ -181,6 +146,15 @@
<Protocol Usage="SOMETIMES_CONSUMED">
<ProtocolCName>gEfiDriverBindingProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="ALWAYS_CONSUMED">
<ProtocolCName>gEfiUnixThunkProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="ALWAYS_CONSUMED">
<ProtocolCName>gEfiUnixIoProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="ALWAYS_CONSUMED">
<ProtocolCName>gEfiUnixUgaIoProtocolGuid</ProtocolCName>
</Protocol>
</Protocols>
<DataHubs>
<DataHubRecord Usage="SOMETIMES_CONSUMED">

1
EdkUnixPkg/Dxe/PlatformBds/PlatformData.c
View File

@ -20,7 +20,6 @@ Abstract:
--*/
#include "Generic/Bds.h"
#include "BdsPlatform.h"
//

400
EdkUnixPkg/Include/Library/EdkGenericBdsLib.h
View File

@ -1,400 +0,0 @@
/*++
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:
BdsLib.h
Abstract:
BDS library definition, include the file and data structure
--*/
#ifndef _BDS_LIB_H_
#define _BDS_LIB_H_
extern EFI_HANDLE mBdsImageHandle;
//
// Constants which are variable names used to access variables
//
#define VarLegacyDevOrder L"LegacyDevOrder"
//
// Data structures and defines
//
#define FRONT_PAGE_QUESTION_ID 0x0000
#define FRONT_PAGE_DATA_WIDTH 0x01
//
// ConnectType
//
#define CONSOLE_OUT 0x00000001
#define STD_ERROR 0x00000002
#define CONSOLE_IN 0x00000004
#define CONSOLE_ALL (CONSOLE_OUT | CONSOLE_IN | STD_ERROR)
//
// Load Option Attributes defined in EFI Specification
//
#define LOAD_OPTION_ACTIVE 0x00000001
#define LOAD_OPTION_FORCE_RECONNECT 0x00000002
#define IS_LOAD_OPTION_TYPE(_c, _Mask) (BOOLEAN) (((_c) & (_Mask)) != 0)
//
// Define Maxmim characters that will be accepted
//
#define MAX_CHAR 480
#define MAX_CHAR_SIZE (MAX_CHAR * 2)
#define MIN_ALIGNMENT_SIZE 4
#define ALIGN_SIZE(a) ((a % MIN_ALIGNMENT_SIZE) ? MIN_ALIGNMENT_SIZE - (a % MIN_ALIGNMENT_SIZE) : 0)
//
// Define maximum characters for boot option variable "BootXXXX"
//
#define BOOT_OPTION_MAX_CHAR 10
//
// This data structure is the part of BDS_CONNECT_ENTRY that we can hard code.
//
#define BDS_LOAD_OPTION_SIGNATURE EFI_SIGNATURE_32 ('B', 'd', 'C', 'O')
typedef struct {
UINTN Signature;
LIST_ENTRY Link;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *OptionName;
UINTN OptionNumber;
UINT16 BootCurrent;
UINT32 Attribute;
CHAR16 *Description;
VOID *LoadOptions;
UINT32 LoadOptionsSize;
} BDS_COMMON_OPTION;
typedef struct {
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
UINTN ConnectType;
} BDS_CONSOLE_CONNECT_ENTRY;
//
// Lib Functions
//
//
// Bds boot relate lib functions
//
EFI_STATUS
BdsLibUpdateBootOrderList (
IN LIST_ENTRY *BdsOptionList,
IN CHAR16 *VariableName
);
VOID
BdsLibBootNext (
VOID
);
EFI_STATUS
BdsLibBootViaBootOption (
IN BDS_COMMON_OPTION * Option,
IN EFI_DEVICE_PATH_PROTOCOL * DevicePath,
OUT UINTN *ExitDataSize,
OUT CHAR16 **ExitData OPTIONAL
);
EFI_STATUS
BdsLibEnumerateAllBootOption (
IN OUT LIST_ENTRY *BdsBootOptionList
);
VOID
BdsLibBuildOptionFromHandle (
IN EFI_HANDLE Handle,
IN LIST_ENTRY *BdsBootOptionList
);
VOID
BdsLibBuildOptionFromShell (
IN EFI_HANDLE Handle,
IN LIST_ENTRY *BdsBootOptionList
);
//
// Bds misc lib functions
//
UINT16
BdsLibGetTimeout (
VOID
);
EFI_STATUS
BdsLibGetBootMode (
OUT EFI_BOOT_MODE *BootMode
);
VOID
BdsLibLoadDrivers (
IN LIST_ENTRY *BdsDriverLists
);
EFI_STATUS
BdsLibBuildOptionFromVar (
IN LIST_ENTRY *BdsCommonOptionList,
IN CHAR16 *VariableName
);
VOID *
BdsLibGetVariableAndSize (
IN CHAR16 *Name,
IN EFI_GUID *VendorGuid,
OUT UINTN *VariableSize
);
EFI_STATUS
BdsLibOutputStrings (
IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *ConOut,
...
);
BDS_COMMON_OPTION *
BdsLibVariableToOption (
IN OUT LIST_ENTRY *BdsCommonOptionList,
IN CHAR16 *VariableName
);
EFI_STATUS
BdsLibRegisterNewOption (
IN LIST_ENTRY *BdsOptionList,
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
IN CHAR16 *String,
IN CHAR16 *VariableName
);
//
// Bds connect or disconnect driver lib funcion
//
VOID
BdsLibConnectAllDriversToAllControllers (
VOID
);
VOID
BdsLibConnectAll (
VOID
);
EFI_STATUS
BdsLibConnectDevicePath (
IN EFI_DEVICE_PATH_PROTOCOL *DevicePathToConnect
);
EFI_STATUS
BdsLibConnectAllEfi (
VOID
);
EFI_STATUS
BdsLibDisconnectAllEfi (
VOID
);
//
// Bds console relate lib functions
//
VOID
BdsLibConnectAllConsoles (
VOID
);
EFI_STATUS
BdsLibConnectAllDefaultConsoles (
VOID
);
EFI_STATUS
BdsLibUpdateConsoleVariable (
IN CHAR16 *ConVarName,
IN EFI_DEVICE_PATH_PROTOCOL *CustomizedConDevicePath,
IN EFI_DEVICE_PATH_PROTOCOL *ExclusiveDevicePath
);
EFI_STATUS
BdsLibConnectConsoleVariable (
IN CHAR16 *ConVarName
);
//
// Bds device path relate lib functions
//
EFI_DEVICE_PATH_PROTOCOL *
BdsLibUnpackDevicePath (
IN EFI_DEVICE_PATH_PROTOCOL *DevPath
);
VOID
BdsLibSafeFreePool (
IN VOID *Buffer
);
EFI_DEVICE_PATH_PROTOCOL *
BdsLibDelPartMatchInstance (
IN EFI_DEVICE_PATH_PROTOCOL *Multi,
IN EFI_DEVICE_PATH_PROTOCOL *Single
);
BOOLEAN
BdsLibMatchDevicePaths (
IN EFI_DEVICE_PATH_PROTOCOL *Multi,
IN EFI_DEVICE_PATH_PROTOCOL *Single
);
CHAR16 *
DevicePathToStr (
EFI_DEVICE_PATH_PROTOCOL *DevPath
);
VOID *
EfiLibGetVariable (
IN CHAR16 *Name,
IN EFI_GUID *VendorGuid
);
//
// Internal definitions
//
typedef struct {
CHAR16 *str;
UINTN len;
UINTN maxlen;
} POOL_PRINT;
typedef struct {
UINT8 Type;
UINT8 SubType;
VOID (*Function) (POOL_PRINT *, VOID *);
} DEVICE_PATH_STRING_TABLE;
//
// Internal functions
//
EFI_STATUS
BdsBootByDiskSignatureAndPartition (
IN BDS_COMMON_OPTION * Option,
IN HARDDRIVE_DEVICE_PATH * HardDriveDevicePath,
IN UINT32 LoadOptionsSize,
IN VOID *LoadOptions,
OUT UINTN *ExitDataSize,
OUT CHAR16 **ExitData OPTIONAL
);
//
// Notes: EFI 64 shadow all option rom
//
#ifdef EFI64
#define EFI64_SHADOW_ALL_LEGACY_ROM() ShadowAllOptionRom ();
VOID
ShadowAllOptionRom();
#else
#define EFI64_SHADOW_ALL_LEGACY_ROM()
#endif
//
// BBS support macros and functions
//
#ifdef EFI32
#define REFRESH_LEGACY_BOOT_OPTIONS \
BdsDeleteAllInvalidLegacyBootOptions ();\
BdsAddNonExistingLegacyBootOptions (); \
BdsUpdateLegacyDevOrder ()
#else
#define REFRESH_LEGACY_BOOT_OPTIONS
#endif
EFI_STATUS
BdsDeleteAllInvalidLegacyBootOptions (
VOID
);
EFI_STATUS
BdsAddNonExistingLegacyBootOptions (
VOID
);
EFI_STATUS
BdsUpdateLegacyDevOrder (
VOID
);
EFI_STATUS
BdsRefreshBbsTableForBoot (
IN BDS_COMMON_OPTION *Entry
);
EFI_STATUS
BdsDeleteBootOption (
IN UINTN OptionNumber,
IN OUT UINT16 *BootOrder,
IN OUT UINTN *BootOrderSize
);
//
//The interface functions relate with Setup Browser Reset Reminder feature
//
VOID
EnableResetReminderFeature (
VOID
);
VOID
DisableResetReminderFeature (
VOID
);
VOID
EnableResetRequired (
VOID
);
VOID
DisableResetRequired (
VOID
);
BOOLEAN
IsResetReminderFeatureEnable (
VOID
);
BOOLEAN
IsResetRequired (
VOID
);
VOID
SetupResetReminder (
VOID
);
EFI_STATUS
BdsLibGetHiiHandles (
IN EFI_HII_PROTOCOL *Hii,
IN OUT UINT16 *HandleBufferLength,
OUT EFI_HII_HANDLE **HiiHandles
);
#endif // _BDS_LIB_H_

1097
EdkUnixPkg/Library/EdkGenericBdsLib/BdsBoot.c
View File

File diff suppressed because it is too large Load Diff

798
EdkUnixPkg/Library/EdkGenericBdsLib/BdsBoot.c.orig
View File

@ -1,798 +0,0 @@
/*++
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:
BdsBoot.c
Abstract:
BDS Lib functions which relate with create or process the boot
option.
--*/
#include "Performance.h"
BOOLEAN mEnumBootDevice = FALSE;
EFI_STATUS
BdsLibDoLegacyBoot (
IN BDS_COMMON_OPTION *Option
)
/*++
Routine Description:
Boot the legacy system with the boot option
Arguments:
Option - The legacy boot option which have BBS device path
Returns:
EFI_UNSUPPORTED - There is no legacybios protocol, do not support
legacy boot.
EFI_STATUS - Return the status of LegacyBios->LegacyBoot ().
--*/
{
EFI_STATUS Status;
EFI_LEGACY_BIOS_PROTOCOL *LegacyBios;
Status = gBS->LocateProtocol (&gEfiLegacyBiosProtocolGuid, NULL,
(void **)&LegacyBios);
if (EFI_ERROR (Status)) {
//
// If no LegacyBios protocol we do not support legacy boot
//
return EFI_UNSUPPORTED;
}
//
// Notes: if we seperate the int 19, then we don't need to refresh BBS
//
BdsRefreshBbsTableForBoot (Option);
//
// Write boot to OS performance data to a file
//
PERF_CODE (
WriteBootToOsPerformanceData ();
);
DEBUG ((EFI_D_INFO | EFI_D_LOAD, "Legacy Boot: %S\n", Option->Description));
return LegacyBios->LegacyBoot (
LegacyBios,
(BBS_BBS_DEVICE_PATH *) Option->DevicePath,
Option->LoadOptionsSize,
Option->LoadOptions
);
}
EFI_STATUS
BdsLibBootViaBootOption (
IN BDS_COMMON_OPTION * Option,
IN EFI_DEVICE_PATH_PROTOCOL * DevicePath,
OUT UINTN *ExitDataSize,
OUT CHAR16 **ExitData OPTIONAL
)
/*++
Routine Description:
Process the boot option follow the EFI 1.1 specification and
special treat the legacy boot option with BBS_DEVICE_PATH.
Arguments:
Option - The boot option need to be processed
DevicePath - The device path which describe where to load
the boot image or the legcy BBS device path
to boot the legacy OS
ExitDataSize - Returned directly from gBS->StartImage ()
ExitData - Returned directly from gBS->StartImage ()
Returns:
EFI_SUCCESS - Status from gBS->StartImage (),
or BdsBootByDiskSignatureAndPartition ()
EFI_NOT_FOUND - If the Device Path is not found in the system
--*/
{
EFI_STATUS Status;
EFI_HANDLE Handle;
EFI_HANDLE ImageHandle;
EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
EFI_DEVICE_PATH_PROTOCOL *FilePath;
EFI_LOADED_IMAGE_PROTOCOL *ImageInfo;
EFI_ACPI_S3_SAVE_PROTOCOL *AcpiS3Save;
*ExitDataSize = 0;
*ExitData = NULL;
//
// Notes: put EFI64 ROM Shadow Solution
//
EFI64_SHADOW_ALL_LEGACY_ROM ();
//
// Notes: this code can be remove after the s3 script table
// hook on the event EFI_EVENT_SIGNAL_READY_TO_BOOT or
// EFI_EVENT_SIGNAL_LEGACY_BOOT
//
Status = gBS->LocateProtocol (&gEfiAcpiS3SaveProtocolGuid, NULL,
(VOID **)&AcpiS3Save);
if (!EFI_ERROR (Status)) {
AcpiS3Save->S3Save (AcpiS3Save, NULL);
}
//
// If it's Device Path that starts with a hard drive path,
// this routine will do the booting.
//
Status = BdsBootByDiskSignatureAndPartition (
Option,
(HARDDRIVE_DEVICE_PATH *) DevicePath,
Option->LoadOptionsSize,
Option->LoadOptions,
ExitDataSize,
ExitData
);
if (!EFI_ERROR (Status)) {
//
// If we found a disk signature and partition device path return success
//
return EFI_SUCCESS;
}
EfiSignalEventReadyToBoot ();
//
// Set Boot Current
//
gRT->SetVariable (
L"BootCurrent",
&gEfiGlobalVariableGuid,
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
sizeof (UINT16),
&Option->BootCurrent
);
if ((DevicePathType (Option->DevicePath) == BBS_DEVICE_PATH) &&
(DevicePathSubType (Option->DevicePath) == BBS_BBS_DP)
) {
//
// Check to see if we should legacy BOOT. If yes then do the legacy boot
//
return BdsLibDoLegacyBoot (Option);
}
DEBUG ((EFI_D_INFO | EFI_D_LOAD, "Booting EFI 1.1 way %S\n", Option->Description));
Status = gBS->LoadImage (
TRUE,
mBdsImageHandle,
DevicePath,
NULL,
0,
&ImageHandle
);
//
// If we didn't find an image, we may need to load the default
// boot behavior for the device.
//
if (EFI_ERROR (Status)) {
//
// Find a Simple File System protocol on the device path. If the remaining
// device path is set to end then no Files are being specified, so try
// the removable media file name.
//
TempDevicePath = DevicePath;
Status = gBS->LocateDevicePath (
&gEfiSimpleFileSystemProtocolGuid,
&TempDevicePath,
&Handle
);
if (!EFI_ERROR (Status) && IsDevicePathEnd (TempDevicePath)) {
FilePath = FileDevicePath (Handle, EFI_REMOVABLE_MEDIA_FILE_NAME);
if (FilePath) {
Status = gBS->LoadImage (
TRUE,
mBdsImageHandle,
FilePath,
NULL,
0,
&ImageHandle
);
if (EFI_ERROR (Status)) {
//
// The DevicePath failed, and it's not a valid
// removable media device.
//
goto Done;
}
}
} else {
Status = EFI_NOT_FOUND;
}
}
if (EFI_ERROR (Status)) {
//
// It there is any error from the Boot attempt exit now.
//
goto Done;
}
//
// Provide the image with it's load options
//
Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid,
(VOID **) &ImageInfo);
ASSERT_EFI_ERROR (Status);
if (Option->LoadOptionsSize != 0) {
ImageInfo->LoadOptionsSize = Option->LoadOptionsSize;
ImageInfo->LoadOptions = Option->LoadOptions;
}
//
// Before calling the image, enable the Watchdog Timer for
// the 5 Minute period
//
gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);
Status = gBS->StartImage (ImageHandle, ExitDataSize, ExitData);
DEBUG ((EFI_D_INFO | EFI_D_LOAD, "Image Return Status = %r\n", Status));
//
// Clear the Watchdog Timer after the image returns
//
gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
Done:
//
// Clear Boot Current
//
gRT->SetVariable (
L"BootCurrent",
&gEfiGlobalVariableGuid,
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
0,
&Option->BootCurrent
);
return Status;
}
EFI_STATUS
BdsBootByDiskSignatureAndPartition (
IN BDS_COMMON_OPTION * Option,
IN HARDDRIVE_DEVICE_PATH * HardDriveDevicePath,
IN UINT32 LoadOptionsSize,
IN VOID *LoadOptions,
OUT UINTN *ExitDataSize,
OUT CHAR16 **ExitData OPTIONAL
)
/*++
Routine Description:
Check to see if a hard ware device path was passed in. If it was then search
all the block IO devices for the passed in hard drive device path.
Arguments:
Option - The current processing boot option.
HardDriveDevicePath - EFI Device Path to boot, if it starts with a hard
drive device path.
LoadOptionsSize - Passed into gBS->StartImage ()
via the loaded image protocol.
LoadOptions - Passed into gBS->StartImage ()
via the loaded image protocol.
ExitDataSize - returned directly from gBS->StartImage ()
ExitData - returned directly from gBS->StartImage ()
Returns:
EFI_SUCCESS - Status from gBS->StartImage (),
or BootByDiskSignatureAndPartition ()
EFI_NOT_FOUND - If the Device Path is not found in the system
--*/
{
EFI_STATUS Status;
UINTN BlockIoHandleCount;
EFI_HANDLE *BlockIoBuffer;
EFI_DEVICE_PATH_PROTOCOL *BlockIoDevicePath;
EFI_DEVICE_PATH_PROTOCOL *BlockIoHdDevicePath;
HARDDRIVE_DEVICE_PATH *TmpHdPath;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
UINTN Index;
BOOLEAN DevicePathMatch;
HARDDRIVE_DEVICE_PATH *TempPath;
*ExitDataSize = 0;
*ExitData = NULL;
if ( !((DevicePathType (&HardDriveDevicePath->Header) == MEDIA_DEVICE_PATH) &&
(DevicePathSubType (&HardDriveDevicePath->Header) == MEDIA_HARDDRIVE_DP))
) {
//
// If the HardDriveDevicePath does not start with a Hard Drive Device Path
// exit.
//
return EFI_NOT_FOUND;
}
//
// The boot device have already been connected
//
Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiBlockIoProtocolGuid, NULL, &BlockIoHandleCount, &BlockIoBuffer);
if (EFI_ERROR (Status) || BlockIoHandleCount == 0) {
//
// If there was an error or there are no device handles that support
// the BLOCK_IO Protocol, then return.
//
return EFI_NOT_FOUND;
}
//
// Loop through all the device handles that support the BLOCK_IO Protocol
//
for (Index = 0; Index < BlockIoHandleCount; Index++) {
Status = gBS->HandleProtocol (BlockIoBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID *) &BlockIoDevicePath);
if (EFI_ERROR (Status) || BlockIoDevicePath == NULL) {
continue;
}
//
// Make PreviousDevicePath == the device path node before the end node
//
DevicePath = BlockIoDevicePath;
BlockIoHdDevicePath = NULL;
//
// find HardDriver device path node
//
while (!IsDevicePathEnd (DevicePath)) {
if ((DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) &&
(DevicePathSubType (DevicePath) == MEDIA_HARDDRIVE_DP)
) {
BlockIoHdDevicePath = DevicePath;
break;
}
DevicePath = NextDevicePathNode (DevicePath);
}
if (BlockIoHdDevicePath == NULL) {
continue;
}
//
// See if the harddrive device path in blockio matches the orig Hard Drive Node
//
DevicePathMatch = FALSE;
TmpHdPath = (HARDDRIVE_DEVICE_PATH *) BlockIoHdDevicePath;
TempPath = (HARDDRIVE_DEVICE_PATH *) BdsLibUnpackDevicePath ((EFI_DEVICE_PATH_PROTOCOL *) HardDriveDevicePath);
//
// Only several fields will be checked. NOT whole NODE
//
if ( TmpHdPath->PartitionNumber == TempPath->PartitionNumber &&
TmpHdPath->MBRType == TempPath->MBRType &&
TmpHdPath->SignatureType == TempPath->SignatureType &&
CompareGuid ((EFI_GUID *) TmpHdPath->Signature, (EFI_GUID *) TempPath->Signature)) {
//
// Get the matched device path
//
DevicePathMatch = TRUE;
}
//
// Only do the boot, when devicepath match
//
if (DevicePathMatch) {
//
// Combine the Block IO and Hard Drive Device path together and try
// to boot from it.
//
DevicePath = NextDevicePathNode ((EFI_DEVICE_PATH_PROTOCOL *) HardDriveDevicePath);
NewDevicePath = AppendDevicePath (BlockIoDevicePath, DevicePath);
//
// Recursive boot with new device path
//
Status = BdsLibBootViaBootOption (Option, NewDevicePath, ExitDataSize, ExitData);
if (!EFI_ERROR (Status)) {
break;
}
}
}
gBS->FreePool (BlockIoBuffer);
return Status;
}
EFI_STATUS
BdsLibEnumerateAllBootOption (
IN OUT LIST_ENTRY *BdsBootOptionList
)
/*++
Routine Description:
This function will enumerate all possible boot device in the system,
it will only excute once of every boot.
Arguments:
BdsBootOptionList - The header of the link list which indexed all
current boot options
Returns:
EFI_SUCCESS - Finished all the boot device enumerate and create
the boot option base on that boot device
--*/
{
EFI_STATUS Status;
UINT16 BootOptionNumber;
UINTN NumberFileSystemHandles;
EFI_HANDLE *FileSystemHandles;
UINTN NumberBlkIoHandles;
EFI_HANDLE *BlkIoHandles;
EFI_BLOCK_IO_PROTOCOL *BlkIo;
UINTN Index;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
UINTN NumberLoadFileHandles;
EFI_HANDLE *LoadFileHandles;
VOID *ProtocolInstance;
EFI_FIRMWARE_VOLUME_PROTOCOL *Fv;
UINTN FvHandleCount;
EFI_HANDLE *FvHandleBuffer;
EFI_FV_FILETYPE Type;
UINTN Size;
EFI_FV_FILE_ATTRIBUTES Attributes;
UINT32 AuthenticationStatus;
BootOptionNumber = 0;
//
// If the boot device enumerate happened, just get the boot
// device from the boot order variable
//
if (mEnumBootDevice) {
BdsLibBuildOptionFromVar (BdsBootOptionList, L"BootOrder");
return EFI_SUCCESS;
}
//
// Notes: this dirty code is to get the legacy boot option from the
// BBS table and create to variable as the EFI boot option, it should
// be removed after the CSM can provide legacy boot option directly
//
REFRESH_LEGACY_BOOT_OPTIONS;
//
// Check all the block IO to create boot option
//
gBS->LocateHandleBuffer (
ByProtocol,
&gEfiBlockIoProtocolGuid,
NULL,
&NumberBlkIoHandles,
&BlkIoHandles
);
for (Index = 0; Index < NumberBlkIoHandles; Index++) {
Status = gBS->HandleProtocol (
BlkIoHandles[Index],
&gEfiBlockIoProtocolGuid,
(VOID **) &BlkIo
);
if (EFI_ERROR (Status)) {
continue;
}
if (!BlkIo->Media->RemovableMedia) {
//
// Skip fixed Media device on first loop interration
//
continue;
}
DevicePath = DevicePathFromHandle (BlkIoHandles[Index]);
if ((DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) &&
(DevicePathSubType (DevicePath) == MEDIA_HARDDRIVE_DP)
) {
//
// Build the boot option
//
BdsLibBuildOptionFromHandle (BlkIoHandles[Index], BdsBootOptionList);
BootOptionNumber++;
}
}
if (NumberBlkIoHandles) {
gBS->FreePool (BlkIoHandles);
}
//
// Parse Fixed Disk Devices.
//
gBS->LocateHandleBuffer (
ByProtocol,
&gEfiSimpleFileSystemProtocolGuid,
NULL,
&NumberFileSystemHandles,
&FileSystemHandles
);
for (Index = 0; Index < NumberFileSystemHandles; Index++) {
Status = gBS->HandleProtocol (
FileSystemHandles[Index],
&gEfiBlockIoProtocolGuid,
(VOID **) &BlkIo
);
if (!EFI_ERROR (Status)) {
if (BlkIo->Media->RemovableMedia) {
//
// If the file system handle supports a BlkIo protocol,
// skip the removable media devices
//
continue;
}
}
DevicePath = DevicePathFromHandle (FileSystemHandles[Index]);
if ((DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) &&
(DevicePathSubType (DevicePath) == MEDIA_HARDDRIVE_DP)
) {
//
// If the FileSystem protocol does not contain a BlkIo protocol,
// then build it
//
BdsLibBuildOptionFromHandle (FileSystemHandles[Index], BdsBootOptionList);
BootOptionNumber++;
}
}
if (NumberFileSystemHandles) {
gBS->FreePool (FileSystemHandles);
}
//
// Parse Network Boot Device
//
gBS->LocateHandleBuffer (
ByProtocol,
&gEfiSimpleNetworkProtocolGuid,
NULL,
&NumberLoadFileHandles,
&LoadFileHandles
);
for (Index = 0; Index < NumberLoadFileHandles; Index++) {
Status = gBS->HandleProtocol (
LoadFileHandles[Index],
&gEfiLoadFileProtocolGuid,
(VOID **) &ProtocolInstance
);
if (EFI_ERROR (Status)) {
continue;
}
BdsLibBuildOptionFromHandle (LoadFileHandles[Index], BdsBootOptionList);
BootOptionNumber++;
}
if (NumberLoadFileHandles) {
gBS->FreePool (LoadFileHandles);
}
//
// Check if we have on flash shell
//
gBS->LocateHandleBuffer (
ByProtocol,
&gEfiFirmwareVolumeProtocolGuid,
NULL,
&FvHandleCount,
&FvHandleBuffer
);
for (Index = 0; Index < FvHandleCount; Index++) {
gBS->HandleProtocol (
FvHandleBuffer[Index],
&gEfiFirmwareVolumeProtocolGuid,
(VOID **) &Fv
);
Status = Fv->ReadFile (
Fv,
&gEfiShellFileGuid,
NULL,
&Size,
&Type,
&Attributes,
&AuthenticationStatus
);
if (EFI_ERROR (Status)) {
//
// Skip if no shell file in the FV
//
continue;
}
//
// Build the shell boot option
//
BdsLibBuildOptionFromShell (FvHandleBuffer[Index], BdsBootOptionList);
BootOptionNumber++;
}
if (FvHandleCount) {
gBS->FreePool (FvHandleBuffer);
}
//
// Make sure every boot only have one time
// boot device enumerate
//
BdsLibBuildOptionFromVar (BdsBootOptionList, L"BootOrder");
mEnumBootDevice = TRUE;
return EFI_SUCCESS;
}
VOID
BdsLibBuildOptionFromHandle (
IN EFI_HANDLE Handle,
IN LIST_ENTRY *BdsBootOptionList
)
/*++
Routine Description:
Build the boot option with the handle parsed in
Arguments:
Handle - The handle which present the device path to create boot option
BdsBootOptionList - The header of the link list which indexed all current
boot options
Returns:
VOID
--*/
{
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *TempString;
DevicePath = DevicePathFromHandle (Handle);
TempString = DevicePathToStr (DevicePath);
//
// Create and register new boot option
//
BdsLibRegisterNewOption (BdsBootOptionList, DevicePath, TempString, L"BootOrder");
}
VOID
BdsLibBuildOptionFromShell (
IN EFI_HANDLE Handle,
IN OUT LIST_ENTRY *BdsBootOptionList
)
/*++
Routine Description:
Build the on flash shell boot option with the handle parsed in
Arguments:
Handle - The handle which present the device path to create on flash shell
boot option
BdsBootOptionList - The header of the link list which indexed all current
boot options
Returns:
None
--*/
{
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
MEDIA_FW_VOL_FILEPATH_DEVICE_PATH ShellNode;
DevicePath = DevicePathFromHandle (Handle);
//
// Build the shell device path
//
EfiInitializeFwVolDevicepathNode (&ShellNode, &gEfiShellFileGuid);
DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *) &ShellNode);
//
// Create and register the shell boot option
//
BdsLibRegisterNewOption (BdsBootOptionList, DevicePath, L"Internal EFI Shell", L"BootOrder");
}
VOID
BdsLibBootNext (
VOID
)
/*++
Routine Description:
Boot from the EFI1.1 spec defined "BootNext" variable
Arguments:
None
Returns:
None
--*/
{
UINT16 *BootNext;
UINTN BootNextSize;
CHAR16 Buffer[20];
BDS_COMMON_OPTION *BootOption;
LIST_ENTRY TempList;
UINTN ExitDataSize;
CHAR16 *ExitData;
//
// Init the boot option name buffer and temp link list
//
InitializeListHead (&TempList);
ZeroMem (Buffer, sizeof (Buffer));
BootNext = BdsLibGetVariableAndSize (
L"BootNext",
&gEfiGlobalVariableGuid,
&BootNextSize
);
//
// Clear the boot next variable first
//
if (BootNext != NULL) {
gRT->SetVariable (
L"BootNext",
&gEfiGlobalVariableGuid,
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
0,
BootNext
);
//
// Start to build the boot option and try to boot
//
UnicodeSPrint (Buffer, sizeof (Buffer), L"Boot%04x", *BootNext);
BootOption = BdsLibVariableToOption (&TempList, Buffer);
BdsLibConnectDevicePath (BootOption->DevicePath);
BdsLibBootViaBootOption (BootOption, BootOption->DevicePath, &ExitDataSize, &ExitData);
}
}

357
EdkUnixPkg/Library/EdkGenericBdsLib/BdsConnect.c
View File

@ -1,357 +0,0 @@
/*++
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:
BdsConnect.c
Abstract:
BDS Lib functions which relate with connect the device
--*/
VOID
BdsLibConnectAll (
VOID
)
/*++
Routine Description:
This function will connect all the system driver to controller
first, and then special connect the default console, this make
sure all the system controller avialbe and the platform default
console connected.
Arguments:
None
Returns:
None
--*/
{
//
// Connect the platform console first
//
BdsLibConnectAllDefaultConsoles ();
//
// Generic way to connect all the drivers
//
BdsLibConnectAllDriversToAllControllers ();
//
// Here we have the assumption that we have already had
// platform default console
//
BdsLibConnectAllDefaultConsoles ();
}
VOID
BdsLibGenericConnectAll (
VOID
)
/*++
Routine Description:
This function will connect all the system drivers to all controllers
first, and then connect all the console devices the system current
have. After this we should get all the device work and console avariable
if the system have console device.
Arguments:
None
Returns:
None
--*/
{
//
// Most generic way to connect all the drivers
//
BdsLibConnectAllDriversToAllControllers ();
BdsLibConnectAllConsoles ();
}
EFI_STATUS
BdsLibConnectDevicePath (
IN EFI_DEVICE_PATH_PROTOCOL *DevicePathToConnect
)
/*++
Routine Description:
This function will create all handles associate with every device
path node. If the handle associate with one device path node can not
be created success, then still give one chance to do the dispatch,
which load the missing drivers if possible.
Arguments:
DevicePathToConnect - The device path which will be connected, it can
be a multi-instance device path
Returns:
EFI_SUCCESS - All handles associate with every device path
node have been created
EFI_OUT_OF_RESOURCES - There is no resource to create new handles
EFI_NOT_FOUND - Create the handle associate with one device
path node failed
--*/
{
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
EFI_DEVICE_PATH_PROTOCOL *CopyOfDevicePath;
EFI_DEVICE_PATH_PROTOCOL *Instance;
EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath;
EFI_DEVICE_PATH_PROTOCOL *Next;
EFI_HANDLE Handle;
EFI_HANDLE PreviousHandle;
UINTN Size;
if (DevicePathToConnect == NULL) {
return EFI_SUCCESS;
}
DevicePath = DuplicateDevicePath (DevicePathToConnect);
CopyOfDevicePath = DevicePath;
if (DevicePath == NULL) {
return EFI_OUT_OF_RESOURCES;
}
do {
//
// The outer loop handles multi instance device paths.
// Only console variables contain multiple instance device paths.
//
// After this call DevicePath points to the next Instance
//
Instance = GetNextDevicePathInstance (&DevicePath, &Size);
Next = Instance;
while (!IsDevicePathEndType (Next)) {
Next = NextDevicePathNode (Next);
}
SetDevicePathEndNode (Next);
//
// Start the real work of connect with RemainingDevicePath
//
PreviousHandle = NULL;
do {
//
// Find the handle that best matches the Device Path. If it is only a
// partial match the remaining part of the device path is returned in
// RemainingDevicePath.
//
RemainingDevicePath = Instance;
Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &RemainingDevicePath, &Handle);
if (!EFI_ERROR (Status)) {
if (Handle == PreviousHandle) {
//
// If no forward progress is made try invoking the Dispatcher.
// A new FV may have been added to the system an new drivers
// may now be found.
// Status == EFI_SUCCESS means a driver was dispatched
// Status == EFI_NOT_FOUND means no new drivers were dispatched
//
Status = gDS->Dispatch ();
}
if (!EFI_ERROR (Status)) {
PreviousHandle = Handle;
//
// Connect all drivers that apply to Handle and RemainingDevicePath,
// the Recursive flag is FALSE so only one level will be expanded.
//
// Do not check the connect status here, if the connect controller fail,
// then still give the chance to do dispatch, because partial
// RemainingDevicepath may be in the new FV
//
// 1. If the connect fail, RemainingDevicepath and handle will not
// change, so next time will do the dispatch, then dispatch's status
// will take effect
// 2. If the connect success, the RemainingDevicepath and handle will
// change, then avoid the dispatch, we have chance to continue the
// next connection
//
gBS->ConnectController (Handle, NULL, RemainingDevicePath, FALSE);
}
}
//
// Loop until RemainingDevicePath is an empty device path
//
} while (!EFI_ERROR (Status) && !IsDevicePathEnd (RemainingDevicePath));
} while (DevicePath != NULL);
if (CopyOfDevicePath != NULL) {
gBS->FreePool (CopyOfDevicePath);
}
//
// All handle with DevicePath exists in the handle database
//
return Status;
}
EFI_STATUS
BdsLibConnectAllEfi (
VOID
)
/*++
Routine Description:
This function will connect all current system handles recursively. The
connection will finish until every handle's child handle created if it have.
Arguments:
None
Returns:
EFI_SUCCESS - All handles and it's child handle have been connected
EFI_STATUS - Return the status of gBS->LocateHandleBuffer().
--*/
{
EFI_STATUS Status;
UINTN HandleCount;
EFI_HANDLE *HandleBuffer;
UINTN Index;
Status = gBS->LocateHandleBuffer (
AllHandles,
NULL,
NULL,
&HandleCount,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
return Status;
}
for (Index = 0; Index < HandleCount; Index++) {
Status = gBS->ConnectController (HandleBuffer[Index], NULL, NULL, TRUE);
}
gBS->FreePool (HandleBuffer);
return EFI_SUCCESS;
}
EFI_STATUS
BdsLibDisconnectAllEfi (
VOID
)
/*++
Routine Description:
This function will disconnect all current system handles. The disconnection
will finish until every handle have been disconnected.
Arguments:
None
Returns:
EFI_SUCCESS - All handles have been disconnected
EFI_STATUS - Return the status of gBS->LocateHandleBuffer().
--*/
{
EFI_STATUS Status;
UINTN HandleCount;
EFI_HANDLE *HandleBuffer;
UINTN Index;
//
// Disconnect all
//
Status = gBS->LocateHandleBuffer (
AllHandles,
NULL,
NULL,
&HandleCount,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
return Status;
}
for (Index = 0; Index < HandleCount; Index++) {
Status = gBS->DisconnectController (HandleBuffer[Index], NULL, NULL);
}
gBS->FreePool (HandleBuffer);
return EFI_SUCCESS;
}
VOID
BdsLibConnectAllDriversToAllControllers (
VOID
)
/*++
Routine Description:
Connects all drivers to all controllers.
This function make sure all the current system driver will manage
the correspoinding controllers if have. And at the same time, make
sure all the system controllers have driver to manage it if have.
Arguments:
None
Returns:
None
--*/
{
EFI_STATUS Status;
do {
//
// Connect All EFI 1.10 drivers following EFI 1.10 algorithm
//
BdsLibConnectAllEfi ();
//
// Check to see if it's possible to dispatch an more DXE drivers.
// The BdsLibConnectAllEfi () may have made new DXE drivers show up.
// If anything is Dispatched Status == EFI_SUCCESS and we will try
// the connect again.
//
Status = gDS->Dispatch ();
} while (!EFI_ERROR (Status));
}

394
EdkUnixPkg/Library/EdkGenericBdsLib/BdsConsole.c
View File

@ -1,394 +0,0 @@
/*++
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:
BdsConsole.c
Abstract:
BDS Lib functions which contain all the code to connect console device
--*/
BOOLEAN
IsNvNeed (
IN CHAR16 *ConVarName
)
{
CHAR16 *Ptr;
Ptr = ConVarName;
//
// If the variable includes "Dev" at last, we consider
// it does not support NV attribute.
//
while (*Ptr) {
Ptr++;
}
if ((*(Ptr - 3) == 'D') && (*(Ptr - 2) == 'e') && (*(Ptr - 1) == 'v')) {
return FALSE;
} else {
return TRUE;
}
}
EFI_STATUS
BdsLibUpdateConsoleVariable (
IN CHAR16 *ConVarName,
IN EFI_DEVICE_PATH_PROTOCOL *CustomizedConDevicePath,
IN EFI_DEVICE_PATH_PROTOCOL *ExclusiveDevicePath
)
/*++
Routine Description:
This function update console variable based on ConVarName, it can
add or remove one specific console device path from the variable
Arguments:
ConVarName - Console related variable name, ConIn, ConOut, ErrOut.
CustomizedConDevicePath - The console device path which will be added to
the console variable ConVarName, this parameter
can not be multi-instance.
ExclusiveDevicePath - The console device path which will be removed
from the console variable ConVarName, this
parameter can not be multi-instance.
Returns:
EFI_UNSUPPORTED - Add or remove the same device path.
EFI_SUCCESS - Success add or remove the device path from
the console variable.
--*/
{
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *VarConsole;
UINTN DevicePathSize;
EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
EFI_DEVICE_PATH_PROTOCOL *TempNewDevicePath;
UINT32 Attributes;
VarConsole = NULL;
DevicePathSize = 0;
Status = EFI_UNSUPPORTED;
//
// Notes: check the device path point, here should check
// with compare memory
//
if (CustomizedConDevicePath == ExclusiveDevicePath) {
return EFI_UNSUPPORTED;
}
//
// Delete the ExclusiveDevicePath from current default console
//
VarConsole = BdsLibGetVariableAndSize (
ConVarName,
&gEfiGlobalVariableGuid,
&DevicePathSize
);
//
// Initialize NewDevicePath
//
NewDevicePath = VarConsole;
//
// If ExclusiveDevicePath is even the part of the instance in VarConsole, delete it.
// In the end, NewDevicePath is the final device path.
//
if (ExclusiveDevicePath != NULL && VarConsole != NULL) {
NewDevicePath = BdsLibDelPartMatchInstance (VarConsole, ExclusiveDevicePath);
}
//
// Try to append customized device path to NewDevicePath.
//
if (CustomizedConDevicePath != NULL) {
if (!BdsLibMatchDevicePaths (NewDevicePath, CustomizedConDevicePath)) {
//
// Check if there is part of CustomizedConDevicePath in NewDevicePath, delete it.
//
NewDevicePath = BdsLibDelPartMatchInstance (NewDevicePath, CustomizedConDevicePath);
//
// In the first check, the default console variable will be null,
// just append current customized device path
//
TempNewDevicePath = NewDevicePath;
NewDevicePath = AppendDevicePathInstance (NewDevicePath, CustomizedConDevicePath);
BdsLibSafeFreePool(TempNewDevicePath);
}
}
//
// The attribute for ConInDev, ConOutDev and ErrOutDev does not include NV.
//
if (IsNvNeed(ConVarName)) {
//
// ConVarName has NV attribute.
//
Attributes = EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE;
} else {
//
// ConVarName does not have NV attribute.
//
Attributes = EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
}
//
// Finally, Update the variable of the default console by NewDevicePath
//
gRT->SetVariable (
ConVarName,
&gEfiGlobalVariableGuid,
Attributes,
GetDevicePathSize (NewDevicePath),
NewDevicePath
);
if (VarConsole == NewDevicePath) {
BdsLibSafeFreePool(VarConsole);
} else {
BdsLibSafeFreePool(VarConsole);
BdsLibSafeFreePool(NewDevicePath);
}
return EFI_SUCCESS;
}
EFI_STATUS
BdsLibConnectConsoleVariable (
IN CHAR16 *ConVarName
)
/*++
Routine Description:
Connect the console device base on the variable ConVarName, if
device path of the ConVarName is multi-instance device path, if
anyone of the instances is connected success, then this function
will return success.
Arguments:
ConVarName - Console related variable name, ConIn, ConOut, ErrOut.
Returns:
EFI_NOT_FOUND - There is not any console devices connected success
EFI_SUCCESS - Success connect any one instance of the console
device path base on the variable ConVarName.
--*/
{
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *StartDevicePath;
UINTN VariableSize;
EFI_DEVICE_PATH_PROTOCOL *Instance;
EFI_DEVICE_PATH_PROTOCOL *Next;
EFI_DEVICE_PATH_PROTOCOL *CopyOfDevicePath;
UINTN Size;
BOOLEAN DeviceExist;
Status = EFI_SUCCESS;
DeviceExist = FALSE;
//
// Check if the console variable exist
//
StartDevicePath = BdsLibGetVariableAndSize (
ConVarName,
&gEfiGlobalVariableGuid,
&VariableSize
);
if (StartDevicePath == NULL) {
return EFI_UNSUPPORTED;
}
CopyOfDevicePath = StartDevicePath;
do {
//
// Check every instance of the console variable
//
Instance = GetNextDevicePathInstance (&CopyOfDevicePath, &Size);
Next = Instance;
while (!IsDevicePathEndType (Next)) {
Next = NextDevicePathNode (Next);
}
SetDevicePathEndNode (Next);
//
// Connect the instance device path
//
Status = BdsLibConnectDevicePath (Instance);
if (EFI_ERROR (Status)) {
//
// Delete the instance from the console varialbe
//
BdsLibUpdateConsoleVariable (ConVarName, NULL, Instance);
} else {
DeviceExist = TRUE;
}
BdsLibSafeFreePool(Instance);
} while (CopyOfDevicePath != NULL);
gBS->FreePool (StartDevicePath);
if (DeviceExist == FALSE) {
return EFI_NOT_FOUND;
}
return EFI_SUCCESS;
}
VOID
BdsLibConnectAllConsoles (
VOID
)
/*++
Routine Description:
This function will search every simpletxt devive in current system,
and make every simpletxt device as pertantial console device.
Arguments:
None
Returns:
None
--*/
{
EFI_STATUS Status;
UINTN Index;
EFI_DEVICE_PATH_PROTOCOL *ConDevicePath;
UINTN HandleCount;
EFI_HANDLE *HandleBuffer;
Index = 0;
HandleCount = 0;
HandleBuffer = NULL;
ConDevicePath = NULL;
//
// Update all the console varables
//
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiSimpleTextInProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
for (Index = 0; Index < HandleCount; Index++) {
Status = gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiDevicePathProtocolGuid,
(VOID **) &ConDevicePath
);
BdsLibUpdateConsoleVariable (L"ConIn", ConDevicePath, NULL);
}
BdsLibSafeFreePool(HandleBuffer);
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiSimpleTextOutProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
for (Index = 0; Index < HandleCount; Index++) {
Status = gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiDevicePathProtocolGuid,
(VOID **) &ConDevicePath
);
BdsLibUpdateConsoleVariable (L"ConOut", ConDevicePath, NULL);
BdsLibUpdateConsoleVariable (L"ErrOut", ConDevicePath, NULL);
}
BdsLibSafeFreePool(HandleBuffer);
//
// Connect all console variables
//
BdsLibConnectAllDefaultConsoles ();
}
EFI_STATUS
BdsLibConnectAllDefaultConsoles (
VOID
)
/*++
Routine Description:
This function will connect console device base on the console
device variable ConIn, ConOut and ErrOut.
Arguments:
None
Returns:
EFI_SUCCESS - At least one of the ConIn and ConOut device have
been connected success.
EFI_STATUS - Return the status of BdsLibConnectConsoleVariable ().
--*/
{
EFI_STATUS Status;
//
// Connect all default console variables
//
//
// Because possibly the platform is legacy free, in such case,
// ConIn devices (Serial Port and PS2 Keyboard ) does not exist,
// so we need not check the status.
//
BdsLibConnectConsoleVariable (L"ConIn");
//
// It seems impossible not to have any ConOut device on platform,
// so we check the status here.
//
Status = BdsLibConnectConsoleVariable (L"ConOut");
if (EFI_ERROR (Status)) {
return Status;
}
//
// Special treat the err out device, becaues the null
// err out var is legal.
//
BdsLibConnectConsoleVariable (L"ErrOut");
return EFI_SUCCESS;
}

1120
EdkUnixPkg/Library/EdkGenericBdsLib/BdsMisc.c
View File

File diff suppressed because it is too large Load Diff

983
EdkUnixPkg/Library/EdkGenericBdsLib/BdsMisc.c.orig
View File

@ -1,983 +0,0 @@
/*++
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:
BdsMisc.c
Abstract:
Misc BDS library function
--*/
#define MAX_STRING_LEN 200
static BOOLEAN mFeaturerSwitch = TRUE;
static BOOLEAN mResetRequired = FALSE;
extern UINT16 gPlatformBootTimeOutDefault;
UINT16
BdsLibGetTimeout (
VOID
)
/*++
Routine Description:
Return the default value for system Timeout variable.
Arguments:
None
Returns:
Timeout value.
--*/
{
UINT16 Timeout;
UINTN Size;
EFI_STATUS Status;
//
// Return Timeout variable or 0xffff if no valid
// Timeout variable exists.
//
Size = sizeof (UINT16);
Status = gRT->GetVariable (L"Timeout", &gEfiGlobalVariableGuid, NULL, &Size, &Timeout);
if (!EFI_ERROR (Status)) {
return Timeout;
}
//
// To make the current EFI Automatic-Test activity possible, just add
// following code to make AutoBoot enabled when this variable is not
// present.
// This code should be removed later.
//
Timeout = gPlatformBootTimeOutDefault;
//
// Notes: Platform should set default variable if non exists on all error cases!!!
//
Status = gRT->SetVariable (
L"Timeout",
&gEfiGlobalVariableGuid,
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
sizeof (UINT16),
&Timeout
);
return Timeout;
}
VOID
BdsLibLoadDrivers (
IN LIST_ENTRY *BdsDriverLists
)
/*++
Routine Description:
The function will go through the driver optoin link list, load and start
every driver the driver optoin device path point to.
Arguments:
BdsDriverLists - The header of the current driver option link list
Returns:
None
--*/
{
EFI_STATUS Status;
LIST_ENTRY *Link;
BDS_COMMON_OPTION *Option;
EFI_HANDLE ImageHandle;
EFI_LOADED_IMAGE_PROTOCOL *ImageInfo;
UINTN ExitDataSize;
CHAR16 *ExitData;
BOOLEAN ReconnectAll;
ReconnectAll = FALSE;
//
// Process the driver option
//
for (Link = BdsDriverLists->ForwardLink; Link != BdsDriverLists; Link = Link->ForwardLink) {
Option = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE);
//
// 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 (Option->Attribute, LOAD_OPTION_ACTIVE)) {
continue;
}
//
// If a driver load option is marked as LOAD_OPTION_FORCE_RECONNECT,
// then all of the EFI drivers in the system will be disconnected and
// reconnected after the last driver load option is processed.
//
if (IS_LOAD_OPTION_TYPE (Option->Attribute, LOAD_OPTION_FORCE_RECONNECT)) {
ReconnectAll = TRUE;
}
//
// Make sure the driver path is connected.
//
BdsLibConnectDevicePath (Option->DevicePath);
//
// Load and start the image that Driver#### describes
//
Status = gBS->LoadImage (
FALSE,
mBdsImageHandle,
Option->DevicePath,
NULL,
0,
&ImageHandle
);
if (!EFI_ERROR (Status)) {
gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid,
(VOID **)&ImageInfo);
//
// Verify whether this image is a driver, if not,
// exit it and continue to parse next load option
//
if (ImageInfo->ImageCodeType != EfiBootServicesCode && ImageInfo->ImageCodeType != EfiRuntimeServicesCode) {
gBS->Exit (ImageHandle, EFI_INVALID_PARAMETER, 0, NULL);
continue;
}
if (Option->LoadOptionsSize != 0) {
ImageInfo->LoadOptionsSize = Option->LoadOptionsSize;
ImageInfo->LoadOptions = Option->LoadOptions;
}
//
// Before calling the image, enable the Watchdog Timer for
// the 5 Minute period
//
gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);
Status = gBS->StartImage (ImageHandle, &ExitDataSize, &ExitData);
DEBUG ((EFI_D_INFO | EFI_D_LOAD, "Driver Return Status = %r\n", Status));
//
// Clear the Watchdog Timer after the image returns
//
gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
}
}
//
// Process the LOAD_OPTION_FORCE_RECONNECT driver option
//
if (ReconnectAll) {
BdsLibDisconnectAllEfi ();
BdsLibConnectAll ();
}
}
EFI_STATUS
BdsLibRegisterNewOption (
IN LIST_ENTRY *BdsOptionList,
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
IN CHAR16 *String,
IN CHAR16 *VariableName
)
/*++
Routine Description:
This function will register the new boot#### or driver#### option base on
the VariableName. The new registered boot#### or driver#### will be linked
to BdsOptionList and also update to the VariableName. After the boot#### or
driver#### updated, the BootOrder or DriverOrder will also be updated.
Arguments:
BdsOptionList - The header of the boot#### or driver#### link list
DevicePath - The device path which the boot####
or driver#### option present
String - The description of the boot#### or driver####
VariableName - Indicate if the boot#### or driver#### option
Returns:
EFI_SUCCESS - The boot#### or driver#### have been success registered
EFI_STATUS - Return the status of gRT->SetVariable ().
--*/
{
EFI_STATUS Status;
UINTN Index;
UINT16 MaxOptionNumber;
UINT16 RegisterOptionNumber;
UINT16 *TempOptionPtr;
UINTN TempOptionSize;
UINT16 *OptionOrderPtr;
VOID *OptionPtr;
UINTN OptionSize;
UINT8 *TempPtr;
EFI_DEVICE_PATH_PROTOCOL *OptionDevicePath;
CHAR16 *Description;
CHAR16 OptionName[10];
BOOLEAN UpdateBootDevicePath;
OptionPtr = NULL;
OptionSize = 0;
TempPtr = NULL;
OptionDevicePath = NULL;
Description = NULL;
MaxOptionNumber = 0;
OptionOrderPtr = NULL;
UpdateBootDevicePath = FALSE;
ZeroMem (OptionName, sizeof (OptionName));
TempOptionSize = 0;
TempOptionPtr = BdsLibGetVariableAndSize (
VariableName,
&gEfiGlobalVariableGuid,
&TempOptionSize
);
//
// Compare with current option variable
//
for (Index = 0; Index < TempOptionSize / sizeof (UINT16); Index++) {
//
// Got the max option#### number
//
if (MaxOptionNumber < TempOptionPtr[Index]) {
MaxOptionNumber = TempOptionPtr[Index];
}
if (*VariableName == 'B') {
UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", TempOptionPtr[Index]);
} else {
UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", TempOptionPtr[Index]);
}
OptionPtr = BdsLibGetVariableAndSize (
OptionName,
&gEfiGlobalVariableGuid,
&OptionSize
);
TempPtr = OptionPtr;
TempPtr += sizeof (UINT32) + sizeof (UINT16);
Description = (CHAR16 *) TempPtr;
TempPtr += StrSize ((CHAR16 *) TempPtr);
OptionDevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;
//
// Notes: the description may will change base on the GetStringToken
//
if (CompareMem (Description, String, StrSize (Description)) == 0) {
if (CompareMem (OptionDevicePath, DevicePath, GetDevicePathSize (OptionDevicePath)) == 0) {
//
// Got the option, so just return
//
gBS->FreePool (OptionPtr);
gBS->FreePool (TempOptionPtr);
return EFI_SUCCESS;
} else {
//
// Boot device path changed, need update.
//
UpdateBootDevicePath = TRUE;
break;
}
}
gBS->FreePool (OptionPtr);
}
OptionSize = sizeof (UINT32) + sizeof (UINT16) + StrSize (String) + GetDevicePathSize (DevicePath);
OptionPtr = AllocateZeroPool (OptionSize);
TempPtr = OptionPtr;
*(UINT32 *) TempPtr = LOAD_OPTION_ACTIVE;
TempPtr += sizeof (UINT32);
*(UINT16 *) TempPtr = (UINT16) GetDevicePathSize (DevicePath);
TempPtr += sizeof (UINT16);
CopyMem (TempPtr, String, StrSize (String));
TempPtr += StrSize (String);
CopyMem (TempPtr, DevicePath, GetDevicePathSize (DevicePath));
if (UpdateBootDevicePath) {
//
// The number in option#### to be updated
//
RegisterOptionNumber = TempOptionPtr[Index];
} else {
//
// The new option#### number
//
RegisterOptionNumber = MaxOptionNumber + 1;
}
if (*VariableName == 'B') {
UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", RegisterOptionNumber);
} else {
UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", RegisterOptionNumber);
}
Status = gRT->SetVariable (
OptionName,
&gEfiGlobalVariableGuid,
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
OptionSize,
OptionPtr
);
if (EFI_ERROR (Status) || UpdateBootDevicePath) {
gBS->FreePool (OptionPtr);
gBS->FreePool (TempOptionPtr);
return Status;
}
gBS->FreePool (OptionPtr);
//
// Update the option order variable
//
OptionOrderPtr = AllocateZeroPool ((Index + 1) * sizeof (UINT16));
CopyMem (OptionOrderPtr, TempOptionPtr, Index * sizeof (UINT16));
OptionOrderPtr[Index] = RegisterOptionNumber;
Status = gRT->SetVariable (
VariableName,
&gEfiGlobalVariableGuid,
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
(Index + 1) * sizeof (UINT16),
OptionOrderPtr
);
if (EFI_ERROR (Status)) {
gBS->FreePool (TempOptionPtr);
gBS->FreePool (OptionOrderPtr);
return Status;
}
gBS->FreePool (TempOptionPtr);
gBS->FreePool (OptionOrderPtr);
return EFI_SUCCESS;
}
BDS_COMMON_OPTION *
BdsLibVariableToOption (
IN OUT LIST_ENTRY *BdsCommonOptionList,
IN CHAR16 *VariableName
)
/*++
Routine Description:
Build the boot#### or driver#### option from the VariableName, the
build boot#### or driver#### will also be linked to BdsCommonOptionList
Arguments:
BdsCommonOptionList - The header of the boot#### or driver#### option link list
VariableName - EFI Variable name indicate if it is boot#### or driver####
Returns:
BDS_COMMON_OPTION - Get the option just been created
NULL - Failed to get the new option
--*/
{
UINT32 Attribute;
UINT16 FilePathSize;
UINT8 *Variable;
UINT8 *TempPtr;
UINTN VariableSize;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
BDS_COMMON_OPTION *Option;
VOID *LoadOptions;
UINT32 LoadOptionsSize;
CHAR16 *Description;
//
// Read the variable. We will never free this data.
//
Variable = BdsLibGetVariableAndSize (
VariableName,
&gEfiGlobalVariableGuid,
&VariableSize
);
if (Variable == NULL) {
return NULL;
}
//
// Notes: careful defined the variable of Boot#### or
// Driver####, consider use some macro to abstract the code
//
//
// Get the option attribute
//
TempPtr = Variable;
Attribute = *(UINT32 *) Variable;
TempPtr += sizeof (UINT32);
//
// Get the option's device path size
//
FilePathSize = *(UINT16 *) TempPtr;
TempPtr += sizeof (UINT16);
//
// Get the option's description string
//
Description = (CHAR16 *) TempPtr;
//
// Get the option's description string size
//
TempPtr += StrSize ((CHAR16 *) TempPtr);
//
// Get the option's device path
//
DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;
TempPtr += FilePathSize;
LoadOptions = TempPtr;
LoadOptionsSize = (UINT32) (VariableSize - (UINTN) (TempPtr - Variable));
//
// The Console variables may have multiple device paths, so make
// an Entry for each one.
//
Option = AllocateZeroPool (sizeof (BDS_COMMON_OPTION));
if (Option == NULL) {
return NULL;
}
Option->Signature = BDS_LOAD_OPTION_SIGNATURE;
Option->DevicePath = AllocateZeroPool (GetDevicePathSize (DevicePath));
CopyMem (Option->DevicePath, DevicePath, GetDevicePathSize (DevicePath));
Option->Attribute = Attribute;
Option->Description = AllocateZeroPool (StrSize (Description));
CopyMem (Option->Description, Description, StrSize (Description));
Option->LoadOptions = AllocateZeroPool (LoadOptionsSize);
CopyMem (Option->LoadOptions, LoadOptions, LoadOptionsSize);
Option->LoadOptionsSize = LoadOptionsSize;
//
// Insert active entry to BdsDeviceList
//
if ((Option->Attribute & LOAD_OPTION_ACTIVE) == LOAD_OPTION_ACTIVE) {
InsertTailList (BdsCommonOptionList, &Option->Link);
gBS->FreePool (Variable);
return Option;
}
gBS->FreePool (Variable);
gBS->FreePool (Option);
return NULL;
}
EFI_STATUS
BdsLibBuildOptionFromVar (
IN LIST_ENTRY *BdsCommonOptionList,
IN CHAR16 *VariableName
)
/*++
Routine Description:
Process BootOrder, or DriverOrder variables, by calling
BdsLibVariableToOption () for each UINT16 in the variables.
Arguments:
BdsCommonOptionList - The header of the option list base on variable
VariableName
VariableName - EFI Variable name indicate the BootOrder or DriverOrder
Returns:
EFI_SUCCESS - Success create the boot option or driver option list
EFI_OUT_OF_RESOURCES - Failed to get the boot option or driver option list
--*/
{
UINT16 *OptionOrder;
UINTN OptionOrderSize;
UINTN Index;
BDS_COMMON_OPTION *Option;
CHAR16 OptionName[20];
//
// Zero Buffer in order to get all BOOT#### variables
//
ZeroMem (OptionName, sizeof (OptionName));
//
// Read the BootOrder, or DriverOrder variable.
//
OptionOrder = BdsLibGetVariableAndSize (
VariableName,
&gEfiGlobalVariableGuid,
&OptionOrderSize
);
if (OptionOrder == NULL) {
return EFI_OUT_OF_RESOURCES;
}
for (Index = 0; Index < OptionOrderSize / sizeof (UINT16); Index++) {
if (*VariableName == 'B') {
UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", OptionOrder[Index]);
} else {
UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", OptionOrder[Index]);
}
Option = BdsLibVariableToOption (BdsCommonOptionList, OptionName);
Option->BootCurrent = OptionOrder[Index];
}
gBS->FreePool (OptionOrder);
return EFI_SUCCESS;
}
EFI_STATUS
BdsLibGetBootMode (
OUT EFI_BOOT_MODE *BootMode
)
/*++
Routine Description:
Get boot mode by looking up configuration table and parsing HOB list
Arguments:
BootMode - Boot mode from PEI handoff HOB.
Returns:
EFI_SUCCESS - Successfully get boot mode
EFI_NOT_FOUND - Can not find the current system boot mode
--*/
{
EFI_HOB_HANDOFF_INFO_TABLE *HobList;
HobList = GetHobList ();
ASSERT (HobList->Header.HobType == EFI_HOB_TYPE_HANDOFF);
*BootMode = HobList->BootMode;
return EFI_SUCCESS;
}
VOID *
BdsLibGetVariableAndSize (
IN CHAR16 *Name,
IN EFI_GUID *VendorGuid,
OUT UINTN *VariableSize
)
/*++
Routine Description:
Read the EFI variable (VendorGuid/Name) and return a dynamically allocated
buffer, and the size of the buffer. If failure return NULL.
Arguments:
Name - String part of EFI variable name
VendorGuid - GUID part of EFI variable name
VariableSize - Returns the size of the EFI variable that was read
Returns:
Dynamically allocated memory that contains a copy of the EFI variable.
Caller is responsible freeing the buffer.
NULL - Variable was not read
--*/
{
EFI_STATUS Status;
UINTN BufferSize;
VOID *Buffer;
Buffer = NULL;
//
// Pass in a zero size buffer to find the required buffer size.
//
BufferSize = 0;
Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer);
if (Status == EFI_BUFFER_TOO_SMALL) {
//
// Allocate the buffer to return
//
Buffer = AllocateZeroPool (BufferSize);
if (Buffer == NULL) {
return NULL;
}
//
// Read variable into the allocated buffer.
//
Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer);
if (EFI_ERROR (Status)) {
BufferSize = 0;
}
}
*VariableSize = BufferSize;
return Buffer;
}
BOOLEAN
BdsLibMatchDevicePaths (
IN EFI_DEVICE_PATH_PROTOCOL *Multi,
IN EFI_DEVICE_PATH_PROTOCOL *Single
)
/*++
Routine Description:
Function compares a device path data structure to that of all the nodes of a
second device path instance.
Arguments:
Multi - A pointer to a multi-instance device path data structure.
Single - A pointer to a single-instance device path data structure.
Returns:
TRUE - If the Single is contained within Multi
FALSE - The Single is not match within Multi
--*/
{
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
EFI_DEVICE_PATH_PROTOCOL *DevicePathInst;
UINTN Size;
if (!Multi || !Single) {
return FALSE;
}
DevicePath = Multi;
DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
Size -= sizeof (EFI_DEVICE_PATH_PROTOCOL);
//
// Search for the match of 'Single' in 'Multi'
//
while (DevicePathInst != NULL) {
//
// If the single device path is found in multiple device paths,
// return success
//
if (Size == 0) {
return FALSE;
}
if (CompareMem (Single, DevicePathInst, Size) == 0) {
return TRUE;
}
gBS->FreePool (DevicePathInst);
DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
Size -= sizeof (EFI_DEVICE_PATH_PROTOCOL);
}
return FALSE;
}
EFI_STATUS
BdsLibOutputStrings (
IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *ConOut,
...
)
/*++
Routine Description:
This function prints a series of strings.
Arguments:
ConOut - Pointer to EFI_SIMPLE_TEXT_OUT_PROTOCOL
... - A variable argument list containing series of strings,
the last string must be NULL.
Returns:
EFI_SUCCESS - Success print out the string using ConOut.
EFI_STATUS - Return the status of the ConOut->OutputString ().
--*/
{
VA_LIST args;
EFI_STATUS Status;
CHAR16 *String;
Status = EFI_SUCCESS;
VA_START (args, ConOut);
while (!EFI_ERROR (Status)) {
//
// If String is NULL, then it's the end of the list
//
String = VA_ARG (args, CHAR16 *);
if (!String) {
break;
}
Status = ConOut->OutputString (ConOut, String);
if (EFI_ERROR (Status)) {
break;
}
}
return Status;
}
//
// Following are BDS Lib functions which contain all the code about setup browser reset reminder feature.
// Setup Browser reset reminder feature is that an reset reminder will be given before user leaves the setup browser if
// user change any option setting which needs a reset to be effective, and the reset will be applied according to the user selection.
//
VOID
EnableResetReminderFeature (
VOID
)
/*++
Routine Description:
Enable the setup browser reset reminder feature.
This routine is used in platform tip. If the platform policy need the feature, use the routine to enable it.
Arguments:
VOID
Returns:
VOID
--*/
{
mFeaturerSwitch = TRUE;
}
VOID
DisableResetReminderFeature (
VOID
)
/*++
Routine Description:
Disable the setup browser reset reminder feature.
This routine is used in platform tip. If the platform policy do not want the feature, use the routine to disable it.
Arguments:
VOID
Returns:
VOID
--*/
{
mFeaturerSwitch = FALSE;
}
VOID
EnableResetRequired (
VOID
)
/*++
Routine Description:
Record the info that a reset is required.
A module boolean variable is used to record whether a reset is required.
Arguments:
VOID
Returns:
VOID
--*/
{
mResetRequired = TRUE;
}
VOID
DisableResetRequired (
VOID
)
/*++
Routine Description:
Record the info that no reset is required.
A module boolean variable is used to record whether a reset is required.
Arguments:
VOID
Returns:
VOID
--*/
{
mResetRequired = FALSE;
}
BOOLEAN
IsResetReminderFeatureEnable (
VOID
)
/*++
Routine Description:
Check whether platform policy enable the reset reminder feature. The default is enabled.
Arguments:
VOID
Returns:
VOID
--*/
{
return mFeaturerSwitch;
}
BOOLEAN
IsResetRequired (
VOID
)
/*++
Routine Description:
Check if user changed any option setting which needs a system reset to be effective.
Arguments:
VOID
Returns:
VOID
--*/
{
return mResetRequired;
}
VOID
SetupResetReminder (
VOID
)
/*++
Routine Description:
Check whether a reset is needed, and finish the reset reminder feature.
If a reset is needed, Popup a menu to notice user, and finish the feature
according to the user selection.
Arguments:
VOID
Returns:
VOID
--*/
{
EFI_STATUS Status;
EFI_FORM_BROWSER_PROTOCOL *Browser;
EFI_INPUT_KEY Key;
CHAR16 *StringBuffer1;
CHAR16 *StringBuffer2;
//
//check any reset required change is applied? if yes, reset system
//
if (IsResetReminderFeatureEnable ()) {
if (IsResetRequired ()) {
Status = gBS->LocateProtocol (
&gEfiFormBrowserProtocolGuid,
NULL,
(VOID **)&Browser
);
StringBuffer1 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
ASSERT (StringBuffer1 != NULL);
StringBuffer2 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
ASSERT (StringBuffer2 != NULL);
StrCpy (StringBuffer1, L"Configuration changed. Reset to apply it Now ? ");
StrCpy (StringBuffer2, L"Enter (YES) / Esc (NO)");
//
// Popup a menu to notice user
//
do {
Browser->CreatePopUp (2, TRUE, 0, NULL, &Key, StringBuffer1, StringBuffer2);
} while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
gBS->FreePool (StringBuffer1);
gBS->FreePool (StringBuffer2);
//
// If the user hits the YES Response key, reset
//
if ((Key.UnicodeChar == CHAR_CARRIAGE_RETURN)) {
gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
}
gST->ConOut->ClearScreen (gST->ConOut);
}
}
}

1040
EdkUnixPkg/Library/EdkGenericBdsLib/DevicePath.c
View File

File diff suppressed because it is too large Load Diff

113
EdkUnixPkg/Library/EdkGenericBdsLib/EdkGenericBdsLib.msa
View File

@ -1,113 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0">
<MsaHeader>
<ModuleName>EdkGenericBdsLib</ModuleName>
<ModuleType>DXE_DRIVER</ModuleType>
<GuidValue>f3aaea62-8985-11db-baff-0040d02b1835</GuidValue>
<Version>1.0</Version>
<Abstract>EDK Generic BDS Common APIs Library Instance.</Abstract>
<Description>The library instance provides common library routines help in
performance measurement, device path debug print, boot device selections,
boot device connection, console supports in BDS phase and boot from boot
device.
</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>EdkGenericBdsLib</OutputFileBasename>
</ModuleDefinitions>
<LibraryClassDefinitions>
<LibraryClass Usage="ALWAYS_PRODUCED">
<Keyword>EdkGenericBdsLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>BaseLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>DxeServicesTableLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>DebugLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>PrintLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>HobLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>BaseMemoryLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>MemoryAllocationLib</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>PerformanceLib</Keyword>
</LibraryClass>
</LibraryClassDefinitions>
<SourceFiles>
<Filename>BdsBoot.c</Filename>
<Filename>BdsConsole.c</Filename>
<Filename>BdsConnect.c</Filename>
<Filename>DevicePath.c</Filename>
<Filename>Performance.h</Filename>
<Filename>Performance.c</Filename>
<Filename>BdsMisc.c</Filename>
<Filename SupArchList="IPF">Ipf/ShadowRom.c</Filename>
</SourceFiles>
<PackageDependencies>
<Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>
<Package PackageGuid="68169ab0-d41b-4009-9060-292c253ac43d"/>
<Package PackageGuid="f2805c44-8985-11db-9e98-0040d02b1835"/>
</PackageDependencies>
<Protocols>
<Protocol Usage="ALWAYS_CONSUMED">
<ProtocolCName>gEfiLoadedImageProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="ALWAYS_CONSUMED">
<ProtocolCName>gEfiFirmwareVolumeProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="ALWAYS_CONSUMED">
<ProtocolCName>gEfiAcpiS3SaveProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="ALWAYS_CONSUMED">
<ProtocolCName>gEfiSimpleTextOutProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="ALWAYS_CONSUMED">
<ProtocolCName>gEfiSimpleTextInProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="ALWAYS_CONSUMED">
<ProtocolCName>gEfiSimpleNetworkProtocolGuid</ProtocolCName>
</Protocol>
</Protocols>
<Guids>
<GuidCNames Usage="ALWAYS_CONSUMED">
<GuidCName>gEfiShellFileGuid</GuidCName>
</GuidCNames>
</Guids>
<Externs>
<Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>
<Specification>EDK_RELEASE_VERSION 0x00020000</Specification>
</Externs>
</ModuleSurfaceArea>

53
EdkUnixPkg/Library/EdkGenericBdsLib/Ipf/ShadowRom.c
View File

@ -1,53 +0,0 @@
/*++
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:
ShadowRom.c
Abstract:
Shadow all option rom
Revision History
--*/
#include "Tiano.h"
#include "EfiDriverLib.h"
#include EFI_PROTOCOL_DEFINITION (LegacyBios)
UINT8 mShadowRomFlag = 0;
VOID
ShadowAllOptionRom()
{
EFI_STATUS Status;
EFI_LEGACY_BIOS_PROTOCOL *LegacyBios;
//
// Rom shadow only do once.
//
if (mShadowRomFlag == 0) {
Status = gBS->LocateProtocol (
&gEfiLegacyBiosProtocolGuid,
NULL,
&LegacyBios
);
if (!EFI_ERROR (Status)) {
LegacyBios->PrepareToBootEfi (LegacyBios, NULL, NULL);
}
mShadowRomFlag = 1;
}
return ;
}

399
EdkUnixPkg/Library/EdkGenericBdsLib/Performance.c
View File

@ -1,399 +0,0 @@
/*++
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:
Performance.c
Abstract:
This file include the file which can help to get the system
performance, all the function will only include if the performance
switch is set.
--*/
#include "Performance.h"
VOID
ClearDebugRegisters (
VOID
)
{
//
// BugBug: We should not need to do this. We need to root cause this bug!!!!
//
AsmWriteDr0 (0);
AsmWriteDr1 (0);
}
STATIC
VOID
GetShortPdbFileName (
CHAR8 *PdbFileName,
CHAR8 *GaugeString
)
/*++
Routine Description:
Arguments:
Returns:
--*/
{
UINTN Index;
UINTN Index1;
UINTN StartIndex;
UINTN EndIndex;
if (PdbFileName == NULL) {
AsciiStrCpy (GaugeString, " ");
} else {
StartIndex = 0;
for (EndIndex = 0; PdbFileName[EndIndex] != 0; EndIndex++)
;
for (Index = 0; PdbFileName[Index] != 0; Index++) {
if (PdbFileName[Index] == '\\') {
StartIndex = Index + 1;
}
if (PdbFileName[Index] == '.') {
EndIndex = Index;
}
}
Index1 = 0;
for (Index = StartIndex; Index < EndIndex; Index++) {
GaugeString[Index1] = PdbFileName[Index];
Index1++;
if (Index1 == PERF_TOKEN_LENGTH - 1) {
break;
}
}
GaugeString[Index1] = 0;
}
return ;
}
STATIC
CHAR8 *
GetPdbPath (
VOID *ImageBase
)
/*++
Routine Description:
Located PDB path name in PE image
Arguments:
ImageBase - base of PE to search
Returns:
Pointer into image at offset of PDB file name if PDB file name is found,
Otherwise a pointer to an empty string.
--*/
{
PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
ZeroMem (&ImageContext, sizeof (ImageContext));
ImageContext.Handle = ImageBase;
ImageContext.ImageRead = PeCoffLoaderImageReadFromMemory;
PeCoffLoaderGetImageInfo (&ImageContext);
return ImageContext.PdbPointer;
}
STATIC
VOID
GetNameFromHandle (
IN EFI_HANDLE Handle,
OUT CHAR8 *GaugeString
)
{
EFI_STATUS Status;
EFI_LOADED_IMAGE_PROTOCOL *Image;
CHAR8 *PdbFileName;
EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
AsciiStrCpy (GaugeString, " ");
//
// Get handle name from image protocol
//
Status = gBS->HandleProtocol (
Handle,
&gEfiLoadedImageProtocolGuid,
(VOID **)&Image
);
if (EFI_ERROR (Status)) {
Status = gBS->OpenProtocol (
Handle,
&gEfiDriverBindingProtocolGuid,
(VOID **) &DriverBinding,
NULL,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
return ;
}
//
// Get handle name from image protocol
//
Status = gBS->HandleProtocol (
DriverBinding->ImageHandle,
&gEfiLoadedImageProtocolGuid,
(VOID **)&Image
);
}
PdbFileName = GetPdbPath (Image->ImageBase);
if (PdbFileName != NULL) {
GetShortPdbFileName (PdbFileName, GaugeString);
}
return ;
}
VOID
WriteBootToOsPerformanceData (
VOID
)
/*++
Routine Description:
Allocates a block of memory and writes performance data of booting to OS into it.
Arguments:
None
Returns:
None
--*/
{
EFI_STATUS Status;
EFI_CPU_ARCH_PROTOCOL *Cpu;
EFI_PHYSICAL_ADDRESS mAcpiLowMemoryBase;
UINT32 mAcpiLowMemoryLength;
UINT32 LimitCount;
PERF_HEADER mPerfHeader;
PERF_DATA mPerfData;
EFI_HANDLE *Handles;
UINTN NoHandles;
CHAR8 GaugeString[PERF_TOKEN_LENGTH];
UINT8 *Ptr;
UINT32 mIndex;
UINT64 Ticker;
UINT64 Freq;
UINT32 Duration;
UINT64 CurrentTicker;
UINT64 TimerPeriod;
UINTN LogEntryKey;
CONST VOID *Handle;
CONST CHAR8 *Token;
CONST CHAR8 *Module;
UINT64 StartTicker;
UINT64 EndTicker;
//
// Retrive time stamp count as early as possilbe
//
Ticker = AsmReadTsc ();
//
// Allocate a block of memory that contain performance data to OS
//
mAcpiLowMemoryBase = 0xFFFFFFFF;
Status = gBS->AllocatePages (
AllocateMaxAddress,
EfiReservedMemoryType,
4,
&mAcpiLowMemoryBase
);
if (EFI_ERROR (Status)) {
return ;
}
mAcpiLowMemoryLength = EFI_PAGES_TO_SIZE(4);
Ptr = (UINT8 *) ((UINT32) mAcpiLowMemoryBase + sizeof (PERF_HEADER));
LimitCount = (mAcpiLowMemoryLength - sizeof (PERF_HEADER)) / sizeof (PERF_DATA);
//
// Initialize performance data structure
//
ZeroMem (&mPerfHeader, sizeof (PERF_HEADER));
//
// Get CPU frequency
//
Status = gBS->LocateProtocol (
&gEfiCpuArchProtocolGuid,
NULL,
(VOID **)&Cpu
);
if (EFI_ERROR (Status)) {
gBS->FreePages (mAcpiLowMemoryBase, 4);
return ;
}
//
// Get Cpu Frequency
//
Status = Cpu->GetTimerValue (Cpu, 0, &(CurrentTicker), &TimerPeriod);
if (EFI_ERROR (Status)) {
gBS->FreePages (mAcpiLowMemoryBase, 4);
return ;
}
Freq = DivU64x32 (1000000000000ULL, (UINTN) TimerPeriod);
mPerfHeader.CpuFreq = Freq;
//
// Record BDS raw performance data
//
mPerfHeader.BDSRaw = Ticker;
//
// Put Detailed performance data into memory
//
Handles = NULL;
Status = gBS->LocateHandleBuffer (
AllHandles,
NULL,
NULL,
&NoHandles,
&Handles
);
if (EFI_ERROR (Status)) {
gBS->FreePages (mAcpiLowMemoryBase, 4);
return ;
}
//
// Get DXE drivers performance
//
for (mIndex = 0; mIndex < NoHandles; mIndex++) {
Ticker = 0;
LogEntryKey = 0;
while ((LogEntryKey = GetPerformanceMeasurement (
LogEntryKey,
&Handle,
&Token,
&Module,
&StartTicker,
&EndTicker)) != 0) {
if ((Handle == Handles[mIndex]) && (StartTicker < EndTicker)) {
Ticker += (EndTicker - StartTicker);
}
}
Duration = (UINT32) DivU64x32 (
Ticker,
(UINT32) Freq
);
if (Duration > 0) {
ZeroMem (&mPerfData, sizeof (PERF_DATA));
GetNameFromHandle (Handles[mIndex], GaugeString);
AsciiStrCpy (mPerfData.Token, GaugeString);
mPerfData.Duration = Duration;
CopyMem (Ptr, &mPerfData, sizeof (PERF_DATA));
Ptr += sizeof (PERF_DATA);
mPerfHeader.Count++;
if (mPerfHeader.Count == LimitCount) {
goto Done;
}
}
}
gBS->FreePool (Handles);
//
// Get inserted performance data
//
LogEntryKey = 0;
while ((LogEntryKey = GetPerformanceMeasurement (
LogEntryKey,
&Handle,
&Token,
&Module,
&StartTicker,
&EndTicker)) != 0) {
if ((Handle == NULL) && (StartTicker <= EndTicker)) {
ZeroMem (&mPerfData, sizeof (PERF_DATA));
AsciiStrnCpy (mPerfData.Token, Token, DXE_PERFORMANCE_STRING_SIZE);
mPerfData.Duration = (UINT32) DivU64x32 (
EndTicker - StartTicker,
(UINT32) Freq
);
CopyMem (Ptr, &mPerfData, sizeof (PERF_DATA));
Ptr += sizeof (PERF_DATA);
mPerfHeader.Count++;
if (mPerfHeader.Count == LimitCount) {
goto Done;
}
}
}
Done:
ClearDebugRegisters ();
mPerfHeader.Signiture = 0x66726550;
//
// Put performance data to memory
//
CopyMem (
(UINT32 *) (UINT32) mAcpiLowMemoryBase,
&mPerfHeader,
sizeof (PERF_HEADER)
);
gRT->SetVariable (
L"PerfDataMemAddr",
&gEfiGlobalVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
sizeof (UINT32),
(VOID *) &mAcpiLowMemoryBase
);
return ;
}

55
EdkUnixPkg/Library/EdkGenericBdsLib/Performance.h
View File

@ -1,55 +0,0 @@
/*++
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:
Performance.h
Abstract:
This file included the performance relete function header and
definition.
--*/
#ifndef _PERF_H_
#define _PERF_H_
#define PERF_TOKEN_LENGTH 28
#define PERF_PEI_ENTRY_MAX_NUM 50
typedef struct {
CHAR8 Token[PERF_TOKEN_LENGTH];
UINT32 Duration;
} PERF_DATA;
typedef struct {
UINT64 BootToOs;
UINT64 S3Resume;
UINT32 S3EntryNum;
PERF_DATA S3Entry[PERF_PEI_ENTRY_MAX_NUM];
UINT64 CpuFreq;
UINT64 BDSRaw;
UINT32 Count;
UINT32 Signiture;
} PERF_HEADER;
VOID
WriteBootToOsPerformanceData (
VOID
);
VOID
ClearDebugRegisters (
VOID
);
#endif

BIN
EdkUnixPkg/Logo/Logo.bmp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 12 KiB

34
EdkUnixPkg/Logo/Logo.msa
View File

@ -1,34 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0">
<MsaHeader>
<ModuleName>Logo</ModuleName>
<ModuleType>BASE</ModuleType>
<GuidValue>7BB28B99-61BB-11D5-9A5D-0090273FC14D</GuidValue>
<Version>1.0</Version>
<Abstract>Component description file for creating a Logo file.</Abstract>
<Description>This module provides the logo bitmap picture shown on setup screen.</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>true</BinaryModule>
<OutputFileBasename>Logo</OutputFileBasename>
</ModuleDefinitions>
<SourceFiles>
<Filename>Logo.bmp</Filename>
</SourceFiles>
<PackageDependencies>
<Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>
</PackageDependencies>
<Externs>
<Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>
<Specification>EDK_RELEASE_VERSION 0x00020000</Specification>
</Externs>
</ModuleSurfaceArea>