InOsEmuPkg: Rename package to EmulatorPkg & Sec to Host

* Rename InOsEmuPkg to EmulatorPkg
* Rename Unix/Sec to Unix/Host

Signed-off-by: jljusten
Reviewed-by: andrewfish
Reviewed-by: geekboy15a

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@11918 6f19259b-4bc3-4df7-8a09-765794883524

6 files changed, 2274 insertions, 0 deletions

diff --git a/EmulatorPkg/EmuGopDxe/ComponentName.c b/EmulatorPkg/EmuGopDxe/ComponentName.c
new file mode 100644
index 0000000000..e10f607cec
--- /dev/null
+++ b/EmulatorPkg/EmuGopDxe/ComponentName.c
@@ -0,0 +1,250 @@
+/** @file

+

+Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>

+Portions copyright (c) 2010,Apple Inc. All rights reserved.<BR>

+This program and the accompanying materials                          

+are licensed and made available under the terms and conditions of the BSD License         

+which accompanies this distribution.  The full text of the license may be found at        

+http://opensource.org/licenses/bsd-license.php                                            

+                                                                                          

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+

+Module Name:

+

+  ComponentName.c

+

+Abstract:

+

+**/

+

+#include "Gop.h"

+

+//

+// EFI Component Name Functions

+//

+EFI_STATUS

+EFIAPI

+EmuGopComponentNameGetDriverName (

+  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,

+  IN  CHAR8                        *Language,

+  OUT CHAR16                       **DriverName

+  );

+

+EFI_STATUS

+EFIAPI

+EmuGopComponentNameGetControllerName (

+  IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,

+  IN  EFI_HANDLE                                      ControllerHandle,

+  IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,

+  IN  CHAR8                                           *Language,

+  OUT CHAR16                                          **ControllerName

+  );

+

+//

+// EFI Component Name Protocol

+//

+EFI_COMPONENT_NAME_PROTOCOL     gEmuGopComponentName = {

+  EmuGopComponentNameGetDriverName,

+  EmuGopComponentNameGetControllerName,

+  "eng"

+};

+

+//

+// EFI Component Name 2 Protocol

+//

+GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gEmuGopComponentName2 = {

+  (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) EmuGopComponentNameGetDriverName,

+  (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) EmuGopComponentNameGetControllerName,

+  "en"

+};

+

+

+EFI_UNICODE_STRING_TABLE mEmuGopDriverNameTable[] = {

+  { "eng", L"Emulator GOP Driver" },

+  { NULL , NULL }

+};

+

+

+/**

+  Retrieves a Unicode string that is the user readable name of the driver.

+

+  This function retrieves the user readable name of a driver in the form of a

+  Unicode string. If the driver specified by This has a user readable name in

+  the language specified by Language, then a pointer to the driver name is

+  returned in DriverName, and EFI_SUCCESS is returned. If the driver specified

+  by This does not support the language specified by Language,

+  then EFI_UNSUPPORTED is returned.

+

+  @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or

+                                EFI_COMPONENT_NAME_PROTOCOL instance.

+

+  @param  Language[in]          A pointer to a Null-terminated ASCII string

+                                array indicating the language. This is the

+                                language of the driver name that the caller is

+                                requesting, and it must match one of the

+                                languages specified in SupportedLanguages. The

+                                number of languages supported by a driver is up

+                                to the driver writer. Language is specified

+                                in RFC 4646 or ISO 639-2 language code format.

+

+  @param  DriverName[out]       A pointer to the Unicode string to return.

+                                This Unicode string is the name of the

+                                driver specified by This in the language

+                                specified by Language.

+

+  @retval EFI_SUCCESS           The Unicode string for the Driver specified by

+                                This and the language specified by Language was

+                                returned in DriverName.

+

+  @retval EFI_INVALID_PARAMETER Language is NULL.

+

+  @retval EFI_INVALID_PARAMETER DriverName is NULL.

+

+  @retval EFI_UNSUPPORTED       The driver specified by This does not support

+                                the language specified by Language.

+

+**/

+EFI_STATUS

+EFIAPI

+EmuGopComponentNameGetDriverName (

+  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,

+  IN  CHAR8                        *Language,

+  OUT CHAR16                       **DriverName

+  )

+{

+  return LookupUnicodeString2 (

+           Language,

+           This->SupportedLanguages,

+           mEmuGopDriverNameTable,

+           DriverName,

+           (BOOLEAN)(This == &gEmuGopComponentName)

+           );

+}

+

+

+/**

+  Retrieves a Unicode string that is the user readable name of the controller

+  that is being managed by a driver.

+

+  This function retrieves the user readable name of the controller specified by

+  ControllerHandle and ChildHandle in the form of a Unicode string. If the

+  driver specified by This has a user readable name in the language specified by

+  Language, then a pointer to the controller name is returned in ControllerName,

+  and EFI_SUCCESS is returned.  If the driver specified by This is not currently

+  managing the controller specified by ControllerHandle and ChildHandle,

+  then EFI_UNSUPPORTED is returned.  If the driver specified by This does not

+  support the language specified by Language, then EFI_UNSUPPORTED is returned.

+

+  @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or

+                                EFI_COMPONENT_NAME_PROTOCOL instance.

+

+  @param  ControllerHandle[in]  The handle of a controller that the driver

+                                specified by This is managing.  This handle

+                                specifies the controller whose name is to be

+                                returned.

+

+  @param  ChildHandle[in]       The handle of the child controller to retrieve

+                                the name of.  This is an optional parameter that

+                                may be NULL.  It will be NULL for device

+                                drivers.  It will also be NULL for a bus drivers

+                                that wish to retrieve the name of the bus

+                                controller.  It will not be NULL for a bus

+                                driver that wishes to retrieve the name of a

+                                child controller.

+

+  @param  Language[in]          A pointer to a Null-terminated ASCII string

+                                array indicating the language.  This is the

+                                language of the driver name that the caller is

+                                requesting, and it must match one of the

+                                languages specified in SupportedLanguages. The

+                                number of languages supported by a driver is up

+                                to the driver writer. Language is specified in

+                                RFC 4646 or ISO 639-2 language code format.

+

+  @param  ControllerName[out]   A pointer to the Unicode string to return.

+                                This Unicode string is the name of the

+                                controller specified by ControllerHandle and

+                                ChildHandle in the language specified by

+                                Language from the point of view of the driver

+                                specified by This.

+

+  @retval EFI_SUCCESS           The Unicode string for the user readable name in

+                                the language specified by Language for the

+                                driver specified by This was returned in

+                                DriverName.

+

+  @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.

+

+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid

+                                EFI_HANDLE.

+

+  @retval EFI_INVALID_PARAMETER Language is NULL.

+

+  @retval EFI_INVALID_PARAMETER ControllerName is NULL.

+

+  @retval EFI_UNSUPPORTED       The driver specified by This is not currently

+                                managing the controller specified by

+                                ControllerHandle and ChildHandle.

+

+  @retval EFI_UNSUPPORTED       The driver specified by This does not support

+                                the language specified by Language.

+

+**/

+EFI_STATUS

+EFIAPI

+EmuGopComponentNameGetControllerName (

+  IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,

+  IN  EFI_HANDLE                                      ControllerHandle,

+  IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,

+  IN  CHAR8                                           *Language,

+  OUT CHAR16                                          **ControllerName

+  )

+{

+  EFI_STATUS                    Status;

+  EFI_GRAPHICS_OUTPUT_PROTOCOL  *GraphicsOutput;

+  GOP_PRIVATE_DATA              *Private;

+

+  //

+  // This is a device driver, so ChildHandle must be NULL.

+  //

+  if (ChildHandle != NULL) {

+    return EFI_UNSUPPORTED;

+  }

+

+  //

+  // Make sure this driver is currently managing ControllerHandle

+  //

+  Status = EfiTestManagedDevice (

+             ControllerHandle,

+             gEmuGopDriverBinding.DriverBindingHandle,

+             &gEmuIoThunkProtocolGuid

+             );

+  if (EFI_ERROR (Status)) {

+    return EFI_UNSUPPORTED;

+  }

+  //

+  // Get our context back

+  //

+  Status = gBS->OpenProtocol (

+                  ControllerHandle,

+                  &gEfiGraphicsOutputProtocolGuid,

+                  (VOID **)&GraphicsOutput,

+                  gEmuGopDriverBinding.DriverBindingHandle,

+                  ControllerHandle,

+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL

+                  );

+  if (EFI_ERROR (Status)) {

+    return EFI_UNSUPPORTED;

+  }

+

+  Private = GOP_PRIVATE_DATA_FROM_THIS (GraphicsOutput);

+

+  return LookupUnicodeString2 (

+           Language,

+           This->SupportedLanguages,

+           Private->ControllerNameTable,

+           ControllerName,

+           (BOOLEAN)(This == &gEmuGopComponentName)

+           );

+}

diff --git a/EmulatorPkg/EmuGopDxe/EmuGopDxe.inf b/EmulatorPkg/EmuGopDxe/EmuGopDxe.inf
new file mode 100644
index 0000000000..19c7b2e679
--- /dev/null
+++ b/EmulatorPkg/EmuGopDxe/EmuGopDxe.inf
@@ -0,0 +1,69 @@
+## @file

+# GOP driver

+#

+# Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>

+# Portions copyright (c) 2011, Apple Inc. All rights reserved. 

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution. The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#

+##

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = EmuGopDxe

+  FILE_GUID                      = BCC87E0D-86D6-4D4D-8040-2D983D368BD1

+  MODULE_TYPE                    = UEFI_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = InitializeEmuGop

+

+#

+# The following information is for reference only and not required by the build tools.

+#

+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC

+#

+#  DRIVER_BINDING                =  gEmuGopDriverBinding                        

+#  COMPONENT_NAME                =  gEmuGopComponentName                        

+#

+

+[Sources]

+  ComponentName.c

+  GopScreen.c

+  GopDriver.c

+  GopInput.c

+  Gop.h

+

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmulatorPkg/EmulatorPkg.dec

+

+

+[LibraryClasses]

+  UefiBootServicesTableLib

+  MemoryAllocationLib

+  BaseMemoryLib

+  UefiLib

+  UefiDriverEntryPoint

+  BaseLib

+  DebugLib

+  KeyMapLib

+  

+

+[Guids]

+  gEfiEventExitBootServicesGuid                # SOMETIMES_CONSUMED  Create Event: EVENT_GROUP_GUID

+

+

+[Protocols]

+  gEfiGraphicsOutputProtocolGuid

+  gEfiSimpleTextInProtocolGuid                  # PROTOCOL BY_START

+  gEfiSimpleTextInputExProtocolGuid             # PROTOCOL BY_START

+  gEfiSimplePointerProtocolGuid                 # PROTOCOL BY_START

+  gEmuIoThunkProtocolGuid                       # PROTOCOL TO_START

+  gEmuGraphicsWindowProtocolGuid                # PROTOCOL TO_START

diff --git a/EmulatorPkg/EmuGopDxe/Gop.h b/EmulatorPkg/EmuGopDxe/Gop.h
new file mode 100644
index 0000000000..03e33ea636
--- /dev/null
+++ b/EmulatorPkg/EmuGopDxe/Gop.h
@@ -0,0 +1,195 @@
+/*++ @file
+
+Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2010,Apple Inc. All rights reserved.<BR>
+This program and the accompanying materials                          
+are licensed and made available under the terms and conditions of the BSD License         
+which accompanies this distribution.  The full text of the license may be found at        
+http://opensource.org/licenses/bsd-license.php                                            
+                                                                                          
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
+
+**/
+
+#ifndef __UGA_H_
+#define __UGA_H_
+
+#include <PiDxe.h>
+
+#include <Protocol/GraphicsOutput.h>
+#include <Protocol/SimpleTextIn.h>
+#include <Protocol/SimpleTextInEx.h>
+#include <Protocol/SimplePointer.h>
+#include <Protocol/EmuIoThunk.h>
+#include <Protocol/EmuGraphicsWindow.h>
+
+#include <Guid/EventGroup.h>
+
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+#include <Library/UefiDriverEntryPoint.h>
+#include <Library/UefiLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/KeyMapLib.h>
+
+
+#define MAX_Q 256
+
+typedef struct {
+  UINTN         Front;
+  UINTN         Rear;
+  UINTN         Count;
+  EFI_INPUT_KEY Q[MAX_Q];
+} GOP_QUEUE_FIXED;
+
+#define EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE SIGNATURE_32 ('U', 'g', 'S', 'n')
+typedef struct _EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY {
+  UINTN                                 Signature;
+  EFI_HANDLE                            NotifyHandle;
+  EFI_KEY_DATA                          KeyData;
+  EFI_KEY_NOTIFY_FUNCTION               KeyNotificationFn;
+  EFI_EVENT                             Event;
+  LIST_ENTRY                            NotifyEntry;
+} EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY;
+  
+#define GRAPHICS_OUTPUT_INVALIDE_MODE_NUMBER 0xffff
+
+typedef struct {
+  UINT32                     HorizontalResolution;
+  UINT32                     VerticalResolution;
+  UINT32                     ColorDepth;
+  UINT32                     RefreshRate;
+} GOP_MODE_DATA;
+
+
+
+extern EFI_DRIVER_BINDING_PROTOCOL gEmuGopDriverBinding;
+extern EFI_COMPONENT_NAME_PROTOCOL gEmuGopComponentName;
+
+#define EMU_UGA_CLASS_NAME       L"EmuGopWindow"
+
+#define GOP_PRIVATE_DATA_SIGNATURE  SIGNATURE_32 ('G', 'o', 'p', 'N')
+typedef struct {
+  UINT64                            Signature;
+
+  EFI_HANDLE                        Handle;
+  EFI_GRAPHICS_OUTPUT_PROTOCOL      GraphicsOutput;
+  EFI_SIMPLE_TEXT_INPUT_PROTOCOL    SimpleTextIn;
+  EFI_SIMPLE_POINTER_PROTOCOL       SimplePointer;
+
+  EMU_IO_THUNK_PROTOCOL             *EmuIoThunk;
+  EMU_GRAPHICS_WINDOW_PROTOCOL      *EmuGraphicsWindow;
+
+  EFI_UNICODE_STRING_TABLE          *ControllerNameTable;
+
+  EFI_SIMPLE_POINTER_MODE           PointerMode;
+  //
+  // GOP Private Data for QueryMode ()
+  //
+  GOP_MODE_DATA                     *ModeData;
+
+
+  //
+  // UGA Private Data knowing when to start hardware
+  //
+  BOOLEAN                           HardwareNeedsStarting;
+
+  CHAR16                            *WindowName;
+
+  GOP_QUEUE_FIXED                   Queue;
+
+  EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL SimpleTextInEx;
+  EFI_KEY_STATE                     KeyState;
+  LIST_ENTRY                        NotifyList;  
+} GOP_PRIVATE_DATA;
+
+
+#define GOP_PRIVATE_DATA_FROM_THIS(a)  \
+         CR(a, GOP_PRIVATE_DATA, GraphicsOutput, GOP_PRIVATE_DATA_SIGNATURE)
+
+#define GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS(a)  \
+         CR(a, GOP_PRIVATE_DATA, SimpleTextIn, GOP_PRIVATE_DATA_SIGNATURE)
+
+#define GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS(a)  \
+         CR(a, GOP_PRIVATE_DATA, SimpleTextInEx, GOP_PRIVATE_DATA_SIGNATURE)
+
+#define GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS(a)  \
+         CR(a, GOP_PRIVATE_DATA, SimplePointer, GOP_PRIVATE_DATA_SIGNATURE)
+
+
+//
+// Global Protocol Variables
+//
+extern EFI_DRIVER_BINDING_PROTOCOL  gEmuGopDriverBinding;
+extern EFI_COMPONENT_NAME_PROTOCOL  gEmuGopComponentName;
+extern EFI_COMPONENT_NAME2_PROTOCOL gEmuGopComponentName2;
+
+//
+// Gop Hardware abstraction internal worker functions
+//
+EFI_STATUS
+EmuGopSupported (
+  IN  EMU_IO_THUNK_PROTOCOL  *EmuIoThunk
+  );
+
+EFI_STATUS
+EmuGopConstructor (
+  IN  GOP_PRIVATE_DATA    *Private
+  );
+
+EFI_STATUS
+EmuGopDestructor (
+  IN  GOP_PRIVATE_DATA    *Private
+  );
+
+
+EFI_STATUS
+GopPrivateAddQ (
+  IN  GOP_PRIVATE_DATA    *Private,
+  IN  EFI_INPUT_KEY       Key
+  );
+
+EFI_STATUS
+EmuGopInitializeSimpleTextInForWindow (
+  IN  GOP_PRIVATE_DATA    *Private
+  );
+
+EFI_STATUS
+EmuGopInitializeSimplePointerForWindow (
+  IN  GOP_PRIVATE_DATA    *Private
+  );
+
+EFI_STATUS
+EmuGopStartWindow (
+  IN  GOP_PRIVATE_DATA    *Private,
+  IN  UINT32              HorizontalResolution,
+  IN  UINT32              VerticalResolution,
+  IN  UINT32              ColorDepth,
+  IN  UINT32              RefreshRate
+  );
+
+VOID
+EFIAPI
+ShutdownGopEvent (
+  IN EFI_EVENT  Event,
+  IN VOID       *Context
+  );
+
+VOID
+EFIAPI
+GopPrivateMakeCallbackFunction (
+  IN VOID           *Context,
+  IN EFI_KEY_DATA   *KeyData
+  );
+
+VOID
+EFIAPI
+GopPrivateBreakCallbackFunction (
+  IN VOID           *Context,
+  IN EFI_KEY_DATA   *KeyData
+  );
+
+#endif
diff --git a/EmulatorPkg/EmuGopDxe/GopDriver.c b/EmulatorPkg/EmuGopDxe/GopDriver.c
new file mode 100644
index 0000000000..8ddaa86cfa
--- /dev/null
+++ b/EmulatorPkg/EmuGopDxe/GopDriver.c
@@ -0,0 +1,443 @@
+/*++ @file

+

+Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>

+Portions copyright (c) 2010,Apple Inc. All rights reserved.<BR>

+This program and the accompanying materials                          

+are licensed and made available under the terms and conditions of the BSD License         

+which accompanies this distribution.  The full text of the license may be found at        

+http://opensource.org/licenses/bsd-license.php                                            

+                                                                                          

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+

+

+**/

+

+#include "Gop.h"

+

+

+EFI_STATUS

+FreeNotifyList (

+  IN OUT LIST_ENTRY           *ListHead

+  )

+/*++

+

+Routine Description:

+

+Arguments:

+

+  ListHead   - The list head

+

+Returns:

+

+  EFI_SUCCESS           - Free the notify list successfully

+  EFI_INVALID_PARAMETER - ListHead is invalid.

+

+**/

+{

+  EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY *NotifyNode;

+

+  if (ListHead == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+  while (!IsListEmpty (ListHead)) {

+    NotifyNode = CR (

+                   ListHead->ForwardLink, 

+                   EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY, 

+                   NotifyEntry, 

+                   EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE

+                   );

+    RemoveEntryList (ListHead->ForwardLink);

+    gBS->FreePool (NotifyNode);

+  }

+  

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Tests to see if this driver supports a given controller. If a child device is provided, 

+  it further tests to see if this driver supports creating a handle for the specified child device.

+

+  This function checks to see if the driver specified by This supports the device specified by 

+  ControllerHandle. Drivers will typically use the device path attached to 

+  ControllerHandle and/or the services from the bus I/O abstraction attached to 

+  ControllerHandle to determine if the driver supports ControllerHandle. This function 

+  may be called many times during platform initialization. In order to reduce boot times, the tests 

+  performed by this function must be very small, and take as little time as possible to execute. This 

+  function must not change the state of any hardware devices, and this function must be aware that the 

+  device specified by ControllerHandle may already be managed by the same driver or a 

+  different driver. This function must match its calls to AllocatePages() with FreePages(), 

+  AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().  

+  Because ControllerHandle may have been previously started by the same driver, if a protocol is 

+  already in the opened state, then it must not be closed with CloseProtocol(). This is required 

+  to guarantee the state of ControllerHandle is not modified by this function.

+

+  @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.

+  @param[in]  ControllerHandle     The handle of the controller to test. This handle 

+                                   must support a protocol interface that supplies 

+                                   an I/O abstraction to the driver.

+  @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This 

+                                   parameter is ignored by device drivers, and is optional for bus 

+                                   drivers. For bus drivers, if this parameter is not NULL, then 

+                                   the bus driver must determine if the bus controller specified 

+                                   by ControllerHandle and the child controller specified 

+                                   by RemainingDevicePath are both supported by this 

+                                   bus driver.

+

+  @retval EFI_SUCCESS              The device specified by ControllerHandle and

+                                   RemainingDevicePath is supported by the driver specified by This.

+  @retval EFI_ALREADY_STARTED      The device specified by ControllerHandle and

+                                   RemainingDevicePath is already being managed by the driver

+                                   specified by This.

+  @retval EFI_ACCESS_DENIED        The device specified by ControllerHandle and

+                                   RemainingDevicePath is already being managed by a different

+                                   driver or an application that requires exclusive access.

+                                   Currently not implemented.

+  @retval EFI_UNSUPPORTED          The device specified by ControllerHandle and

+                                   RemainingDevicePath is not supported by the driver specified by This.

+**/

+EFI_STATUS

+EFIAPI

+EmuGopDriverBindingSupported (

+  IN  EFI_DRIVER_BINDING_PROTOCOL     *This,

+  IN  EFI_HANDLE                      Handle,

+  IN  EFI_DEVICE_PATH_PROTOCOL        *RemainingDevicePath

+  )

+{

+  EFI_STATUS              Status;

+  EMU_IO_THUNK_PROTOCOL   *EmuIoThunk;

+

+  //

+  // Open the IO Abstraction(s) needed to perform the supported test

+  //

+  Status = gBS->OpenProtocol (

+                  Handle,

+                  &gEmuIoThunkProtocolGuid,

+                  (VOID **)&EmuIoThunk,

+                  This->DriverBindingHandle,

+                  Handle,

+                  EFI_OPEN_PROTOCOL_BY_DRIVER

+                  );

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  Status = EmuGopSupported (EmuIoThunk);

+

+  //

+  // Close the I/O Abstraction(s) used to perform the supported test

+  //

+  gBS->CloseProtocol (

+        Handle,

+        &gEmuIoThunkProtocolGuid,

+        This->DriverBindingHandle,

+        Handle

+        );

+

+  return Status;

+}

+

+

+/**

+  Starts a device controller or a bus controller.

+

+  The Start() function is designed to be invoked from the EFI boot service ConnectController().

+  As a result, much of the error checking on the parameters to Start() has been moved into this 

+  common boot service. It is legal to call Start() from other locations, 

+  but the following calling restrictions must be followed, or the system behavior will not be deterministic.

+  1. ControllerHandle must be a valid EFI_HANDLE.

+  2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned

+     EFI_DEVICE_PATH_PROTOCOL.

+  3. Prior to calling Start(), the Supported() function for the driver specified by This must

+     have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.  

+

+  @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.

+  @param[in]  ControllerHandle     The handle of the controller to start. This handle 

+                                   must support a protocol interface that supplies 

+                                   an I/O abstraction to the driver.

+  @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This 

+                                   parameter is ignored by device drivers, and is optional for bus 

+                                   drivers. For a bus driver, if this parameter is NULL, then handles 

+                                   for all the children of Controller are created by this driver.  

+                                   If this parameter is not NULL and the first Device Path Node is 

+                                   not the End of Device Path Node, then only the handle for the 

+                                   child device specified by the first Device Path Node of 

+                                   RemainingDevicePath is created by this driver.

+                                   If the first Device Path Node of RemainingDevicePath is 

+                                   the End of Device Path Node, no child handle is created by this

+                                   driver.

+

+  @retval EFI_SUCCESS              The device was started.

+  @retval EFI_DEVICE_ERROR         The device could not be started due to a device error.Currently not implemented.

+  @retval EFI_OUT_OF_RESOURCES     The request could not be completed due to a lack of resources.

+  @retval Others                   The driver failded to start the device.

+

+**/

+EFI_STATUS

+EFIAPI

+EmuGopDriverBindingStart (

+  IN  EFI_DRIVER_BINDING_PROTOCOL     *This,

+  IN  EFI_HANDLE                      Handle,

+  IN  EFI_DEVICE_PATH_PROTOCOL        *RemainingDevicePath

+  )

+{

+  EMU_IO_THUNK_PROTOCOL   *EmuIoThunk;

+  EFI_STATUS              Status;

+  GOP_PRIVATE_DATA        *Private;

+

+  //

+  // Grab the protocols we need

+  //

+  Status = gBS->OpenProtocol (

+                  Handle,

+                  &gEmuIoThunkProtocolGuid,

+                  (VOID **)&EmuIoThunk,

+                  This->DriverBindingHandle,

+                  Handle,

+                  EFI_OPEN_PROTOCOL_BY_DRIVER

+                  );

+  if (EFI_ERROR (Status)) {

+    return EFI_UNSUPPORTED;

+  }

+

+  //

+  // Allocate Private context data for SGO inteface.

+  //

+  Private = NULL;

+  Status = gBS->AllocatePool (

+                  EfiBootServicesData,

+                  sizeof (GOP_PRIVATE_DATA),

+                  (VOID **)&Private

+                  );

+  if (EFI_ERROR (Status)) {

+    goto Done;

+  }

+  //

+  // Set up context record

+  //

+  Private->Signature           = GOP_PRIVATE_DATA_SIGNATURE;

+  Private->Handle              = Handle;

+  Private->EmuIoThunk          = EmuIoThunk;

+  Private->WindowName          = EmuIoThunk->ConfigString;

+  Private->ControllerNameTable = NULL;

+

+  AddUnicodeString (

+    "eng",

+    gEmuGopComponentName.SupportedLanguages,

+    &Private->ControllerNameTable,

+    EmuIoThunk->ConfigString

+    );

+  AddUnicodeString2 (

+    "en",

+    gEmuGopComponentName2.SupportedLanguages,

+    &Private->ControllerNameTable,

+    EmuIoThunk->ConfigString,

+    FALSE

+    );

+

+  Status = EmuGopConstructor (Private);

+  if (EFI_ERROR (Status)) {

+    goto Done;

+  }

+  //

+  // Publish the Gop interface to the world

+  //

+  Status = gBS->InstallMultipleProtocolInterfaces (

+                  &Private->Handle,

+                  &gEfiGraphicsOutputProtocolGuid,    &Private->GraphicsOutput,

+                  &gEfiSimpleTextInProtocolGuid,      &Private->SimpleTextIn,

+                  &gEfiSimplePointerProtocolGuid,     &Private->SimplePointer,

+                  &gEfiSimpleTextInputExProtocolGuid, &Private->SimpleTextInEx,

+                  NULL

+                  );

+

+Done:

+  if (EFI_ERROR (Status)) {

+

+    gBS->CloseProtocol (

+          Handle,

+          &gEmuIoThunkProtocolGuid,

+          This->DriverBindingHandle,

+          Handle

+          );

+

+    if (Private != NULL) {

+      //

+      // On Error Free back private data

+      //

+      if (Private->ControllerNameTable != NULL) {

+        FreeUnicodeStringTable (Private->ControllerNameTable);

+      }

+      if (Private->SimpleTextIn.WaitForKey != NULL) {

+        gBS->CloseEvent (Private->SimpleTextIn.WaitForKey);

+      }

+      if (Private->SimpleTextInEx.WaitForKeyEx != NULL) {

+        gBS->CloseEvent (Private->SimpleTextInEx.WaitForKeyEx);

+      }

+      FreeNotifyList (&Private->NotifyList);

+

+      gBS->FreePool (Private);

+    }

+  }

+

+  return Status;

+}

+

+

+

+/**

+  Stops a device controller or a bus controller.

+  

+  The Stop() function is designed to be invoked from the EFI boot service DisconnectController(). 

+  As a result, much of the error checking on the parameters to Stop() has been moved 

+  into this common boot service. It is legal to call Stop() from other locations, 

+  but the following calling restrictions must be followed, or the system behavior will not be deterministic.

+  1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this

+     same driver's Start() function.

+  2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid

+     EFI_HANDLE. In addition, all of these handles must have been created in this driver's

+     Start() function, and the Start() function must have called OpenProtocol() on

+     ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.

+  

+  @param[in]  This              A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.

+  @param[in]  ControllerHandle  A handle to the device being stopped. The handle must 

+                                support a bus specific I/O protocol for the driver 

+                                to use to stop the device.

+  @param[in]  NumberOfChildren  The number of child device handles in ChildHandleBuffer.

+  @param[in]  ChildHandleBuffer An array of child handles to be freed. May be NULL 

+                                if NumberOfChildren is 0.

+

+  @retval EFI_SUCCESS           The device was stopped.

+  @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device error.

+

+**/

+EFI_STATUS

+EFIAPI

+EmuGopDriverBindingStop (

+  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,

+  IN  EFI_HANDLE                   Handle,

+  IN  UINTN                        NumberOfChildren,

+  IN  EFI_HANDLE                   *ChildHandleBuffer

+  )

+{

+  EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;

+  EFI_STATUS                   Status;

+  GOP_PRIVATE_DATA             *Private;

+

+  Status = gBS->OpenProtocol (

+                  Handle,

+                  &gEfiGraphicsOutputProtocolGuid,

+                  (VOID **)&GraphicsOutput,

+                  This->DriverBindingHandle,

+                  Handle,

+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL

+                  );

+  if (EFI_ERROR (Status)) {

+    //

+    // If the GOP interface does not exist the driver is not started

+    //

+    return EFI_NOT_STARTED;

+  }

+

+  //

+  // Get our private context information

+  //

+  Private = GOP_PRIVATE_DATA_FROM_THIS (GraphicsOutput);

+

+  //

+  // Remove the SGO interface from the system

+  //

+  Status = gBS->UninstallMultipleProtocolInterfaces (

+                  Private->Handle,

+                  &gEfiGraphicsOutputProtocolGuid,    &Private->GraphicsOutput,

+                  &gEfiSimpleTextInProtocolGuid,      &Private->SimpleTextIn,

+                  &gEfiSimplePointerProtocolGuid,     &Private->SimplePointer,

+                  &gEfiSimpleTextInputExProtocolGuid, &Private->SimpleTextInEx,

+                  NULL

+                  );

+  if (!EFI_ERROR (Status)) {

+    //

+    // Shutdown the hardware

+    //

+    Status = EmuGopDestructor (Private);

+    if (EFI_ERROR (Status)) {

+      return EFI_DEVICE_ERROR;

+    }

+

+    gBS->CloseProtocol (

+          Handle,

+          &gEmuIoThunkProtocolGuid,

+          This->DriverBindingHandle,

+          Handle

+          );

+

+    //

+    // Free our instance data

+    //

+    FreeUnicodeStringTable (Private->ControllerNameTable);

+    

+    Status = gBS->CloseEvent (Private->SimpleTextIn.WaitForKey);

+    ASSERT_EFI_ERROR (Status);

+    

+    Status = gBS->CloseEvent (Private->SimpleTextInEx.WaitForKeyEx);

+    ASSERT_EFI_ERROR (Status);

+    

+    FreeNotifyList (&Private->NotifyList);

+

+    gBS->FreePool (Private);

+

+  }

+

+  return Status;

+}

+

+

+///

+/// This protocol provides the services required to determine if a driver supports a given controller. 

+/// If a controller is supported, then it also provides routines to start and stop the controller.

+///

+EFI_DRIVER_BINDING_PROTOCOL gEmuGopDriverBinding = {

+  EmuGopDriverBindingSupported,

+  EmuGopDriverBindingStart,

+  EmuGopDriverBindingStop,

+  0xa,

+  NULL,

+  NULL

+};

+

+

+

+/**

+  The user Entry Point for module EmuGop. The user code starts with this function.

+

+  @param[in] ImageHandle    The firmware allocated handle for the EFI image.  

+  @param[in] SystemTable    A pointer to the EFI System Table.

+  

+  @retval EFI_SUCCESS       The entry point is executed successfully.

+  @retval other             Some error occurs when executing this entry point.

+

+**/

+EFI_STATUS

+EFIAPI

+InitializeEmuGop (

+  IN EFI_HANDLE           ImageHandle,

+  IN EFI_SYSTEM_TABLE     *SystemTable

+  )

+{

+  EFI_STATUS              Status;

+

+  Status = EfiLibInstallDriverBindingComponentName2 (

+             ImageHandle,

+             SystemTable,

+             &gEmuGopDriverBinding,

+             ImageHandle,

+             &gEmuGopComponentName,

+             &gEmuGopComponentName2

+             );

+  ASSERT_EFI_ERROR (Status);

+

+

+  return Status;

+}

+

diff --git a/EmulatorPkg/EmuGopDxe/GopInput.c b/EmulatorPkg/EmuGopDxe/GopInput.c
new file mode 100644
index 0000000000..0bc2eb5a02
--- /dev/null
+++ b/EmulatorPkg/EmuGopDxe/GopInput.c
@@ -0,0 +1,897 @@
+/*++ @file
+
+Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2010 0 2011,Apple Inc. All rights reserved.<BR>
+This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+
+**/
+
+#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.
+//
+
+/**
+  Reset the input device and optionally run diagnostics
+
+  @param  This                 Protocol instance pointer.
+  @param  ExtendedVerification Driver may perform diagnostics on reset.
+
+  @retval EFI_SUCCESS          The device was reset.
+  @retval EFI_DEVICE_ERROR     The device is not functioning properly and could not be reset.
+
+**/
+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;
+}
+
+
+/**
+  Reads the next keystroke from the input device. The WaitForKey Event can
+  be used to test for existence of a keystroke via WaitForEvent () call.
+
+  @param  This  Protocol instance pointer.
+  @param  Key   A pointer to a buffer that is filled in with the keystroke
+                information for the key that was pressed.
+
+  @retval EFI_SUCCESS      The keystroke information was returned.
+  @retval EFI_NOT_READY    There was no keystroke data available.
+  @retval EFI_DEVICE_ERROR The keystroke information was not returned due to
+                           hardware errors.
+
+**/
+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);
+  CopyMem (Key, &KeyData.Key, sizeof (EFI_INPUT_KEY));
+
+  //
+  // Leave critical section and return
+  //
+  gBS->RestoreTPL (OldTpl);
+
+  return Status;
+}
+
+
+
+/**
+  SimpleTextIn and SimpleTextInEx Notify Wait Event 
+
+  @param  Event                 Event whose notification function is being invoked.
+  @param  Context               Pointer to GOP_PRIVATE_DATA.
+
+**/
+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
+//
+
+
+/**
+  The Reset() function resets the input device hardware. As part
+  of initialization process, the firmware/device will make a quick
+  but reasonable attempt to verify that the device is functioning.
+  If the ExtendedVerification flag is TRUE the firmware may take
+  an extended amount of time to verify the device is operating on
+  reset. Otherwise the reset operation is to occur as quickly as
+  possible. The hardware verification process is not defined by
+  this specification and is left up to the platform firmware or
+  driver to implement.
+
+  @param This                 A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+
+  @param ExtendedVerification Indicates that the driver may
+                              perform a more exhaustive
+                              verification operation of the
+                              device during reset.
+
+
+  @retval EFI_SUCCESS       The device was reset.
+  
+  @retval EFI_DEVICE_ERROR  The device is not functioning
+                            correctly and could not be reset.
+
+**/
+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.
+
+**/
+{
+  GOP_PRIVATE_DATA *Private;
+
+  Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This);
+  
+  return EFI_SUCCESS;
+}
+
+
+
+/**
+  The function reads the next keystroke from the input device. If
+  there is no pending keystroke the function returns
+  EFI_NOT_READY. If there is a pending keystroke, then
+  KeyData.Key.ScanCode is the EFI scan code defined in Error!
+  Reference source not found. The KeyData.Key.UnicodeChar is the
+  actual printable character or is zero if the key does not
+  represent a printable character (control key, function key,
+  etc.). The KeyData.KeyState is shift state for the character
+  reflected in KeyData.Key.UnicodeChar or KeyData.Key.ScanCode .
+  When interpreting the data from this function, it should be
+  noted that if a class of printable characters that are
+  normally adjusted by shift modifiers (e.g. Shift Key + "f"
+  key) would be presented solely as a KeyData.Key.UnicodeChar
+  without the associated shift state. So in the previous example
+  of a Shift Key + "f" key being pressed, the only pertinent
+  data returned would be KeyData.Key.UnicodeChar with the value
+  of "F". This of course would not typically be the case for
+  non-printable characters such as the pressing of the Right
+  Shift Key + F10 key since the corresponding returned data
+  would be reflected both in the KeyData.KeyState.KeyShiftState
+  and KeyData.Key.ScanCode values. UEFI drivers which implement
+  the EFI_SIMPLE_TEXT_INPUT_EX protocol are required to return
+  KeyData.Key and KeyData.KeyState values. These drivers must
+  always return the most current state of
+  KeyData.KeyState.KeyShiftState and
+  KeyData.KeyState.KeyToggleState. It should also be noted that
+  certain input devices may not be able to produce shift or toggle
+  state information, and in those cases the high order bit in the
+  respective Toggle and Shift state fields should not be active.
+
+  
+  @param This     A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+
+  @param KeyData  A pointer to a buffer that is filled in with
+                  the keystroke state data for the key that was
+                  pressed.
+
+  
+  @retval EFI_SUCCESS     The keystroke information was
+                          returned.
+  
+  @retval EFI_NOT_READY   There was no keystroke data available.
+                          EFI_DEVICE_ERROR The keystroke
+                          information was not returned due to
+                          hardware errors.
+
+
+**/
+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_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;
+}
+
+
+
+/**
+  The SetState() function allows the input device hardware to
+  have state settings adjusted.
+  
+  @param This           A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+  
+  @param KeyToggleState Pointer to the EFI_KEY_TOGGLE_STATE to
+                        set the state for the input device.
+  
+  
+  @retval EFI_SUCCESS       The device state was set appropriately.
+
+  @retval EFI_DEVICE_ERROR  The device is not functioning
+                            correctly and could not have the
+                            setting adjusted.
+
+  @retval EFI_UNSUPPORTED   The device does not support the
+                            ability to have its state set.
+
+**/
+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;
+
+  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->KeySetState (Private->EmuGraphicsWindow, KeyToggleState);
+  //
+  // Leave critical section and return
+  //
+  gBS->RestoreTPL (OldTpl);
+
+  return Status;
+}
+
+
+/**
+  SimpleTextIn and SimpleTextInEx Notify Wait Event 
+
+  @param  Event                 Event whose notification function is being invoked.
+  @param  Context               Pointer to GOP_PRIVATE_DATA.
+
+**/
+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);
+}
+
+
+
+/**
+  The RegisterKeystrokeNotify() function registers a function
+  which will be called when a specified keystroke will occur.
+  
+  @param This                     A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+  
+  @param KeyData                  A pointer to a buffer that is filled in with
+                                  the keystroke information for the key that was
+                                  pressed.
+  
+  @param KeyNotificationFunction  Points to the function to be
+                                  called when the key sequence
+                                  is typed specified by KeyData.
+  
+  
+  @param NotifyHandle             Points to the unique handle assigned to
+                                  the registered notification.
+  
+  @retval EFI_SUCCESS           The device state was set
+                                appropriately.
+
+  @retval EFI_OUT_OF_RESOURCES  Unable to allocate necessary
+                                data structures.
+
+**/
+EFI_STATUS
+EFIAPI
+EmuGopSimpleTextInExRegisterKeyNotify (
+  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
+  IN EFI_KEY_DATA                       *KeyData,
+  IN EFI_KEY_NOTIFY_FUNCTION            KeyNotificationFunction,
+  OUT EFI_HANDLE                        *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;
+  
+}
+
+
+/**
+  The UnregisterKeystrokeNotify() function removes the
+  notification which was previously registered.
+  
+  @param This               A pointer to the EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL instance.
+  
+  @param NotificationHandle The handle of the notification
+                            function being unregistered.
+  
+  @retval EFI_SUCCESS The device state was set appropriately.
+  
+  @retval EFI_INVALID_PARAMETER The NotificationHandle is
+                                invalid.
+
+**/
+EFI_STATUS
+EFIAPI
+EmuGopSimpleTextInExUnregisterKeyNotify (
+  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
+  IN EFI_HANDLE                         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;
+}
+
+
+
+/**
+  Initialize SimplelTextIn and SimpleTextInEx protocols in the Private
+  context structure.
+
+  @param  Private               Context structure to fill in. 
+
+  @return EFI_SUCCESS           Initialization was a success
+
+**/
+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.
+//
+
+
+/**                                                                 
+  Resets the pointer device hardware.
+    
+  @param  This                  A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
+                                instance.                                   
+  @param  ExtendedVerification  Indicates that the driver may perform a more exhaustive
+                                verification operation of the device during reset.                                       
+                                
+  @retval EFI_SUCCESS           The device was reset.
+  @retval EFI_DEVICE_ERROR      The device is not functioning correctly and could not be reset.  
+                                   
+**/
+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;
+}
+
+
+/**                                                                 
+  Retrieves the current state of a pointer device.
+    
+  @param  This                  A pointer to the EFI_SIMPLE_POINTER_PROTOCOL
+                                instance.                                   
+  @param  State                 A pointer to the state information on the pointer device.
+                                
+  @retval EFI_SUCCESS           The state of the pointer device was returned in State.
+  @retval EFI_NOT_READY         The state of the pointer device has not changed since the last call to
+                                GetState().                                                           
+  @retval EFI_DEVICE_ERROR      A device error occurred while attempting to retrieve the pointer device's
+                                current state.                                                           
+                                   
+**/
+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;
+}
+
+
+/**
+  SimplePointer Notify Wait Event 
+
+  @param  Event                 Event whose notification function is being invoked.
+  @param  Context               Pointer to GOP_PRIVATE_DATA.
+
+**/
+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);
+}
+
+
+/**
+  SimplePointer constructor 
+
+  @param  Private Context structure to fill in.      
+
+  @retval EFI_SUCCESS Constructor had success        
+
+**/
+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;
+}
diff --git a/EmulatorPkg/EmuGopDxe/GopScreen.c b/EmulatorPkg/EmuGopDxe/GopScreen.c
new file mode 100644
index 0000000000..7f4333d169
--- /dev/null
+++ b/EmulatorPkg/EmuGopDxe/GopScreen.c
@@ -0,0 +1,420 @@
+/*++ @file
+
+Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2010 - 2011, Apple Inc. All rights reserved.
+This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+Module Name:
+
+    EmuGopScreen.c
+
+Abstract:
+
+  This file produces the graphics abstration of UGA. It is called by
+  EmuGopDriver.c file which deals with the EFI 1.1 driver model.
+  This file just does graphics.
+
+**/
+
+#include "Gop.h"
+
+
+EFI_EVENT               mGopScreenExitBootServicesEvent;
+
+GOP_MODE_DATA mGopModeData[] = {
+    { 800,  600, 0, 0 },
+    { 640,  480, 0, 0 },
+    { 720,  400, 0, 0 },
+    {1024,  768, 0, 0 },
+    {1280, 1024, 0, 0 }
+    };
+
+
+/**
+  Returns information for an available graphics mode that the graphics device
+  and the set of active video output devices supports.
+
+  @param  This                  The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
+  @param  ModeNumber            The mode number to return information on.
+  @param  SizeOfInfo            A pointer to the size, in bytes, of the Info buffer.
+  @param  Info                  A pointer to callee allocated buffer that returns information about ModeNumber.
+
+  @retval EFI_SUCCESS           Mode information returned.
+  @retval EFI_BUFFER_TOO_SMALL  The Info buffer was too small.
+  @retval EFI_DEVICE_ERROR      A hardware error occurred trying to retrieve the video mode.
+  @retval EFI_NOT_STARTED       Video display is not initialized. Call SetMode ()
+  @retval EFI_INVALID_PARAMETER One of the input args was NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+EmuGopQuerytMode (
+  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL          *This,
+  IN  UINT32                                ModeNumber,
+  OUT UINTN                                 *SizeOfInfo,
+  OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  **Info
+  )
+{
+  GOP_PRIVATE_DATA  *Private;
+
+  Private = GOP_PRIVATE_DATA_FROM_THIS (This);
+
+  if (Info == NULL || SizeOfInfo == NULL || (UINTN) ModeNumber >= This->Mode->MaxMode) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  *Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));
+  if (*Info == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  *SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
+
+  (*Info)->Version = 0;
+  (*Info)->HorizontalResolution = Private->ModeData[ModeNumber].HorizontalResolution;
+  (*Info)->VerticalResolution   = Private->ModeData[ModeNumber].VerticalResolution;
+  (*Info)->PixelFormat = PixelBltOnly;
+  (*Info)->PixelsPerScanLine = (*Info)->HorizontalResolution;
+
+  return EFI_SUCCESS;
+}
+
+
+
+/**
+  Set the video device into the specified mode and clears the visible portions of 
+  the output display to black.
+
+  @param  This              The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
+  @param  ModeNumber        Abstraction that defines the current video mode.
+
+  @retval EFI_SUCCESS       The graphics mode specified by ModeNumber was selected.
+  @retval EFI_DEVICE_ERROR  The device had an error and could not complete the request.
+  @retval EFI_UNSUPPORTED   ModeNumber is not supported by this device.
+
+**/
+EFI_STATUS
+EFIAPI
+EmuGopSetMode (
+  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL  *This,
+  IN  UINT32                        ModeNumber
+  )
+{
+  EFI_STATUS                      Status;
+  GOP_PRIVATE_DATA                *Private;
+  GOP_MODE_DATA                   *ModeData;
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL   Fill;
+
+  Private = GOP_PRIVATE_DATA_FROM_THIS (This);
+
+  if (ModeNumber >= This->Mode->MaxMode) {
+    return EFI_UNSUPPORTED;
+  }
+
+  ModeData = &Private->ModeData[ModeNumber];
+  This->Mode->Mode = ModeNumber;
+  Private->GraphicsOutput.Mode->Info->HorizontalResolution = ModeData->HorizontalResolution;
+  Private->GraphicsOutput.Mode->Info->VerticalResolution = ModeData->VerticalResolution;
+  Private->GraphicsOutput.Mode->Info->PixelsPerScanLine = ModeData->HorizontalResolution;
+
+  if (Private->HardwareNeedsStarting) {
+    Status = EmuGopStartWindow (
+              Private,
+              ModeData->HorizontalResolution,
+              ModeData->VerticalResolution,
+              ModeData->ColorDepth,
+              ModeData->RefreshRate
+              );
+    if (EFI_ERROR (Status)) {
+      return EFI_DEVICE_ERROR;
+    }
+
+    Private->HardwareNeedsStarting = FALSE;
+  }
+  
+  
+  Status = Private->EmuGraphicsWindow->Size(
+                            Private->EmuGraphicsWindow,
+                            ModeData->HorizontalResolution,
+                            ModeData->VerticalResolution
+                            );
+
+
+  Fill.Red                      = 0x7f;
+  Fill.Green                    = 0x7F;
+  Fill.Blue                     = 0x7f;
+  This->Blt (
+          This,
+          &Fill,
+          EfiBltVideoFill,
+          0,
+          0,
+          0,
+          0,
+          ModeData->HorizontalResolution,
+          ModeData->VerticalResolution,
+          ModeData->HorizontalResolution * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
+          );
+  return EFI_SUCCESS;
+}
+
+
+
+/**
+  Blt a rectangle of pixels on the graphics screen. Blt stands for BLock Transfer.
+  
+  @param  This         Protocol instance pointer.
+  @param  BltBuffer    Buffer containing data to blit into video buffer. This
+                       buffer has a size of Width*Height*sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
+  @param  BltOperation Operation to perform on BlitBuffer and video memory
+  @param  SourceX      X coordinate of source for the BltBuffer.
+  @param  SourceY      Y coordinate of source for the BltBuffer.
+  @param  DestinationX X coordinate of destination for the BltBuffer.
+  @param  DestinationY Y coordinate of destination for the BltBuffer.
+  @param  Width        Width of rectangle in BltBuffer in pixels.
+  @param  Height       Hight of rectangle in BltBuffer in pixels.
+  @param  Delta        OPTIONAL
+
+  @retval EFI_SUCCESS           The Blt operation completed.
+  @retval EFI_INVALID_PARAMETER BltOperation is not valid.
+  @retval EFI_DEVICE_ERROR      A hardware error occured writting to the video buffer.
+
+**/
+EFI_STATUS
+EFIAPI
+EmuGopBlt (
+  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL            *This,
+  IN  EFI_GRAPHICS_OUTPUT_BLT_PIXEL           *BltBuffer,   OPTIONAL
+  IN  EFI_GRAPHICS_OUTPUT_BLT_OPERATION       BltOperation,
+  IN  UINTN                                   SourceX,
+  IN  UINTN                                   SourceY,
+  IN  UINTN                                   DestinationX,
+  IN  UINTN                                   DestinationY,
+  IN  UINTN                                   Width,
+  IN  UINTN                                   Height,
+  IN  UINTN                                   Delta         OPTIONAL
+  )
+{
+  GOP_PRIVATE_DATA  *Private;
+  EFI_TPL           OriginalTPL;
+  EFI_STATUS        Status;
+  EMU_GRAPHICS_WINDOWS__BLT_ARGS      GopBltArgs;
+
+  Private = GOP_PRIVATE_DATA_FROM_THIS (This);
+
+  if ((BltOperation < 0) || (BltOperation >= EfiGraphicsOutputBltOperationMax)) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (Width == 0 || Height == 0) {
+    return EFI_INVALID_PARAMETER;
+  }
+  //
+  // If Delta is zero, then the entire BltBuffer is being used, so Delta
+  // is the number of bytes in each row of BltBuffer.  Since BltBuffer is Width pixels size,
+  // the number of bytes in each row can be computed.
+  //
+  if (Delta == 0) {
+    Delta = Width * sizeof (EFI_UGA_PIXEL);
+  }
+
+  //
+  // We have to raise to TPL Notify, so we make an atomic write the frame buffer.
+  // We would not want a timer based event (Cursor, ...) to come in while we are
+  // doing this operation.
+  //
+  OriginalTPL = gBS->RaiseTPL (TPL_NOTIFY);
+
+  //
+  // Pack UGA Draw protocol parameters to EMU_GRAPHICS_WINDOWS__BLT_ARGS structure to adapt to
+  // GopBlt() API of Unix UGA IO protocol.
+  //
+  GopBltArgs.DestinationX = DestinationX;
+  GopBltArgs.DestinationY = DestinationY;
+  GopBltArgs.Height       = Height;
+  GopBltArgs.Width        = Width;
+  GopBltArgs.SourceX      = SourceX;
+  GopBltArgs.SourceY      = SourceY;
+  GopBltArgs.Delta        = Delta;
+  Status = Private->EmuGraphicsWindow->Blt (
+                            Private->EmuGraphicsWindow,
+                            (EFI_UGA_PIXEL *)BltBuffer,
+                            (EFI_UGA_BLT_OPERATION)BltOperation,
+                            &GopBltArgs
+                            );
+
+  gBS->RestoreTPL (OriginalTPL);
+
+  return Status;
+}
+
+
+//
+// Construction and Destruction functions
+//
+
+EFI_STATUS
+EmuGopSupported (
+  IN  EMU_IO_THUNK_PROTOCOL  *EmuIoThunk
+  )
+{
+  //
+  // Check to see if the IO abstraction represents a device type we support.
+  //
+  // This would be replaced a check of PCI subsystem ID, etc.
+  //
+  if (!CompareGuid (EmuIoThunk->Protocol, &gEmuGraphicsWindowProtocolGuid)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+EmuGopStartWindow (
+  IN  GOP_PRIVATE_DATA    *Private,
+  IN  UINT32              HorizontalResolution,
+  IN  UINT32              VerticalResolution,
+  IN  UINT32              ColorDepth,
+  IN  UINT32              RefreshRate
+  )
+{
+  EFI_STATUS          Status;
+
+  //
+  // Register to be notified on exit boot services so we can destroy the window.
+  //
+  Status = gBS->CreateEvent (
+                  EVT_SIGNAL_EXIT_BOOT_SERVICES,
+                  TPL_CALLBACK,
+                  ShutdownGopEvent,
+                  Private,
+                  &mGopScreenExitBootServicesEvent
+                  );
+
+  Status = Private->EmuIoThunk->Open (Private->EmuIoThunk);
+  if (!EFI_ERROR (Status)) {
+    Private->EmuGraphicsWindow = Private->EmuIoThunk->Interface;
+    
+    // Register callback to support RegisterKeyNotify()
+    Status  = Private->EmuGraphicsWindow->RegisterKeyNotify (
+                                            Private->EmuGraphicsWindow, 
+                                            GopPrivateMakeCallbackFunction, 
+                                            GopPrivateBreakCallbackFunction, 
+                                            Private
+                                            );
+    ASSERT_EFI_ERROR (Status);
+  }
+  return Status;
+}
+
+EFI_STATUS
+EmuGopConstructor (
+  GOP_PRIVATE_DATA    *Private
+  )
+{
+  Private->ModeData = mGopModeData;
+
+  Private->GraphicsOutput.QueryMode      = EmuGopQuerytMode;
+  Private->GraphicsOutput.SetMode        = EmuGopSetMode;
+  Private->GraphicsOutput.Blt            = EmuGopBlt;
+
+  //
+  // Allocate buffer for Graphics Output Protocol mode information
+  //
+  Private->GraphicsOutput.Mode = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE));
+  if (Private->GraphicsOutput.Mode == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+  Private->GraphicsOutput.Mode->Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));
+  if (Private->GraphicsOutput.Mode->Info == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Private->GraphicsOutput.Mode->MaxMode = sizeof(mGopModeData) / sizeof(GOP_MODE_DATA);
+  //
+  // Till now, we have no idea about the window size.
+  //
+  Private->GraphicsOutput.Mode->Mode = GRAPHICS_OUTPUT_INVALIDE_MODE_NUMBER;
+  Private->GraphicsOutput.Mode->Info->Version = 0;
+  Private->GraphicsOutput.Mode->Info->HorizontalResolution = 0;
+  Private->GraphicsOutput.Mode->Info->VerticalResolution = 0;
+  Private->GraphicsOutput.Mode->Info->PixelFormat = PixelBltOnly;
+  Private->GraphicsOutput.Mode->SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
+  Private->GraphicsOutput.Mode->FrameBufferBase = (EFI_PHYSICAL_ADDRESS) (UINTN) NULL;
+  Private->GraphicsOutput.Mode->FrameBufferSize = 0;
+
+  Private->HardwareNeedsStarting  = TRUE;
+  Private->EmuGraphicsWindow                  = NULL;
+
+  EmuGopInitializeSimpleTextInForWindow (Private);
+
+  EmuGopInitializeSimplePointerForWindow (Private);
+
+  return EFI_SUCCESS;
+}
+
+
+
+EFI_STATUS
+EmuGopDestructor (
+  GOP_PRIVATE_DATA     *Private
+  )
+{
+  EFI_STATUS  Status;
+  
+  Status = EFI_SUCCESS;
+  if (!Private->HardwareNeedsStarting) {
+    Status = Private->EmuIoThunk->Close (Private->EmuIoThunk);
+    Private->EmuGraphicsWindow = NULL;
+  }
+
+  //
+  // Free graphics output protocol occupied resource
+  //
+  if (Private->GraphicsOutput.Mode != NULL) {
+    if (Private->GraphicsOutput.Mode->Info != NULL) {
+      FreePool (Private->GraphicsOutput.Mode->Info);
+    }
+    FreePool (Private->GraphicsOutput.Mode);
+  }
+
+  return EFI_SUCCESS;
+}
+
+
+VOID
+EFIAPI
+ShutdownGopEvent (
+  IN EFI_EVENT  Event,
+  IN VOID       *Context
+  )
+/*++
+
+Routine Description:
+
+  This is the UGA screen's callback notification function for exit-boot-services.
+  All we do here is call EmuGopDestructor().
+
+Arguments:
+
+  Event   - not used
+  Context - pointer to the Private structure.
+
+Returns:
+
+  None.
+
+**/
+{
+  EFI_STATUS  Status;
+  Status = EmuGopDestructor (Context);
+}
+