3 Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
4 Portions copyright (c) 2010 0 2011,Apple Inc. All rights reserved.<BR>
5 SPDX-License-Identifier: BSD-2-Clause-Patent
14 GopPrivateIsKeyRegistered (
15 IN EFI_KEY_DATA
*RegsiteredData
,
16 IN EFI_KEY_DATA
*InputData
24 RegsiteredData - A pointer to a buffer that is filled in with the keystroke
25 state data for the key that was registered.
26 InputData - A pointer to a buffer that is filled in with the keystroke
27 state data for the key that was pressed.
30 TRUE - Key be pressed matches a registered key.
35 ASSERT (RegsiteredData
!= NULL
&& InputData
!= NULL
);
37 if ((RegsiteredData
->Key
.ScanCode
!= InputData
->Key
.ScanCode
) ||
38 (RegsiteredData
->Key
.UnicodeChar
!= InputData
->Key
.UnicodeChar
)) {
43 // Assume KeyShiftState/KeyToggleState = 0 in Registered key data means these state could be ignored.
45 if (RegsiteredData
->KeyState
.KeyShiftState
!= 0 &&
46 RegsiteredData
->KeyState
.KeyShiftState
!= InputData
->KeyState
.KeyShiftState
) {
49 if (RegsiteredData
->KeyState
.KeyToggleState
!= 0 &&
50 RegsiteredData
->KeyState
.KeyToggleState
!= InputData
->KeyState
.KeyToggleState
) {
61 GopPrivateMakeCallbackFunction (
63 IN EFI_KEY_DATA
*KeyData
67 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
68 GOP_PRIVATE_DATA
*Private
= (GOP_PRIVATE_DATA
*)Context
;
72 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
75 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
77 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
79 if (GopPrivateIsKeyRegistered (&CurrentNotify
->KeyData
, KeyData
)) {
80 // We could be called at a high TPL so signal an event to call the registered function
82 gBS
->SignalEvent (CurrentNotify
->Event
);
90 GopPrivateBreakCallbackFunction (
92 IN EFI_KEY_DATA
*KeyData
95 KeyMapBreak (KeyData
);
101 // Simple Text In implementation.
105 Reset the input device and optionally run diagnostics
107 @param This Protocol instance pointer.
108 @param ExtendedVerification Driver may perform diagnostics on reset.
110 @retval EFI_SUCCESS The device was reset.
111 @retval EFI_DEVICE_ERROR The device is not functioning properly and could not be reset.
116 EmuGopSimpleTextInReset (
117 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*This
,
118 IN BOOLEAN ExtendedVerification
121 GOP_PRIVATE_DATA
*Private
;
122 EFI_KEY_DATA KeyData
;
125 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
126 if (Private
->EmuGraphicsWindow
== NULL
) {
131 // Enter critical section
133 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
136 // A reset is draining the Queue
138 while (Private
->EmuGraphicsWindow
->GetKey (Private
->EmuGraphicsWindow
, &KeyData
) == EFI_SUCCESS
)
142 // Leave critical section and return
144 gBS
->RestoreTPL (OldTpl
);
150 Reads the next keystroke from the input device. The WaitForKey Event can
151 be used to test for existence of a keystroke via WaitForEvent () call.
153 @param This Protocol instance pointer.
154 @param Key A pointer to a buffer that is filled in with the keystroke
155 information for the key that was pressed.
157 @retval EFI_SUCCESS The keystroke information was returned.
158 @retval EFI_NOT_READY There was no keystroke data available.
159 @retval EFI_DEVICE_ERROR The keystroke information was not returned due to
165 EmuGopSimpleTextInReadKeyStroke (
166 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*This
,
167 OUT EFI_INPUT_KEY
*Key
170 GOP_PRIVATE_DATA
*Private
;
173 EFI_KEY_DATA KeyData
;
175 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
176 if (Private
->EmuGraphicsWindow
== NULL
) {
177 return EFI_NOT_READY
;
181 // Enter critical section
183 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
185 Status
= Private
->EmuGraphicsWindow
->GetKey (Private
->EmuGraphicsWindow
, &KeyData
);
186 if (!EFI_ERROR (Status
)) {
187 if ((KeyData
.Key
.ScanCode
== 0) && (KeyData
.Key
.UnicodeChar
== 0)) {
188 // Modifier key was pressed
189 Status
= EFI_NOT_READY
;
191 CopyMem (Key
, &KeyData
.Key
, sizeof (EFI_INPUT_KEY
));
196 // Leave critical section and return
198 gBS
->RestoreTPL (OldTpl
);
206 SimpleTextIn and SimpleTextInEx Notify Wait Event
208 @param Event Event whose notification function is being invoked.
209 @param Context Pointer to GOP_PRIVATE_DATA.
214 EmuGopSimpleTextInWaitForKey (
219 GOP_PRIVATE_DATA
*Private
;
223 Private
= (GOP_PRIVATE_DATA
*) Context
;
224 if (Private
->EmuGraphicsWindow
== NULL
) {
229 // Enter critical section
231 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
233 Status
= Private
->EmuGraphicsWindow
->CheckKey (Private
->EmuGraphicsWindow
);
234 if (!EFI_ERROR (Status
)) {
236 // If a there is a key in the queue signal our event.
238 gBS
->SignalEvent (Event
);
241 // Leave critical section and return
243 gBS
->RestoreTPL (OldTpl
);
248 // Simple Text Input Ex protocol functions
253 The Reset() function resets the input device hardware. As part
254 of initialization process, the firmware/device will make a quick
255 but reasonable attempt to verify that the device is functioning.
256 If the ExtendedVerification flag is TRUE the firmware may take
257 an extended amount of time to verify the device is operating on
258 reset. Otherwise the reset operation is to occur as quickly as
259 possible. The hardware verification process is not defined by
260 this specification and is left up to the platform firmware or
263 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
265 @param ExtendedVerification Indicates that the driver may
266 perform a more exhaustive
267 verification operation of the
271 @retval EFI_SUCCESS The device was reset.
273 @retval EFI_DEVICE_ERROR The device is not functioning
274 correctly and could not be reset.
279 EmuGopSimpleTextInExResetEx (
280 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
281 IN BOOLEAN ExtendedVerification
286 Reset the input device and optionaly run diagnostics
289 This - Protocol instance pointer.
290 ExtendedVerification - Driver may perform diagnostics on reset.
293 EFI_SUCCESS - The device was reset.
303 The function reads the next keystroke from the input device. If
304 there is no pending keystroke the function returns
305 EFI_NOT_READY. If there is a pending keystroke, then
306 KeyData.Key.ScanCode is the EFI scan code defined in Error!
307 Reference source not found. The KeyData.Key.UnicodeChar is the
308 actual printable character or is zero if the key does not
309 represent a printable character (control key, function key,
310 etc.). The KeyData.KeyState is shift state for the character
311 reflected in KeyData.Key.UnicodeChar or KeyData.Key.ScanCode .
312 When interpreting the data from this function, it should be
313 noted that if a class of printable characters that are
314 normally adjusted by shift modifiers (e.g. Shift Key + "f"
315 key) would be presented solely as a KeyData.Key.UnicodeChar
316 without the associated shift state. So in the previous example
317 of a Shift Key + "f" key being pressed, the only pertinent
318 data returned would be KeyData.Key.UnicodeChar with the value
319 of "F". This of course would not typically be the case for
320 non-printable characters such as the pressing of the Right
321 Shift Key + F10 key since the corresponding returned data
322 would be reflected both in the KeyData.KeyState.KeyShiftState
323 and KeyData.Key.ScanCode values. UEFI drivers which implement
324 the EFI_SIMPLE_TEXT_INPUT_EX protocol are required to return
325 KeyData.Key and KeyData.KeyState values. These drivers must
326 always return the most current state of
327 KeyData.KeyState.KeyShiftState and
328 KeyData.KeyState.KeyToggleState. It should also be noted that
329 certain input devices may not be able to produce shift or toggle
330 state information, and in those cases the high order bit in the
331 respective Toggle and Shift state fields should not be active.
334 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
336 @param KeyData A pointer to a buffer that is filled in with
337 the keystroke state data for the key that was
341 @retval EFI_SUCCESS The keystroke information was
344 @retval EFI_NOT_READY There was no keystroke data available.
345 EFI_DEVICE_ERROR The keystroke
346 information was not returned due to
353 EmuGopSimpleTextInExReadKeyStrokeEx (
354 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
355 OUT EFI_KEY_DATA
*KeyData
360 Reads the next keystroke from the input device. The WaitForKey Event can
361 be used to test for existance of a keystroke via WaitForEvent () call.
364 This - Protocol instance pointer.
365 KeyData - A pointer to a buffer that is filled in with the keystroke
366 state data for the key that was pressed.
369 EFI_SUCCESS - The keystroke information was returned.
370 EFI_NOT_READY - There was no keystroke data availiable.
371 EFI_DEVICE_ERROR - The keystroke information was not returned due to
373 EFI_INVALID_PARAMETER - KeyData is NULL.
378 GOP_PRIVATE_DATA
*Private
;
382 if (KeyData
== NULL
) {
383 return EFI_INVALID_PARAMETER
;
386 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
387 if (Private
->EmuGraphicsWindow
== NULL
) {
388 return EFI_NOT_READY
;
392 // Enter critical section
394 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
396 Status
= Private
->EmuGraphicsWindow
->GetKey(Private
->EmuGraphicsWindow
, KeyData
);
399 // Leave critical section and return
401 gBS
->RestoreTPL (OldTpl
);
409 The SetState() function allows the input device hardware to
410 have state settings adjusted.
412 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
414 @param KeyToggleState Pointer to the EFI_KEY_TOGGLE_STATE to
415 set the state for the input device.
418 @retval EFI_SUCCESS The device state was set appropriately.
420 @retval EFI_DEVICE_ERROR The device is not functioning
421 correctly and could not have the
424 @retval EFI_UNSUPPORTED The device does not support the
425 ability to have its state set.
430 EmuGopSimpleTextInExSetState (
431 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
432 IN EFI_KEY_TOGGLE_STATE
*KeyToggleState
435 GOP_PRIVATE_DATA
*Private
;
439 if (KeyToggleState
== NULL
) {
440 return EFI_INVALID_PARAMETER
;
443 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
444 if (Private
->EmuGraphicsWindow
== NULL
) {
445 return EFI_NOT_READY
;
448 if (((Private
->KeyState
.KeyToggleState
& EFI_TOGGLE_STATE_VALID
) != EFI_TOGGLE_STATE_VALID
) ||
449 ((*KeyToggleState
& EFI_TOGGLE_STATE_VALID
) != EFI_TOGGLE_STATE_VALID
)) {
450 return EFI_UNSUPPORTED
;
454 // Enter critical section
456 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
458 Status
= Private
->EmuGraphicsWindow
->KeySetState (Private
->EmuGraphicsWindow
, KeyToggleState
);
460 // Leave critical section and return
462 gBS
->RestoreTPL (OldTpl
);
469 SimpleTextIn and SimpleTextInEx Notify Wait Event
471 @param Event Event whose notification function is being invoked.
472 @param Context Pointer to GOP_PRIVATE_DATA.
477 EmuGopRegisterKeyCallback (
482 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*ExNotify
= (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*)Context
;
484 ExNotify
->KeyNotificationFn (&ExNotify
->KeyData
);
490 The RegisterKeystrokeNotify() function registers a function
491 which will be called when a specified keystroke will occur.
493 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
495 @param KeyData A pointer to a buffer that is filled in with
496 the keystroke information for the key that was
499 @param KeyNotificationFunction Points to the function to be
500 called when the key sequence
501 is typed specified by KeyData.
504 @param NotifyHandle Points to the unique handle assigned to
505 the registered notification.
507 @retval EFI_SUCCESS The device state was set
510 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary
516 EmuGopSimpleTextInExRegisterKeyNotify (
517 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
518 IN EFI_KEY_DATA
*KeyData
,
519 IN EFI_KEY_NOTIFY_FUNCTION KeyNotificationFunction
,
520 OUT EFI_HANDLE
*NotifyHandle
524 GOP_PRIVATE_DATA
*Private
;
525 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
527 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*NewNotify
;
529 if (KeyData
== NULL
|| KeyNotificationFunction
== NULL
|| NotifyHandle
== NULL
) {
530 return EFI_INVALID_PARAMETER
;
533 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
536 // Return EFI_SUCCESS if the (KeyData, NotificationFunction) is already registered.
538 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
541 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
543 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
545 if (GopPrivateIsKeyRegistered (&CurrentNotify
->KeyData
, KeyData
)) {
546 if (CurrentNotify
->KeyNotificationFn
== KeyNotificationFunction
) {
547 *NotifyHandle
= CurrentNotify
->NotifyHandle
;
554 // Allocate resource to save the notification function
556 NewNotify
= (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*) AllocateZeroPool (sizeof (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
));
557 if (NewNotify
== NULL
) {
558 return EFI_OUT_OF_RESOURCES
;
561 NewNotify
->Signature
= EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
;
562 NewNotify
->KeyNotificationFn
= KeyNotificationFunction
;
563 NewNotify
->NotifyHandle
= (EFI_HANDLE
) NewNotify
;
564 CopyMem (&NewNotify
->KeyData
, KeyData
, sizeof (KeyData
));
565 InsertTailList (&Private
->NotifyList
, &NewNotify
->NotifyEntry
);
567 Status
= gBS
->CreateEvent (
570 EmuGopRegisterKeyCallback
,
574 ASSERT_EFI_ERROR (Status
);
577 *NotifyHandle
= NewNotify
->NotifyHandle
;
585 The UnregisterKeystrokeNotify() function removes the
586 notification which was previously registered.
588 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
590 @param NotificationHandle The handle of the notification
591 function being unregistered.
593 @retval EFI_SUCCESS The device state was set appropriately.
595 @retval EFI_INVALID_PARAMETER The NotificationHandle is
601 EmuGopSimpleTextInExUnregisterKeyNotify (
602 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
603 IN EFI_HANDLE NotificationHandle
608 Remove a registered notification function from a particular keystroke.
611 This - Protocol instance pointer.
612 NotificationHandle - The handle of the notification function being unregistered.
615 EFI_SUCCESS - The notification function was unregistered successfully.
616 EFI_INVALID_PARAMETER - The NotificationHandle is invalid.
620 GOP_PRIVATE_DATA
*Private
;
622 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
624 if (NotificationHandle
== NULL
) {
625 return EFI_INVALID_PARAMETER
;
628 if (((EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*) NotificationHandle
)->Signature
!= EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
) {
629 return EFI_INVALID_PARAMETER
;
632 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
634 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
637 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
639 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
641 if (CurrentNotify
->NotifyHandle
== NotificationHandle
) {
643 // Remove the notification function from NotifyList and free resources
645 RemoveEntryList (&CurrentNotify
->NotifyEntry
);
647 gBS
->CloseEvent (CurrentNotify
->Event
);
649 gBS
->FreePool (CurrentNotify
);
655 // Can not find the specified Notification Handle
657 return EFI_INVALID_PARAMETER
;
663 Initialize SimplelTextIn and SimpleTextInEx protocols in the Private
666 @param Private Context structure to fill in.
668 @return EFI_SUCCESS Initialization was a success
672 EmuGopInitializeSimpleTextInForWindow (
673 IN GOP_PRIVATE_DATA
*Private
679 // Initialize Simple Text In protoocol
681 Private
->SimpleTextIn
.Reset
= EmuGopSimpleTextInReset
;
682 Private
->SimpleTextIn
.ReadKeyStroke
= EmuGopSimpleTextInReadKeyStroke
;
684 Status
= gBS
->CreateEvent (
687 EmuGopSimpleTextInWaitForKey
,
689 &Private
->SimpleTextIn
.WaitForKey
691 ASSERT_EFI_ERROR (Status
);
695 // Initialize Simple Text In Ex
698 Private
->SimpleTextInEx
.Reset
= EmuGopSimpleTextInExResetEx
;
699 Private
->SimpleTextInEx
.ReadKeyStrokeEx
= EmuGopSimpleTextInExReadKeyStrokeEx
;
700 Private
->SimpleTextInEx
.SetState
= EmuGopSimpleTextInExSetState
;
701 Private
->SimpleTextInEx
.RegisterKeyNotify
= EmuGopSimpleTextInExRegisterKeyNotify
;
702 Private
->SimpleTextInEx
.UnregisterKeyNotify
= EmuGopSimpleTextInExUnregisterKeyNotify
;
704 Private
->SimpleTextInEx
.Reset (&Private
->SimpleTextInEx
, FALSE
);
706 InitializeListHead (&Private
->NotifyList
);
708 Status
= gBS
->CreateEvent (
711 EmuGopSimpleTextInWaitForKey
,
713 &Private
->SimpleTextInEx
.WaitForKeyEx
715 ASSERT_EFI_ERROR (Status
);
728 // Simple Pointer implementation.
733 Resets the pointer device hardware.
735 @param This A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
737 @param ExtendedVerification Indicates that the driver may perform a more exhaustive
738 verification operation of the device during reset.
740 @retval EFI_SUCCESS The device was reset.
741 @retval EFI_DEVICE_ERROR The device is not functioning correctly and could not be reset.
746 EmuGopSimplePointerReset (
747 IN EFI_SIMPLE_POINTER_PROTOCOL
*This
,
748 IN BOOLEAN ExtendedVerification
751 GOP_PRIVATE_DATA
*Private
;
752 EFI_SIMPLE_POINTER_STATE State
;
755 Private
= GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This
);
756 if (Private
->EmuGraphicsWindow
== NULL
) {
761 // Enter critical section
763 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
766 // A reset is draining the Queue
768 while (Private
->EmuGraphicsWindow
->GetPointerState (Private
->EmuGraphicsWindow
, &State
) == EFI_SUCCESS
)
772 // Leave critical section and return
774 gBS
->RestoreTPL (OldTpl
);
780 Retrieves the current state of a pointer device.
782 @param This A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
784 @param State A pointer to the state information on the pointer device.
786 @retval EFI_SUCCESS The state of the pointer device was returned in State.
787 @retval EFI_NOT_READY The state of the pointer device has not changed since the last call to
789 @retval EFI_DEVICE_ERROR A device error occurred while attempting to retrieve the pointer device's
795 EmuGopSimplePointerGetState (
796 IN EFI_SIMPLE_POINTER_PROTOCOL
*This
,
797 IN OUT EFI_SIMPLE_POINTER_STATE
*State
800 GOP_PRIVATE_DATA
*Private
;
804 Private
= GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This
);
805 if (Private
->EmuGraphicsWindow
== NULL
) {
806 return EFI_NOT_READY
;
810 // Enter critical section
812 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
814 Status
= Private
->EmuGraphicsWindow
->GetPointerState (Private
->EmuGraphicsWindow
, State
);
816 // Leave critical section and return
818 gBS
->RestoreTPL (OldTpl
);
825 SimplePointer Notify Wait Event
827 @param Event Event whose notification function is being invoked.
828 @param Context Pointer to GOP_PRIVATE_DATA.
833 EmuGopSimplePointerWaitForInput (
838 GOP_PRIVATE_DATA
*Private
;
842 Private
= (GOP_PRIVATE_DATA
*) Context
;
843 if (Private
->EmuGraphicsWindow
== NULL
) {
848 // Enter critical section
850 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
852 Status
= Private
->EmuGraphicsWindow
->CheckPointer (Private
->EmuGraphicsWindow
);
853 if (!EFI_ERROR (Status
)) {
855 // If the pointer state has changed, signal our event.
857 gBS
->SignalEvent (Event
);
860 // Leave critical section and return
862 gBS
->RestoreTPL (OldTpl
);
867 SimplePointer constructor
869 @param Private Context structure to fill in.
871 @retval EFI_SUCCESS Constructor had success
875 EmuGopInitializeSimplePointerForWindow (
876 IN GOP_PRIVATE_DATA
*Private
882 // Initialize Simple Pointer protoocol
884 Private
->PointerMode
.ResolutionX
= 1;
885 Private
->PointerMode
.ResolutionY
= 1;
886 Private
->PointerMode
.ResolutionZ
= 1;
887 Private
->PointerMode
.LeftButton
= TRUE
;
888 Private
->PointerMode
.RightButton
= TRUE
;
890 Private
->SimplePointer
.Reset
= EmuGopSimplePointerReset
;
891 Private
->SimplePointer
.GetState
= EmuGopSimplePointerGetState
;
892 Private
->SimplePointer
.Mode
= &Private
->PointerMode
;
894 Status
= gBS
->CreateEvent (
897 EmuGopSimplePointerWaitForInput
,
899 &Private
->SimplePointer
.WaitForInput