BmHotkey.c

Go to the documentation of this file.

 
#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;
 
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);
}
 
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);
}
 
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;
 
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);
  }
}
 
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;
}
 
BOOLEAN
BmBitSet (
  IN UINT32  Value,
  IN UINT32  Bit
  )
{
  return (BOOLEAN)((Value & Bit) != 0);
}
 
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;
}
 
VOID
EFIAPI
EfiBootManagerHotkeyBoot (
  VOID
  )
{
  if (mBmHotkeyBootOption.OptionNumber != LoadOptionNumberUnassigned) {
    EfiBootManagerBoot (&mBmHotkeyBootOption);
    EfiBootManagerFreeLoadOption (&mBmHotkeyBootOption);
    mBmHotkeyBootOption.OptionNumber = LoadOptionNumberUnassigned;
  }
}
 
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 ((DEBUG_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 ((DEBUG_INFO, "[Bds]Hotkey for %s pressed - %r\n", OptionName, Status));
          if (EFI_ERROR (Status)) {
            mBmHotkeyBootOption.OptionNumber = LoadOptionNumberUnassigned;
          }
        } else {
          DEBUG ((DEBUG_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;
}
 
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;
}
 
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 ((DEBUG_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;
}
 
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 ((
      DEBUG_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;
}
 
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;
  }
}
 
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;
}
 
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);
  }
}
 
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;
  }
}
 
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;
}
 
VOID
EFIAPI
BmStopHotkeyService (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  LIST_ENTRY  *Link;
  BM_HOTKEY   *Hotkey;
 
  DEBUG ((DEBUG_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);
}
 
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 ((DEBUG_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;
}
 
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;
}
 
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;
}