/***
List all available Usb devices and all their partitions.
@param[in|out] DeviceList The linked list contains all Usb devices.
@retval EFI_SUCCESS The function exited normally.
@retval Other An error occurred.
***/
EFI_STATUS
UsbListAllUsbDevices (
IN OUT LIST_ENTRY *DeviceList
)
{
LIST_ENTRY *DiskNode = NULL;
LIST_ENTRY *PartitionNode = NULL;
DISK_ENTRY *DiskEntry = NULL;
PARTITION_ENTRY *PartitionEntry = NULL;
EFI_BLOCK_IO_PROTOCOL *BlockIo = NULL;
DISK_INFO *DiskInfo = NULL;
PARTITION_INFO *PartitionInfo = NULL;
if (DeviceList == NULL) {
return EFI_INVALID_PARAMETER;
}
DiskNode = GetFirstNode (DeviceList);
while (!IsNull (DeviceList, DiskNode)) {
DiskEntry = (DISK_ENTRY*)DiskNode;
if (DiskEntry != NULL) {
DiskInfo = &(DiskEntry->DiskInfo);
BlockIo = DiskInfo->BlockIo;
Print (L"\n[%d] \n", DiskInfo->DiskIndex);
if (DiskInfo->MaxPartitions > 0) {
PartitionNode = GetFirstNode(&(DiskInfo->PartitionsList));
while (!IsNull (&(DiskInfo->PartitionsList), PartitionNode)) {
PartitionEntry = (PARTITION_ENTRY*)PartitionNode;
if (PartitionEntry != NULL) {
PartitionInfo = &(PartitionEntry->PartitionInfo);
Print (L"|____[Partition] %d, ", PartitionInfo->PartitionNumber);
Print (L"[Size] %ld, ", (PartitionInfo->EndLBA - PartitionInfo->StartLBA + 1));
Print (L"[StartLBA] %ld, [EndLBA] %ld\n", PartitionInfo->StartLBA, PartitionInfo->EndLBA);
}
PartitionNode = GetNextNode (&(DiskInfo->PartitionsList), PartitionNode);
} //end while()
}
}
DiskNode = GetNextNode (DeviceList, DiskNode);
} //end while()
Print (L"Press ESC to return.\n");
return EFI_SUCCESS;
}
/**
Register a notification function for a particular keystroke for the input device.
@param This Protocol instance pointer.
@param KeyData A pointer to a buffer that is filled in with the
keystroke information data for the key that was
pressed.
@param KeyNotificationFunction Points to the function to be called when the key
sequence is typed specified by KeyData.
@param NotifyHandle Points to the unique handle assigned to the
registered notification.
@retval EFI_SUCCESS The notification function was registered
successfully.
@retval EFI_OUT_OF_RESOURCES Unable to allocate resources for necessary data
structures.
@retval EFI_INVALID_PARAMETER KeyData or NotifyHandle is NULL.
**/
EFI_STATUS
EFIAPI
TerminalConInRegisterKeyNotify (
IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
IN EFI_KEY_DATA *KeyData,
IN EFI_KEY_NOTIFY_FUNCTION KeyNotificationFunction,
OUT VOID **NotifyHandle
)
{
TERMINAL_DEV *TerminalDevice;
TERMINAL_CONSOLE_IN_EX_NOTIFY *NewNotify;
LIST_ENTRY *Link;
LIST_ENTRY *NotifyList;
TERMINAL_CONSOLE_IN_EX_NOTIFY *CurrentNotify;
if (KeyData == NULL || NotifyHandle == NULL || KeyNotificationFunction == NULL) {
return EFI_INVALID_PARAMETER;
}
TerminalDevice = TERMINAL_CON_IN_EX_DEV_FROM_THIS (This);
//
// Return EFI_SUCCESS if the (KeyData, NotificationFunction) is already registered.
//
NotifyList = &TerminalDevice->NotifyList;
for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList,Link); Link = GetNextNode (NotifyList,Link)) {
CurrentNotify = CR (
Link,
TERMINAL_CONSOLE_IN_EX_NOTIFY,
NotifyEntry,
TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE
);
if (IsKeyRegistered (&CurrentNotify->KeyData, KeyData)) {
if (CurrentNotify->KeyNotificationFn == KeyNotificationFunction) {
*NotifyHandle = CurrentNotify;
return EFI_SUCCESS;
}
}
}
//
// Allocate resource to save the notification function
//
NewNotify = (TERMINAL_CONSOLE_IN_EX_NOTIFY *) AllocateZeroPool (sizeof (TERMINAL_CONSOLE_IN_EX_NOTIFY));
if (NewNotify == NULL) {
return EFI_OUT_OF_RESOURCES;
}
NewNotify->Signature = TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE;
NewNotify->KeyNotificationFn = KeyNotificationFunction;
CopyMem (&NewNotify->KeyData, KeyData, sizeof (EFI_KEY_DATA));
InsertTailList (&TerminalDevice->NotifyList, &NewNotify->NotifyEntry);
*NotifyHandle = NewNotify;
return EFI_SUCCESS;
}
/**
This call back function is registered with Boot Manager formset.
When user selects a boot option, this call back function will
be triggered. The boot option is saved for later processing.
@param This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
@param Action Specifies the type of action taken by the browser.
@param QuestionId A unique value which is sent to the original exporting driver
so that it can identify the type of data to expect.
@param Type The type of value for the question.
@param Value A pointer to the data being sent to the original exporting driver.
@param ActionRequest On return, points to the action requested by the callback function.
@retval EFI_SUCCESS The callback successfully handled the action.
@retval EFI_INVALID_PARAMETER The setup browser call this function with invalid parameters.
**/
EFI_STATUS
EFIAPI
BootManagerCallback (
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
)
{
BDS_COMMON_OPTION *Option;
LIST_ENTRY *Link;
UINT16 KeyCount;
if (Action == EFI_BROWSER_ACTION_CHANGED) {
if ((Value == NULL) || (ActionRequest == NULL)) {
return EFI_INVALID_PARAMETER;
}
//
// Initialize the key count
//
KeyCount = 0;
for (Link = GetFirstNode (&mBootOptionsList); !IsNull (&mBootOptionsList, Link); Link = GetNextNode (&mBootOptionsList, Link)) {
Option = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE);
KeyCount++;
gOption = Option;
//
// Is this device the one chosen?
//
if (KeyCount == QuestionId) {
//
// Assigning the returned Key to a global allows the original routine to know what was chosen
//
mKeyInput = QuestionId;
//
// Request to exit SendForm(), so that we could boot the selected option
//
*ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
break;
}
}
return EFI_SUCCESS;
}
//
// All other action return unsupported.
//
return EFI_UNSUPPORTED;
}
/**
Adjust option order base on the question value.
@param Question Pointer to current question.
@param PopUpMenuLines The line number of the pop up menu.
@retval EFI_SUCCESS If Option input is processed successfully
@retval EFI_DEVICE_ERROR If operation fails
**/
EFI_STATUS
AdjustOptionOrder (
IN FORM_DISPLAY_ENGINE_STATEMENT *Question,
OUT UINTN *PopUpMenuLines
)
{
UINTN Index;
EFI_IFR_ORDERED_LIST *OrderList;
UINT8 *ValueArray;
UINT8 ValueType;
LIST_ENTRY *Link;
DISPLAY_QUESTION_OPTION *OneOfOption;
EFI_HII_VALUE *HiiValueArray;
Link = GetFirstNode (&Question->OptionListHead);
OneOfOption = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);
ValueArray = Question->CurrentValue.Buffer;
ValueType = OneOfOption->OptionOpCode->Type;
OrderList = (EFI_IFR_ORDERED_LIST *) Question->OpCode;
for (Index = 0; Index < OrderList->MaxContainers; Index++) {
if (GetArrayData (ValueArray, ValueType, Index) == 0) {
break;
}
}
*PopUpMenuLines = Index;
//
// Prepare HiiValue array
//
HiiValueArray = AllocateZeroPool (*PopUpMenuLines * sizeof (EFI_HII_VALUE));
ASSERT (HiiValueArray != NULL);
for (Index = 0; Index < *PopUpMenuLines; Index++) {
HiiValueArray[Index].Type = ValueType;
HiiValueArray[Index].Value.u64 = GetArrayData (ValueArray, ValueType, Index);
}
for (Index = 0; Index < *PopUpMenuLines; Index++) {
OneOfOption = ValueToOption (Question, &HiiValueArray[*PopUpMenuLines - Index - 1]);
if (OneOfOption == NULL) {
return EFI_NOT_FOUND;
}
RemoveEntryList (&OneOfOption->Link);
//
// Insert to head.
//
InsertHeadList (&Question->OptionListHead, &OneOfOption->Link);
}
FreePool (HiiValueArray);
return EFI_SUCCESS;
}
/**
Retrieve one record of from free record buffer. This record is removed from
free record buffer.
This function retrieves one record from free record buffer.
If the pool has been exhausted, then new memory would be allocated for it.
@return Pointer to the free record.
NULL means failure to allocate new memeory for free record buffer.
**/
DATA_HUB_STATUS_CODE_DATA_RECORD *
AcquireRecordBuffer (
VOID
)
{
DATAHUB_STATUSCODE_RECORD *Record;
EFI_TPL CurrentTpl;
LIST_ENTRY *Node;
UINT32 Index;
CurrentTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);
if (!IsListEmpty (&mRecordsBuffer)) {
//
// Strip one entry from free record buffer.
//
Node = GetFirstNode (&mRecordsBuffer);
RemoveEntryList (Node);
Record = BASE_CR (Node, DATAHUB_STATUSCODE_RECORD, Node);
} else {
if (CurrentTpl > TPL_NOTIFY) {
//
// Memory management should work at <=TPL_NOTIFY
//
gBS->RestoreTPL (CurrentTpl);
return NULL;
}
//
// If free record buffer is exhausted, then allocate 16 new records for it.
//
gBS->RestoreTPL (CurrentTpl);
Record = (DATAHUB_STATUSCODE_RECORD *) AllocateZeroPool (sizeof (DATAHUB_STATUSCODE_RECORD) * 16);
if (Record == NULL) {
return NULL;
}
CurrentTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);
//
// Here we only insert 15 new records to the free record buffer, for the first record
// will be returned immediately.
//
for (Index = 1; Index < 16; Index++) {
InsertTailList (&mRecordsBuffer, &Record[Index].Node);
}
}
Record->Signature = DATAHUB_STATUS_CODE_SIGNATURE;
InsertTailList (&mRecordsFifo, &Record->Node);
gBS->RestoreTPL (CurrentTpl);
return (DATA_HUB_STATUS_CODE_DATA_RECORD *) (Record->Data);
}
/**
Get the ONE_OF_OPTION_MAP_ENTRY for a QuestionId that invokes the
EFI_FORM_CALLBACK_PROTOCOL.Callback. The information is needed as
the callback mechanism for EFI_IFR_ONE_OF_OPTION is changed from
EFI_IFR_ONE_OF_OPTION in Framework IFR. Check EFI_IFR_GUID_OPTIONKEY
for detailed information.
@param ThunkContext The Thunk Context.
@param QuestionId The Question Id.
@param Type The Question Type.
@param Value The One Of Option's value.
@return The ONE_OF_OPTION_MAP_ENTRY found.
@retval NULL If no entry is found.
**/
ONE_OF_OPTION_MAP_ENTRY *
GetOneOfOptionMapEntry (
IN HII_THUNK_CONTEXT *ThunkContext,
IN EFI_QUESTION_ID QuestionId,
IN UINT8 Type,
IN EFI_IFR_TYPE_VALUE *Value
)
{
LIST_ENTRY *Link;
LIST_ENTRY *Link2;
ONE_OF_OPTION_MAP_ENTRY *OneOfOptionMapEntry;
ONE_OF_OPTION_MAP *OneOfOptionMap;
FORM_BROWSER_FORMSET *FormSet;
FormSet = ThunkContext->FormSet;
Link = GetFirstNode (&FormSet->OneOfOptionMapListHead);
while (!IsNull (&FormSet->OneOfOptionMapListHead, Link)) {
OneOfOptionMap = ONE_OF_OPTION_MAP_FROM_LINK(Link);
if (OneOfOptionMap->QuestionId == QuestionId) {
ASSERT (OneOfOptionMap->ValueType == Type);
Link2 = GetFirstNode (&OneOfOptionMap->OneOfOptionMapEntryListHead);
while (!IsNull (&OneOfOptionMap->OneOfOptionMapEntryListHead, Link2)) {
OneOfOptionMapEntry = ONE_OF_OPTION_MAP_ENTRY_FROM_LINK (Link2);
if (CompareMem (Value, &OneOfOptionMapEntry->Value, sizeof (EFI_IFR_TYPE_VALUE)) == 0) {
return OneOfOptionMapEntry;
}
Link2 = GetNextNode (&OneOfOptionMap->OneOfOptionMapEntryListHead, Link2);
}
}
Link = GetNextNode (&FormSet->OneOfOptionMapListHead, Link);
}
return NULL;
}
// Free the resources in the file's Region list.
STATIC
VOID
FreeFileRegions (
IN BOOTMON_FS_FILE *File
)
{
LIST_ENTRY *RegionToFlushLink;
BOOTMON_FS_FILE_REGION *Region;
RegionToFlushLink = GetFirstNode (&File->RegionToFlushLink);
while (!IsNull (&File->RegionToFlushLink, RegionToFlushLink)) {
// Repeatedly remove the first node from the list and free its resources.
Region = (BOOTMON_FS_FILE_REGION *) RegionToFlushLink;
RemoveEntryList (RegionToFlushLink);
FreePool (Region->Buffer);
FreePool (Region);
RegionToFlushLink = GetFirstNode (&File->RegionToFlushLink);
}
}
//
// stoplights and stopsigns
//
void vtRoadMap3d::GenerateSigns(vtLodGrid *pLodGrid)
{
if (!pLodGrid)
return;
vtContentManager3d &con = vtGetContent();
osg::Node *stopsign = con.CreateNodeFromItemname("American Stopsign");
osg::Node *stoplight = con.CreateNodeFromItemname("Stoplight (right)");
if (!stopsign || !stoplight)
{
VTLOG("Couldn't find stopsign and stoplight.\n");
return;
}
for (NodeGeom *pN = GetFirstNode(); pN; pN = pN->GetNext())
{
for (int r = 0; r < pN->NumLinks(); r++)
{
osg::Node *shape = NULL;
if (pN->GetIntersectType(r) == IT_STOPSIGN && stopsign)
{
shape = (osg::Node *) stopsign->clone(osg::CopyOp::SHALLOW_COPY);
}
if (pN->GetIntersectType(r) == IT_LIGHT && stoplight)
{
shape = (osg::Node *) stoplight->clone(osg::CopyOp::SHALLOW_COPY);
}
if (!shape) continue;
vtTransform *trans = new vtTransform;
trans->addChild(shape);
LinkGeom *link = pN->GetLink(r);
FPoint3 unit = pN->GetUnitLinkVector(r);
FPoint3 perp(unit.z, unit.y, -unit.x);
FPoint3 offset;
// Turn the sign (yaw) to face the oncoming traffic
trans->RotateLocal(FPoint3(0,1,0), pN->GetLinkAngle(r) + PID2f);
if (pN->GetIntersectType(r) == IT_STOPSIGN)
{
offset = pN->m_p3 + (unit * 6.0f) + (perp * (link->m_fRightWidth));
}
if (pN->GetIntersectType(r) == IT_LIGHT)
{
offset = pN->m_p3 - (unit * 6.0f) + (perp * (link->m_fRightWidth));
}
trans->Translate(offset);
pLodGrid->AddToGrid(trans);
}
}
}
/**
Initialize Question's members.
@param OpCodeData Pointer of the raw OpCode data.
@param FormSet Pointer of the current FormSet.
@param Form Pointer of the current Form.
@return The Question.
**/
FORM_BROWSER_STATEMENT *
CreateQuestion (
IN UINT8 *OpCodeData,
IN OUT FORM_BROWSER_FORMSET *FormSet,
IN OUT FORM_BROWSER_FORM *Form
)
{
FORM_BROWSER_STATEMENT *Statement;
EFI_IFR_QUESTION_HEADER *QuestionHdr;
LIST_ENTRY *Link;
FORMSET_STORAGE *Storage;
Statement = CreateStatement (OpCodeData, FormSet, Form);
if (Statement == NULL) {
return NULL;
}
QuestionHdr = (EFI_IFR_QUESTION_HEADER *) (OpCodeData + sizeof (EFI_IFR_OP_HEADER));
CopyMem (&Statement->QuestionId, &QuestionHdr->QuestionId, sizeof (EFI_QUESTION_ID));
CopyMem (&Statement->VarStoreId, &QuestionHdr->VarStoreId, sizeof (EFI_VARSTORE_ID));
CopyMem (&Statement->VarStoreInfo.VarOffset, &QuestionHdr->VarStoreInfo.VarOffset, sizeof (UINT16));
if (FormSet->MaxQuestionId < QuestionHdr->QuestionId) {
FormSet->MaxQuestionId = QuestionHdr->QuestionId;
}
Statement->QuestionFlags = QuestionHdr->Flags;
if (Statement->VarStoreId == 0) {
//
// VarStoreId of zero indicates no variable storage
//
return Statement;
}
//
// Find Storage for this Question
//
Link = GetFirstNode (&FormSet->StorageListHead);
while (!IsNull (&FormSet->StorageListHead, Link)) {
Storage = FORMSET_STORAGE_FROM_LINK (Link);
if (Storage->VarStoreId == Statement->VarStoreId) {
Statement->Storage = Storage;
break;
}
Link = GetNextNode (&FormSet->StorageListHead, Link);
}
ASSERT (Statement->Storage != NULL);
return Statement;
}
/**
Reads the next keystroke from the input device. The WaitForKey Event can
be used to test for existence of a keystroke via WaitForEvent () call.
@param TerminalDevice Terminal driver private structure
@param KeyData A pointer to a buffer that is filled in with the
keystroke state data for the key that was
pressed.
@retval EFI_SUCCESS The keystroke information was returned.
@retval EFI_NOT_READY There was no keystroke data available.
@retval EFI_DEVICE_ERROR The keystroke information was not returned due
to hardware errors.
@retval EFI_INVALID_PARAMETER KeyData is NULL.
**/
EFI_STATUS
ReadKeyStrokeWorker (
IN TERMINAL_DEV *TerminalDevice,
OUT EFI_KEY_DATA *KeyData
)
{
EFI_STATUS Status;
LIST_ENTRY *Link;
LIST_ENTRY *NotifyList;
TERMINAL_CONSOLE_IN_EX_NOTIFY *CurrentNotify;
if (KeyData == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// Initialize *Key to nonsense value.
//
KeyData->Key.ScanCode = SCAN_NULL;
KeyData->Key.UnicodeChar = 0;
Status = TerminalConInCheckForKey (&TerminalDevice->SimpleInput);
if (EFI_ERROR (Status)) {
return EFI_NOT_READY;
}
if (!EfiKeyFiFoRemoveOneKey (TerminalDevice, &KeyData->Key)) {
return EFI_NOT_READY;
}
KeyData->KeyState.KeyShiftState = 0;
KeyData->KeyState.KeyToggleState = 0;
//
// Invoke notification functions if exist
//
NotifyList = &TerminalDevice->NotifyList;
for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList,Link); Link = GetNextNode (NotifyList,Link)) {
CurrentNotify = CR (
Link,
TERMINAL_CONSOLE_IN_EX_NOTIFY,
NotifyEntry,
TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE
);
if (IsKeyRegistered (&CurrentNotify->KeyData, KeyData)) {
CurrentNotify->KeyNotificationFn (KeyData);
}
}
return EFI_SUCCESS;
}
/**
Return the boot description for the controller.
@param Handle Controller handle.
@return The description string.
**/
CHAR16 *
BmGetBootDescription (
IN EFI_HANDLE Handle
)
{
LIST_ENTRY *Link;
BM_BOOT_DESCRIPTION_ENTRY *Entry;
CHAR16 *Description;
CHAR16 *DefaultDescription;
CHAR16 *Temp;
UINTN Index;
//
// Firstly get the default boot description
//
DefaultDescription = NULL;
for (Index = 0; Index < sizeof (mBmBootDescriptionHandlers) / sizeof (mBmBootDescriptionHandlers[0]); Index++) {
DefaultDescription = mBmBootDescriptionHandlers[Index] (Handle);
if (DefaultDescription != NULL) {
//
// Avoid description confusion between UEFI & Legacy boot option by adding "UEFI " prefix
// ONLY for core provided boot description handler.
//
Temp = AllocatePool (StrSize (DefaultDescription) + sizeof (mBmUefiPrefix));
ASSERT (Temp != NULL);
StrCpyS (Temp, (StrSize (DefaultDescription) + sizeof (mBmUefiPrefix)) / sizeof (CHAR16), mBmUefiPrefix);
StrCatS (Temp, (StrSize (DefaultDescription) + sizeof (mBmUefiPrefix)) / sizeof (CHAR16), DefaultDescription);
FreePool (DefaultDescription);
DefaultDescription = Temp;
break;
}
}
ASSERT (DefaultDescription != NULL);
//
// Secondly query platform for the better boot description
//
for ( Link = GetFirstNode (&mPlatformBootDescriptionHandlers)
; !IsNull (&mPlatformBootDescriptionHandlers, Link)
; Link = GetNextNode (&mPlatformBootDescriptionHandlers, Link)
) {
Entry = CR (Link, BM_BOOT_DESCRIPTION_ENTRY, Link, BM_BOOT_DESCRIPTION_ENTRY_SIGNATURE);
Description = Entry->Handler (Handle, DefaultDescription);
if (Description != NULL) {
FreePool (DefaultDescription);
return Description;
}
}
return DefaultDescription;
}
/**
Remove a registered notification function from a particular keystroke.
@param This Protocol instance pointer.
@param NotificationHandle The handle of the notification function being unregistered.
@retval EFI_SUCCESS The notification function was unregistered successfully.
@retval EFI_INVALID_PARAMETER The NotificationHandle is invalid
**/
EFI_STATUS
EFIAPI
USBKeyboardUnregisterKeyNotify (
IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
IN EFI_HANDLE NotificationHandle
)
{
USB_KB_DEV *UsbKeyboardDevice;
KEYBOARD_CONSOLE_IN_EX_NOTIFY *CurrentNotify;
LIST_ENTRY *Link;
LIST_ENTRY *NotifyList;
if (NotificationHandle == NULL) {
return EFI_INVALID_PARAMETER;
}
if (((KEYBOARD_CONSOLE_IN_EX_NOTIFY *) NotificationHandle)->Signature != USB_KB_CONSOLE_IN_EX_NOTIFY_SIGNATURE) {
return EFI_INVALID_PARAMETER;
}
UsbKeyboardDevice = TEXT_INPUT_EX_USB_KB_DEV_FROM_THIS (This);
//
// Traverse notify list of USB keyboard and remove the entry of NotificationHandle.
//
NotifyList = &UsbKeyboardDevice->NotifyList;
for (Link = GetFirstNode (NotifyList);
!IsNull (NotifyList, Link);
Link = GetNextNode (NotifyList, Link)) {
CurrentNotify = CR (
Link,
KEYBOARD_CONSOLE_IN_EX_NOTIFY,
NotifyEntry,
USB_KB_CONSOLE_IN_EX_NOTIFY_SIGNATURE
);
if (CurrentNotify->NotifyHandle == NotificationHandle) {
//
// Remove the notification function from NotifyList and free resources
//
RemoveEntryList (&CurrentNotify->NotifyEntry);
FreePool (CurrentNotify);
return EFI_SUCCESS;
}
}
//
// Cannot find the matching entry in database.
//
return EFI_INVALID_PARAMETER;
}
/**
Resets an SD card that is connected to the SD controller.
The ResetDevice() function resets the SD card specified by Slot.
If this SD controller does not support a device reset operation, EFI_UNSUPPORTED is
returned.
If Slot is not in a valid slot number for this SD controller, EFI_INVALID_PARAMETER
is returned.
If the device reset operation is completed, EFI_SUCCESS is returned.
@param[in] This A pointer to the EFI_SD_MMC_PASS_THRU_PROTOCOL instance.
@param[in] Slot Specifies the slot number of the SD card to be reset.
@retval EFI_SUCCESS The SD card specified by Slot was reset.
@retval EFI_UNSUPPORTED The SD controller does not support a device reset operation.
@retval EFI_INVALID_PARAMETER Slot number is invalid.
@retval EFI_NO_MEDIA SD Device not present in the Slot.
@retval EFI_DEVICE_ERROR The reset command failed due to a device error
**/
EFI_STATUS
EFIAPI
SdMmcPassThruResetDevice (
IN EFI_SD_MMC_PASS_THRU_PROTOCOL *This,
IN UINT8 Slot
)
{
SD_MMC_HC_PRIVATE_DATA *Private;
LIST_ENTRY *Link;
LIST_ENTRY *NextLink;
SD_MMC_HC_TRB *Trb;
EFI_TPL OldTpl;
if (This == NULL) {
return EFI_INVALID_PARAMETER;
}
Private = SD_MMC_HC_PRIVATE_FROM_THIS (This);
if (!Private->Slot[Slot].Enable) {
return EFI_INVALID_PARAMETER;
}
if (!Private->Slot[Slot].MediaPresent) {
return EFI_NO_MEDIA;
}
if (!Private->Slot[Slot].Initialized) {
return EFI_DEVICE_ERROR;
}
//
// Free all async I/O requests in the queue
//
OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
for (Link = GetFirstNode (&Private->Queue);
!IsNull (&Private->Queue, Link);
Link = NextLink) {
NextLink = GetNextNode (&Private->Queue, Link);
RemoveEntryList (Link);
Trb = SD_MMC_HC_TRB_FROM_THIS (Link);
Trb->Packet->TransactionStatus = EFI_ABORTED;
gBS->SignalEvent (Trb->Event);
SdMmcFreeTrb (Trb);
}
gBS->RestoreTPL (OldTpl);
return EFI_SUCCESS;
}
/**
* Gets the number of a nodes on a given node.
*
* @param refNode Node to check level.
* @return The previous node or NULL if there's no previous.
*/
size_t VDFTree::CountBranchNodes(VDFNode *refNode)
{
VDFNode *firstNode;
size_t counter;
firstNode = GetFirstNode(refNode);
counter = 0;
while(firstNode) {
counter++;
firstNode = firstNode->nextNode;
}
return counter;
}
/**
Notification function of EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE.
This is a notification function registered on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.
It convers pointer to new virtual address.
@param Event Event whose notification function is being invoked.
@param Context Pointer to the notification function's context.
**/
VOID
EFIAPI
VariableClassAddressChangeEvent (
IN EFI_EVENT Event,
IN VOID *Context
)
{
LIST_ENTRY *Link;
VARIABLE_ENTRY *Entry;
EFI_STATUS Status;
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->GetBlockSize);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->GetPhysicalAddress);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->GetAttributes);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->SetAttributes);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->Read);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->Write);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance->EraseBlocks);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->FvbInstance);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->PlatformLangCodes);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->LangCodes);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->PlatformLang);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal->VariableGlobal.VolatileVariableBase);
EfiConvertPointer (0x0, (VOID **) &mVariableModuleGlobal);
EfiConvertPointer (0x0, (VOID **) &mHashCtx);
EfiConvertPointer (0x0, (VOID **) &mSerializationRuntimeBuffer);
EfiConvertPointer (0x0, (VOID **) &mNvVariableCache);
EfiConvertPointer (0x0, (VOID **) &mPubKeyStore);
EfiConvertPointer (0x0, (VOID **) &mCertDbStore);
//
// in the list of locked variables, convert the name pointers first
//
for ( Link = GetFirstNode (&mLockedVariableList)
; !IsNull (&mLockedVariableList, Link)
; Link = GetNextNode (&mLockedVariableList, Link)
) {
Entry = BASE_CR (Link, VARIABLE_ENTRY, Link);
Status = EfiConvertPointer (0x0, (VOID **) &Entry->Name);
ASSERT_EFI_ERROR (Status);
}
//
// second, convert the list itself using UefiRuntimeLib
//
Status = EfiConvertList (0x0, &mLockedVariableList);
ASSERT_EFI_ERROR (Status);
}
/**
Process key notify.
@param Event Indicates the event that invoke this function.
@param Context Indicates the calling context.
**/
VOID
EFIAPI
KeyNotifyProcessHandler (
IN EFI_EVENT Event,
IN VOID *Context
)
{
EFI_STATUS Status;
VIRTUAL_KEYBOARD_DEV *VirtualKeyboardPrivate;
EFI_KEY_DATA KeyData;
LIST_ENTRY *Link;
LIST_ENTRY *NotifyList;
VIRTUAL_KEYBOARD_CONSOLE_IN_EX_NOTIFY *CurrentNotify;
EFI_TPL OldTpl;
VirtualKeyboardPrivate = (VIRTUAL_KEYBOARD_DEV *) Context;
//
// Invoke notification functions.
//
NotifyList = &VirtualKeyboardPrivate->NotifyList;
while (TRUE) {
//
// Enter critical section
//
OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
Status = Dequeue (&VirtualKeyboardPrivate->QueueForNotify, &KeyData);
//
// Leave critical section
//
gBS->RestoreTPL (OldTpl);
if (EFI_ERROR (Status)) {
break;
}
for (Link = GetFirstNode (NotifyList);
!IsNull (NotifyList, Link);
Link = GetNextNode (NotifyList, Link)) {
CurrentNotify = CR (Link,
VIRTUAL_KEYBOARD_CONSOLE_IN_EX_NOTIFY,
NotifyEntry,
VIRTUAL_KEYBOARD_CONSOLE_IN_EX_NOTIFY_SIGNATURE
);
if (IsKeyRegistered (&CurrentNotify->KeyData, &KeyData)) {
CurrentNotify->KeyNotificationFn (&KeyData);
}
}
}
}
/**
Search for Framework SMI handler information according to specific PI SMM dispatch handle.
@param[in] DispatchHandle The unique handle assigned by SmiHandlerRegister().
@return Pointer to CALLBACK_INFO. If NULL, no callback info record is found.
**/
CALLBACK_INFO *
GetCallbackInfo (
IN EFI_HANDLE DispatchHandle
)
{
LIST_ENTRY *Node;
Node = GetFirstNode (&mCallbackInfoListHead);
while (!IsNull (&mCallbackInfoListHead, Node)) {
if (((CALLBACK_INFO *)Node)->DispatchHandle == DispatchHandle) {
return (CALLBACK_INFO *)Node;
}
Node = GetNextNode (&mCallbackInfoListHead, Node);
}
return NULL;
}
/***
Get all partitions of all USB devices in linked list.
@param[in|out] DeviceList - Linked list of USB devices.
@param[in] MaxDevices - Number of USB devices in linked list.
@retval EFI_SUCCESS The function exited normally.
@retval Other An error occurred.
***/
EFI_STATUS
UsbGetAllPartitions (
IN OUT LIST_ENTRY *DeviceList,
IN UINTN MaxDevices
)
{
EFI_STATUS Status;
LIST_ENTRY ChildHandleList[MaxDevices];
LIST_ENTRY *Node = NULL;
DISK_ENTRY *DiskEntry = NULL;
UINTN MaxPartitions, Index;
if (IsListEmpty (DeviceList)) {
return EFI_INVALID_PARAMETER;
}
Index = 0;
Node = GetFirstNode (DeviceList);
while (!IsNull (DeviceList, Node)) {
DiskEntry = (DISK_ENTRY*)Node;
MaxPartitions = 0;
Status = GetChildHandles (
DiskEntry->DiskInfo.DiskHandle,
&gEfiBlockIoProtocolGuid,
&gEfiDiskIoProtocolGuid,
&ChildHandleList[Index]
);
if (Status == EFI_SUCCESS) {
Status = CheckGptMbrPartitions (
&ChildHandleList[Index],
DiskEntry->DiskInfo.BlockIo->Media->MediaId,
&(DiskEntry->DiskInfo.PartitionsList),
&MaxPartitions
);
if (Status == EFI_SUCCESS) {
DiskEntry->DiskInfo.MaxPartitions = MaxPartitions;
DBG ("MaxPartitions: %d\n", MaxPartitions);
}
}
Index++;
Node = GetNextNode (DeviceList, Node);
}
DBG ("OK\n");
return EFI_SUCCESS;
}
/**
Complete the current request
This routine is called at TPL_I2C_SYNC.
@param[in] I2cHostContext Address of an I2C_HOST_CONTEXT structure.
@param[in] Status Status of the I2C operation.
@return This routine returns the input status value.
**/
EFI_STATUS
I2cHostRequestComplete (
I2C_HOST_CONTEXT *I2cHostContext,
EFI_STATUS Status
)
{
I2C_REQUEST *I2cRequest;
LIST_ENTRY *EntryHeader;
LIST_ENTRY *Entry;
//
// Remove the current I2C request from the list
//
EntryHeader = &I2cHostContext->RequestList;
Entry = GetFirstNode (EntryHeader);
I2cRequest = I2C_REQUEST_FROM_ENTRY (Entry);
//
// Save the status for QueueRequest
//
if ( NULL != I2cRequest->Status ) {
*I2cRequest->Status = Status;
}
//
// Notify the user of the I2C request completion
//
if ( NULL != I2cRequest->Event ) {
gBS->SignalEvent (I2cRequest->Event);
}
//
// Done with this request, remove the current request from list
//
RemoveEntryList (&I2cRequest->Link);
FreePool (I2cRequest->RequestPacket);
FreePool (I2cRequest);
//
// If there is more I2C request, start next one
//
if(!IsListEmpty (EntryHeader)) {
I2cHostRequestEnable (I2cHostContext);
}
return Status;
}
/**
Remove a registered notification function from a particular keystroke.
@param This Protocol instance pointer.
@param NotificationHandle The handle of the notification function being
unregistered.
@retval EFI_SUCCESS The notification function was unregistered
successfully.
@retval EFI_INVALID_PARAMETER The NotificationHandle is invalid.
**/
EFI_STATUS
EFIAPI
TerminalConInUnregisterKeyNotify (
IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
IN EFI_HANDLE NotificationHandle
)
{
TERMINAL_DEV *TerminalDevice;
LIST_ENTRY *Link;
TERMINAL_CONSOLE_IN_EX_NOTIFY *CurrentNotify;
LIST_ENTRY *NotifyList;
if (NotificationHandle == NULL) {
return EFI_INVALID_PARAMETER;
}
if (((TERMINAL_CONSOLE_IN_EX_NOTIFY *) NotificationHandle)->Signature != TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE) {
return EFI_INVALID_PARAMETER;
}
TerminalDevice = TERMINAL_CON_IN_EX_DEV_FROM_THIS (This);
NotifyList = &TerminalDevice->NotifyList;
for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList,Link); Link = GetNextNode (NotifyList,Link)) {
CurrentNotify = CR (
Link,
TERMINAL_CONSOLE_IN_EX_NOTIFY,
NotifyEntry,
TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE
);
if (CurrentNotify->NotifyHandle == NotificationHandle) {
//
// Remove the notification function from NotifyList and free resources
//
RemoveEntryList (&CurrentNotify->NotifyEntry);
gBS->FreePool (CurrentNotify);
return EFI_SUCCESS;
}
}
//
// Can not find the matching entry in database.
//
return EFI_INVALID_PARAMETER;
}
/**
Update the value of a given alias on the list. If the alias is not there then add it.
@param[in] Alias The alias to test for.
@param[in] CommandString The updated command string.
@param[in, out] List The list to search.
@retval EFI_SUCCESS The operation was completed successfully.
@retval EFI_OUT_OF_RESOURCES There was not enough free memory.
**/
EFI_STATUS
EFIAPI
InternalUpdateAliasOnList(
IN CONST CHAR16 *Alias,
IN CONST CHAR16 *CommandString,
IN OUT LIST_ENTRY *List
)
{
ALIAS_LIST *Node;
BOOLEAN Found;
//
// assert for NULL parameter
//
ASSERT(Alias != NULL);
//
// check for the Alias
//
for ( Node = (ALIAS_LIST *)GetFirstNode(List), Found = FALSE
; !IsNull(List, &Node->Link)
; Node = (ALIAS_LIST *)GetNextNode(List, &Node->Link)
){
ASSERT(Node->CommandString != NULL);
ASSERT(Node->Alias != NULL);
if (StrCmp(Node->Alias, Alias)==0) {
FreePool(Node->CommandString);
Node->CommandString = NULL;
Node->CommandString = StrnCatGrow(&Node->CommandString, NULL, CommandString, 0);
Found = TRUE;
break;
}
}
if (!Found) {
Node = AllocateZeroPool(sizeof(ALIAS_LIST));
if (Node == NULL) {
return (EFI_OUT_OF_RESOURCES);
}
ASSERT(Node->Alias == NULL);
Node->Alias = StrnCatGrow(&Node->Alias, NULL, Alias, 0);
ASSERT(Node->CommandString == NULL);
Node->CommandString = StrnCatGrow(&Node->CommandString, NULL, CommandString, 0);
InsertTailList(List, &Node->Link);
}
return (EFI_SUCCESS);
}
/**
function to add each command name from the linked list to the string list.
the resultant list is a double NULL terminated list of NULL terminated strings.
@param[in,out] DestList double pointer to the list. may be NULL.
@param[in,out] DestSize pointer to the size of list. may be 0, if DestList is NULL.
@param[in] SourceList the double linked list of commands.
@retval EFI_SUCCESS the operation was successful.
**/
EFI_STATUS
CopyListOfCommandNames(
IN OUT CHAR16 **DestList,
IN OUT UINTN *DestSize,
IN CONST COMMAND_LIST *SourceList
)
{
CONST COMMAND_LIST *Node;
for ( Node = (COMMAND_LIST*)GetFirstNode(&SourceList->Link)
; SourceList != NULL && !IsListEmpty(&SourceList->Link) && !IsNull(&SourceList->Link, &Node->Link)
; Node = (COMMAND_LIST*)GetNextNode(&SourceList->Link, &Node->Link)
) {
LexicalInsertIntoList(DestList, DestSize, Node->CommandString);
}
return (EFI_SUCCESS);
}
/**
Insert one pre-fetched key into the FIFO buffer.
@param TerminalDevice Terminal driver private structure.
@param Key The key will be input.
@retval TRUE If insert successfully.
@retval FLASE If FIFO buffer is full before key insertion,
and the key is lost.
**/
BOOLEAN
EfiKeyFiFoInsertOneKey (
TERMINAL_DEV *TerminalDevice,
EFI_INPUT_KEY *Key
)
{
UINT8 Tail;
LIST_ENTRY *Link;
LIST_ENTRY *NotifyList;
TERMINAL_CONSOLE_IN_EX_NOTIFY *CurrentNotify;
EFI_KEY_DATA KeyData;
Tail = TerminalDevice->EfiKeyFiFo->Tail;
CopyMem (&KeyData.Key, Key, sizeof (EFI_INPUT_KEY));
KeyData.KeyState.KeyShiftState = 0;
KeyData.KeyState.KeyToggleState = 0;
//
// Invoke notification functions if exist
//
NotifyList = &TerminalDevice->NotifyList;
for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList,Link); Link = GetNextNode (NotifyList,Link)) {
CurrentNotify = CR (
Link,
TERMINAL_CONSOLE_IN_EX_NOTIFY,
NotifyEntry,
TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE
);
if (IsKeyRegistered (&CurrentNotify->KeyData, &KeyData)) {
CurrentNotify->KeyNotificationFn (&KeyData);
}
}
if (IsEfiKeyFiFoFull (TerminalDevice)) {
//
// Efi Key FIFO is full
//
return FALSE;
}
CopyMem (&TerminalDevice->EfiKeyFiFo->Data[Tail], Key, sizeof (EFI_INPUT_KEY));
TerminalDevice->EfiKeyFiFo->Tail = (UINT8) ((Tail + 1) % (FIFO_MAX_NUMBER + 1));
return TRUE;
}
/**
Callback function for SimpleTextInEx protocol install events
@param Event the event that is signaled.
@param Context not used here.
**/
VOID
EFIAPI
TxtInExCallback (
IN EFI_EVENT Event,
IN VOID *Context
)
{
EFI_STATUS Status;
UINTN BufferSize;
EFI_HANDLE Handle;
EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TxtInEx;
LIST_ENTRY *Link;
while (TRUE) {
BufferSize = sizeof (EFI_HANDLE);
Status = gBS->LocateHandle (
ByRegisterNotify,
NULL,
mTxtInExRegistration,
&BufferSize,
&Handle
);
if (EFI_ERROR (Status)) {
//
// If no more notification events exist
//
return ;
}
Status = gBS->HandleProtocol (
Handle,
&gEfiSimpleTextInputExProtocolGuid,
(VOID **) &TxtInEx
);
ASSERT_EFI_ERROR (Status);
//
// Register the hot key notification for the existing items in the list
//
EfiAcquireLock (&mHotkeyLock);
for (Link = GetFirstNode (&mHotkeyList); !IsNull (&mHotkeyList, Link); Link = GetNextNode (&mHotkeyList, Link)) {
RegisterHotkeyNotify (TxtInEx, HOTKEY_FROM_LINK (Link));
}
EfiReleaseLock (&mHotkeyLock);
}
}
EFIAPI
ShellCommandFindMapItem (
IN CONST CHAR16 *MapKey
)
{
SHELL_MAP_LIST *MapListItem;
for ( MapListItem = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
; !IsNull(&gShellMapList.Link, &MapListItem->Link)
; MapListItem = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &MapListItem->Link)
){
if (gUnicodeCollation->StriColl(gUnicodeCollation,MapListItem->MapName,(CHAR16*)MapKey) == 0) {
return (MapListItem);
}
}
return (NULL);
}
/**
Get the first EFI_IFR_VARSTORE from the FormSet.
@param FormSet The Form Set.
@retval FORMSET_STORAGE * Return the first EFI_IFR_VARSTORE.
@retval NULL If the Form Set does not have EFI_IFR_VARSTORE.
**/
FORMSET_STORAGE *
GetFirstStorageOfFormSet (
IN CONST FORM_BROWSER_FORMSET * FormSet
)
{
LIST_ENTRY *StorageList;
FORMSET_STORAGE *Storage;
StorageList = GetFirstNode (&FormSet->StorageListHead);
if (!IsNull (&FormSet->StorageListHead, StorageList)) {
Storage = FORMSET_STORAGE_FROM_LINK (StorageList);
return Storage;
}
return NULL;
}
/**
Search the Head list for a EFI_DATA_HUB_FILTER_DRIVER member that
represents Event and return it.
@param Head Pointer to head of dual linked list of EFI_DATA_HUB_FILTER_DRIVER structures.
@param Event Event to be search for in the Head list.
@retval EFI_DATA_HUB_FILTER_DRIVER Returned if Event stored in the Head doubly linked list.
@retval NULL If Event is not in the list
**/
DATA_HUB_FILTER_DRIVER *
FindFilterDriverByEvent (
IN LIST_ENTRY *Head,
IN EFI_EVENT Event
)
{
DATA_HUB_FILTER_DRIVER *FilterEntry;
LIST_ENTRY *Link;
for (Link = GetFirstNode(Head); Link != Head; Link = GetNextNode(Head, Link)) {
FilterEntry = FILTER_ENTRY_FROM_LINK (Link);
if (FilterEntry->Event == Event) {
return FilterEntry;
}
}
return NULL;
}
VOID
QNCSmmPeriodicTimerClearSource (
IN QNC_SMM_SOURCE_DESC *SrcDesc
)
/*++
Routine Description:
This function is responsible for calculating and enabling any timers that are required
to dispatch messages to children. The SrcDesc argument isn't acutally used.
Arguments:
SrcDesc - Pointer to the QNC_SMM_SOURCE_DESC instance.
Returns:
None.
--*/
{
DATABASE_RECORD *RecordInDb;
LIST_ENTRY *LinkInDb;
QNCSmmPeriodicTimerProgramTimers ();
//
// Reset Elapsed time
//
LinkInDb = GetFirstNode (&mPrivateData.CallbackDataBase);
while (!IsNull (&mPrivateData.CallbackDataBase, LinkInDb)) {
RecordInDb = DATABASE_RECORD_FROM_LINK (LinkInDb);
if (RecordInDb->ProtocolType == PeriodicTimerType) {
//
// This child is registerd with the PeriodicTimer protocol and Callback
// has been invoked, so reset the ElapsedTime to 0
//
if (RecordInDb->CommBuffer.PeriodicTimer.ElapsedTime >= RecordInDb->ChildContext.PeriodicTimer.Period) {
RecordInDb->CommBuffer.PeriodicTimer.ElapsedTime = 0;
}
}
LinkInDb = GetNextNode (&mPrivateData.CallbackDataBase, &RecordInDb->Link);
}
}
/**
Internal Function. Allocate a pool by specified PoolIndex.
@param PoolType Type of pool to allocate.
@param PoolIndex Index which indicate the Pool size.
@param FreePoolHdr The returned Free pool.
@retval EFI_OUT_OF_RESOURCES Allocation failed.
@retval EFI_SUCCESS Pool successfully allocated.
**/
EFI_STATUS
InternalAllocPoolByIndex (
IN EFI_MEMORY_TYPE PoolType,
IN UINTN PoolIndex,
OUT FREE_POOL_HEADER **FreePoolHdr
)
{
EFI_STATUS Status;
FREE_POOL_HEADER *Hdr;
POOL_TAIL *Tail;
EFI_PHYSICAL_ADDRESS Address;
SMM_POOL_TYPE SmmPoolType;
Address = 0;
SmmPoolType = UefiMemoryTypeToSmmPoolType(PoolType);
ASSERT (PoolIndex <= MAX_POOL_INDEX);
Status = EFI_SUCCESS;
Hdr = NULL;
if (PoolIndex == MAX_POOL_INDEX) {
Status = SmmInternalAllocatePages (AllocateAnyPages, PoolType,
EFI_SIZE_TO_PAGES (MAX_POOL_SIZE << 1),
&Address, FALSE);
if (EFI_ERROR (Status)) {
return EFI_OUT_OF_RESOURCES;
}
Hdr = (FREE_POOL_HEADER *) (UINTN) Address;
} else if (!IsListEmpty (&mSmmPoolLists[SmmPoolType][PoolIndex])) {
Hdr = BASE_CR (GetFirstNode (&mSmmPoolLists[SmmPoolType][PoolIndex]), FREE_POOL_HEADER, Link);
RemoveEntryList (&Hdr->Link);
} else {
Status = InternalAllocPoolByIndex (PoolType, PoolIndex + 1, &Hdr);
if (!EFI_ERROR (Status)) {
Hdr->Header.Signature = 0;
Hdr->Header.Size >>= 1;
Hdr->Header.Available = TRUE;
Hdr->Header.Type = 0;
Tail = HEAD_TO_TAIL(&Hdr->Header);
Tail->Signature = 0;
Tail->Size = 0;
InsertHeadList (&mSmmPoolLists[SmmPoolType][PoolIndex], &Hdr->Link);
Hdr = (FREE_POOL_HEADER*)((UINT8*)Hdr + Hdr->Header.Size);
}
}
/**
Insert the String Package into the Package Lists which has the TAG GUID matching
the PackageListGuid of the String Package.
The Package List must have only IFR Package and no String Package.
Otherwise, ASSERT.
@param Private The HII THUNK driver context data.
@param StringPackageThunkContext The HII THUNK context data.
@param StringPackageListHeader The String Package List Header.
**/
VOID
UpdatePackListWithOnlyIfrPack (
IN HII_THUNK_PRIVATE_DATA *Private,
IN HII_THUNK_CONTEXT *StringPackageThunkContext,
IN CONST EFI_HII_PACKAGE_LIST_HEADER *StringPackageListHeader
)
{
EFI_STATUS Status;
LIST_ENTRY *Link;
HII_THUNK_CONTEXT *ThunkContext;
Link = GetFirstNode (&Private->ThunkContextListHead);
while (!IsNull (&Private->ThunkContextListHead, Link)) {
ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);
if (StringPackageThunkContext != ThunkContext) {
//
// Skip the String Package Thunk Entry itself.
//
if (CompareGuid (&StringPackageListHeader->PackageListGuid, &ThunkContext->TagGuid)) {
ASSERT (ThunkContext->StringPackageCount == 0 && ThunkContext->IfrPackageCount == 1);
ThunkContext->StringPackageCount = GetPackageCountByType (StringPackageListHeader, EFI_HII_PACKAGE_STRINGS);
Status = mHiiDatabase->UpdatePackageList (
mHiiDatabase,
ThunkContext->UefiHiiHandle,
StringPackageListHeader
);
ASSERT_EFI_ERROR (Status);
ThunkContext->SharingStringPack = TRUE;
StringPackageThunkContext->SharingStringPack = TRUE;
}
}
Link = GetNextNode (&Private->ThunkContextListHead, Link);
}
}