GopInput.c

/*++ @file
 
Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
Portions copyright (c) 2010 0 2011,Apple Inc. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
 
 
**/
 
#include "Gop.h"
 
BOOLEAN
GopPrivateIsKeyRegistered (
  IN EFI_KEY_DATA  *RegsiteredData,
  IN EFI_KEY_DATA  *InputData
  )
 
/*++
 
Routine Description:
 
Arguments:
 
  RegsiteredData    - A pointer to a buffer that is filled in with the keystroke
                      state data for the key that was registered.
  InputData         - A pointer to a buffer that is filled in with the keystroke
                      state data for the key that was pressed.
 
Returns:
  TRUE              - Key be pressed matches a registered key.
  FLASE             - Match failed.
 
**/
{
  ASSERT (RegsiteredData != NULL && InputData != NULL);
 
  if ((RegsiteredData->Key.ScanCode    != InputData->Key.ScanCode) ||
      (RegsiteredData->Key.UnicodeChar != InputData->Key.UnicodeChar))
  {
    return FALSE;
  }
 
  //
  // Assume KeyShiftState/KeyToggleState = 0 in Registered key data means these state could be ignored.
  //
  if ((RegsiteredData->KeyState.KeyShiftState != 0) &&
      (RegsiteredData->KeyState.KeyShiftState != InputData->KeyState.KeyShiftState))
  {
    return FALSE;
  }
 
  if ((RegsiteredData->KeyState.KeyToggleState != 0) &&
      (RegsiteredData->KeyState.KeyToggleState != InputData->KeyState.KeyToggleState))
  {
    return FALSE;
  }
 
  return TRUE;
}
 
VOID
EFIAPI
GopPrivateMakeCallbackFunction (
  IN VOID          *Context,
  IN EFI_KEY_DATA  *KeyData
  )
{
  LIST_ENTRY                       *Link;
  EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY  *CurrentNotify;
  GOP_PRIVATE_DATA                 *Private = (GOP_PRIVATE_DATA *)Context;
 
  KeyMapMake (KeyData);
 
  for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) {
    CurrentNotify = CR (
                      Link,
                      EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY,
                      NotifyEntry,
                      EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
                      );
    if (GopPrivateIsKeyRegistered (&CurrentNotify->KeyData, KeyData)) {
      // We could be called at a high TPL so signal an event to call the registered function
      // at a lower TPL.
      gBS->SignalEvent (CurrentNotify->Event);
    }
  }
}
 
VOID
EFIAPI
GopPrivateBreakCallbackFunction (
  IN VOID          *Context,
  IN EFI_KEY_DATA  *KeyData
  )
{
  KeyMapBreak (KeyData);
}
 
//
// Simple Text In implementation.
//
 
EFI_STATUS
EFIAPI
EmuGopSimpleTextInReset (
  IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL  *This,
  IN BOOLEAN                         ExtendedVerification
  )
{
  GOP_PRIVATE_DATA  *Private;
  EFI_KEY_DATA      KeyData;
  EFI_TPL           OldTpl;
 
  Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This);
  if (Private->EmuGraphicsWindow == NULL) {
    return EFI_SUCCESS;
  }
 
  //
  // Enter critical section
  //
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  //
  // A reset is draining the Queue
  //
  while (Private->EmuGraphicsWindow->GetKey (Private->EmuGraphicsWindow, &KeyData) == EFI_SUCCESS) {
  }
 
  //
  // Leave critical section and return
  //
  gBS->RestoreTPL (OldTpl);
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EmuGopSimpleTextInReadKeyStroke (
  IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL  *This,
  OUT EFI_INPUT_KEY                  *Key
  )
{
  GOP_PRIVATE_DATA  *Private;
  EFI_STATUS        Status;
  EFI_TPL           OldTpl;
  EFI_KEY_DATA      KeyData;
 
  Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This);
  if (Private->EmuGraphicsWindow == NULL) {
    return EFI_NOT_READY;
  }
 
  //
  // Enter critical section
  //
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  Status = Private->EmuGraphicsWindow->GetKey (Private->EmuGraphicsWindow, &KeyData);
  if (!EFI_ERROR (Status)) {
    if ((KeyData.Key.ScanCode == 0) && (KeyData.Key.UnicodeChar == 0)) {
      // Modifier key was pressed
      Status = EFI_NOT_READY;
    } else {
      CopyMem (Key, &KeyData.Key, sizeof (EFI_INPUT_KEY));
    }
  }
 
  //
  // Leave critical section and return
  //
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
VOID
EFIAPI
EmuGopSimpleTextInWaitForKey (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  GOP_PRIVATE_DATA  *Private;
  EFI_STATUS        Status;
  EFI_TPL           OldTpl;
 
  Private = (GOP_PRIVATE_DATA *)Context;
  if (Private->EmuGraphicsWindow == NULL) {
    return;
  }
 
  //
  // Enter critical section
  //
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  Status = Private->EmuGraphicsWindow->CheckKey (Private->EmuGraphicsWindow);
  if (!EFI_ERROR (Status)) {
    //
    // If a there is a key in the queue signal our event.
    //
    gBS->SignalEvent (Event);
  }
 
  //
  // Leave critical section and return
  //
  gBS->RestoreTPL (OldTpl);
}
 
//
// Simple Text Input Ex protocol functions
//
 
EFI_STATUS
EFIAPI
EmuGopSimpleTextInExResetEx (
  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
  IN BOOLEAN                            ExtendedVerification
  )
 
/*++
 
  Routine Description:
    Reset the input device and optionaly run diagnostics
 
  Arguments:
    This                 - Protocol instance pointer.
    ExtendedVerification - Driver may perform diagnostics on reset.
 
  Returns:
    EFI_SUCCESS           - The device was reset.
 
**/
{
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EmuGopSimpleTextInExReadKeyStrokeEx (
  IN  EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
  OUT EFI_KEY_DATA                       *KeyData
  )
 
/*++
 
  Routine Description:
    Reads the next keystroke from the input device. The WaitForKey Event can
    be used to test for existance of a keystroke via WaitForEvent () call.
 
  Arguments:
    This       - Protocol instance pointer.
    KeyData    - A pointer to a buffer that is filled in with the keystroke
                 state data for the key that was pressed.
 
  Returns:
    EFI_SUCCESS           - The keystroke information was returned.
    EFI_NOT_READY         - There was no keystroke data availiable.
    EFI_DEVICE_ERROR      - The keystroke information was not returned due to
                            hardware errors.
    EFI_INVALID_PARAMETER - KeyData is NULL.
 
**/
{
  EFI_STATUS        Status;
  GOP_PRIVATE_DATA  *Private;
  EFI_TPL           OldTpl;
 
  if (KeyData == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This);
  if (Private->EmuGraphicsWindow == NULL) {
    return EFI_NOT_READY;
  }
 
  //
  // Enter critical section
  //
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  Status = Private->EmuGraphicsWindow->GetKey (Private->EmuGraphicsWindow, KeyData);
 
  //
  // Leave critical section and return
  //
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuGopSimpleTextInExSetState (
  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
  IN EFI_KEY_TOGGLE_STATE               *KeyToggleState
  )
{
  GOP_PRIVATE_DATA  *Private;
  EFI_STATUS        Status;
  EFI_TPL           OldTpl;
 
  if (KeyToggleState == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This);
  if (Private->EmuGraphicsWindow == NULL) {
    return EFI_NOT_READY;
  }
 
  if (((Private->KeyState.KeyToggleState & EFI_TOGGLE_STATE_VALID) != EFI_TOGGLE_STATE_VALID) ||
      ((*KeyToggleState & EFI_TOGGLE_STATE_VALID) != EFI_TOGGLE_STATE_VALID))
  {
    return EFI_UNSUPPORTED;
  }
 
  //
  // Enter critical section
  //
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  Status = Private->EmuGraphicsWindow->KeySetState (Private->EmuGraphicsWindow, KeyToggleState);
  //
  // Leave critical section and return
  //
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
VOID
EFIAPI
EmuGopRegisterKeyCallback (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY  *ExNotify = (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY *)Context;
 
  ExNotify->KeyNotificationFn (&ExNotify->KeyData);
}
 
EFI_STATUS
EFIAPI
EmuGopSimpleTextInExRegisterKeyNotify (
  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
  IN EFI_KEY_DATA                       *KeyData,
  IN EFI_KEY_NOTIFY_FUNCTION            KeyNotificationFunction,
  OUT VOID                              **NotifyHandle
  )
{
  EFI_STATUS                       Status;
  GOP_PRIVATE_DATA                 *Private;
  EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY  *CurrentNotify;
  LIST_ENTRY                       *Link;
  EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY  *NewNotify;
 
  if ((KeyData == NULL) || (KeyNotificationFunction == NULL) || (NotifyHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This);
 
  //
  // Return EFI_SUCCESS if the (KeyData, NotificationFunction) is already registered.
  //
  for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) {
    CurrentNotify = CR (
                      Link,
                      EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY,
                      NotifyEntry,
                      EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
                      );
    if (GopPrivateIsKeyRegistered (&CurrentNotify->KeyData, KeyData)) {
      if (CurrentNotify->KeyNotificationFn == KeyNotificationFunction) {
        *NotifyHandle = CurrentNotify->NotifyHandle;
        return EFI_SUCCESS;
      }
    }
  }
 
  //
  // Allocate resource to save the notification function
  //
  NewNotify = (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY *)AllocateZeroPool (sizeof (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY));
  if (NewNotify == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  NewNotify->Signature         = EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE;
  NewNotify->KeyNotificationFn = KeyNotificationFunction;
  NewNotify->NotifyHandle      = (EFI_HANDLE)NewNotify;
  CopyMem (&NewNotify->KeyData, KeyData, sizeof (KeyData));
  InsertTailList (&Private->NotifyList, &NewNotify->NotifyEntry);
 
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  TPL_NOTIFY,
                  EmuGopRegisterKeyCallback,
                  NewNotify,
                  &NewNotify->Event
                  );
  ASSERT_EFI_ERROR (Status);
 
  *NotifyHandle = NewNotify->NotifyHandle;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EmuGopSimpleTextInExUnregisterKeyNotify (
  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
  IN VOID                               *NotificationHandle
  )
 
/*++
 
  Routine Description:
    Remove a registered notification function from a particular keystroke.
 
  Arguments:
    This                    - Protocol instance pointer.
    NotificationHandle      - The handle of the notification function being unregistered.
 
  Returns:
    EFI_SUCCESS             - The notification function was unregistered successfully.
    EFI_INVALID_PARAMETER   - The NotificationHandle is invalid.
 
**/
{
  GOP_PRIVATE_DATA                 *Private;
  LIST_ENTRY                       *Link;
  EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY  *CurrentNotify;
 
  if (NotificationHandle == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (((EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY *)NotificationHandle)->Signature != EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE) {
    return EFI_INVALID_PARAMETER;
  }
 
  Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This);
 
  for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) {
    CurrentNotify = CR (
                      Link,
                      EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY,
                      NotifyEntry,
                      EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
                      );
    if (CurrentNotify->NotifyHandle == NotificationHandle) {
      //
      // Remove the notification function from NotifyList and free resources
      //
      RemoveEntryList (&CurrentNotify->NotifyEntry);
 
      gBS->CloseEvent (CurrentNotify->Event);
 
      gBS->FreePool (CurrentNotify);
      return EFI_SUCCESS;
    }
  }
 
  //
  // Can not find the specified Notification Handle
  //
  return EFI_INVALID_PARAMETER;
}
 
EFI_STATUS
EmuGopInitializeSimpleTextInForWindow (
  IN  GOP_PRIVATE_DATA  *Private
  )
{
  EFI_STATUS  Status;
 
  //
  // Initialize Simple Text In protoocol
  //
  Private->SimpleTextIn.Reset         = EmuGopSimpleTextInReset;
  Private->SimpleTextIn.ReadKeyStroke = EmuGopSimpleTextInReadKeyStroke;
 
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_WAIT,
                  TPL_NOTIFY,
                  EmuGopSimpleTextInWaitForKey,
                  Private,
                  &Private->SimpleTextIn.WaitForKey
                  );
  ASSERT_EFI_ERROR (Status);
 
  //
  // Initialize Simple Text In Ex
  //
 
  Private->SimpleTextInEx.Reset               = EmuGopSimpleTextInExResetEx;
  Private->SimpleTextInEx.ReadKeyStrokeEx     = EmuGopSimpleTextInExReadKeyStrokeEx;
  Private->SimpleTextInEx.SetState            = EmuGopSimpleTextInExSetState;
  Private->SimpleTextInEx.RegisterKeyNotify   = EmuGopSimpleTextInExRegisterKeyNotify;
  Private->SimpleTextInEx.UnregisterKeyNotify = EmuGopSimpleTextInExUnregisterKeyNotify;
 
  Private->SimpleTextInEx.Reset (&Private->SimpleTextInEx, FALSE);
 
  InitializeListHead (&Private->NotifyList);
 
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_WAIT,
                  TPL_NOTIFY,
                  EmuGopSimpleTextInWaitForKey,
                  Private,
                  &Private->SimpleTextInEx.WaitForKeyEx
                  );
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}
 
//
// Simple Pointer implementation.
//
 
EFI_STATUS
EFIAPI
EmuGopSimplePointerReset (
  IN EFI_SIMPLE_POINTER_PROTOCOL  *This,
  IN BOOLEAN                      ExtendedVerification
  )
{
  GOP_PRIVATE_DATA          *Private;
  EFI_SIMPLE_POINTER_STATE  State;
  EFI_TPL                   OldTpl;
 
  Private = GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This);
  if (Private->EmuGraphicsWindow == NULL) {
    return EFI_SUCCESS;
  }
 
  //
  // Enter critical section
  //
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  //
  // A reset is draining the Queue
  //
  while (Private->EmuGraphicsWindow->GetPointerState (Private->EmuGraphicsWindow, &State) == EFI_SUCCESS) {
  }
 
  //
  // Leave critical section and return
  //
  gBS->RestoreTPL (OldTpl);
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EmuGopSimplePointerGetState (
  IN EFI_SIMPLE_POINTER_PROTOCOL   *This,
  IN OUT EFI_SIMPLE_POINTER_STATE  *State
  )
{
  GOP_PRIVATE_DATA  *Private;
  EFI_STATUS        Status;
  EFI_TPL           OldTpl;
 
  Private = GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This);
  if (Private->EmuGraphicsWindow == NULL) {
    return EFI_NOT_READY;
  }
 
  //
  // Enter critical section
  //
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  Status = Private->EmuGraphicsWindow->GetPointerState (Private->EmuGraphicsWindow, State);
  //
  // Leave critical section and return
  //
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
VOID
EFIAPI
EmuGopSimplePointerWaitForInput (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  GOP_PRIVATE_DATA  *Private;
  EFI_STATUS        Status;
  EFI_TPL           OldTpl;
 
  Private = (GOP_PRIVATE_DATA *)Context;
  if (Private->EmuGraphicsWindow == NULL) {
    return;
  }
 
  //
  // Enter critical section
  //
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  Status = Private->EmuGraphicsWindow->CheckPointer (Private->EmuGraphicsWindow);
  if (!EFI_ERROR (Status)) {
    //
    // If the pointer state has changed, signal our event.
    //
    gBS->SignalEvent (Event);
  }
 
  //
  // Leave critical section and return
  //
  gBS->RestoreTPL (OldTpl);
}
 
EFI_STATUS
EmuGopInitializeSimplePointerForWindow (
  IN  GOP_PRIVATE_DATA  *Private
  )
{
  EFI_STATUS  Status;
 
  //
  // Initialize Simple Pointer protoocol
  //
  Private->PointerMode.ResolutionX = 1;
  Private->PointerMode.ResolutionY = 1;
  Private->PointerMode.ResolutionZ = 1;
  Private->PointerMode.LeftButton  = TRUE;
  Private->PointerMode.RightButton = TRUE;
 
  Private->SimplePointer.Reset    = EmuGopSimplePointerReset;
  Private->SimplePointer.GetState = EmuGopSimplePointerGetState;
  Private->SimplePointer.Mode     = &Private->PointerMode;
 
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_WAIT,
                  TPL_NOTIFY,
                  EmuGopSimplePointerWaitForInput,
                  Private,
                  &Private->SimplePointer.WaitForInput
                  );
 
  return Status;
}