3 Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
4 Portions copyright (c) 2010 0 2011,Apple Inc. 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
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.
20 GopPrivateIsKeyRegistered (
21 IN EFI_KEY_DATA
*RegsiteredData
,
22 IN EFI_KEY_DATA
*InputData
30 RegsiteredData - A pointer to a buffer that is filled in with the keystroke
31 state data for the key that was registered.
32 InputData - A pointer to a buffer that is filled in with the keystroke
33 state data for the key that was pressed.
36 TRUE - Key be pressed matches a registered key.
41 ASSERT (RegsiteredData
!= NULL
&& InputData
!= NULL
);
43 if ((RegsiteredData
->Key
.ScanCode
!= InputData
->Key
.ScanCode
) ||
44 (RegsiteredData
->Key
.UnicodeChar
!= InputData
->Key
.UnicodeChar
)) {
49 // Assume KeyShiftState/KeyToggleState = 0 in Registered key data means these state could be ignored.
51 if (RegsiteredData
->KeyState
.KeyShiftState
!= 0 &&
52 RegsiteredData
->KeyState
.KeyShiftState
!= InputData
->KeyState
.KeyShiftState
) {
55 if (RegsiteredData
->KeyState
.KeyToggleState
!= 0 &&
56 RegsiteredData
->KeyState
.KeyToggleState
!= InputData
->KeyState
.KeyToggleState
) {
67 GopPrivateMakeCallbackFunction (
69 IN EFI_KEY_DATA
*KeyData
73 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
74 GOP_PRIVATE_DATA
*Private
= (GOP_PRIVATE_DATA
*)Context
;
78 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
81 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
83 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
85 if (GopPrivateIsKeyRegistered (&CurrentNotify
->KeyData
, KeyData
)) {
86 // We could be called at a high TPL so signal an event to call the registered function
88 gBS
->SignalEvent (CurrentNotify
->Event
);
96 GopPrivateBreakCallbackFunction (
98 IN EFI_KEY_DATA
*KeyData
101 KeyMapBreak (KeyData
);
107 // Simple Text In implementation.
111 Reset the input device and optionally run diagnostics
113 @param This Protocol instance pointer.
114 @param ExtendedVerification Driver may perform diagnostics on reset.
116 @retval EFI_SUCCESS The device was reset.
117 @retval EFI_DEVICE_ERROR The device is not functioning properly and could not be reset.
122 EmuGopSimpleTextInReset (
123 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*This
,
124 IN BOOLEAN ExtendedVerification
127 GOP_PRIVATE_DATA
*Private
;
128 EFI_KEY_DATA KeyData
;
131 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
132 if (Private
->EmuGraphicsWindow
== NULL
) {
137 // Enter critical section
139 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
142 // A reset is draining the Queue
144 while (Private
->EmuGraphicsWindow
->GetKey (Private
->EmuGraphicsWindow
, &KeyData
) == EFI_SUCCESS
)
148 // Leave critical section and return
150 gBS
->RestoreTPL (OldTpl
);
156 Reads the next keystroke from the input device. The WaitForKey Event can
157 be used to test for existence of a keystroke via WaitForEvent () call.
159 @param This Protocol instance pointer.
160 @param Key A pointer to a buffer that is filled in with the keystroke
161 information for the key that was pressed.
163 @retval EFI_SUCCESS The keystroke information was returned.
164 @retval EFI_NOT_READY There was no keystroke data available.
165 @retval EFI_DEVICE_ERROR The keystroke information was not returned due to
171 EmuGopSimpleTextInReadKeyStroke (
172 IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*This
,
173 OUT EFI_INPUT_KEY
*Key
176 GOP_PRIVATE_DATA
*Private
;
179 EFI_KEY_DATA KeyData
;
181 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
182 if (Private
->EmuGraphicsWindow
== NULL
) {
183 return EFI_NOT_READY
;
187 // Enter critical section
189 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
191 Status
= Private
->EmuGraphicsWindow
->GetKey (Private
->EmuGraphicsWindow
, &KeyData
);
192 if (!EFI_ERROR (Status
)) {
193 if ((KeyData
.Key
.ScanCode
== 0) && (KeyData
.Key
.UnicodeChar
== 0)) {
194 // Modifier key was pressed
195 Status
= EFI_NOT_READY
;
197 CopyMem (Key
, &KeyData
.Key
, sizeof (EFI_INPUT_KEY
));
202 // Leave critical section and return
204 gBS
->RestoreTPL (OldTpl
);
212 SimpleTextIn and SimpleTextInEx Notify Wait Event
214 @param Event Event whose notification function is being invoked.
215 @param Context Pointer to GOP_PRIVATE_DATA.
220 EmuGopSimpleTextInWaitForKey (
225 GOP_PRIVATE_DATA
*Private
;
229 Private
= (GOP_PRIVATE_DATA
*) Context
;
230 if (Private
->EmuGraphicsWindow
== NULL
) {
235 // Enter critical section
237 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
239 Status
= Private
->EmuGraphicsWindow
->CheckKey (Private
->EmuGraphicsWindow
);
240 if (!EFI_ERROR (Status
)) {
242 // If a there is a key in the queue signal our event.
244 gBS
->SignalEvent (Event
);
247 // Leave critical section and return
249 gBS
->RestoreTPL (OldTpl
);
254 // Simple Text Input Ex protocol functions
259 The Reset() function resets the input device hardware. As part
260 of initialization process, the firmware/device will make a quick
261 but reasonable attempt to verify that the device is functioning.
262 If the ExtendedVerification flag is TRUE the firmware may take
263 an extended amount of time to verify the device is operating on
264 reset. Otherwise the reset operation is to occur as quickly as
265 possible. The hardware verification process is not defined by
266 this specification and is left up to the platform firmware or
269 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
271 @param ExtendedVerification Indicates that the driver may
272 perform a more exhaustive
273 verification operation of the
277 @retval EFI_SUCCESS The device was reset.
279 @retval EFI_DEVICE_ERROR The device is not functioning
280 correctly and could not be reset.
285 EmuGopSimpleTextInExResetEx (
286 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
287 IN BOOLEAN ExtendedVerification
292 Reset the input device and optionaly run diagnostics
295 This - Protocol instance pointer.
296 ExtendedVerification - Driver may perform diagnostics on reset.
299 EFI_SUCCESS - The device was reset.
303 GOP_PRIVATE_DATA
*Private
;
305 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
313 The function reads the next keystroke from the input device. If
314 there is no pending keystroke the function returns
315 EFI_NOT_READY. If there is a pending keystroke, then
316 KeyData.Key.ScanCode is the EFI scan code defined in Error!
317 Reference source not found. The KeyData.Key.UnicodeChar is the
318 actual printable character or is zero if the key does not
319 represent a printable character (control key, function key,
320 etc.). The KeyData.KeyState is shift state for the character
321 reflected in KeyData.Key.UnicodeChar or KeyData.Key.ScanCode .
322 When interpreting the data from this function, it should be
323 noted that if a class of printable characters that are
324 normally adjusted by shift modifiers (e.g. Shift Key + "f"
325 key) would be presented solely as a KeyData.Key.UnicodeChar
326 without the associated shift state. So in the previous example
327 of a Shift Key + "f" key being pressed, the only pertinent
328 data returned would be KeyData.Key.UnicodeChar with the value
329 of "F". This of course would not typically be the case for
330 non-printable characters such as the pressing of the Right
331 Shift Key + F10 key since the corresponding returned data
332 would be reflected both in the KeyData.KeyState.KeyShiftState
333 and KeyData.Key.ScanCode values. UEFI drivers which implement
334 the EFI_SIMPLE_TEXT_INPUT_EX protocol are required to return
335 KeyData.Key and KeyData.KeyState values. These drivers must
336 always return the most current state of
337 KeyData.KeyState.KeyShiftState and
338 KeyData.KeyState.KeyToggleState. It should also be noted that
339 certain input devices may not be able to produce shift or toggle
340 state information, and in those cases the high order bit in the
341 respective Toggle and Shift state fields should not be active.
344 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
346 @param KeyData A pointer to a buffer that is filled in with
347 the keystroke state data for the key that was
351 @retval EFI_SUCCESS The keystroke information was
354 @retval EFI_NOT_READY There was no keystroke data available.
355 EFI_DEVICE_ERROR The keystroke
356 information was not returned due to
363 EmuGopSimpleTextInExReadKeyStrokeEx (
364 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
365 OUT EFI_KEY_DATA
*KeyData
370 Reads the next keystroke from the input device. The WaitForKey Event can
371 be used to test for existance of a keystroke via WaitForEvent () call.
374 This - Protocol instance pointer.
375 KeyData - A pointer to a buffer that is filled in with the keystroke
376 state data for the key that was pressed.
379 EFI_SUCCESS - The keystroke information was returned.
380 EFI_NOT_READY - There was no keystroke data availiable.
381 EFI_DEVICE_ERROR - The keystroke information was not returned due to
383 EFI_INVALID_PARAMETER - KeyData is NULL.
388 GOP_PRIVATE_DATA
*Private
;
392 if (KeyData
== NULL
) {
393 return EFI_INVALID_PARAMETER
;
396 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
397 if (Private
->EmuGraphicsWindow
== NULL
) {
398 return EFI_NOT_READY
;
402 // Enter critical section
404 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
406 Status
= Private
->EmuGraphicsWindow
->GetKey(Private
->EmuGraphicsWindow
, KeyData
);
409 // Leave critical section and return
411 gBS
->RestoreTPL (OldTpl
);
419 The SetState() function allows the input device hardware to
420 have state settings adjusted.
422 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
424 @param KeyToggleState Pointer to the EFI_KEY_TOGGLE_STATE to
425 set the state for the input device.
428 @retval EFI_SUCCESS The device state was set appropriately.
430 @retval EFI_DEVICE_ERROR The device is not functioning
431 correctly and could not have the
434 @retval EFI_UNSUPPORTED The device does not support the
435 ability to have its state set.
440 EmuGopSimpleTextInExSetState (
441 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
442 IN EFI_KEY_TOGGLE_STATE
*KeyToggleState
445 GOP_PRIVATE_DATA
*Private
;
449 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This
);
450 if (Private
->EmuGraphicsWindow
== NULL
) {
451 return EFI_NOT_READY
;
455 // Enter critical section
457 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
459 Status
= Private
->EmuGraphicsWindow
->KeySetState (Private
->EmuGraphicsWindow
, KeyToggleState
);
461 // Leave critical section and return
463 gBS
->RestoreTPL (OldTpl
);
470 SimpleTextIn and SimpleTextInEx Notify Wait Event
472 @param Event Event whose notification function is being invoked.
473 @param Context Pointer to GOP_PRIVATE_DATA.
478 EmuGopRegisterKeyCallback (
483 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*ExNotify
= (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*)Context
;
485 ExNotify
->KeyNotificationFn (&ExNotify
->KeyData
);
491 The RegisterKeystrokeNotify() function registers a function
492 which will be called when a specified keystroke will occur.
494 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
496 @param KeyData A pointer to a buffer that is filled in with
497 the keystroke information for the key that was
500 @param KeyNotificationFunction Points to the function to be
501 called when the key sequence
502 is typed specified by KeyData.
505 @param NotifyHandle Points to the unique handle assigned to
506 the registered notification.
508 @retval EFI_SUCCESS The device state was set
511 @retval EFI_OUT_OF_RESOURCES Unable to allocate necessary
517 EmuGopSimpleTextInExRegisterKeyNotify (
518 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
519 IN EFI_KEY_DATA
*KeyData
,
520 IN EFI_KEY_NOTIFY_FUNCTION KeyNotificationFunction
,
521 OUT EFI_HANDLE
*NotifyHandle
525 GOP_PRIVATE_DATA
*Private
;
526 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
528 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*NewNotify
;
530 if (KeyData
== NULL
|| KeyNotificationFunction
== NULL
|| NotifyHandle
== NULL
) {
531 return EFI_INVALID_PARAMETER
;
534 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
537 // Return EFI_SUCCESS if the (KeyData, NotificationFunction) is already registered.
539 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
542 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
544 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
546 if (GopPrivateIsKeyRegistered (&CurrentNotify
->KeyData
, KeyData
)) {
547 if (CurrentNotify
->KeyNotificationFn
== KeyNotificationFunction
) {
548 *NotifyHandle
= CurrentNotify
->NotifyHandle
;
555 // Allocate resource to save the notification function
557 NewNotify
= (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*) AllocateZeroPool (sizeof (EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
));
558 if (NewNotify
== NULL
) {
559 return EFI_OUT_OF_RESOURCES
;
562 NewNotify
->Signature
= EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
;
563 NewNotify
->KeyNotificationFn
= KeyNotificationFunction
;
564 NewNotify
->NotifyHandle
= (EFI_HANDLE
) NewNotify
;
565 CopyMem (&NewNotify
->KeyData
, KeyData
, sizeof (KeyData
));
566 InsertTailList (&Private
->NotifyList
, &NewNotify
->NotifyEntry
);
568 Status
= gBS
->CreateEvent (
571 EmuGopRegisterKeyCallback
,
575 ASSERT_EFI_ERROR (Status
);
578 *NotifyHandle
= NewNotify
->NotifyHandle
;
586 The UnregisterKeystrokeNotify() function removes the
587 notification which was previously registered.
589 @param This A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
591 @param NotificationHandle The handle of the notification
592 function being unregistered.
594 @retval EFI_SUCCESS The device state was set appropriately.
596 @retval EFI_INVALID_PARAMETER The NotificationHandle is
602 EmuGopSimpleTextInExUnregisterKeyNotify (
603 IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*This
,
604 IN EFI_HANDLE NotificationHandle
609 Remove a registered notification function from a particular keystroke.
612 This - Protocol instance pointer.
613 NotificationHandle - The handle of the notification function being unregistered.
616 EFI_SUCCESS - The notification function was unregistered successfully.
617 EFI_INVALID_PARAMETER - The NotificationHandle is invalid.
621 GOP_PRIVATE_DATA
*Private
;
623 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*CurrentNotify
;
625 if (NotificationHandle
== NULL
) {
626 return EFI_INVALID_PARAMETER
;
629 if (((EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
*) NotificationHandle
)->Signature
!= EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
) {
630 return EFI_INVALID_PARAMETER
;
633 Private
= GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This
);
635 for (Link
= Private
->NotifyList
.ForwardLink
; Link
!= &Private
->NotifyList
; Link
= Link
->ForwardLink
) {
638 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY
,
640 EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
642 if (CurrentNotify
->NotifyHandle
== NotificationHandle
) {
644 // Remove the notification function from NotifyList and free resources
646 RemoveEntryList (&CurrentNotify
->NotifyEntry
);
648 gBS
->CloseEvent (CurrentNotify
->Event
);
650 gBS
->FreePool (CurrentNotify
);
656 // Can not find the specified Notification Handle
658 return EFI_INVALID_PARAMETER
;
664 Initialize SimplelTextIn and SimpleTextInEx protocols in the Private
667 @param Private Context structure to fill in.
669 @return EFI_SUCCESS Initialization was a success
673 EmuGopInitializeSimpleTextInForWindow (
674 IN GOP_PRIVATE_DATA
*Private
680 // Initialize Simple Text In protoocol
682 Private
->SimpleTextIn
.Reset
= EmuGopSimpleTextInReset
;
683 Private
->SimpleTextIn
.ReadKeyStroke
= EmuGopSimpleTextInReadKeyStroke
;
685 Status
= gBS
->CreateEvent (
688 EmuGopSimpleTextInWaitForKey
,
690 &Private
->SimpleTextIn
.WaitForKey
692 ASSERT_EFI_ERROR (Status
);
696 // Initialize Simple Text In Ex
699 Private
->SimpleTextInEx
.Reset
= EmuGopSimpleTextInExResetEx
;
700 Private
->SimpleTextInEx
.ReadKeyStrokeEx
= EmuGopSimpleTextInExReadKeyStrokeEx
;
701 Private
->SimpleTextInEx
.SetState
= EmuGopSimpleTextInExSetState
;
702 Private
->SimpleTextInEx
.RegisterKeyNotify
= EmuGopSimpleTextInExRegisterKeyNotify
;
703 Private
->SimpleTextInEx
.UnregisterKeyNotify
= EmuGopSimpleTextInExUnregisterKeyNotify
;
705 Private
->SimpleTextInEx
.Reset (&Private
->SimpleTextInEx
, FALSE
);
707 InitializeListHead (&Private
->NotifyList
);
709 Status
= gBS
->CreateEvent (
712 EmuGopSimpleTextInWaitForKey
,
714 &Private
->SimpleTextInEx
.WaitForKeyEx
716 ASSERT_EFI_ERROR (Status
);
729 // Simple Pointer implementation.
734 Resets the pointer device hardware.
736 @param This A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
738 @param ExtendedVerification Indicates that the driver may perform a more exhaustive
739 verification operation of the device during reset.
741 @retval EFI_SUCCESS The device was reset.
742 @retval EFI_DEVICE_ERROR The device is not functioning correctly and could not be reset.
747 EmuGopSimplePointerReset (
748 IN EFI_SIMPLE_POINTER_PROTOCOL
*This
,
749 IN BOOLEAN ExtendedVerification
752 GOP_PRIVATE_DATA
*Private
;
753 EFI_SIMPLE_POINTER_STATE State
;
756 Private
= GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This
);
757 if (Private
->EmuGraphicsWindow
== NULL
) {
762 // Enter critical section
764 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
767 // A reset is draining the Queue
769 while (Private
->EmuGraphicsWindow
->GetPointerState (Private
->EmuGraphicsWindow
, &State
) == EFI_SUCCESS
)
773 // Leave critical section and return
775 gBS
->RestoreTPL (OldTpl
);
781 Retrieves the current state of a pointer device.
783 @param This A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
785 @param State A pointer to the state information on the pointer device.
787 @retval EFI_SUCCESS The state of the pointer device was returned in State.
788 @retval EFI_NOT_READY The state of the pointer device has not changed since the last call to
790 @retval EFI_DEVICE_ERROR A device error occurred while attempting to retrieve the pointer device's
796 EmuGopSimplePointerGetState (
797 IN EFI_SIMPLE_POINTER_PROTOCOL
*This
,
798 IN OUT EFI_SIMPLE_POINTER_STATE
*State
801 GOP_PRIVATE_DATA
*Private
;
805 Private
= GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS (This
);
806 if (Private
->EmuGraphicsWindow
== NULL
) {
807 return EFI_NOT_READY
;
811 // Enter critical section
813 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
815 Status
= Private
->EmuGraphicsWindow
->GetPointerState (Private
->EmuGraphicsWindow
, State
);
817 // Leave critical section and return
819 gBS
->RestoreTPL (OldTpl
);
826 SimplePointer Notify Wait Event
828 @param Event Event whose notification function is being invoked.
829 @param Context Pointer to GOP_PRIVATE_DATA.
834 EmuGopSimplePointerWaitForInput (
839 GOP_PRIVATE_DATA
*Private
;
843 Private
= (GOP_PRIVATE_DATA
*) Context
;
844 if (Private
->EmuGraphicsWindow
== NULL
) {
849 // Enter critical section
851 OldTpl
= gBS
->RaiseTPL (TPL_NOTIFY
);
853 Status
= Private
->EmuGraphicsWindow
->CheckPointer (Private
->EmuGraphicsWindow
);
854 if (!EFI_ERROR (Status
)) {
856 // If the pointer state has changed, signal our event.
858 gBS
->SignalEvent (Event
);
861 // Leave critical section and return
863 gBS
->RestoreTPL (OldTpl
);
868 SimplePointer constructor
870 @param Private Context structure to fill in.
872 @retval EFI_SUCCESS Constructor had success
876 EmuGopInitializeSimplePointerForWindow (
877 IN GOP_PRIVATE_DATA
*Private
883 // Initialize Simple Pointer protoocol
885 Private
->PointerMode
.ResolutionX
= 1;
886 Private
->PointerMode
.ResolutionY
= 1;
887 Private
->PointerMode
.ResolutionZ
= 1;
888 Private
->PointerMode
.LeftButton
= TRUE
;
889 Private
->PointerMode
.RightButton
= TRUE
;
891 Private
->SimplePointer
.Reset
= EmuGopSimplePointerReset
;
892 Private
->SimplePointer
.GetState
= EmuGopSimplePointerGetState
;
893 Private
->SimplePointer
.Mode
= &Private
->PointerMode
;
895 Status
= gBS
->CreateEvent (
898 EmuGopSimplePointerWaitForInput
,
900 &Private
->SimplePointer
.WaitForInput