| /** @file | |
| Hotkey library functions. | |
| Copyright (c) 2011 - 2017, Intel Corporation. All rights reserved.<BR> | |
| (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR> | |
| 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. | |
| **/ | |
| #include "InternalBm.h" | |
| // | |
| // Lock for linked list | |
| // | |
| EFI_LOCK mBmHotkeyLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_NOTIFY); | |
| LIST_ENTRY mBmHotkeyList = INITIALIZE_LIST_HEAD_VARIABLE (mBmHotkeyList); | |
| EFI_EVENT mBmHotkeyTriggered = NULL; | |
| BOOLEAN mBmHotkeyServiceStarted = FALSE; | |
| UINTN mBmHotkeySupportCount = 0; | |
| // | |
| // Set OptionNumber as unassigned value to indicate the option isn't initialized | |
| // | |
| EFI_BOOT_MANAGER_LOAD_OPTION mBmHotkeyBootOption = { LoadOptionNumberUnassigned }; | |
| EFI_BOOT_MANAGER_KEY_OPTION *mBmContinueKeyOption = NULL; | |
| VOID *mBmTxtInExRegistration = NULL; | |
| /** | |
| Return the buffer size of the EFI_BOOT_MANAGER_KEY_OPTION data. | |
| @param KeyOption The input key option info. | |
| @retval The buffer size of the key option data. | |
| **/ | |
| UINTN | |
| BmSizeOfKeyOption ( | |
| IN CONST EFI_BOOT_MANAGER_KEY_OPTION *KeyOption | |
| ) | |
| { | |
| return OFFSET_OF (EFI_BOOT_MANAGER_KEY_OPTION, Keys) | |
| + KeyOption->KeyData.Options.InputKeyCount * sizeof (EFI_INPUT_KEY); | |
| } | |
| /** | |
| Check whether the input key option is valid. | |
| @param KeyOption Key option. | |
| @param KeyOptionSize Size of the key option. | |
| @retval TRUE Input key option is valid. | |
| @retval FALSE Input key option is not valid. | |
| **/ | |
| BOOLEAN | |
| BmIsKeyOptionValid ( | |
| IN CONST EFI_BOOT_MANAGER_KEY_OPTION *KeyOption, | |
| IN UINTN KeyOptionSize | |
| ) | |
| { | |
| UINT16 OptionName[BM_OPTION_NAME_LEN]; | |
| UINT8 *BootOption; | |
| UINTN BootOptionSize; | |
| UINT32 Crc; | |
| if (BmSizeOfKeyOption (KeyOption) != KeyOptionSize) { | |
| return FALSE; | |
| } | |
| // | |
| // Check whether corresponding Boot Option exist | |
| // | |
| UnicodeSPrint ( | |
| OptionName, sizeof (OptionName), L"%s%04x", | |
| mBmLoadOptionName[LoadOptionTypeBoot], KeyOption->BootOption | |
| ); | |
| GetEfiGlobalVariable2 (OptionName, (VOID **) &BootOption, &BootOptionSize); | |
| if (BootOption == NULL) { | |
| return FALSE; | |
| } | |
| // | |
| // Check CRC for Boot Option | |
| // | |
| gBS->CalculateCrc32 (BootOption, BootOptionSize, &Crc); | |
| FreePool (BootOption); | |
| return (BOOLEAN) (KeyOption->BootOptionCrc == Crc); | |
| } | |
| /** | |
| Check whether the input variable is an key option variable. | |
| @param Name Input variable name. | |
| @param Guid Input variable guid. | |
| @param OptionNumber The option number of this key option variable. | |
| @retval TRUE Input variable is a key option variable. | |
| @retval FALSE Input variable is not a key option variable. | |
| **/ | |
| BOOLEAN | |
| BmIsKeyOptionVariable ( | |
| CHAR16 *Name, | |
| EFI_GUID *Guid, | |
| UINT16 *OptionNumber | |
| ) | |
| { | |
| UINTN Index; | |
| UINTN Uint; | |
| if (!CompareGuid (Guid, &gEfiGlobalVariableGuid) || | |
| (StrSize (Name) != sizeof (L"Key####")) || | |
| (StrnCmp (Name, L"Key", 3) != 0) | |
| ) { | |
| return FALSE; | |
| } | |
| *OptionNumber = 0; | |
| for (Index = 3; Index < 7; Index++) { | |
| Uint = BmCharToUint (Name[Index]); | |
| if (Uint == -1) { | |
| return FALSE; | |
| } else { | |
| *OptionNumber = (UINT16) Uint + *OptionNumber * 0x10; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| typedef struct { | |
| EFI_BOOT_MANAGER_KEY_OPTION *KeyOptions; | |
| UINTN KeyOptionCount; | |
| } BM_COLLECT_KEY_OPTIONS_PARAM; | |
| /** | |
| Visitor function to collect the key options from NV storage. | |
| @param Name Variable name. | |
| @param Guid Variable GUID. | |
| @param Context The same context passed to BmForEachVariable. | |
| **/ | |
| VOID | |
| BmCollectKeyOptions ( | |
| CHAR16 *Name, | |
| EFI_GUID *Guid, | |
| VOID *Context | |
| ) | |
| { | |
| UINTN Index; | |
| BM_COLLECT_KEY_OPTIONS_PARAM *Param; | |
| VOID *KeyOption; | |
| UINT16 OptionNumber; | |
| UINTN KeyOptionSize; | |
| Param = (BM_COLLECT_KEY_OPTIONS_PARAM *) Context; | |
| if (BmIsKeyOptionVariable (Name, Guid, &OptionNumber)) { | |
| GetEfiGlobalVariable2 (Name, &KeyOption, &KeyOptionSize); | |
| ASSERT (KeyOption != NULL); | |
| if (BmIsKeyOptionValid (KeyOption, KeyOptionSize)) { | |
| Param->KeyOptions = ReallocatePool ( | |
| Param->KeyOptionCount * sizeof (EFI_BOOT_MANAGER_KEY_OPTION), | |
| (Param->KeyOptionCount + 1) * sizeof (EFI_BOOT_MANAGER_KEY_OPTION), | |
| Param->KeyOptions | |
| ); | |
| ASSERT (Param->KeyOptions != NULL); | |
| // | |
| // Insert the key option in order | |
| // | |
| for (Index = 0; Index < Param->KeyOptionCount; Index++) { | |
| if (OptionNumber < Param->KeyOptions[Index].OptionNumber) { | |
| break; | |
| } | |
| } | |
| CopyMem (&Param->KeyOptions[Index + 1], &Param->KeyOptions[Index], (Param->KeyOptionCount - Index) * sizeof (EFI_BOOT_MANAGER_KEY_OPTION)); | |
| CopyMem (&Param->KeyOptions[Index], KeyOption, KeyOptionSize); | |
| Param->KeyOptions[Index].OptionNumber = OptionNumber; | |
| Param->KeyOptionCount++; | |
| } | |
| FreePool (KeyOption); | |
| } | |
| } | |
| /** | |
| Return the array of key options. | |
| @param Count Return the number of key options. | |
| @retval NULL No key option. | |
| @retval Other Pointer to the key options. | |
| **/ | |
| EFI_BOOT_MANAGER_KEY_OPTION * | |
| BmGetKeyOptions ( | |
| OUT UINTN *Count | |
| ) | |
| { | |
| BM_COLLECT_KEY_OPTIONS_PARAM Param; | |
| if (Count == NULL) { | |
| return NULL; | |
| } | |
| Param.KeyOptions = NULL; | |
| Param.KeyOptionCount = 0; | |
| BmForEachVariable (BmCollectKeyOptions, (VOID *) &Param); | |
| *Count = Param.KeyOptionCount; | |
| return Param.KeyOptions; | |
| } | |
| /** | |
| Check whether the bit is set in the value. | |
| @param Value The value need to be check. | |
| @param Bit The bit filed need to be check. | |
| @retval TRUE The bit is set. | |
| @retval FALSE The bit is not set. | |
| **/ | |
| BOOLEAN | |
| BmBitSet ( | |
| IN UINT32 Value, | |
| IN UINT32 Bit | |
| ) | |
| { | |
| return (BOOLEAN) ((Value & Bit) != 0); | |
| } | |
| /** | |
| Initialize the KeyData and Key[] in the EFI_BOOT_MANAGER_KEY_OPTION. | |
| @param Modifier Input key info. | |
| @param Args Va_list info. | |
| @param KeyOption Key info which need to update. | |
| @retval EFI_SUCCESS Succeed to initialize the KeyData and Key[]. | |
| @return EFI_INVALID_PARAMETER Input parameter error. | |
| **/ | |
| EFI_STATUS | |
| BmInitializeKeyFields ( | |
| IN UINT32 Modifier, | |
| IN VA_LIST Args, | |
| OUT EFI_BOOT_MANAGER_KEY_OPTION *KeyOption | |
| ) | |
| { | |
| EFI_INPUT_KEY *Key; | |
| if (KeyOption == NULL) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| Key = NULL; | |
| while (KeyOption->KeyData.Options.InputKeyCount < sizeof (KeyOption->Keys) / sizeof (KeyOption->Keys[0])) { | |
| Key = VA_ARG (Args, EFI_INPUT_KEY *); | |
| if (Key == NULL) { | |
| break; | |
| } | |
| CopyMem ( | |
| &KeyOption->Keys[KeyOption->KeyData.Options.InputKeyCount], | |
| Key, | |
| sizeof (EFI_INPUT_KEY) | |
| ); | |
| KeyOption->KeyData.Options.InputKeyCount++; | |
| } | |
| if (Key != NULL) { | |
| // | |
| // Too many keys | |
| // | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| if ((Modifier & ~(EFI_BOOT_MANAGER_SHIFT_PRESSED | |
| | EFI_BOOT_MANAGER_CONTROL_PRESSED | |
| | EFI_BOOT_MANAGER_ALT_PRESSED | |
| | EFI_BOOT_MANAGER_LOGO_PRESSED | |
| | EFI_BOOT_MANAGER_MENU_KEY_PRESSED | |
| | EFI_BOOT_MANAGER_SYS_REQ_PRESSED | |
| )) != 0) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| if (BmBitSet (Modifier, EFI_BOOT_MANAGER_SHIFT_PRESSED)) { | |
| KeyOption->KeyData.Options.ShiftPressed = 1; | |
| } | |
| if (BmBitSet (Modifier, EFI_BOOT_MANAGER_CONTROL_PRESSED)) { | |
| KeyOption->KeyData.Options.ControlPressed = 1; | |
| } | |
| if (BmBitSet (Modifier, EFI_BOOT_MANAGER_ALT_PRESSED)) { | |
| KeyOption->KeyData.Options.AltPressed = 1; | |
| } | |
| if (BmBitSet (Modifier, EFI_BOOT_MANAGER_LOGO_PRESSED)) { | |
| KeyOption->KeyData.Options.LogoPressed = 1; | |
| } | |
| if (BmBitSet (Modifier, EFI_BOOT_MANAGER_MENU_KEY_PRESSED)) { | |
| KeyOption->KeyData.Options.MenuPressed = 1; | |
| } | |
| if (BmBitSet (Modifier, EFI_BOOT_MANAGER_SYS_REQ_PRESSED)) { | |
| KeyOption->KeyData.Options.SysReqPressed = 1; | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Try to boot the boot option triggered by hot key. | |
| **/ | |
| VOID | |
| EFIAPI | |
| EfiBootManagerHotkeyBoot ( | |
| VOID | |
| ) | |
| { | |
| if (mBmHotkeyBootOption.OptionNumber != LoadOptionNumberUnassigned) { | |
| EfiBootManagerBoot (&mBmHotkeyBootOption); | |
| EfiBootManagerFreeLoadOption (&mBmHotkeyBootOption); | |
| mBmHotkeyBootOption.OptionNumber = LoadOptionNumberUnassigned; | |
| } | |
| } | |
| /** | |
| This is the common notification function for HotKeys, it will be registered | |
| with SimpleTextInEx protocol interface - RegisterKeyNotify() of ConIn handle. | |
| @param KeyData A pointer to a buffer that is filled in with the keystroke | |
| information for the key that was pressed. | |
| @retval EFI_SUCCESS KeyData is successfully processed. | |
| @return EFI_NOT_FOUND Fail to find boot option variable. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| BmHotkeyCallback ( | |
| IN EFI_KEY_DATA *KeyData | |
| ) | |
| { | |
| LIST_ENTRY *Link; | |
| BM_HOTKEY *Hotkey; | |
| CHAR16 OptionName[BM_OPTION_NAME_LEN]; | |
| EFI_STATUS Status; | |
| EFI_KEY_DATA *HotkeyData; | |
| if (mBmHotkeyBootOption.OptionNumber != LoadOptionNumberUnassigned) { | |
| // | |
| // Do not process sequential hotkey stroke until the current boot option returns | |
| // | |
| return EFI_SUCCESS; | |
| } | |
| DEBUG ((EFI_D_INFO, "[Bds]BmHotkeyCallback: %04x:%04x\n", KeyData->Key.ScanCode, KeyData->Key.UnicodeChar)); | |
| EfiAcquireLock (&mBmHotkeyLock); | |
| for ( Link = GetFirstNode (&mBmHotkeyList) | |
| ; !IsNull (&mBmHotkeyList, Link) | |
| ; Link = GetNextNode (&mBmHotkeyList, Link) | |
| ) { | |
| Hotkey = BM_HOTKEY_FROM_LINK (Link); | |
| // | |
| // Is this Key Stroke we are waiting for? | |
| // | |
| ASSERT (Hotkey->WaitingKey < (sizeof (Hotkey->KeyData) / sizeof (Hotkey->KeyData[0]))); | |
| HotkeyData = &Hotkey->KeyData[Hotkey->WaitingKey]; | |
| if ((KeyData->Key.ScanCode == HotkeyData->Key.ScanCode) && | |
| (KeyData->Key.UnicodeChar == HotkeyData->Key.UnicodeChar) && | |
| (((KeyData->KeyState.KeyShiftState & EFI_SHIFT_STATE_VALID) != 0) ? | |
| (KeyData->KeyState.KeyShiftState == HotkeyData->KeyState.KeyShiftState) : TRUE | |
| ) | |
| ) { | |
| // | |
| // Receive an expecting key stroke, transit to next waiting state | |
| // | |
| Hotkey->WaitingKey++; | |
| if (Hotkey->WaitingKey == Hotkey->CodeCount) { | |
| // | |
| // Reset to initial waiting state | |
| // | |
| Hotkey->WaitingKey = 0; | |
| // | |
| // Received the whole key stroke sequence | |
| // | |
| Status = gBS->SignalEvent (mBmHotkeyTriggered); | |
| ASSERT_EFI_ERROR (Status); | |
| if (!Hotkey->IsContinue) { | |
| // | |
| // Launch its BootOption | |
| // | |
| UnicodeSPrint ( | |
| OptionName, sizeof (OptionName), L"%s%04x", | |
| mBmLoadOptionName[LoadOptionTypeBoot], Hotkey->BootOption | |
| ); | |
| Status = EfiBootManagerVariableToLoadOption (OptionName, &mBmHotkeyBootOption); | |
| DEBUG ((EFI_D_INFO, "[Bds]Hotkey for %s pressed - %r\n", OptionName, Status)); | |
| if (EFI_ERROR (Status)) { | |
| mBmHotkeyBootOption.OptionNumber = LoadOptionNumberUnassigned; | |
| } | |
| } else { | |
| DEBUG ((EFI_D_INFO, "[Bds]Continue key pressed!\n")); | |
| } | |
| } | |
| } else { | |
| // | |
| // Receive an unexpected key stroke, reset to initial waiting state | |
| // | |
| Hotkey->WaitingKey = 0; | |
| } | |
| } | |
| EfiReleaseLock (&mBmHotkeyLock); | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Return the active Simple Text Input Ex handle array. | |
| If the SystemTable.ConsoleInHandle is NULL, the function returns all | |
| founded Simple Text Input Ex handles. | |
| Otherwise, it just returns the ConsoleInHandle. | |
| @param Count Return the handle count. | |
| @retval The active console handles. | |
| **/ | |
| EFI_HANDLE * | |
| BmGetActiveConsoleIn ( | |
| OUT UINTN *Count | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_HANDLE *Handles; | |
| Handles = NULL; | |
| *Count = 0; | |
| if (gST->ConsoleInHandle != NULL) { | |
| Status = gBS->OpenProtocol ( | |
| gST->ConsoleInHandle, | |
| &gEfiSimpleTextInputExProtocolGuid, | |
| NULL, | |
| gImageHandle, | |
| NULL, | |
| EFI_OPEN_PROTOCOL_TEST_PROTOCOL | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| Handles = AllocateCopyPool (sizeof (EFI_HANDLE), &gST->ConsoleInHandle); | |
| if (Handles != NULL) { | |
| *Count = 1; | |
| } | |
| } | |
| } else { | |
| Status = gBS->LocateHandleBuffer ( | |
| ByProtocol, | |
| &gEfiSimpleTextInputExProtocolGuid, | |
| NULL, | |
| Count, | |
| &Handles | |
| ); | |
| } | |
| return Handles; | |
| } | |
| /** | |
| Unregister hotkey notify list. | |
| @param Hotkey Hotkey list. | |
| @retval EFI_SUCCESS Unregister hotkey notify success. | |
| @retval Others Unregister hotkey notify failed. | |
| **/ | |
| EFI_STATUS | |
| BmUnregisterHotkeyNotify ( | |
| IN BM_HOTKEY *Hotkey | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINTN Index; | |
| UINTN KeyIndex; | |
| EFI_HANDLE *Handles; | |
| UINTN HandleCount; | |
| EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TxtInEx; | |
| VOID *NotifyHandle; | |
| Handles = BmGetActiveConsoleIn (&HandleCount); | |
| for (Index = 0; Index < HandleCount; Index++) { | |
| Status = gBS->HandleProtocol (Handles[Index], &gEfiSimpleTextInputExProtocolGuid, (VOID **) &TxtInEx); | |
| ASSERT_EFI_ERROR (Status); | |
| for (KeyIndex = 0; KeyIndex < Hotkey->CodeCount; KeyIndex++) { | |
| Status = TxtInEx->RegisterKeyNotify ( | |
| TxtInEx, | |
| &Hotkey->KeyData[KeyIndex], | |
| BmHotkeyCallback, | |
| &NotifyHandle | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| Status = TxtInEx->UnregisterKeyNotify (TxtInEx, NotifyHandle); | |
| DEBUG ((EFI_D_INFO, "[Bds]UnregisterKeyNotify: %04x/%04x %r\n", Hotkey->KeyData[KeyIndex].Key.ScanCode, Hotkey->KeyData[KeyIndex].Key.UnicodeChar, Status)); | |
| } | |
| } | |
| } | |
| if (Handles != NULL) { | |
| FreePool (Handles); | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Register hotkey notify list. | |
| @param TxtInEx Pointer to EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL protocol. | |
| @param Hotkey Hotkey list. | |
| @retval EFI_SUCCESS Register hotkey notify success. | |
| @retval Others Register hotkey notify failed. | |
| **/ | |
| EFI_STATUS | |
| BmRegisterHotkeyNotify ( | |
| IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TxtInEx, | |
| IN BM_HOTKEY *Hotkey | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINTN Index; | |
| VOID *NotifyHandle; | |
| for (Index = 0; Index < Hotkey->CodeCount; Index++) { | |
| Status = TxtInEx->RegisterKeyNotify ( | |
| TxtInEx, | |
| &Hotkey->KeyData[Index], | |
| BmHotkeyCallback, | |
| &NotifyHandle | |
| ); | |
| DEBUG (( | |
| EFI_D_INFO, | |
| "[Bds]RegisterKeyNotify: %04x/%04x %08x/%02x %r\n", | |
| Hotkey->KeyData[Index].Key.ScanCode, | |
| Hotkey->KeyData[Index].Key.UnicodeChar, | |
| Hotkey->KeyData[Index].KeyState.KeyShiftState, | |
| Hotkey->KeyData[Index].KeyState.KeyToggleState, | |
| Status | |
| )); | |
| if (EFI_ERROR (Status)) { | |
| // | |
| // some of the hotkey registry failed | |
| // do not unregister all in case we have both CTRL-ALT-P and CTRL-ALT-P-R | |
| // | |
| break; | |
| } | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Generate key shift state base on the input key option info. | |
| @param Depth Which key is checked. | |
| @param KeyOption Input key option info. | |
| @param KeyShiftState Input key shift state. | |
| @param KeyShiftStates Return possible key shift state array. | |
| @param KeyShiftStateCount Possible key shift state count. | |
| **/ | |
| VOID | |
| BmGenerateKeyShiftState ( | |
| IN UINTN Depth, | |
| IN EFI_BOOT_MANAGER_KEY_OPTION *KeyOption, | |
| IN UINT32 KeyShiftState, | |
| IN UINT32 *KeyShiftStates, | |
| IN UINTN *KeyShiftStateCount | |
| ) | |
| { | |
| switch (Depth) { | |
| case 0: | |
| if (KeyOption->KeyData.Options.ShiftPressed) { | |
| BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_RIGHT_SHIFT_PRESSED, KeyShiftStates, KeyShiftStateCount); | |
| BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_LEFT_SHIFT_PRESSED, KeyShiftStates, KeyShiftStateCount); | |
| } else { | |
| BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState, KeyShiftStates, KeyShiftStateCount); | |
| } | |
| break; | |
| case 1: | |
| if (KeyOption->KeyData.Options.ControlPressed) { | |
| BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_RIGHT_CONTROL_PRESSED, KeyShiftStates, KeyShiftStateCount); | |
| BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_LEFT_CONTROL_PRESSED, KeyShiftStates, KeyShiftStateCount); | |
| } else { | |
| BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState, KeyShiftStates, KeyShiftStateCount); | |
| } | |
| break; | |
| case 2: | |
| if (KeyOption->KeyData.Options.AltPressed) { | |
| BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_RIGHT_ALT_PRESSED, KeyShiftStates, KeyShiftStateCount); | |
| BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_LEFT_ALT_PRESSED, KeyShiftStates, KeyShiftStateCount); | |
| } else { | |
| BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState, KeyShiftStates, KeyShiftStateCount); | |
| } | |
| break; | |
| case 3: | |
| if (KeyOption->KeyData.Options.LogoPressed) { | |
| BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_RIGHT_LOGO_PRESSED, KeyShiftStates, KeyShiftStateCount); | |
| BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_LEFT_LOGO_PRESSED, KeyShiftStates, KeyShiftStateCount); | |
| } else { | |
| BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState, KeyShiftStates, KeyShiftStateCount); | |
| } | |
| break; | |
| case 4: | |
| if (KeyOption->KeyData.Options.MenuPressed) { | |
| KeyShiftState |= EFI_MENU_KEY_PRESSED; | |
| } | |
| if (KeyOption->KeyData.Options.SysReqPressed) { | |
| KeyShiftState |= EFI_SYS_REQ_PRESSED; | |
| } | |
| KeyShiftStates[*KeyShiftStateCount] = KeyShiftState; | |
| (*KeyShiftStateCount)++; | |
| break; | |
| } | |
| } | |
| /** | |
| Add it to hot key database, register it to existing TxtInEx. | |
| New TxtInEx will be automatically registered with all the hot key in dababase | |
| @param KeyOption Input key option info. | |
| **/ | |
| EFI_STATUS | |
| BmProcessKeyOption ( | |
| IN EFI_BOOT_MANAGER_KEY_OPTION *KeyOption | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TxtInEx; | |
| EFI_HANDLE *Handles; | |
| UINTN HandleCount; | |
| UINTN HandleIndex; | |
| UINTN Index; | |
| BM_HOTKEY *Hotkey; | |
| UINTN KeyIndex; | |
| // | |
| // 16 is enough to enumerate all the possible combination of LEFT_XXX and RIGHT_XXX | |
| // | |
| UINT32 KeyShiftStates[16]; | |
| UINTN KeyShiftStateCount; | |
| if (KeyOption->KeyData.Options.InputKeyCount > mBmHotkeySupportCount) { | |
| return EFI_UNSUPPORTED; | |
| } | |
| KeyShiftStateCount = 0; | |
| BmGenerateKeyShiftState (0, KeyOption, EFI_SHIFT_STATE_VALID, KeyShiftStates, &KeyShiftStateCount); | |
| ASSERT (KeyShiftStateCount <= ARRAY_SIZE (KeyShiftStates)); | |
| EfiAcquireLock (&mBmHotkeyLock); | |
| Handles = BmGetActiveConsoleIn (&HandleCount); | |
| for (Index = 0; Index < KeyShiftStateCount; Index++) { | |
| Hotkey = AllocateZeroPool (sizeof (BM_HOTKEY)); | |
| ASSERT (Hotkey != NULL); | |
| Hotkey->Signature = BM_HOTKEY_SIGNATURE; | |
| Hotkey->BootOption = KeyOption->BootOption; | |
| Hotkey->IsContinue = (BOOLEAN) (KeyOption == mBmContinueKeyOption); | |
| Hotkey->CodeCount = (UINT8) KeyOption->KeyData.Options.InputKeyCount; | |
| for (KeyIndex = 0; KeyIndex < Hotkey->CodeCount; KeyIndex++) { | |
| CopyMem (&Hotkey->KeyData[KeyIndex].Key, &KeyOption->Keys[KeyIndex], sizeof (EFI_INPUT_KEY)); | |
| Hotkey->KeyData[KeyIndex].KeyState.KeyShiftState = KeyShiftStates[Index]; | |
| } | |
| InsertTailList (&mBmHotkeyList, &Hotkey->Link); | |
| for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) { | |
| Status = gBS->HandleProtocol (Handles[HandleIndex], &gEfiSimpleTextInputExProtocolGuid, (VOID **) &TxtInEx); | |
| ASSERT_EFI_ERROR (Status); | |
| BmRegisterHotkeyNotify (TxtInEx, Hotkey); | |
| } | |
| } | |
| if (Handles != NULL) { | |
| FreePool (Handles); | |
| } | |
| EfiReleaseLock (&mBmHotkeyLock); | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Callback function for SimpleTextInEx protocol install events | |
| @param Event the event that is signaled. | |
| @param Context not used here. | |
| **/ | |
| VOID | |
| EFIAPI | |
| BmTxtInExCallback ( | |
| 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, | |
| mBmTxtInExRegistration, | |
| &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 (&mBmHotkeyLock); | |
| for (Link = GetFirstNode (&mBmHotkeyList); !IsNull (&mBmHotkeyList, Link); Link = GetNextNode (&mBmHotkeyList, Link)) { | |
| BmRegisterHotkeyNotify (TxtInEx, BM_HOTKEY_FROM_LINK (Link)); | |
| } | |
| EfiReleaseLock (&mBmHotkeyLock); | |
| } | |
| } | |
| /** | |
| Free the key options returned from BmGetKeyOptions. | |
| @param KeyOptions Pointer to the key options. | |
| @param KeyOptionCount Number of the key options. | |
| @retval EFI_SUCCESS The key options are freed. | |
| @retval EFI_NOT_FOUND KeyOptions is NULL. | |
| **/ | |
| EFI_STATUS | |
| BmFreeKeyOptions ( | |
| IN EFI_BOOT_MANAGER_KEY_OPTION *KeyOptions, | |
| IN UINTN KeyOptionCount | |
| ) | |
| { | |
| if (KeyOptions != NULL) { | |
| FreePool (KeyOptions); | |
| return EFI_SUCCESS; | |
| } else { | |
| return EFI_NOT_FOUND; | |
| } | |
| } | |
| /** | |
| Register the key option to exit the waiting of the Boot Manager timeout. | |
| Platform should ensure that the continue key option isn't conflict with | |
| other boot key options. | |
| @param Modifier Key shift state. | |
| @param ... Parameter list of pointer of EFI_INPUT_KEY. | |
| @retval EFI_SUCCESS Successfully register the continue key option. | |
| @retval EFI_ALREADY_STARTED The continue key option is already registered. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| EfiBootManagerRegisterContinueKeyOption ( | |
| IN UINT32 Modifier, | |
| ... | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_BOOT_MANAGER_KEY_OPTION KeyOption; | |
| VA_LIST Args; | |
| if (mBmContinueKeyOption != NULL) { | |
| return EFI_ALREADY_STARTED; | |
| } | |
| ZeroMem (&KeyOption, sizeof (EFI_BOOT_MANAGER_KEY_OPTION)); | |
| VA_START (Args, Modifier); | |
| Status = BmInitializeKeyFields (Modifier, Args, &KeyOption); | |
| VA_END (Args); | |
| if (!EFI_ERROR (Status)) { | |
| mBmContinueKeyOption = AllocateCopyPool (sizeof (EFI_BOOT_MANAGER_KEY_OPTION), &KeyOption); | |
| ASSERT (mBmContinueKeyOption != NULL); | |
| if (mBmHotkeyServiceStarted) { | |
| BmProcessKeyOption (mBmContinueKeyOption); | |
| } | |
| } | |
| return Status; | |
| } | |
| /** | |
| Stop the hotkey processing. | |
| @param Event Event pointer related to hotkey service. | |
| @param Context Context pass to this function. | |
| **/ | |
| VOID | |
| EFIAPI | |
| BmStopHotkeyService ( | |
| IN EFI_EVENT Event, | |
| IN VOID *Context | |
| ) | |
| { | |
| LIST_ENTRY *Link; | |
| BM_HOTKEY *Hotkey; | |
| DEBUG ((EFI_D_INFO, "[Bds]Stop Hotkey Service!\n")); | |
| gBS->CloseEvent (Event); | |
| EfiAcquireLock (&mBmHotkeyLock); | |
| for (Link = GetFirstNode (&mBmHotkeyList); !IsNull (&mBmHotkeyList, Link); ) { | |
| Hotkey = BM_HOTKEY_FROM_LINK (Link); | |
| BmUnregisterHotkeyNotify (Hotkey); | |
| Link = RemoveEntryList (Link); | |
| FreePool (Hotkey); | |
| } | |
| EfiReleaseLock (&mBmHotkeyLock); | |
| } | |
| /** | |
| Start the hot key service so that the key press can trigger the boot option. | |
| @param HotkeyTriggered Return the waitable event and it will be signaled | |
| when a valid hot key is pressed. | |
| @retval EFI_SUCCESS The hot key service is started. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| EfiBootManagerStartHotkeyService ( | |
| IN EFI_EVENT *HotkeyTriggered | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_BOOT_MANAGER_KEY_OPTION *KeyOptions; | |
| UINTN KeyOptionCount; | |
| UINTN Index; | |
| EFI_EVENT Event; | |
| UINT32 *BootOptionSupport; | |
| GetEfiGlobalVariable2 (EFI_BOOT_OPTION_SUPPORT_VARIABLE_NAME, (VOID **) &BootOptionSupport, NULL); | |
| if (BootOptionSupport != NULL) { | |
| if ((*BootOptionSupport & EFI_BOOT_OPTION_SUPPORT_KEY) != 0) { | |
| mBmHotkeySupportCount = ((*BootOptionSupport & EFI_BOOT_OPTION_SUPPORT_COUNT) >> LowBitSet32 (EFI_BOOT_OPTION_SUPPORT_COUNT)); | |
| } | |
| FreePool (BootOptionSupport); | |
| } | |
| if (mBmHotkeySupportCount == 0) { | |
| DEBUG ((EFI_D_INFO, "Bds: BootOptionSupport NV variable forbids starting the hotkey service.\n")); | |
| return EFI_UNSUPPORTED; | |
| } | |
| Status = gBS->CreateEvent ( | |
| EVT_NOTIFY_WAIT, | |
| TPL_CALLBACK, | |
| EfiEventEmptyFunction, | |
| NULL, | |
| &mBmHotkeyTriggered | |
| ); | |
| ASSERT_EFI_ERROR (Status); | |
| if (HotkeyTriggered != NULL) { | |
| *HotkeyTriggered = mBmHotkeyTriggered; | |
| } | |
| KeyOptions = BmGetKeyOptions (&KeyOptionCount); | |
| for (Index = 0; Index < KeyOptionCount; Index ++) { | |
| BmProcessKeyOption (&KeyOptions[Index]); | |
| } | |
| BmFreeKeyOptions (KeyOptions, KeyOptionCount); | |
| if (mBmContinueKeyOption != NULL) { | |
| BmProcessKeyOption (mBmContinueKeyOption); | |
| } | |
| // | |
| // Hook hotkey on every future SimpleTextInputEx instance when | |
| // SystemTable.ConsoleInHandle == NULL, which means the console | |
| // manager (ConSplitter) is absent. | |
| // | |
| if (gST->ConsoleInHandle == NULL) { | |
| EfiCreateProtocolNotifyEvent ( | |
| &gEfiSimpleTextInputExProtocolGuid, | |
| TPL_CALLBACK, | |
| BmTxtInExCallback, | |
| NULL, | |
| &mBmTxtInExRegistration | |
| ); | |
| } | |
| Status = EfiCreateEventReadyToBootEx ( | |
| TPL_CALLBACK, | |
| BmStopHotkeyService, | |
| NULL, | |
| &Event | |
| ); | |
| ASSERT_EFI_ERROR (Status); | |
| mBmHotkeyServiceStarted = TRUE; | |
| return Status; | |
| } | |
| /** | |
| Add the key option. | |
| It adds the key option variable and the key option takes affect immediately. | |
| @param AddedOption Return the added key option. | |
| @param BootOptionNumber The boot option number for the key option. | |
| @param Modifier Key shift state. | |
| @param ... Parameter list of pointer of EFI_INPUT_KEY. | |
| @retval EFI_SUCCESS The key option is added. | |
| @retval EFI_ALREADY_STARTED The hot key is already used by certain key option. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| EfiBootManagerAddKeyOptionVariable ( | |
| OUT EFI_BOOT_MANAGER_KEY_OPTION *AddedOption, OPTIONAL | |
| IN UINT16 BootOptionNumber, | |
| IN UINT32 Modifier, | |
| ... | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| VA_LIST Args; | |
| VOID *BootOption; | |
| UINTN BootOptionSize; | |
| CHAR16 BootOptionName[BM_OPTION_NAME_LEN]; | |
| EFI_BOOT_MANAGER_KEY_OPTION KeyOption; | |
| EFI_BOOT_MANAGER_KEY_OPTION *KeyOptions; | |
| UINTN KeyOptionCount; | |
| UINTN Index; | |
| UINTN KeyOptionNumber; | |
| CHAR16 KeyOptionName[sizeof ("Key####")]; | |
| UnicodeSPrint ( | |
| BootOptionName, sizeof (BootOptionName), L"%s%04x", | |
| mBmLoadOptionName[LoadOptionTypeBoot], BootOptionNumber | |
| ); | |
| GetEfiGlobalVariable2 (BootOptionName, &BootOption, &BootOptionSize); | |
| if (BootOption == NULL) { | |
| return EFI_NOT_FOUND; | |
| } | |
| ZeroMem (&KeyOption, sizeof (EFI_BOOT_MANAGER_KEY_OPTION)); | |
| KeyOption.BootOption = BootOptionNumber; | |
| Status = gBS->CalculateCrc32 (BootOption, BootOptionSize, &KeyOption.BootOptionCrc); | |
| ASSERT_EFI_ERROR (Status); | |
| FreePool (BootOption); | |
| VA_START (Args, Modifier); | |
| Status = BmInitializeKeyFields (Modifier, Args, &KeyOption); | |
| VA_END (Args); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| KeyOptionNumber = LoadOptionNumberUnassigned; | |
| // | |
| // Check if the hot key sequence was defined already | |
| // | |
| KeyOptions = BmGetKeyOptions (&KeyOptionCount); | |
| for (Index = 0; Index < KeyOptionCount; Index++) { | |
| if ((KeyOptions[Index].KeyData.PackedValue == KeyOption.KeyData.PackedValue) && | |
| (CompareMem (KeyOptions[Index].Keys, KeyOption.Keys, KeyOption.KeyData.Options.InputKeyCount * sizeof (EFI_INPUT_KEY)) == 0)) { | |
| break; | |
| } | |
| if ((KeyOptionNumber == LoadOptionNumberUnassigned) && | |
| (KeyOptions[Index].OptionNumber > Index) | |
| ){ | |
| KeyOptionNumber = Index; | |
| } | |
| } | |
| BmFreeKeyOptions (KeyOptions, KeyOptionCount); | |
| if (Index < KeyOptionCount) { | |
| return EFI_ALREADY_STARTED; | |
| } | |
| if (KeyOptionNumber == LoadOptionNumberUnassigned) { | |
| KeyOptionNumber = KeyOptionCount; | |
| } | |
| UnicodeSPrint (KeyOptionName, sizeof (KeyOptionName), L"Key%04x", KeyOptionNumber); | |
| Status = gRT->SetVariable ( | |
| KeyOptionName, | |
| &gEfiGlobalVariableGuid, | |
| EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE, | |
| BmSizeOfKeyOption (&KeyOption), | |
| &KeyOption | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| // | |
| // Return the Key Option in case needed by caller | |
| // | |
| if (AddedOption != NULL) { | |
| CopyMem (AddedOption, &KeyOption, sizeof (EFI_BOOT_MANAGER_KEY_OPTION)); | |
| } | |
| // | |
| // Register the newly added hot key | |
| // Calling this function before EfiBootManagerStartHotkeyService doesn't | |
| // need to call BmProcessKeyOption | |
| // | |
| if (mBmHotkeyServiceStarted) { | |
| BmProcessKeyOption (&KeyOption); | |
| } | |
| } | |
| return Status; | |
| } | |
| /** | |
| Delete the Key Option variable and unregister the hot key | |
| @param DeletedOption Return the deleted key options. | |
| @param Modifier Key shift state. | |
| @param ... Parameter list of pointer of EFI_INPUT_KEY. | |
| @retval EFI_SUCCESS The key option is deleted. | |
| @retval EFI_NOT_FOUND The key option cannot be found. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| EfiBootManagerDeleteKeyOptionVariable ( | |
| IN EFI_BOOT_MANAGER_KEY_OPTION *DeletedOption, OPTIONAL | |
| IN UINT32 Modifier, | |
| ... | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINTN Index; | |
| VA_LIST Args; | |
| EFI_BOOT_MANAGER_KEY_OPTION KeyOption; | |
| EFI_BOOT_MANAGER_KEY_OPTION *KeyOptions; | |
| UINTN KeyOptionCount; | |
| LIST_ENTRY *Link; | |
| BM_HOTKEY *Hotkey; | |
| UINT32 ShiftState; | |
| BOOLEAN Match; | |
| CHAR16 KeyOptionName[sizeof ("Key####")]; | |
| ZeroMem (&KeyOption, sizeof (EFI_BOOT_MANAGER_KEY_OPTION)); | |
| VA_START (Args, Modifier); | |
| Status = BmInitializeKeyFields (Modifier, Args, &KeyOption); | |
| VA_END (Args); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| EfiAcquireLock (&mBmHotkeyLock); | |
| // | |
| // Delete the key option from active hot key list | |
| // Could have multiple entries when modifier isn't 0 because we map the ShiftPressed to RIGHT_SHIFT and RIGHT_SHIFT | |
| // | |
| for (Link = GetFirstNode (&mBmHotkeyList); !IsNull (&mBmHotkeyList, Link); ) { | |
| Hotkey = BM_HOTKEY_FROM_LINK (Link); | |
| Match = (BOOLEAN) (Hotkey->CodeCount == KeyOption.KeyData.Options.InputKeyCount); | |
| for (Index = 0; Match && (Index < Hotkey->CodeCount); Index++) { | |
| ShiftState = Hotkey->KeyData[Index].KeyState.KeyShiftState; | |
| if ( | |
| (BmBitSet (ShiftState, EFI_RIGHT_SHIFT_PRESSED | EFI_LEFT_SHIFT_PRESSED) != KeyOption.KeyData.Options.ShiftPressed) || | |
| (BmBitSet (ShiftState, EFI_RIGHT_CONTROL_PRESSED | EFI_LEFT_CONTROL_PRESSED) != KeyOption.KeyData.Options.ControlPressed) || | |
| (BmBitSet (ShiftState, EFI_RIGHT_ALT_PRESSED | EFI_LEFT_ALT_PRESSED) != KeyOption.KeyData.Options.AltPressed) || | |
| (BmBitSet (ShiftState, EFI_RIGHT_LOGO_PRESSED | EFI_LEFT_LOGO_PRESSED) != KeyOption.KeyData.Options.LogoPressed) || | |
| (BmBitSet (ShiftState, EFI_MENU_KEY_PRESSED) != KeyOption.KeyData.Options.MenuPressed) || | |
| (BmBitSet (ShiftState, EFI_SYS_REQ_PRESSED) != KeyOption.KeyData.Options.SysReqPressed) || | |
| (CompareMem (&Hotkey->KeyData[Index].Key, &KeyOption.Keys[Index], sizeof (EFI_INPUT_KEY)) != 0) | |
| ) { | |
| // | |
| // Break when any field doesn't match | |
| // | |
| Match = FALSE; | |
| break; | |
| } | |
| } | |
| if (Match) { | |
| Link = RemoveEntryList (Link); | |
| FreePool (Hotkey); | |
| } else { | |
| Link = GetNextNode (&mBmHotkeyList, Link); | |
| } | |
| } | |
| // | |
| // Delete the key option from the variable | |
| // | |
| Status = EFI_NOT_FOUND; | |
| KeyOptions = BmGetKeyOptions (&KeyOptionCount); | |
| for (Index = 0; Index < KeyOptionCount; Index++) { | |
| if ((KeyOptions[Index].KeyData.PackedValue == KeyOption.KeyData.PackedValue) && | |
| (CompareMem ( | |
| KeyOptions[Index].Keys, KeyOption.Keys, | |
| KeyOption.KeyData.Options.InputKeyCount * sizeof (EFI_INPUT_KEY)) == 0) | |
| ) { | |
| UnicodeSPrint (KeyOptionName, sizeof (KeyOptionName), L"Key%04x", KeyOptions[Index].OptionNumber); | |
| Status = gRT->SetVariable ( | |
| KeyOptionName, | |
| &gEfiGlobalVariableGuid, | |
| EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE, | |
| 0, | |
| NULL | |
| ); | |
| // | |
| // Return the deleted key option in case needed by caller | |
| // | |
| if (DeletedOption != NULL) { | |
| CopyMem (DeletedOption, &KeyOptions[Index], sizeof (EFI_BOOT_MANAGER_KEY_OPTION)); | |
| } | |
| break; | |
| } | |
| } | |
| BmFreeKeyOptions (KeyOptions, KeyOptionCount); | |
| EfiReleaseLock (&mBmHotkeyLock); | |
| return Status; | |
| } |