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