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
13 GopPrivateIsKeyRegistered (
14 IN EFI_KEY_DATA
*RegsiteredData
,
15 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
))
44 // Assume KeyShiftState/KeyToggleState = 0 in Registered key data means these state could be ignored.
46 if ((RegsiteredData
->KeyState
.KeyShiftState
!= 0) &&
47 (RegsiteredData
->KeyState
.KeyShiftState
!= InputData
->KeyState
.KeyShiftState
))
52 if ((RegsiteredData
->KeyState
.KeyToggleState
!= 0) &&
53 (RegsiteredData
->KeyState
.KeyToggleState
!= InputData
->KeyState
.KeyToggleState
))
63 GopPrivateMakeCallbackFunction (
65 IN EFI_KEY_DATA
*KeyData
69 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
70 GOP_PRIVATE_DATA
*Private
= (GOP_PRIVATE_DATA
*)Context
;
74 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
77 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
79 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
81 if (GopPrivateIsKeyRegistered (&CurrentNotify
->KeyData
, KeyData
)) {
82 // We could be called at a high TPL so signal an event to call the registered function
84 gBS
->SignalEvent (CurrentNotify
->Event
);
91 GopPrivateBreakCallbackFunction (
93 IN EFI_KEY_DATA
*KeyData
96 KeyMapBreak (KeyData
);
100 // Simple Text In implementation.
104 Reset the input device and optionally run diagnostics
106 @param This Protocol instance pointer.
107 @param ExtendedVerification Driver may perform diagnostics on reset.
109 @retval EFI_SUCCESS The device was reset.
110 @retval EFI_DEVICE_ERROR The device is not functioning properly and could not be reset.
115 EmuGopSimpleTextInReset (
116 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*This
,
117 IN BOOLEAN ExtendedVerification
120 GOP_PRIVATE_DATA
*Private
;
121 EFI_KEY_DATA KeyData
;
124 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
125 if (Private
->EmuGraphicsWindow
== NULL
) {
130 // Enter critical section
132 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
135 // A reset is draining the Queue
137 while (Private
->EmuGraphicsWindow
->GetKey (Private
->EmuGraphicsWindow
, &KeyData
) == EFI_SUCCESS
) {
141 // Leave critical section and return
143 gBS
->RestoreTPL (OldTpl
);
148 Reads the next keystroke from the input device. The WaitForKey Event can
149 be used to test for existence of a keystroke via WaitForEvent () call.
151 @param This Protocol instance pointer.
152 @param Key A pointer to a buffer that is filled in with the keystroke
153 information for the key that was pressed.
155 @retval EFI_SUCCESS The keystroke information was returned.
156 @retval EFI_NOT_READY There was no keystroke data available.
157 @retval EFI_DEVICE_ERROR The keystroke information was not returned due to
163 EmuGopSimpleTextInReadKeyStroke (
164 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*This
,
165 OUT EFI_INPUT_KEY
*Key
168 GOP_PRIVATE_DATA
*Private
;
171 EFI_KEY_DATA KeyData
;
173 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
174 if (Private
->EmuGraphicsWindow
== NULL
) {
175 return EFI_NOT_READY
;
179 // Enter critical section
181 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
183 Status
= Private
->EmuGraphicsWindow
->GetKey (Private
->EmuGraphicsWindow
, &KeyData
);
184 if (!EFI_ERROR (Status
)) {
185 if ((KeyData
.Key
.ScanCode
== 0) && (KeyData
.Key
.UnicodeChar
== 0)) {
186 // Modifier key was pressed
187 Status
= EFI_NOT_READY
;
189 CopyMem (Key
, &KeyData
.Key
, sizeof (EFI_INPUT_KEY
));
194 // Leave critical section and return
196 gBS
->RestoreTPL (OldTpl
);
202 SimpleTextIn and SimpleTextInEx Notify Wait Event
204 @param Event Event whose notification function is being invoked.
205 @param Context Pointer to GOP_PRIVATE_DATA.
210 EmuGopSimpleTextInWaitForKey (
215 GOP_PRIVATE_DATA
*Private
;
219 Private
= (GOP_PRIVATE_DATA
*)Context
;
220 if (Private
->EmuGraphicsWindow
== NULL
) {
225 // Enter critical section
227 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
229 Status
= Private
->EmuGraphicsWindow
->CheckKey (Private
->EmuGraphicsWindow
);
230 if (!EFI_ERROR (Status
)) {
232 // If a there is a key in the queue signal our event.
234 gBS
->SignalEvent (Event
);
238 // Leave critical section and return
240 gBS
->RestoreTPL (OldTpl
);
244 // Simple Text Input Ex protocol functions
248 The Reset() function resets the input device hardware. As part
249 of initialization process, the firmware/device will make a quick
250 but reasonable attempt to verify that the device is functioning.
251 If the ExtendedVerification flag is TRUE the firmware may take
252 an extended amount of time to verify the device is operating on
253 reset. Otherwise the reset operation is to occur as quickly as
254 possible. The hardware verification process is not defined by
255 this specification and is left up to the platform firmware or
258 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
260 @param ExtendedVerification Indicates that the driver may
261 perform a more exhaustive
262 verification operation of the
266 @retval EFI_SUCCESS The device was reset.
268 @retval EFI_DEVICE_ERROR The device is not functioning
269 correctly and could not be reset.
274 EmuGopSimpleTextInExResetEx (
275 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
276 IN BOOLEAN ExtendedVerification
282 Reset the input device and optionaly run diagnostics
285 This - Protocol instance pointer.
286 ExtendedVerification - Driver may perform diagnostics on reset.
289 EFI_SUCCESS - The device was reset.
297 The function reads the next keystroke from the input device. If
298 there is no pending keystroke the function returns
299 EFI_NOT_READY. If there is a pending keystroke, then
300 KeyData.Key.ScanCode is the EFI scan code defined in Error!
301 Reference source not found. The KeyData.Key.UnicodeChar is the
302 actual printable character or is zero if the key does not
303 represent a printable character (control key, function key,
304 etc.). The KeyData.KeyState is shift state for the character
305 reflected in KeyData.Key.UnicodeChar or KeyData.Key.ScanCode .
306 When interpreting the data from this function, it should be
307 noted that if a class of printable characters that are
308 normally adjusted by shift modifiers (e.g. Shift Key + "f"
309 key) would be presented solely as a KeyData.Key.UnicodeChar
310 without the associated shift state. So in the previous example
311 of a Shift Key + "f" key being pressed, the only pertinent
312 data returned would be KeyData.Key.UnicodeChar with the value
313 of "F". This of course would not typically be the case for
314 non-printable characters such as the pressing of the Right
315 Shift Key + F10 key since the corresponding returned data
316 would be reflected both in the KeyData.KeyState.KeyShiftState
317 and KeyData.Key.ScanCode values. UEFI drivers which implement
318 the EFI_SIMPLE_TEXT_INPUT_EX protocol are required to return
319 KeyData.Key and KeyData.KeyState values. These drivers must
320 always return the most current state of
321 KeyData.KeyState.KeyShiftState and
322 KeyData.KeyState.KeyToggleState. It should also be noted that
323 certain input devices may not be able to produce shift or toggle
324 state information, and in those cases the high order bit in the
325 respective Toggle and Shift state fields should not be active.
328 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
330 @param KeyData A pointer to a buffer that is filled in with
331 the keystroke state data for the key that was
335 @retval EFI_SUCCESS The keystroke information was
338 @retval EFI_NOT_READY There was no keystroke data available.
339 EFI_DEVICE_ERROR The keystroke
340 information was not returned due to
347 EmuGopSimpleTextInExReadKeyStrokeEx (
348 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
349 OUT EFI_KEY_DATA
*KeyData
355 Reads the next keystroke from the input device. The WaitForKey Event can
356 be used to test for existance of a keystroke via WaitForEvent () call.
359 This - Protocol instance pointer.
360 KeyData - A pointer to a buffer that is filled in with the keystroke
361 state data for the key that was pressed.
364 EFI_SUCCESS - The keystroke information was returned.
365 EFI_NOT_READY - There was no keystroke data availiable.
366 EFI_DEVICE_ERROR - The keystroke information was not returned due to
368 EFI_INVALID_PARAMETER - KeyData is NULL.
373 GOP_PRIVATE_DATA
*Private
;
376 if (KeyData
== NULL
) {
377 return EFI_INVALID_PARAMETER
;
380 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
381 if (Private
->EmuGraphicsWindow
== NULL
) {
382 return EFI_NOT_READY
;
386 // Enter critical section
388 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
390 Status
= Private
->EmuGraphicsWindow
->GetKey (Private
->EmuGraphicsWindow
, KeyData
);
393 // Leave critical section and return
395 gBS
->RestoreTPL (OldTpl
);
401 The SetState() function allows the input device hardware to
402 have state settings adjusted.
404 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
406 @param KeyToggleState Pointer to the EFI_KEY_TOGGLE_STATE to
407 set the state for the input device.
410 @retval EFI_SUCCESS The device state was set appropriately.
412 @retval EFI_DEVICE_ERROR The device is not functioning
413 correctly and could not have the
416 @retval EFI_UNSUPPORTED The device does not support the
417 ability to have its state set.
422 EmuGopSimpleTextInExSetState (
423 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
424 IN EFI_KEY_TOGGLE_STATE
*KeyToggleState
427 GOP_PRIVATE_DATA
*Private
;
431 if (KeyToggleState
== NULL
) {
432 return EFI_INVALID_PARAMETER
;
435 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
436 if (Private
->EmuGraphicsWindow
== NULL
) {
437 return EFI_NOT_READY
;
440 if (((Private
->KeyState
.KeyToggleState
& EFI_TOGGLE_STATE_VALID
) != EFI_TOGGLE_STATE_VALID
) ||
441 ((*KeyToggleState
& EFI_TOGGLE_STATE_VALID
) != EFI_TOGGLE_STATE_VALID
))
443 return EFI_UNSUPPORTED
;
447 // Enter critical section
449 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
451 Status
= Private
->EmuGraphicsWindow
->KeySetState (Private
->EmuGraphicsWindow
, KeyToggleState
);
453 // Leave critical section and return
455 gBS
->RestoreTPL (OldTpl
);
461 SimpleTextIn and SimpleTextInEx Notify Wait Event
463 @param Event Event whose notification function is being invoked.
464 @param Context Pointer to GOP_PRIVATE_DATA.
469 EmuGopRegisterKeyCallback (
474 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*ExNotify
= (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*)Context
;
476 ExNotify
->KeyNotificationFn (&ExNotify
->KeyData
);
480 The RegisterKeystrokeNotify() function registers a function
481 which will be called when a specified keystroke will occur.
483 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
485 @param KeyData A pointer to a buffer that is filled in with
486 the keystroke information for the key that was
489 @param KeyNotificationFunction Points to the function to be
490 called when the key sequence
491 is typed specified by KeyData.
494 @param NotifyHandle Points to the unique handle assigned to
495 the registered notification.
497 @retval EFI_SUCCESS The device state was set
500 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary
506 EmuGopSimpleTextInExRegisterKeyNotify (
507 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
508 IN EFI_KEY_DATA
*KeyData
,
509 IN EFI_KEY_NOTIFY_FUNCTION KeyNotificationFunction
,
510 OUT VOID
**NotifyHandle
514 GOP_PRIVATE_DATA
*Private
;
515 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
517 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*NewNotify
;
519 if ((KeyData
== NULL
) || (KeyNotificationFunction
== NULL
) || (NotifyHandle
== NULL
)) {
520 return EFI_INVALID_PARAMETER
;
523 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
526 // Return EFI_SUCCESS if the (KeyData, NotificationFunction) is already registered.
528 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
531 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
533 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
535 if (GopPrivateIsKeyRegistered (&CurrentNotify
->KeyData
, KeyData
)) {
536 if (CurrentNotify
->KeyNotificationFn
== KeyNotificationFunction
) {
537 *NotifyHandle
= CurrentNotify
->NotifyHandle
;
544 // Allocate resource to save the notification function
546 NewNotify
= (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*)AllocateZeroPool (sizeof (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
));
547 if (NewNotify
== NULL
) {
548 return EFI_OUT_OF_RESOURCES
;
551 NewNotify
->Signature
= EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
;
552 NewNotify
->KeyNotificationFn
= KeyNotificationFunction
;
553 NewNotify
->NotifyHandle
= (EFI_HANDLE
)NewNotify
;
554 CopyMem (&NewNotify
->KeyData
, KeyData
, sizeof (KeyData
));
555 InsertTailList (&Private
->NotifyList
, &NewNotify
->NotifyEntry
);
557 Status
= gBS
->CreateEvent (
560 EmuGopRegisterKeyCallback
,
564 ASSERT_EFI_ERROR (Status
);
566 *NotifyHandle
= NewNotify
->NotifyHandle
;
572 The UnregisterKeystrokeNotify() function removes the
573 notification which was previously registered.
575 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
577 @param NotificationHandle The handle of the notification
578 function being unregistered.
580 @retval EFI_SUCCESS The device state was set appropriately.
582 @retval EFI_INVALID_PARAMETER The NotificationHandle is
588 EmuGopSimpleTextInExUnregisterKeyNotify (
589 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
590 IN VOID
*NotificationHandle
596 Remove a registered notification function from a particular keystroke.
599 This - Protocol instance pointer.
600 NotificationHandle - The handle of the notification function being unregistered.
603 EFI_SUCCESS - The notification function was unregistered successfully.
604 EFI_INVALID_PARAMETER - The NotificationHandle is invalid.
608 GOP_PRIVATE_DATA
*Private
;
610 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
612 if (NotificationHandle
== NULL
) {
613 return EFI_INVALID_PARAMETER
;
616 if (((EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*)NotificationHandle
)->Signature
!= EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
) {
617 return EFI_INVALID_PARAMETER
;
620 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
622 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
625 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
627 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
629 if (CurrentNotify
->NotifyHandle
== NotificationHandle
) {
631 // Remove the notification function from NotifyList and free resources
633 RemoveEntryList (&CurrentNotify
->NotifyEntry
);
635 gBS
->CloseEvent (CurrentNotify
->Event
);
637 gBS
->FreePool (CurrentNotify
);
643 // Can not find the specified Notification Handle
645 return EFI_INVALID_PARAMETER
;
649 Initialize SimplelTextIn and SimpleTextInEx protocols in the Private
652 @param Private Context structure to fill in.
654 @return EFI_SUCCESS Initialization was a success
658 EmuGopInitializeSimpleTextInForWindow (
659 IN GOP_PRIVATE_DATA
*Private
665 // Initialize Simple Text In protoocol
667 Private
->SimpleTextIn
.Reset
= EmuGopSimpleTextInReset
;
668 Private
->SimpleTextIn
.ReadKeyStroke
= EmuGopSimpleTextInReadKeyStroke
;
670 Status
= gBS
->CreateEvent (
673 EmuGopSimpleTextInWaitForKey
,
675 &Private
->SimpleTextIn
.WaitForKey
677 ASSERT_EFI_ERROR (Status
);
680 // Initialize Simple Text In Ex
683 Private
->SimpleTextInEx
.Reset
= EmuGopSimpleTextInExResetEx
;
684 Private
->SimpleTextInEx
.ReadKeyStrokeEx
= EmuGopSimpleTextInExReadKeyStrokeEx
;
685 Private
->SimpleTextInEx
.SetState
= EmuGopSimpleTextInExSetState
;
686 Private
->SimpleTextInEx
.RegisterKeyNotify
= EmuGopSimpleTextInExRegisterKeyNotify
;
687 Private
->SimpleTextInEx
.UnregisterKeyNotify
= EmuGopSimpleTextInExUnregisterKeyNotify
;
689 Private
->SimpleTextInEx
.Reset (&Private
->SimpleTextInEx
, FALSE
);
691 InitializeListHead (&Private
->NotifyList
);
693 Status
= gBS
->CreateEvent (
696 EmuGopSimpleTextInWaitForKey
,
698 &Private
->SimpleTextInEx
.WaitForKeyEx
700 ASSERT_EFI_ERROR (Status
);
706 // Simple Pointer implementation.
710 Resets the pointer device hardware.
712 @param This A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
714 @param ExtendedVerification Indicates that the driver may perform a more exhaustive
715 verification operation of the device during reset.
717 @retval EFI_SUCCESS The device was reset.
718 @retval EFI_DEVICE_ERROR The device is not functioning correctly and could not be reset.
723 EmuGopSimplePointerReset (
724 IN EFI_SIMPLE_POINTER_PROTOCOL
*This
,
725 IN BOOLEAN ExtendedVerification
728 GOP_PRIVATE_DATA
*Private
;
729 EFI_SIMPLE_POINTER_STATE State
;
732 Private
= GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This
);
733 if (Private
->EmuGraphicsWindow
== NULL
) {
738 // Enter critical section
740 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
743 // A reset is draining the Queue
745 while (Private
->EmuGraphicsWindow
->GetPointerState (Private
->EmuGraphicsWindow
, &State
) == EFI_SUCCESS
) {
749 // Leave critical section and return
751 gBS
->RestoreTPL (OldTpl
);
756 Retrieves the current state of a pointer device.
758 @param This A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
760 @param State A pointer to the state information on the pointer device.
762 @retval EFI_SUCCESS The state of the pointer device was returned in State.
763 @retval EFI_NOT_READY The state of the pointer device has not changed since the last call to
765 @retval EFI_DEVICE_ERROR A device error occurred while attempting to retrieve the pointer device's
771 EmuGopSimplePointerGetState (
772 IN EFI_SIMPLE_POINTER_PROTOCOL
*This
,
773 IN OUT EFI_SIMPLE_POINTER_STATE
*State
776 GOP_PRIVATE_DATA
*Private
;
780 Private
= GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This
);
781 if (Private
->EmuGraphicsWindow
== NULL
) {
782 return EFI_NOT_READY
;
786 // Enter critical section
788 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
790 Status
= Private
->EmuGraphicsWindow
->GetPointerState (Private
->EmuGraphicsWindow
, State
);
792 // Leave critical section and return
794 gBS
->RestoreTPL (OldTpl
);
800 SimplePointer Notify Wait Event
802 @param Event Event whose notification function is being invoked.
803 @param Context Pointer to GOP_PRIVATE_DATA.
808 EmuGopSimplePointerWaitForInput (
813 GOP_PRIVATE_DATA
*Private
;
817 Private
= (GOP_PRIVATE_DATA
*)Context
;
818 if (Private
->EmuGraphicsWindow
== NULL
) {
823 // Enter critical section
825 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
827 Status
= Private
->EmuGraphicsWindow
->CheckPointer (Private
->EmuGraphicsWindow
);
828 if (!EFI_ERROR (Status
)) {
830 // If the pointer state has changed, signal our event.
832 gBS
->SignalEvent (Event
);
836 // Leave critical section and return
838 gBS
->RestoreTPL (OldTpl
);
842 SimplePointer constructor
844 @param Private Context structure to fill in.
846 @retval EFI_SUCCESS Constructor had success
850 EmuGopInitializeSimplePointerForWindow (
851 IN GOP_PRIVATE_DATA
*Private
857 // Initialize Simple Pointer protoocol
859 Private
->PointerMode
.ResolutionX
= 1;
860 Private
->PointerMode
.ResolutionY
= 1;
861 Private
->PointerMode
.ResolutionZ
= 1;
862 Private
->PointerMode
.LeftButton
= TRUE
;
863 Private
->PointerMode
.RightButton
= TRUE
;
865 Private
->SimplePointer
.Reset
= EmuGopSimplePointerReset
;
866 Private
->SimplePointer
.GetState
= EmuGopSimplePointerGetState
;
867 Private
->SimplePointer
.Mode
= &Private
->PointerMode
;
869 Status
= gBS
->CreateEvent (
872 EmuGopSimplePointerWaitForInput
,
874 &Private
->SimplePointer
.WaitForInput