VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Library/UefiBootManagerLib/BmHotkey.c@ 77662

Last change on this file since 77662 was 77662, checked in by vboxsync, 6 years ago

EFI: First step in UDK2018 merge. Does not build yet.
  • Property svn:eol-style set to native
File size: 34.9 KB
Line 
1/** @file
2 Hotkey library functions.
3
4Copyright (c) 2011 - 2017, Intel Corporation. All rights reserved.<BR>
5(C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
6This program and the accompanying materials
7are licensed and made available under the terms and conditions of the BSD License
8which accompanies this distribution. The full text of the license may be found at
9http://opensource.org/licenses/bsd-license.php
10
11THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14**/
15
16#include "InternalBm.h"
17
18//
19// Lock for linked list
20//
21EFI_LOCK mBmHotkeyLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_NOTIFY);
22LIST_ENTRY mBmHotkeyList = INITIALIZE_LIST_HEAD_VARIABLE (mBmHotkeyList);
23EFI_EVENT mBmHotkeyTriggered = NULL;
24BOOLEAN mBmHotkeyServiceStarted = FALSE;
25UINTN mBmHotkeySupportCount = 0;
26
27//
28// Set OptionNumber as unassigned value to indicate the option isn't initialized
29//
30EFI_BOOT_MANAGER_LOAD_OPTION mBmHotkeyBootOption = { LoadOptionNumberUnassigned };
31
32EFI_BOOT_MANAGER_KEY_OPTION *mBmContinueKeyOption = NULL;
33VOID *mBmTxtInExRegistration = NULL;
34
35
36/**
37 Return the buffer size of the EFI_BOOT_MANAGER_KEY_OPTION data.
38
39 @param KeyOption The input key option info.
40
41 @retval The buffer size of the key option data.
42**/
43UINTN
44BmSizeOfKeyOption (
45 IN CONST EFI_BOOT_MANAGER_KEY_OPTION *KeyOption
46 )
47{
48 return OFFSET_OF (EFI_BOOT_MANAGER_KEY_OPTION, Keys)
49 + KeyOption->KeyData.Options.InputKeyCount * sizeof (EFI_INPUT_KEY);
50}
51
52/**
53
54 Check whether the input key option is valid.
55
56 @param KeyOption Key option.
57 @param KeyOptionSize Size of the key option.
58
59 @retval TRUE Input key option is valid.
60 @retval FALSE Input key option is not valid.
61**/
62BOOLEAN
63BmIsKeyOptionValid (
64 IN CONST EFI_BOOT_MANAGER_KEY_OPTION *KeyOption,
65 IN UINTN KeyOptionSize
66)
67{
68 UINT16 OptionName[BM_OPTION_NAME_LEN];
69 UINT8 *BootOption;
70 UINTN BootOptionSize;
71 UINT32 Crc;
72
73 if (BmSizeOfKeyOption (KeyOption) != KeyOptionSize) {
74 return FALSE;
75 }
76
77 //
78 // Check whether corresponding Boot Option exist
79 //
80 UnicodeSPrint (
81 OptionName, sizeof (OptionName), L"%s%04x",
82 mBmLoadOptionName[LoadOptionTypeBoot], KeyOption->BootOption
83 );
84 GetEfiGlobalVariable2 (OptionName, (VOID **) &BootOption, &BootOptionSize);
85
86 if (BootOption == NULL) {
87 return FALSE;
88 }
89
90 //
91 // Check CRC for Boot Option
92 //
93 gBS->CalculateCrc32 (BootOption, BootOptionSize, &Crc);
94 FreePool (BootOption);
95
96 return (BOOLEAN) (KeyOption->BootOptionCrc == Crc);
97}
98
99/**
100
101 Check whether the input variable is an key option variable.
102
103 @param Name Input variable name.
104 @param Guid Input variable guid.
105 @param OptionNumber The option number of this key option variable.
106
107 @retval TRUE Input variable is a key option variable.
108 @retval FALSE Input variable is not a key option variable.
109**/
110BOOLEAN
111BmIsKeyOptionVariable (
112 CHAR16 *Name,
113 EFI_GUID *Guid,
114 UINT16 *OptionNumber
115 )
116{
117 UINTN Index;
118 UINTN Uint;
119
120 if (!CompareGuid (Guid, &gEfiGlobalVariableGuid) ||
121 (StrSize (Name) != sizeof (L"Key####")) ||
122 (StrnCmp (Name, L"Key", 3) != 0)
123 ) {
124 return FALSE;
125 }
126
127 *OptionNumber = 0;
128 for (Index = 3; Index < 7; Index++) {
129 Uint = BmCharToUint (Name[Index]);
130 if (Uint == -1) {
131 return FALSE;
132 } else {
133 *OptionNumber = (UINT16) Uint + *OptionNumber * 0x10;
134 }
135 }
136
137 return TRUE;
138}
139
140typedef struct {
141 EFI_BOOT_MANAGER_KEY_OPTION *KeyOptions;
142 UINTN KeyOptionCount;
143} BM_COLLECT_KEY_OPTIONS_PARAM;
144
145/**
146 Visitor function to collect the key options from NV storage.
147
148 @param Name Variable name.
149 @param Guid Variable GUID.
150 @param Context The same context passed to BmForEachVariable.
151**/
152VOID
153BmCollectKeyOptions (
154 CHAR16 *Name,
155 EFI_GUID *Guid,
156 VOID *Context
157 )
158{
159 UINTN Index;
160 BM_COLLECT_KEY_OPTIONS_PARAM *Param;
161 VOID *KeyOption;
162 UINT16 OptionNumber;
163 UINTN KeyOptionSize;
164
165 Param = (BM_COLLECT_KEY_OPTIONS_PARAM *) Context;
166
167 if (BmIsKeyOptionVariable (Name, Guid, &OptionNumber)) {
168 GetEfiGlobalVariable2 (Name, &KeyOption, &KeyOptionSize);
169 ASSERT (KeyOption != NULL);
170 if (BmIsKeyOptionValid (KeyOption, KeyOptionSize)) {
171 Param->KeyOptions = ReallocatePool (
172 Param->KeyOptionCount * sizeof (EFI_BOOT_MANAGER_KEY_OPTION),
173 (Param->KeyOptionCount + 1) * sizeof (EFI_BOOT_MANAGER_KEY_OPTION),
174 Param->KeyOptions
175 );
176 ASSERT (Param->KeyOptions != NULL);
177 //
178 // Insert the key option in order
179 //
180 for (Index = 0; Index < Param->KeyOptionCount; Index++) {
181 if (OptionNumber < Param->KeyOptions[Index].OptionNumber) {
182 break;
183 }
184 }
185 CopyMem (&Param->KeyOptions[Index + 1], &Param->KeyOptions[Index], (Param->KeyOptionCount - Index) * sizeof (EFI_BOOT_MANAGER_KEY_OPTION));
186 CopyMem (&Param->KeyOptions[Index], KeyOption, KeyOptionSize);
187 Param->KeyOptions[Index].OptionNumber = OptionNumber;
188 Param->KeyOptionCount++;
189 }
190 FreePool (KeyOption);
191 }
192}
193
194/**
195 Return the array of key options.
196
197 @param Count Return the number of key options.
198
199 @retval NULL No key option.
200 @retval Other Pointer to the key options.
201**/
202EFI_BOOT_MANAGER_KEY_OPTION *
203BmGetKeyOptions (
204 OUT UINTN *Count
205 )
206{
207 BM_COLLECT_KEY_OPTIONS_PARAM Param;
208
209 if (Count == NULL) {
210 return NULL;
211 }
212
213 Param.KeyOptions = NULL;
214 Param.KeyOptionCount = 0;
215
216 BmForEachVariable (BmCollectKeyOptions, (VOID *) &Param);
217
218 *Count = Param.KeyOptionCount;
219
220 return Param.KeyOptions;
221}
222
223/**
224 Check whether the bit is set in the value.
225
226 @param Value The value need to be check.
227 @param Bit The bit filed need to be check.
228
229 @retval TRUE The bit is set.
230 @retval FALSE The bit is not set.
231**/
232BOOLEAN
233BmBitSet (
234 IN UINT32 Value,
235 IN UINT32 Bit
236 )
237{
238 return (BOOLEAN) ((Value & Bit) != 0);
239}
240
241/**
242 Initialize the KeyData and Key[] in the EFI_BOOT_MANAGER_KEY_OPTION.
243
244 @param Modifier Input key info.
245 @param Args Va_list info.
246 @param KeyOption Key info which need to update.
247
248 @retval EFI_SUCCESS Succeed to initialize the KeyData and Key[].
249 @return EFI_INVALID_PARAMETER Input parameter error.
250**/
251EFI_STATUS
252BmInitializeKeyFields (
253 IN UINT32 Modifier,
254 IN VA_LIST Args,
255 OUT EFI_BOOT_MANAGER_KEY_OPTION *KeyOption
256 )
257{
258 EFI_INPUT_KEY *Key;
259
260 if (KeyOption == NULL) {
261 return EFI_INVALID_PARAMETER;
262 }
263
264 Key = NULL;
265 while (KeyOption->KeyData.Options.InputKeyCount < sizeof (KeyOption->Keys) / sizeof (KeyOption->Keys[0])) {
266 Key = VA_ARG (Args, EFI_INPUT_KEY *);
267 if (Key == NULL) {
268 break;
269 }
270 CopyMem (
271 &KeyOption->Keys[KeyOption->KeyData.Options.InputKeyCount],
272 Key,
273 sizeof (EFI_INPUT_KEY)
274 );
275 KeyOption->KeyData.Options.InputKeyCount++;
276 }
277
278 if (Key != NULL) {
279 //
280 // Too many keys
281 //
282 return EFI_INVALID_PARAMETER;
283 }
284
285 if ((Modifier & ~(EFI_BOOT_MANAGER_SHIFT_PRESSED
286 | EFI_BOOT_MANAGER_CONTROL_PRESSED
287 | EFI_BOOT_MANAGER_ALT_PRESSED
288 | EFI_BOOT_MANAGER_LOGO_PRESSED
289 | EFI_BOOT_MANAGER_MENU_KEY_PRESSED
290 | EFI_BOOT_MANAGER_SYS_REQ_PRESSED
291 )) != 0) {
292 return EFI_INVALID_PARAMETER;
293 }
294
295 if (BmBitSet (Modifier, EFI_BOOT_MANAGER_SHIFT_PRESSED)) {
296 KeyOption->KeyData.Options.ShiftPressed = 1;
297 }
298 if (BmBitSet (Modifier, EFI_BOOT_MANAGER_CONTROL_PRESSED)) {
299 KeyOption->KeyData.Options.ControlPressed = 1;
300 }
301 if (BmBitSet (Modifier, EFI_BOOT_MANAGER_ALT_PRESSED)) {
302 KeyOption->KeyData.Options.AltPressed = 1;
303 }
304 if (BmBitSet (Modifier, EFI_BOOT_MANAGER_LOGO_PRESSED)) {
305 KeyOption->KeyData.Options.LogoPressed = 1;
306 }
307 if (BmBitSet (Modifier, EFI_BOOT_MANAGER_MENU_KEY_PRESSED)) {
308 KeyOption->KeyData.Options.MenuPressed = 1;
309 }
310 if (BmBitSet (Modifier, EFI_BOOT_MANAGER_SYS_REQ_PRESSED)) {
311 KeyOption->KeyData.Options.SysReqPressed = 1;
312 }
313
314 return EFI_SUCCESS;
315}
316
317/**
318 Try to boot the boot option triggered by hot key.
319**/
320VOID
321EFIAPI
322EfiBootManagerHotkeyBoot (
323 VOID
324 )
325{
326 if (mBmHotkeyBootOption.OptionNumber != LoadOptionNumberUnassigned) {
327 EfiBootManagerBoot (&mBmHotkeyBootOption);
328 EfiBootManagerFreeLoadOption (&mBmHotkeyBootOption);
329 mBmHotkeyBootOption.OptionNumber = LoadOptionNumberUnassigned;
330 }
331}
332
333/**
334 This is the common notification function for HotKeys, it will be registered
335 with SimpleTextInEx protocol interface - RegisterKeyNotify() of ConIn handle.
336
337 @param KeyData A pointer to a buffer that is filled in with the keystroke
338 information for the key that was pressed.
339
340 @retval EFI_SUCCESS KeyData is successfully processed.
341 @return EFI_NOT_FOUND Fail to find boot option variable.
342**/
343EFI_STATUS
344EFIAPI
345BmHotkeyCallback (
346 IN EFI_KEY_DATA *KeyData
347)
348{
349 LIST_ENTRY *Link;
350 BM_HOTKEY *Hotkey;
351 CHAR16 OptionName[BM_OPTION_NAME_LEN];
352 EFI_STATUS Status;
353 EFI_KEY_DATA *HotkeyData;
354
355 if (mBmHotkeyBootOption.OptionNumber != LoadOptionNumberUnassigned) {
356 //
357 // Do not process sequential hotkey stroke until the current boot option returns
358 //
359 return EFI_SUCCESS;
360 }
361
362 DEBUG ((EFI_D_INFO, "[Bds]BmHotkeyCallback: %04x:%04x\n", KeyData->Key.ScanCode, KeyData->Key.UnicodeChar));
363
364 EfiAcquireLock (&mBmHotkeyLock);
365 for ( Link = GetFirstNode (&mBmHotkeyList)
366 ; !IsNull (&mBmHotkeyList, Link)
367 ; Link = GetNextNode (&mBmHotkeyList, Link)
368 ) {
369 Hotkey = BM_HOTKEY_FROM_LINK (Link);
370
371 //
372 // Is this Key Stroke we are waiting for?
373 //
374 ASSERT (Hotkey->WaitingKey < (sizeof (Hotkey->KeyData) / sizeof (Hotkey->KeyData[0])));
375 HotkeyData = &Hotkey->KeyData[Hotkey->WaitingKey];
376 if ((KeyData->Key.ScanCode == HotkeyData->Key.ScanCode) &&
377 (KeyData->Key.UnicodeChar == HotkeyData->Key.UnicodeChar) &&
378 (((KeyData->KeyState.KeyShiftState & EFI_SHIFT_STATE_VALID) != 0) ?
379 (KeyData->KeyState.KeyShiftState == HotkeyData->KeyState.KeyShiftState) : TRUE
380 )
381 ) {
382
383 //
384 // Receive an expecting key stroke, transit to next waiting state
385 //
386 Hotkey->WaitingKey++;
387
388 if (Hotkey->WaitingKey == Hotkey->CodeCount) {
389 //
390 // Reset to initial waiting state
391 //
392 Hotkey->WaitingKey = 0;
393 //
394 // Received the whole key stroke sequence
395 //
396 Status = gBS->SignalEvent (mBmHotkeyTriggered);
397 ASSERT_EFI_ERROR (Status);
398
399 if (!Hotkey->IsContinue) {
400 //
401 // Launch its BootOption
402 //
403 UnicodeSPrint (
404 OptionName, sizeof (OptionName), L"%s%04x",
405 mBmLoadOptionName[LoadOptionTypeBoot], Hotkey->BootOption
406 );
407 Status = EfiBootManagerVariableToLoadOption (OptionName, &mBmHotkeyBootOption);
408 DEBUG ((EFI_D_INFO, "[Bds]Hotkey for %s pressed - %r\n", OptionName, Status));
409 if (EFI_ERROR (Status)) {
410 mBmHotkeyBootOption.OptionNumber = LoadOptionNumberUnassigned;
411 }
412 } else {
413 DEBUG ((EFI_D_INFO, "[Bds]Continue key pressed!\n"));
414 }
415 }
416 } else {
417 //
418 // Receive an unexpected key stroke, reset to initial waiting state
419 //
420 Hotkey->WaitingKey = 0;
421 }
422
423 }
424 EfiReleaseLock (&mBmHotkeyLock);
425
426 return EFI_SUCCESS;
427}
428
429/**
430 Return the active Simple Text Input Ex handle array.
431 If the SystemTable.ConsoleInHandle is NULL, the function returns all
432 founded Simple Text Input Ex handles.
433 Otherwise, it just returns the ConsoleInHandle.
434
435 @param Count Return the handle count.
436
437 @retval The active console handles.
438**/
439EFI_HANDLE *
440BmGetActiveConsoleIn (
441 OUT UINTN *Count
442 )
443{
444 EFI_STATUS Status;
445 EFI_HANDLE *Handles;
446
447 Handles = NULL;
448 *Count = 0;
449
450 if (gST->ConsoleInHandle != NULL) {
451 Status = gBS->OpenProtocol (
452 gST->ConsoleInHandle,
453 &gEfiSimpleTextInputExProtocolGuid,
454 NULL,
455 gImageHandle,
456 NULL,
457 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
458 );
459 if (!EFI_ERROR (Status)) {
460 Handles = AllocateCopyPool (sizeof (EFI_HANDLE), &gST->ConsoleInHandle);
461 if (Handles != NULL) {
462 *Count = 1;
463 }
464 }
465 } else {
466 Status = gBS->LocateHandleBuffer (
467 ByProtocol,
468 &gEfiSimpleTextInputExProtocolGuid,
469 NULL,
470 Count,
471 &Handles
472 );
473 }
474
475 return Handles;
476}
477
478/**
479 Unregister hotkey notify list.
480
481 @param Hotkey Hotkey list.
482
483 @retval EFI_SUCCESS Unregister hotkey notify success.
484 @retval Others Unregister hotkey notify failed.
485**/
486EFI_STATUS
487BmUnregisterHotkeyNotify (
488 IN BM_HOTKEY *Hotkey
489 )
490{
491 EFI_STATUS Status;
492 UINTN Index;
493 UINTN KeyIndex;
494 EFI_HANDLE *Handles;
495 UINTN HandleCount;
496 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TxtInEx;
497 VOID *NotifyHandle;
498
499 Handles = BmGetActiveConsoleIn (&HandleCount);
500 for (Index = 0; Index < HandleCount; Index++) {
501 Status = gBS->HandleProtocol (Handles[Index], &gEfiSimpleTextInputExProtocolGuid, (VOID **) &TxtInEx);
502 ASSERT_EFI_ERROR (Status);
503 for (KeyIndex = 0; KeyIndex < Hotkey->CodeCount; KeyIndex++) {
504 Status = TxtInEx->RegisterKeyNotify (
505 TxtInEx,
506 &Hotkey->KeyData[KeyIndex],
507 BmHotkeyCallback,
508 &NotifyHandle
509 );
510 if (!EFI_ERROR (Status)) {
511 Status = TxtInEx->UnregisterKeyNotify (TxtInEx, NotifyHandle);
512 DEBUG ((EFI_D_INFO, "[Bds]UnregisterKeyNotify: %04x/%04x %r\n", Hotkey->KeyData[KeyIndex].Key.ScanCode, Hotkey->KeyData[KeyIndex].Key.UnicodeChar, Status));
513 }
514 }
515 }
516
517 if (Handles != NULL) {
518 FreePool (Handles);
519 }
520
521 return EFI_SUCCESS;
522}
523
524/**
525 Register hotkey notify list.
526
527 @param TxtInEx Pointer to EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL protocol.
528 @param Hotkey Hotkey list.
529
530 @retval EFI_SUCCESS Register hotkey notify success.
531 @retval Others Register hotkey notify failed.
532**/
533EFI_STATUS
534BmRegisterHotkeyNotify (
535 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TxtInEx,
536 IN BM_HOTKEY *Hotkey
537 )
538{
539 EFI_STATUS Status;
540 UINTN Index;
541 VOID *NotifyHandle;
542
543 for (Index = 0; Index < Hotkey->CodeCount; Index++) {
544 Status = TxtInEx->RegisterKeyNotify (
545 TxtInEx,
546 &Hotkey->KeyData[Index],
547 BmHotkeyCallback,
548 &NotifyHandle
549 );
550 DEBUG ((
551 EFI_D_INFO,
552 "[Bds]RegisterKeyNotify: %04x/%04x %08x/%02x %r\n",
553 Hotkey->KeyData[Index].Key.ScanCode,
554 Hotkey->KeyData[Index].Key.UnicodeChar,
555 Hotkey->KeyData[Index].KeyState.KeyShiftState,
556 Hotkey->KeyData[Index].KeyState.KeyToggleState,
557 Status
558 ));
559 if (EFI_ERROR (Status)) {
560 //
561 // some of the hotkey registry failed
562 // do not unregister all in case we have both CTRL-ALT-P and CTRL-ALT-P-R
563 //
564 break;
565 }
566 }
567
568 return EFI_SUCCESS;
569}
570
571/**
572 Generate key shift state base on the input key option info.
573
574 @param Depth Which key is checked.
575 @param KeyOption Input key option info.
576 @param KeyShiftState Input key shift state.
577 @param KeyShiftStates Return possible key shift state array.
578 @param KeyShiftStateCount Possible key shift state count.
579**/
580VOID
581BmGenerateKeyShiftState (
582 IN UINTN Depth,
583 IN EFI_BOOT_MANAGER_KEY_OPTION *KeyOption,
584 IN UINT32 KeyShiftState,
585 IN UINT32 *KeyShiftStates,
586 IN UINTN *KeyShiftStateCount
587 )
588{
589 switch (Depth) {
590 case 0:
591 if (KeyOption->KeyData.Options.ShiftPressed) {
592 BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_RIGHT_SHIFT_PRESSED, KeyShiftStates, KeyShiftStateCount);
593 BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_LEFT_SHIFT_PRESSED, KeyShiftStates, KeyShiftStateCount);
594 } else {
595 BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState, KeyShiftStates, KeyShiftStateCount);
596 }
597 break;
598
599 case 1:
600 if (KeyOption->KeyData.Options.ControlPressed) {
601 BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_RIGHT_CONTROL_PRESSED, KeyShiftStates, KeyShiftStateCount);
602 BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_LEFT_CONTROL_PRESSED, KeyShiftStates, KeyShiftStateCount);
603 } else {
604 BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState, KeyShiftStates, KeyShiftStateCount);
605 }
606 break;
607
608 case 2:
609 if (KeyOption->KeyData.Options.AltPressed) {
610 BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_RIGHT_ALT_PRESSED, KeyShiftStates, KeyShiftStateCount);
611 BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_LEFT_ALT_PRESSED, KeyShiftStates, KeyShiftStateCount);
612 } else {
613 BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState, KeyShiftStates, KeyShiftStateCount);
614 }
615 break;
616 case 3:
617 if (KeyOption->KeyData.Options.LogoPressed) {
618 BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_RIGHT_LOGO_PRESSED, KeyShiftStates, KeyShiftStateCount);
619 BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState | EFI_LEFT_LOGO_PRESSED, KeyShiftStates, KeyShiftStateCount);
620 } else {
621 BmGenerateKeyShiftState (Depth + 1, KeyOption, KeyShiftState, KeyShiftStates, KeyShiftStateCount);
622 }
623 break;
624 case 4:
625 if (KeyOption->KeyData.Options.MenuPressed) {
626 KeyShiftState |= EFI_MENU_KEY_PRESSED;
627 }
628 if (KeyOption->KeyData.Options.SysReqPressed) {
629 KeyShiftState |= EFI_SYS_REQ_PRESSED;
630 }
631 KeyShiftStates[*KeyShiftStateCount] = KeyShiftState;
632 (*KeyShiftStateCount)++;
633 break;
634 }
635}
636
637/**
638 Add it to hot key database, register it to existing TxtInEx.
639 New TxtInEx will be automatically registered with all the hot key in dababase
640
641 @param KeyOption Input key option info.
642**/
643EFI_STATUS
644BmProcessKeyOption (
645 IN EFI_BOOT_MANAGER_KEY_OPTION *KeyOption
646 )
647{
648 EFI_STATUS Status;
649 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TxtInEx;
650 EFI_HANDLE *Handles;
651 UINTN HandleCount;
652 UINTN HandleIndex;
653 UINTN Index;
654 BM_HOTKEY *Hotkey;
655 UINTN KeyIndex;
656 //
657 // 16 is enough to enumerate all the possible combination of LEFT_XXX and RIGHT_XXX
658 //
659 UINT32 KeyShiftStates[16];
660 UINTN KeyShiftStateCount;
661
662 if (KeyOption->KeyData.Options.InputKeyCount > mBmHotkeySupportCount) {
663 return EFI_UNSUPPORTED;
664 }
665
666 KeyShiftStateCount = 0;
667 BmGenerateKeyShiftState (0, KeyOption, EFI_SHIFT_STATE_VALID, KeyShiftStates, &KeyShiftStateCount);
668 ASSERT (KeyShiftStateCount <= ARRAY_SIZE (KeyShiftStates));
669
670 EfiAcquireLock (&mBmHotkeyLock);
671
672 Handles = BmGetActiveConsoleIn (&HandleCount);
673
674 for (Index = 0; Index < KeyShiftStateCount; Index++) {
675 Hotkey = AllocateZeroPool (sizeof (BM_HOTKEY));
676 ASSERT (Hotkey != NULL);
677
678 Hotkey->Signature = BM_HOTKEY_SIGNATURE;
679 Hotkey->BootOption = KeyOption->BootOption;
680 Hotkey->IsContinue = (BOOLEAN) (KeyOption == mBmContinueKeyOption);
681 Hotkey->CodeCount = (UINT8) KeyOption->KeyData.Options.InputKeyCount;
682
683 for (KeyIndex = 0; KeyIndex < Hotkey->CodeCount; KeyIndex++) {
684 CopyMem (&Hotkey->KeyData[KeyIndex].Key, &KeyOption->Keys[KeyIndex], sizeof (EFI_INPUT_KEY));
685 Hotkey->KeyData[KeyIndex].KeyState.KeyShiftState = KeyShiftStates[Index];
686 }
687 InsertTailList (&mBmHotkeyList, &Hotkey->Link);
688
689 for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
690 Status = gBS->HandleProtocol (Handles[HandleIndex], &gEfiSimpleTextInputExProtocolGuid, (VOID **) &TxtInEx);
691 ASSERT_EFI_ERROR (Status);
692 BmRegisterHotkeyNotify (TxtInEx, Hotkey);
693 }
694 }
695
696 if (Handles != NULL) {
697 FreePool (Handles);
698 }
699 EfiReleaseLock (&mBmHotkeyLock);
700
701 return EFI_SUCCESS;
702}
703
704/**
705 Callback function for SimpleTextInEx protocol install events
706
707 @param Event the event that is signaled.
708 @param Context not used here.
709
710**/
711VOID
712EFIAPI
713BmTxtInExCallback (
714 IN EFI_EVENT Event,
715 IN VOID *Context
716 )
717{
718 EFI_STATUS Status;
719 UINTN BufferSize;
720 EFI_HANDLE Handle;
721 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TxtInEx;
722 LIST_ENTRY *Link;
723
724 while (TRUE) {
725 BufferSize = sizeof (EFI_HANDLE);
726 Status = gBS->LocateHandle (
727 ByRegisterNotify,
728 NULL,
729 mBmTxtInExRegistration,
730 &BufferSize,
731 &Handle
732 );
733 if (EFI_ERROR (Status)) {
734 //
735 // If no more notification events exist
736 //
737 return ;
738 }
739
740 Status = gBS->HandleProtocol (
741 Handle,
742 &gEfiSimpleTextInputExProtocolGuid,
743 (VOID **) &TxtInEx
744 );
745 ASSERT_EFI_ERROR (Status);
746
747 //
748 // Register the hot key notification for the existing items in the list
749 //
750 EfiAcquireLock (&mBmHotkeyLock);
751 for (Link = GetFirstNode (&mBmHotkeyList); !IsNull (&mBmHotkeyList, Link); Link = GetNextNode (&mBmHotkeyList, Link)) {
752 BmRegisterHotkeyNotify (TxtInEx, BM_HOTKEY_FROM_LINK (Link));
753 }
754 EfiReleaseLock (&mBmHotkeyLock);
755 }
756}
757
758/**
759 Free the key options returned from BmGetKeyOptions.
760
761 @param KeyOptions Pointer to the key options.
762 @param KeyOptionCount Number of the key options.
763
764 @retval EFI_SUCCESS The key options are freed.
765 @retval EFI_NOT_FOUND KeyOptions is NULL.
766**/
767EFI_STATUS
768BmFreeKeyOptions (
769 IN EFI_BOOT_MANAGER_KEY_OPTION *KeyOptions,
770 IN UINTN KeyOptionCount
771 )
772{
773 if (KeyOptions != NULL) {
774 FreePool (KeyOptions);
775 return EFI_SUCCESS;
776 } else {
777 return EFI_NOT_FOUND;
778 }
779}
780
781/**
782 Register the key option to exit the waiting of the Boot Manager timeout.
783 Platform should ensure that the continue key option isn't conflict with
784 other boot key options.
785
786 @param Modifier Key shift state.
787 @param ... Parameter list of pointer of EFI_INPUT_KEY.
788
789 @retval EFI_SUCCESS Successfully register the continue key option.
790 @retval EFI_ALREADY_STARTED The continue key option is already registered.
791**/
792EFI_STATUS
793EFIAPI
794EfiBootManagerRegisterContinueKeyOption (
795 IN UINT32 Modifier,
796 ...
797 )
798{
799 EFI_STATUS Status;
800 EFI_BOOT_MANAGER_KEY_OPTION KeyOption;
801 VA_LIST Args;
802
803 if (mBmContinueKeyOption != NULL) {
804 return EFI_ALREADY_STARTED;
805 }
806
807 ZeroMem (&KeyOption, sizeof (EFI_BOOT_MANAGER_KEY_OPTION));
808 VA_START (Args, Modifier);
809 Status = BmInitializeKeyFields (Modifier, Args, &KeyOption);
810 VA_END (Args);
811
812 if (!EFI_ERROR (Status)) {
813 mBmContinueKeyOption = AllocateCopyPool (sizeof (EFI_BOOT_MANAGER_KEY_OPTION), &KeyOption);
814 ASSERT (mBmContinueKeyOption != NULL);
815 if (mBmHotkeyServiceStarted) {
816 BmProcessKeyOption (mBmContinueKeyOption);
817 }
818 }
819
820 return Status;
821}
822
823/**
824 Stop the hotkey processing.
825
826 @param Event Event pointer related to hotkey service.
827 @param Context Context pass to this function.
828**/
829VOID
830EFIAPI
831BmStopHotkeyService (
832 IN EFI_EVENT Event,
833 IN VOID *Context
834 )
835{
836 LIST_ENTRY *Link;
837 BM_HOTKEY *Hotkey;
838
839 DEBUG ((EFI_D_INFO, "[Bds]Stop Hotkey Service!\n"));
840 gBS->CloseEvent (Event);
841
842 EfiAcquireLock (&mBmHotkeyLock);
843 for (Link = GetFirstNode (&mBmHotkeyList); !IsNull (&mBmHotkeyList, Link); ) {
844 Hotkey = BM_HOTKEY_FROM_LINK (Link);
845 BmUnregisterHotkeyNotify (Hotkey);
846 Link = RemoveEntryList (Link);
847 FreePool (Hotkey);
848 }
849 EfiReleaseLock (&mBmHotkeyLock);
850}
851
852/**
853 Start the hot key service so that the key press can trigger the boot option.
854
855 @param HotkeyTriggered Return the waitable event and it will be signaled
856 when a valid hot key is pressed.
857
858 @retval EFI_SUCCESS The hot key service is started.
859**/
860EFI_STATUS
861EFIAPI
862EfiBootManagerStartHotkeyService (
863 IN EFI_EVENT *HotkeyTriggered
864 )
865{
866 EFI_STATUS Status;
867 EFI_BOOT_MANAGER_KEY_OPTION *KeyOptions;
868 UINTN KeyOptionCount;
869 UINTN Index;
870 EFI_EVENT Event;
871 UINT32 *BootOptionSupport;
872
873 GetEfiGlobalVariable2 (EFI_BOOT_OPTION_SUPPORT_VARIABLE_NAME, (VOID **) &BootOptionSupport, NULL);
874 if (BootOptionSupport != NULL) {
875 if ((*BootOptionSupport & EFI_BOOT_OPTION_SUPPORT_KEY) != 0) {
876 mBmHotkeySupportCount = ((*BootOptionSupport & EFI_BOOT_OPTION_SUPPORT_COUNT) >> LowBitSet32 (EFI_BOOT_OPTION_SUPPORT_COUNT));
877 }
878 FreePool (BootOptionSupport);
879 }
880
881 if (mBmHotkeySupportCount == 0) {
882 DEBUG ((EFI_D_INFO, "Bds: BootOptionSupport NV variable forbids starting the hotkey service.\n"));
883 return EFI_UNSUPPORTED;
884 }
885
886 Status = gBS->CreateEvent (
887 EVT_NOTIFY_WAIT,
888 TPL_CALLBACK,
889 EfiEventEmptyFunction,
890 NULL,
891 &mBmHotkeyTriggered
892 );
893 ASSERT_EFI_ERROR (Status);
894
895 if (HotkeyTriggered != NULL) {
896 *HotkeyTriggered = mBmHotkeyTriggered;
897 }
898
899 KeyOptions = BmGetKeyOptions (&KeyOptionCount);
900 for (Index = 0; Index < KeyOptionCount; Index ++) {
901 BmProcessKeyOption (&KeyOptions[Index]);
902 }
903 BmFreeKeyOptions (KeyOptions, KeyOptionCount);
904
905 if (mBmContinueKeyOption != NULL) {
906 BmProcessKeyOption (mBmContinueKeyOption);
907 }
908
909 //
910 // Hook hotkey on every future SimpleTextInputEx instance when
911 // SystemTable.ConsoleInHandle == NULL, which means the console
912 // manager (ConSplitter) is absent.
913 //
914 if (gST->ConsoleInHandle == NULL) {
915 EfiCreateProtocolNotifyEvent (
916 &gEfiSimpleTextInputExProtocolGuid,
917 TPL_CALLBACK,
918 BmTxtInExCallback,
919 NULL,
920 &mBmTxtInExRegistration
921 );
922 }
923
924 Status = EfiCreateEventReadyToBootEx (
925 TPL_CALLBACK,
926 BmStopHotkeyService,
927 NULL,
928 &Event
929 );
930 ASSERT_EFI_ERROR (Status);
931
932 mBmHotkeyServiceStarted = TRUE;
933 return Status;
934}
935
936/**
937 Add the key option.
938 It adds the key option variable and the key option takes affect immediately.
939
940 @param AddedOption Return the added key option.
941 @param BootOptionNumber The boot option number for the key option.
942 @param Modifier Key shift state.
943 @param ... Parameter list of pointer of EFI_INPUT_KEY.
944
945 @retval EFI_SUCCESS The key option is added.
946 @retval EFI_ALREADY_STARTED The hot key is already used by certain key option.
947**/
948EFI_STATUS
949EFIAPI
950EfiBootManagerAddKeyOptionVariable (
951 OUT EFI_BOOT_MANAGER_KEY_OPTION *AddedOption, OPTIONAL
952 IN UINT16 BootOptionNumber,
953 IN UINT32 Modifier,
954 ...
955 )
956{
957 EFI_STATUS Status;
958 VA_LIST Args;
959 VOID *BootOption;
960 UINTN BootOptionSize;
961 CHAR16 BootOptionName[BM_OPTION_NAME_LEN];
962 EFI_BOOT_MANAGER_KEY_OPTION KeyOption;
963 EFI_BOOT_MANAGER_KEY_OPTION *KeyOptions;
964 UINTN KeyOptionCount;
965 UINTN Index;
966 UINTN KeyOptionNumber;
967 CHAR16 KeyOptionName[sizeof ("Key####")];
968
969 UnicodeSPrint (
970 BootOptionName, sizeof (BootOptionName), L"%s%04x",
971 mBmLoadOptionName[LoadOptionTypeBoot], BootOptionNumber
972 );
973 GetEfiGlobalVariable2 (BootOptionName, &BootOption, &BootOptionSize);
974
975 if (BootOption == NULL) {
976 return EFI_NOT_FOUND;
977 }
978
979 ZeroMem (&KeyOption, sizeof (EFI_BOOT_MANAGER_KEY_OPTION));
980 KeyOption.BootOption = BootOptionNumber;
981 Status = gBS->CalculateCrc32 (BootOption, BootOptionSize, &KeyOption.BootOptionCrc);
982 ASSERT_EFI_ERROR (Status);
983 FreePool (BootOption);
984
985 VA_START (Args, Modifier);
986 Status = BmInitializeKeyFields (Modifier, Args, &KeyOption);
987 VA_END (Args);
988 if (EFI_ERROR (Status)) {
989 return Status;
990 }
991
992 KeyOptionNumber = LoadOptionNumberUnassigned;
993 //
994 // Check if the hot key sequence was defined already
995 //
996 KeyOptions = BmGetKeyOptions (&KeyOptionCount);
997 for (Index = 0; Index < KeyOptionCount; Index++) {
998 if ((KeyOptions[Index].KeyData.PackedValue == KeyOption.KeyData.PackedValue) &&
999 (CompareMem (KeyOptions[Index].Keys, KeyOption.Keys, KeyOption.KeyData.Options.InputKeyCount * sizeof (EFI_INPUT_KEY)) == 0)) {
1000 break;
1001 }
1002
1003 if ((KeyOptionNumber == LoadOptionNumberUnassigned) &&
1004 (KeyOptions[Index].OptionNumber > Index)
1005 ){
1006 KeyOptionNumber = Index;
1007 }
1008 }
1009 BmFreeKeyOptions (KeyOptions, KeyOptionCount);
1010
1011 if (Index < KeyOptionCount) {
1012 return EFI_ALREADY_STARTED;
1013 }
1014
1015 if (KeyOptionNumber == LoadOptionNumberUnassigned) {
1016 KeyOptionNumber = KeyOptionCount;
1017 }
1018
1019 UnicodeSPrint (KeyOptionName, sizeof (KeyOptionName), L"Key%04x", KeyOptionNumber);
1020
1021 Status = gRT->SetVariable (
1022 KeyOptionName,
1023 &gEfiGlobalVariableGuid,
1024 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
1025 BmSizeOfKeyOption (&KeyOption),
1026 &KeyOption
1027 );
1028 if (!EFI_ERROR (Status)) {
1029 //
1030 // Return the Key Option in case needed by caller
1031 //
1032 if (AddedOption != NULL) {
1033 CopyMem (AddedOption, &KeyOption, sizeof (EFI_BOOT_MANAGER_KEY_OPTION));
1034 }
1035
1036 //
1037 // Register the newly added hot key
1038 // Calling this function before EfiBootManagerStartHotkeyService doesn't
1039 // need to call BmProcessKeyOption
1040 //
1041 if (mBmHotkeyServiceStarted) {
1042 BmProcessKeyOption (&KeyOption);
1043 }
1044 }
1045
1046 return Status;
1047}
1048
1049/**
1050 Delete the Key Option variable and unregister the hot key
1051
1052 @param DeletedOption Return the deleted key options.
1053 @param Modifier Key shift state.
1054 @param ... Parameter list of pointer of EFI_INPUT_KEY.
1055
1056 @retval EFI_SUCCESS The key option is deleted.
1057 @retval EFI_NOT_FOUND The key option cannot be found.
1058**/
1059EFI_STATUS
1060EFIAPI
1061EfiBootManagerDeleteKeyOptionVariable (
1062 IN EFI_BOOT_MANAGER_KEY_OPTION *DeletedOption, OPTIONAL
1063 IN UINT32 Modifier,
1064 ...
1065 )
1066{
1067 EFI_STATUS Status;
1068 UINTN Index;
1069 VA_LIST Args;
1070 EFI_BOOT_MANAGER_KEY_OPTION KeyOption;
1071 EFI_BOOT_MANAGER_KEY_OPTION *KeyOptions;
1072 UINTN KeyOptionCount;
1073 LIST_ENTRY *Link;
1074 BM_HOTKEY *Hotkey;
1075 UINT32 ShiftState;
1076 BOOLEAN Match;
1077 CHAR16 KeyOptionName[sizeof ("Key####")];
1078
1079 ZeroMem (&KeyOption, sizeof (EFI_BOOT_MANAGER_KEY_OPTION));
1080 VA_START (Args, Modifier);
1081 Status = BmInitializeKeyFields (Modifier, Args, &KeyOption);
1082 VA_END (Args);
1083
1084 if (EFI_ERROR (Status)) {
1085 return Status;
1086 }
1087
1088 EfiAcquireLock (&mBmHotkeyLock);
1089 //
1090 // Delete the key option from active hot key list
1091 // Could have multiple entries when modifier isn't 0 because we map the ShiftPressed to RIGHT_SHIFT and RIGHT_SHIFT
1092 //
1093 for (Link = GetFirstNode (&mBmHotkeyList); !IsNull (&mBmHotkeyList, Link); ) {
1094 Hotkey = BM_HOTKEY_FROM_LINK (Link);
1095 Match = (BOOLEAN) (Hotkey->CodeCount == KeyOption.KeyData.Options.InputKeyCount);
1096
1097 for (Index = 0; Match && (Index < Hotkey->CodeCount); Index++) {
1098 ShiftState = Hotkey->KeyData[Index].KeyState.KeyShiftState;
1099 if (
1100 (BmBitSet (ShiftState, EFI_RIGHT_SHIFT_PRESSED | EFI_LEFT_SHIFT_PRESSED) != KeyOption.KeyData.Options.ShiftPressed) ||
1101 (BmBitSet (ShiftState, EFI_RIGHT_CONTROL_PRESSED | EFI_LEFT_CONTROL_PRESSED) != KeyOption.KeyData.Options.ControlPressed) ||
1102 (BmBitSet (ShiftState, EFI_RIGHT_ALT_PRESSED | EFI_LEFT_ALT_PRESSED) != KeyOption.KeyData.Options.AltPressed) ||
1103 (BmBitSet (ShiftState, EFI_RIGHT_LOGO_PRESSED | EFI_LEFT_LOGO_PRESSED) != KeyOption.KeyData.Options.LogoPressed) ||
1104 (BmBitSet (ShiftState, EFI_MENU_KEY_PRESSED) != KeyOption.KeyData.Options.MenuPressed) ||
1105 (BmBitSet (ShiftState, EFI_SYS_REQ_PRESSED) != KeyOption.KeyData.Options.SysReqPressed) ||
1106 (CompareMem (&Hotkey->KeyData[Index].Key, &KeyOption.Keys[Index], sizeof (EFI_INPUT_KEY)) != 0)
1107 ) {
1108 //
1109 // Break when any field doesn't match
1110 //
1111 Match = FALSE;
1112 break;
1113 }
1114 }
1115
1116 if (Match) {
1117 Link = RemoveEntryList (Link);
1118 FreePool (Hotkey);
1119 } else {
1120 Link = GetNextNode (&mBmHotkeyList, Link);
1121 }
1122 }
1123
1124 //
1125 // Delete the key option from the variable
1126 //
1127 Status = EFI_NOT_FOUND;
1128 KeyOptions = BmGetKeyOptions (&KeyOptionCount);
1129 for (Index = 0; Index < KeyOptionCount; Index++) {
1130 if ((KeyOptions[Index].KeyData.PackedValue == KeyOption.KeyData.PackedValue) &&
1131 (CompareMem (
1132 KeyOptions[Index].Keys, KeyOption.Keys,
1133 KeyOption.KeyData.Options.InputKeyCount * sizeof (EFI_INPUT_KEY)) == 0)
1134 ) {
1135 UnicodeSPrint (KeyOptionName, sizeof (KeyOptionName), L"Key%04x", KeyOptions[Index].OptionNumber);
1136 Status = gRT->SetVariable (
1137 KeyOptionName,
1138 &gEfiGlobalVariableGuid,
1139 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
1140 0,
1141 NULL
1142 );
1143 //
1144 // Return the deleted key option in case needed by caller
1145 //
1146 if (DeletedOption != NULL) {
1147 CopyMem (DeletedOption, &KeyOptions[Index], sizeof (EFI_BOOT_MANAGER_KEY_OPTION));
1148 }
1149 break;
1150 }
1151 }
1152 BmFreeKeyOptions (KeyOptions, KeyOptionCount);
1153
1154 EfiReleaseLock (&mBmHotkeyLock);
1155
1156 return Status;
1157}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette