sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

UEFI HII: Merge UEFI HII support changes from branch.

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@4599 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
qwang12
2008-01-21 14:39:56 +00:00
parent f79314fa8f
commit 93e3992d1e
139 changed files with 59162 additions and 382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1664
MdeModulePkg/Universal/BdsDxe/BootMaint/BBSsupport.c Normal file
View File

File diff suppressed because it is too large Load Diff

78
MdeModulePkg/Universal/BdsDxe/BootMaint/BBSsupport.h Normal file
View File

@@ -0,0 +1,78 @@
/*++
Copyright (c) 2004 - 2008, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
BBSsupport.h
Abstract:
declares interface functions
Revision History
--*/
#ifndef _EFI_BDS_BBS_SUPPORT_H
#define _EFI_BDS_BBS_SUPPORT_H
#include "BootMaint.h"
//
// Bugbug: Candidate for a PCD entries
//
#define MAX_BBS_ENTRIES 0x100
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

391
MdeModulePkg/Universal/BdsDxe/BootMaint/Bm.vfr Normal file
View File

@@ -0,0 +1,391 @@
// *++
//
// Copyright (c) 2004 - 2007, 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 "FormGuid.h"
#define LABEL_END 0xffff
formset
guid = BOOT_MAINT_FORMSET_GUID,
title = STRING_TOKEN(STR_FORM_MAIN_TITLE),
help = STRING_TOKEN(STR_NULL_STRING),
class = 0,
subclass = 0,
varstore BMM_FAKE_NV_DATA,
varid = VARSTORE_ID_BOOT_MAINT,
name = BmmData,
guid = BOOT_MAINT_FORMSET_GUID;
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,
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,
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,
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,
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,
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,
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,
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,
//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,
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,
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,
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;
label LABEL_END;
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);
//help = STRING_TOKEN(STR_FORM_GOTO_MAIN),
//flags = INTERACTIVE,
//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,
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,
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,
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;
label LABEL_END;
endform;
form formid = FORM_BOOT_DEL_ID,
title = STRING_TOKEN(STR_FORM_BOOT_DEL_TITLE);
label FORM_BOOT_DEL_ID;
label LABEL_END;
endform;
form formid = FORM_BOOT_CHG_ID,
title = STRING_TOKEN(STR_FORM_BOOT_CHG_TITLE);
label FORM_BOOT_CHG_ID;
label LABEL_END;
endform;
form formid = FORM_BOOT_NEXT_ID,
title = STRING_TOKEN(STR_FORM_BOOT_NEXT_TITLE);
label FORM_BOOT_NEXT_ID;
label LABEL_END;
endform;
form formid = FORM_TIME_OUT_ID,
title = STRING_TOKEN(STR_FORM_TIME_OUT_TITLE);
label FORM_TIME_OUT_ID;
label LABEL_END;
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,
//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,
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;
label LABEL_END;
endform;
form formid = FORM_DRV_CHG_ID,
title = STRING_TOKEN(STR_FORM_DRV_CHG_TITLE);
label FORM_DRV_CHG_ID;
label LABEL_END;
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,
//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,
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,
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,
key = FORM_CON_ERR_ID;
goto FORM_CON_MODE_ID,
prompt = STRING_TOKEN(STR_FORM_MODE_TITLE),
help = STRING_TOKEN(STR_FORM_MODE_HELP),
flags = INTERACTIVE,
key = FORM_CON_MODE_ID;
goto FORM_CON_COM_ID,
prompt = STRING_TOKEN(STR_FORM_COM_TITLE),
help = STRING_TOKEN(STR_FORM_COM_HELP),
flags = INTERACTIVE,
key = FORM_CON_COM_ID;
endform;
form formid = FORM_CON_MODE_ID,
title = STRING_TOKEN(STR_FORM_MODE_TITLE);
label FORM_CON_MODE_ID;
label LABEL_END;
endform;
form formid = FORM_CON_COM_ID,
title = STRING_TOKEN(STR_FORM_COM_TITLE);
label FORM_CON_COM_ID;
label LABEL_END;
endform;
form formid = FORM_CON_COM_SETUP_ID,
title = STRING_TOKEN(STR_CON_COM_SETUP);
label FORM_CON_COM_SETUP_ID;
label LABEL_END;
endform;
form formid = FORM_FILE_SEEK_ID,
title = STRING_TOKEN(STR_FORM_BOOT_ADD_TITLE);
label FORM_FILE_SEEK_ID;
label LABEL_END;
endform;
form formid = FORM_FILE_NEW_SEEK_ID,
title = STRING_TOKEN(STR_FORM_BOOT_ADD_TITLE);
label FORM_FILE_NEW_SEEK_ID;
label LABEL_END;
endform;
form formid = FORM_DRV_ADD_FILE_ID,
title = STRING_TOKEN(STR_FORM_DRV_ADD_FILE_TITLE);
label FORM_DRV_ADD_FILE_ID;
label LABEL_END;
endform;
form formid = FORM_DRV_ADD_HANDLE_ID,
title = STRING_TOKEN(STR_FORM_DRV_ADD_HANDLE_TITLE);
label FORM_DRV_ADD_HANDLE_ID;
label LABEL_END;
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;
label LABEL_END;
endform;
form formid = FORM_CON_IN_ID,
title = STRING_TOKEN(STR_FORM_CON_IN_TITLE);
label FORM_CON_IN_ID;
label LABEL_END;
endform;
form formid = FORM_CON_OUT_ID,
title = STRING_TOKEN(STR_FORM_CON_OUT_TITLE);
label FORM_CON_OUT_ID;
label LABEL_END;
endform;
form formid = FORM_CON_ERR_ID,
title = STRING_TOKEN(STR_FORM_STD_ERR_TITLE);
label FORM_CON_ERR_ID;
label LABEL_END;
endform;
form formid = FORM_SET_FD_ORDER_ID,
title = STRING_TOKEN(STR_FORM_SET_FD_ORDER_TITLE);
label FORM_SET_FD_ORDER_ID;
label LABEL_END;
endform;
form formid = FORM_SET_HD_ORDER_ID,
title = STRING_TOKEN(STR_FORM_SET_HD_ORDER_TITLE);
label FORM_SET_HD_ORDER_ID;
label LABEL_END;
endform;
form formid = FORM_SET_CD_ORDER_ID,
title = STRING_TOKEN(STR_FORM_SET_CD_ORDER_TITLE);
label FORM_SET_CD_ORDER_ID;
label LABEL_END;
endform;
form formid = FORM_SET_NET_ORDER_ID,
title = STRING_TOKEN(STR_FORM_SET_NET_ORDER_TITLE);
label FORM_SET_NET_ORDER_ID;
label LABEL_END;
endform;
form formid = FORM_SET_BEV_ORDER_ID,
title = STRING_TOKEN(STR_FORM_SET_BEV_ORDER_TITLE);
label FORM_SET_BEV_ORDER_ID;
label LABEL_END;
endform;
endformset;

563
MdeModulePkg/Universal/BdsDxe/BootMaint/BmLib.c Normal file
View File

@@ -0,0 +1,563 @@
/*++
Copyright (c) 2004 - 2008, 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"
VOID *
EfiAllocateZeroPool (
IN UINTN Size
)
/*++
Routine Description:
Wrap original AllocatePool gBS call
and ZeroMem gBS call into a single
function in order to decrease code length
Arguments:
Returns:
Valid pointer to the allocated buffer
Null for failure
--*/
{
EFI_STATUS Status;
VOID *Ptr;
Status = gBS->AllocatePool (EfiBootServicesData, Size, &Ptr);
if (EFI_ERROR (Status)) {
Ptr = NULL;
return Ptr;
}
ZeroMem (Ptr, Size);
return Ptr;
}
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,
(VOID **) 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 = EfiAllocateZeroPool (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 = EfiAllocateZeroPool (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 = EfiAllocateZeroPool (NewSize);
}
if (OldPool) {
if (NewPool) {
CopyMem (NewPool, OldPool, OldSize < NewSize ? OldSize : NewSize);
}
SafeFreePool (OldPool);
}
return NewPool;
}
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)) {
GetProducerString (&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)) {
GetProducerString (&Record->ProducerName, Port->PortExternalConnectorDesignator, &Desc);
return Desc;
}
}
}
} while (TimeCompare (&Record->LogTime, &CurTime) && Count != 0);
return NULL;
}

BIN
MdeModulePkg/Universal/BdsDxe/BootMaint/Bmstring.uni Normal file
View File

Binary file not shown.

1331
MdeModulePkg/Universal/BdsDxe/BootMaint/BootMaint.c Normal file
View File

File diff suppressed because it is too large Load Diff

1087
MdeModulePkg/Universal/BdsDxe/BootMaint/BootMaint.h Normal file
View File

File diff suppressed because it is too large Load Diff

1697
MdeModulePkg/Universal/BdsDxe/BootMaint/BootOption.c Normal file
View File

File diff suppressed because it is too large Load Diff

992
MdeModulePkg/Universal/BdsDxe/BootMaint/ConsoleOption.c Normal file
View File

@@ -0,0 +1,992 @@
/*++
Copyright (c) 2004 - 2008, 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
RetrieveUartUid (
IN EFI_HANDLE Handle,
IN OUT UINT32 *AcpiUid
)
/*++
Routine Description:
Retrieve ACPI UID of UART from device path
Arguments:
Handles - EFI_SERIAL_IO_PROTOCOL handle
Returns:
TRUE - Find valid UID from device path
FALSE - Can't find
--*/
{
UINT32 Match;
UINT8 *Ptr;
ACPI_HID_DEVICE_PATH *Acpi;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
gBS->HandleProtocol (
Handle,
&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) {
if (AcpiUid != NULL) {
*AcpiUid = Acpi->UID;
}
return TRUE;
} else {
return FALSE;
}
}
VOID
SortedUartHandle (
IN EFI_HANDLE *Handles,
IN UINTN NoHandles
)
/*++
Routine Description:
Sort Uart handles array with Acpi->UID from low to high
Arguments:
Handles - EFI_SERIAL_IO_PROTOCOL handle buffer
NoHandles - EFI_SERIAL_IO_PROTOCOL handle count
Returns:
None
--*/
{
UINTN Index1;
UINTN Index2;
UINTN Position;
UINT32 AcpiUid1;
UINT32 AcpiUid2;
UINT32 TempAcpiUid;
EFI_HANDLE TempHandle;
for (Index1 = 0; Index1 < NoHandles-1; Index1++) {
if (!RetrieveUartUid (Handles[Index1], &AcpiUid1)) {
continue;
}
TempHandle = Handles[Index1];
Position = Index1;
TempAcpiUid = AcpiUid1;
for (Index2 = Index1+1; Index2 < NoHandles; Index2++) {
if (!RetrieveUartUid (Handles[Index2], &AcpiUid2)) {
continue;
}
if (AcpiUid2 < TempAcpiUid) {
TempAcpiUid = AcpiUid2;
TempHandle = Handles[Index2];
Position = Index2;
}
}
Handles[Position] = Handles[Index1];
Handles[Index1] = TempHandle;
}
}
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;
}
//
// Sort Uart handles array with Acpi->UID from low to high
// then Terminal menu can be built from low Acpi->UID to high Acpi->UID
//
SortedUartHandle (Handles, NoHandles);
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) {
SafeFreePool (Handles);
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++;
}
}
SafeFreePool (Handles);
//
// 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 = EfiAllocateZeroPool (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;
TYPE_OF_TERMINAL Terminal;
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
);
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;
}
VOID
GetConsoleOutMode (
IN BMM_CALLBACK_DATA *CallbackData
)
/*++
Routine Description:
Get mode number according to column and row
Arguments:
CallbackData - BMM_CALLBACK_DATA
Returns:
None.
--*/
{
UINTN Col;
UINTN Row;
UINTN CurrentCol;
UINTN CurrentRow;
UINTN Mode;
UINTN MaxMode;
EFI_STATUS Status;
CONSOLE_OUT_MODE *ModeInfo;
EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *ConOut;
ConOut = gST->ConOut;
MaxMode = (UINTN) (ConOut->Mode->MaxMode);
ModeInfo = EfiLibGetVariable (VarConOutMode, &gEfiGenericPlatformVariableGuid);
if (ModeInfo != NULL) {
CurrentCol = ModeInfo->Column;
CurrentRow = ModeInfo->Row;
for (Mode = 0; Mode < MaxMode; Mode++) {
Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
if (!EFI_ERROR(Status)) {
if (CurrentCol == Col && CurrentRow == Row) {
CallbackData->BmmFakeNvData.ConsoleOutMode = (UINT16) Mode;
break;
}
}
}
}
SafeFreePool (ModeInfo);
}

324
MdeModulePkg/Universal/BdsDxe/BootMaint/Data.c Normal file
View File

@@ -0,0 +1,324 @@
/*++
Copyright (c) 2004 - 2007, 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 gUpdateData;
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,
0
};
//
// Console Input Device Selection Menu
//
BM_MENU_OPTION ConsoleInpMenu = {
BM_MENU_OPTION_SIGNATURE,
NULL,
0
};
//
// Console Output Device Selection Menu
//
BM_MENU_OPTION ConsoleOutMenu = {
BM_MENU_OPTION_SIGNATURE,
NULL,
0
};
//
// Error Output Device Selection Menu
//
BM_MENU_OPTION ConsoleErrMenu = {
BM_MENU_OPTION_SIGNATURE,
NULL,
0
};
//
// Boot Option from variable Menu
//
BM_MENU_OPTION BootOptionMenu = {
BM_MENU_OPTION_SIGNATURE,
NULL,
0
};
//
// Driver Option from variable menu
//
BM_MENU_OPTION DriverOptionMenu = {
BM_MENU_OPTION_SIGNATURE,
NULL,
0
};
//
// Legacy FD Info from LegacyBios.GetBbsInfo()
//
BM_MENU_OPTION LegacyFDMenu = {
BM_MENU_OPTION_SIGNATURE,
NULL,
0
};
//
// Legacy HD Info from LegacyBios.GetBbsInfo()
//
BM_MENU_OPTION LegacyHDMenu = {
BM_MENU_OPTION_SIGNATURE,
NULL,
0
};
//
// Legacy CD Info from LegacyBios.GetBbsInfo()
//
BM_MENU_OPTION LegacyCDMenu = {
BM_MENU_OPTION_SIGNATURE,
NULL,
0
};
//
// Legacy NET Info from LegacyBios.GetBbsInfo()
//
BM_MENU_OPTION LegacyNETMenu = {
BM_MENU_OPTION_SIGNATURE,
NULL,
0
};
//
// Legacy NET Info from LegacyBios.GetBbsInfo()
//
BM_MENU_OPTION LegacyBEVMenu = {
BM_MENU_OPTION_SIGNATURE,
NULL,
0
};
//
// Files and sub-directories in current directory menu
//
BM_MENU_OPTION DirectoryMenu = {
BM_MENU_OPTION_SIGNATURE,
NULL,
0
};
//
// Handles in current system selection menu
//
BM_MENU_OPTION DriverMenu = {
BM_MENU_OPTION_SIGNATURE,
NULL,
0
};
BM_MENU_OPTION TerminalMenu = {
BM_MENU_OPTION_SIGNATURE,
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
};

134
MdeModulePkg/Universal/BdsDxe/BootMaint/FE.vfr Normal file
View File

@@ -0,0 +1,134 @@
// *++
//
// Copyright (c) 2004 - 2007, 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 "FormGuid.h"
#define LABEL_END 0xffff
formset
guid = FILE_EXPLORE_FORMSET_GUID,
title = STRING_TOKEN(STR_FILE_EXPLORER_TITLE),
help = STRING_TOKEN(STR_NULL_STRING),
class = 0,
subclass = 0,
varstore FILE_EXPLORER_NV_DATA,
varid = VARSTORE_ID_BOOT_MAINT,
name = FeData,
guid = FILE_EXPLORE_FORMSET_GUID;
form formid = FORM_FILE_EXPLORER_ID,
title = STRING_TOKEN(STR_FILE_EXPLORER_TITLE);
label FORM_FILE_EXPLORER_ID;
label LABEL_END;
endform;
form formid = FORM_BOOT_ADD_DESCRIPTION_ID,
title = STRING_TOKEN(STR_FORM_BOOT_ADD_DESC_TITLE);
label FORM_BOOT_ADD_DESCRIPTION_ID;
label LABEL_END;
subtitle text = STRING_TOKEN(STR_NULL_STRING);
string varid = FeData.DescriptionData,
prompt = STRING_TOKEN(STR_LOAD_OPTION_DESC),
help = STRING_TOKEN(STR_NULL_STRING),
minsize = 6,
maxsize = 75,
endstring;
string varid = FeData.OptionalData,
prompt = STRING_TOKEN(STR_OPTIONAL_DATA),
help = STRING_TOKEN(STR_NULL_STRING),
minsize = 0,
maxsize = 120,
endstring;
subtitle text = STRING_TOKEN(STR_NULL_STRING);
text
help = STRING_TOKEN(STR_SAVE_AND_EXIT),
text = STRING_TOKEN(STR_SAVE_AND_EXIT),
text = STRING_TOKEN(STR_NULL_STRING),
flags = INTERACTIVE,
key = KEY_VALUE_SAVE_AND_EXIT_BOOT;
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,
key = KEY_VALUE_NO_SAVE_AND_EXIT_BOOT;
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;
label LABEL_END;
subtitle text = STRING_TOKEN(STR_NULL_STRING);
string varid = FeData.DescriptionData,
prompt = STRING_TOKEN(STR_LOAD_OPTION_DESC),
help = STRING_TOKEN(STR_NULL_STRING),
minsize = 6,
maxsize = 75,
endstring;
string varid = FeData.OptionalData,
prompt = STRING_TOKEN(STR_OPTIONAL_DATA),
help = STRING_TOKEN(STR_NULL_STRING),
minsize = 0,
maxsize = 120,
endstring;
checkbox varid = FeData.ForceReconnect,
prompt = STRING_TOKEN(STR_LOAD_OPTION_FORCE_RECON),
help = STRING_TOKEN(STR_LOAD_OPTION_FORCE_RECON),
flags = CHECKBOX_DEFAULT,
key = 0,
endcheckbox;
subtitle text = STRING_TOKEN(STR_NULL_STRING);
text
help = STRING_TOKEN(STR_SAVE_AND_EXIT),
text = STRING_TOKEN(STR_SAVE_AND_EXIT),
text = STRING_TOKEN(STR_NULL_STRING),
flags = INTERACTIVE,
key = KEY_VALUE_SAVE_AND_EXIT_DRIVER; //BUGBUB: allow duplicate key in one formset???
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,
key = KEY_VALUE_NO_SAVE_AND_EXIT_DRIVER;
endform;
endformset;

327
MdeModulePkg/Universal/BdsDxe/BootMaint/FileExplorer.c Normal file
View File

@@ -0,0 +1,327 @@
/*++
Copyright (c) 2004 - 2008, 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
Abstract:
File explorer related functions.
--*/
#include "BootMaint.h"
VOID
UpdateFileExplorePage (
IN BMM_CALLBACK_DATA *CallbackData,
BM_MENU_OPTION *MenuOption
)
/*++
Routine Description:
Update the File Explore page.
Arguments:
MenuOption - Pointer to menu options to display.
Returns:
None.
--*/
{
UINTN Index;
BM_MENU_ENTRY *NewMenuEntry;
BM_FILE_CONTEXT *NewFileContext;
EFI_FORM_ID FormId;
NewMenuEntry = NULL;
NewFileContext = NULL;
FormId = 0;
RefreshUpdateData ();
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.
//
CreateActionOpCode (
(UINT16) (FILE_OPTION_OFFSET + Index),
NewMenuEntry->DisplayStringToken,
STRING_TOKEN (STR_NULL_STRING),
EFI_IFR_FLAG_CALLBACK,
0,
&gUpdateData
);
} 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_CALLBACK,
(UINT16) (FILE_OPTION_OFFSET + Index),
&gUpdateData
);
}
}
IfrLibUpdateForm (
CallbackData->FeHiiHandle,
&mFileExplorerGuid,
FORM_FILE_EXPLORER_ID,
FORM_FILE_EXPLORER_ID,
FALSE,
&gUpdateData
);
}
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;
EFI_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;
//
// Create Subtitle op-code for the display string of the option.
//
RefreshUpdateData ();
CreateSubTitleOpCode (
NewMenuEntry->DisplayStringToken,
0,
0,
0,
&gUpdateData
);
IfrLibUpdateForm (
CallbackData->FeHiiHandle,
&mFileExplorerGuid,
FormId,
FormId,
FALSE,
&gUpdateData
);
break;
default:
break;
}
}
}
exit:
return ExitFileExplorer;
}
EFI_STATUS
EFIAPI
FileExplorerCallback (
IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
IN EFI_BROWSER_ACTION Action,
IN EFI_QUESTION_ID QuestionId,
IN UINT8 Type,
IN EFI_IFR_TYPE_VALUE *Value,
OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
)
/*++
Routine Description:
This function processes the results of changes in configuration.
Arguments:
This - Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
Action - Specifies the type of action taken by the browser.
QuestionId - A unique value which is sent to the original exporting driver
so that it can identify the type of data to expect.
Type - The type of value for the question.
Value - A pointer to the data being sent to the original exporting driver.
ActionRequest - On return, points to the action requested by the callback function.
Returns:
EFI_SUCCESS - The callback successfully handled the action.
EFI_OUT_OF_RESOURCES - Not enough storage is available to hold the variable and its data.
EFI_DEVICE_ERROR - The variable could not be saved.
EFI_UNSUPPORTED - The specified Action is not supported by the callback.
--*/
{
BMM_CALLBACK_DATA *Private;
FILE_EXPLORER_NV_DATA *NvRamMap;
EFI_STATUS Status;
UINTN BufferSize;
if ((Value == NULL) || (ActionRequest == NULL)) {
return EFI_INVALID_PARAMETER;
}
Status = EFI_SUCCESS;
Private = FE_CALLBACK_DATA_FROM_THIS (This);
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_NONE;
//
// Retrive uncommitted data from Form Browser
//
NvRamMap = &Private->FeFakeNvData;
BufferSize = sizeof (FILE_EXPLORER_NV_DATA);
Status = GetBrowserData (NULL, NULL, &BufferSize, (UINT8 *) NvRamMap);
if (EFI_ERROR (Status)) {
return Status;
}
if (QuestionId == KEY_VALUE_SAVE_AND_EXIT_BOOT || QuestionId == KEY_VALUE_SAVE_AND_EXIT_DRIVER) {
//
// 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);
}
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
} else if (QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT_BOOT || QuestionId == KEY_VALUE_NO_SAVE_AND_EXIT_DRIVER) {
//
// Discard changes and exit formset
//
NvRamMap->OptionalData[0] = 0x0000;
NvRamMap->DescriptionData[0] = 0x0000;
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
} else if (QuestionId < FILE_OPTION_OFFSET) {
//
// Exit File Explorer formset
//
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
} else {
if (UpdateFileExplorer (Private, QuestionId)) {
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
}
}
return Status;
}

216
MdeModulePkg/Universal/BdsDxe/BootMaint/FormGuid.h Normal file
View File

@@ -0,0 +1,216 @@
/*++
Copyright (c) 2004 - 2007, 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, form id and VarStore data structure for Boot Maintenance Manager.
--*/
#ifndef _FORM_GUID_H
#define _FORM_GUID_H
#define BOOT_MAINT_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} \
}
#define FORM_MAIN_ID 0x1001
#define FORM_BOOT_ADD_ID 0x1002
#define FORM_BOOT_DEL_ID 0x1003
#define FORM_BOOT_CHG_ID 0x1004
#define FORM_DRV_ADD_ID 0x1005
#define FORM_DRV_DEL_ID 0x1006
#define FORM_DRV_CHG_ID 0x1007
#define FORM_CON_MAIN_ID 0x1008
#define FORM_CON_IN_ID 0x1009
#define FORM_CON_OUT_ID 0x100A
#define FORM_CON_ERR_ID 0x100B
#define FORM_FILE_SEEK_ID 0x100C
#define FORM_FILE_NEW_SEEK_ID 0x100D
#define FORM_DRV_ADD_FILE_ID 0x100E
#define FORM_DRV_ADD_HANDLE_ID 0x100F
#define FORM_DRV_ADD_HANDLE_DESC_ID 0x1010
#define FORM_BOOT_NEXT_ID 0x1011
#define FORM_TIME_OUT_ID 0x1012
#define FORM_RESET 0x1013
#define FORM_BOOT_SETUP_ID 0x1014
#define FORM_DRIVER_SETUP_ID 0x1015
#define FORM_BOOT_LEGACY_DEVICE_ID 0x1016
#define FORM_CON_COM_ID 0x1017
#define FORM_CON_COM_SETUP_ID 0x1018
#define FORM_SET_FD_ORDER_ID 0x1019
#define FORM_SET_HD_ORDER_ID 0x101A
#define FORM_SET_CD_ORDER_ID 0x101B
#define FORM_SET_NET_ORDER_ID 0x101C
#define FORM_SET_BEV_ORDER_ID 0x101D
#define FORM_FILE_EXPLORER_ID 0x101E
#define FORM_BOOT_ADD_DESCRIPTION_ID 0x101F
#define FORM_DRIVER_ADD_FILE_DESCRIPTION_ID 0x1020
#define FORM_CON_MODE_ID 0x1021
#define MAXIMUM_FORM_ID 0x10FF
#define KEY_VALUE_COM_SET_BAUD_RATE 0x1101
#define KEY_VALUE_COM_SET_DATA_BITS 0x1102
#define KEY_VALUE_COM_SET_STOP_BITS 0x1103
#define KEY_VALUE_COM_SET_PARITY 0x1104
#define KEY_VALUE_COM_SET_TERMI_TYPE 0x1105
#define KEY_VALUE_MAIN_BOOT_NEXT 0x1106
#define KEY_VALUE_BOOT_ADD_DESC_DATA 0x1107
#define KEY_VALUE_BOOT_ADD_OPT_DATA 0x1108
#define KEY_VALUE_DRIVER_ADD_DESC_DATA 0x1109
#define KEY_VALUE_DRIVER_ADD_OPT_DATA 0x110A
#define KEY_VALUE_SAVE_AND_EXIT 0x110B
#define KEY_VALUE_NO_SAVE_AND_EXIT 0x110C
#define KEY_VALUE_BOOT_FROM_FILE 0x110D
#define MAXIMUM_NORMAL_KEY_VALUE 0x11FF
//
// Varstore ID defined for Buffer Stoarge
//
#define VARSTORE_ID_BOOT_MAINT 0x1000
#define VARSTORE_ID_FILE_EXPLORER 0x1001
//
// 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];
//
// We use DisableMap array to record the enable/disable state of each boot device
// It should be taken as a bit array, from left to right there are totally 256 bits
// the most left one stands for BBS table item 0, and the most right one stands for item 256
// If the bit is 1, it means the boot device has been disabled.
//
UINT8 DisableMap[32];
//
// Console Output Text Mode
//
UINT16 ConsoleOutMode;
//
// UINT16 PadArea[10];
//
} BMM_FAKE_NV_DATA;
//
// Key used by File Explorer forms
//
#define KEY_VALUE_SAVE_AND_EXIT_BOOT 0x1000
#define KEY_VALUE_NO_SAVE_AND_EXIT_BOOT 0x1001
#define KEY_VALUE_SAVE_AND_EXIT_DRIVER 0x1002
#define KEY_VALUE_NO_SAVE_AND_EXIT_DRIVER 0x1003
//
// This is the data structure used by File Explorer formset
//
typedef struct {
UINT16 DescriptionData[75];
UINT16 OptionalData[127];
UINT8 Active;
UINT8 ForceReconnect;
} FILE_EXPLORER_NV_DATA;
#endif

1211
MdeModulePkg/Universal/BdsDxe/BootMaint/UpdatePage.c Normal file
View File

File diff suppressed because it is too large Load Diff

1314
MdeModulePkg/Universal/BdsDxe/BootMaint/Variable.c Normal file
View File

File diff suppressed because it is too large Load Diff