diff options
author | Ruiyu Ni <ruiyu.ni@intel.com> | 2018-08-23 13:33:54 +0800 |
---|---|---|
committer | Ruiyu Ni <ruiyu.ni@intel.com> | 2018-08-27 15:20:54 +0800 |
commit | 7a465451be0f1ec2ef1235bac6d14ebe1ca69936 (patch) | |
tree | 3e655a2eed49c847f26879e235f3054c589d8762 /EmulatorPkg | |
parent | 5601e90d5cdbc4cea748e00e34ae07ce39bd700f (diff) | |
download | edk2-7a465451be0f1ec2ef1235bac6d14ebe1ca69936.zip edk2-7a465451be0f1ec2ef1235bac6d14ebe1ca69936.tar.gz edk2-7a465451be0f1ec2ef1235bac6d14ebe1ca69936.tar.bz2 |
EmulatorPkg/Win: Add input/output support
The patch adds GOP and SimpleTextIn[Ex] support.
Now firmware can boot to UI and Shell but timer doesn't work.
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Ruiyu Ni <ruiyu.ni@intel.com>
Cc: Andrew Fish <afish@apple.com>
Reviewed-by: Hao A Wu <hao.a.wu@intel.com>
Diffstat (limited to 'EmulatorPkg')
-rw-r--r-- | EmulatorPkg/Win/Host/WinGop.h | 205 | ||||
-rw-r--r-- | EmulatorPkg/Win/Host/WinGopInput.c | 417 | ||||
-rw-r--r-- | EmulatorPkg/Win/Host/WinGopScreen.c | 872 | ||||
-rw-r--r-- | EmulatorPkg/Win/Host/WinHost.c | 5 | ||||
-rw-r--r-- | EmulatorPkg/Win/Host/WinHost.h | 1 | ||||
-rw-r--r-- | EmulatorPkg/Win/Host/WinHost.inf | 7 |
6 files changed, 1507 insertions, 0 deletions
diff --git a/EmulatorPkg/Win/Host/WinGop.h b/EmulatorPkg/Win/Host/WinGop.h new file mode 100644 index 0000000..de27238 --- /dev/null +++ b/EmulatorPkg/Win/Host/WinGop.h @@ -0,0 +1,205 @@ +/** @file
+
+Copyright (c) 2006 - 2018, Intel Corporation. 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:
+
+ WinGop.h
+
+Abstract:
+
+ Private data for the Gop driver that is bound to the WinNt Thunk protocol
+
+
+**/
+
+#ifndef _WIN_GOP_H_
+#define _WIN_GOP_H_
+
+
+#include "WinHost.h"
+
+#include <Protocol/EmuIoThunk.h>
+#include <Protocol/EmuGraphicsWindow.h>
+#include <Protocol/SimpleTextIn.h>
+#include <Protocol/SimpleTextInEx.h>
+#include <Protocol/GraphicsOutput.h>
+
+//
+// WM_SYSKEYDOWN/WM_SYSKEYUP Notification
+// lParam
+// bit 24: Specifies whether the key is an extended key,
+// such as the right-hand ALT and CTRL keys that appear on
+// an enhanced 101- or 102-key keyboard.
+// The value is 1 if it is an extended key; otherwise, it is 0.
+// bit 29:Specifies the context code.
+// The value is 1 if the ALT key is down while the key is pressed/released;
+// it is 0 if the WM_SYSKEYDOWN message is posted to the active window
+// because no window has the keyboard focus.
+#define GOP_EXTENDED_KEY (0x1 << 24)
+#define GOP_ALT_KEY_PRESSED (0x1 << 29)
+
+#define KEYBOARD_TIMER_INTERVAL 200000 // 0.02s
+
+#define MAX_Q 256
+
+typedef struct {
+ UINTN Front;
+ UINTN Rear;
+ EFI_KEY_DATA Q[MAX_Q];
+ CRITICAL_SECTION Cs;
+} GOP_QUEUE_FIXED;
+
+#define WIN_NT_GOP_CLASS_NAME L"WinNtGopWindow"
+
+
+typedef struct {
+ UINT64 Signature;
+ EMU_GRAPHICS_WINDOW_PROTOCOL GraphicsWindowIo;
+
+ //
+ // GOP Private Data knowing when to start hardware
+ //
+ BOOLEAN HardwareNeedsStarting;
+
+ CHAR16 *WindowName;
+ CHAR16 Buffer[160];
+
+ HANDLE ThreadInited; // Semaphore
+ HANDLE ThreadHandle; // Thread
+ DWORD ThreadId;
+
+ HWND WindowHandle;
+ WNDCLASSEX WindowsClass;
+
+ UINT32 Width;
+ UINT32 Height;
+ //
+ // This screen is used to redraw the scree when windows events happen. It's
+ // updated in the main thread and displayed in the windows thread.
+ //
+ BITMAPV4HEADER *VirtualScreenInfo;
+ RGBQUAD *VirtualScreen;
+
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL *FillLine;
+
+ //
+ // Keyboard Queue used by Simple Text In.
+ // QueueForRead: WinProc thread adds, and main thread removes.
+ //
+ GOP_QUEUE_FIXED QueueForRead;
+
+ EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK MakeRegisterdKeyCallback;
+ EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK BreakRegisterdKeyCallback;
+ VOID *RegisterdKeyCallbackContext;
+
+ EFI_KEY_STATE KeyState;
+ BOOLEAN LeftShift;
+ BOOLEAN RightShift;
+ BOOLEAN LeftAlt;
+ BOOLEAN RightAlt;
+ BOOLEAN LeftCtrl;
+ BOOLEAN RightCtrl;
+ BOOLEAN LeftLogo;
+ BOOLEAN RightLogo;
+ BOOLEAN Menu;
+ BOOLEAN SysReq;
+ BOOLEAN NumLock;
+ BOOLEAN ScrollLock;
+ BOOLEAN CapsLock;
+ BOOLEAN IsPartialKeySupport;
+} GRAPHICS_PRIVATE_DATA;
+#define GRAPHICS_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('g', 'f', 'x', 'd')
+#define GRAPHICS_PRIVATE_DATA_FROM_THIS(a) \
+ CR(a, GRAPHICS_PRIVATE_DATA, GraphicsWindowIo, GRAPHICS_PRIVATE_DATA_SIGNATURE)
+
+
+//
+// Gop Hardware abstraction internal worker functions
+//
+
+/**
+ TODO: Add function description
+
+ @param Private TODO: add argument description
+ @param Key TODO: add argument description
+
+ @return TODO: add return values
+
+**/
+EFI_STATUS
+GopPrivateAddKey (
+ IN GRAPHICS_PRIVATE_DATA *Private,
+ IN EFI_INPUT_KEY Key
+ );
+
+EFI_STATUS
+EFIAPI
+WinNtWndGetKey (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
+ IN EFI_KEY_DATA *KeyData
+ );
+
+EFI_STATUS
+EFIAPI
+WinNtWndCheckKey (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
+ );
+
+EFI_STATUS
+EFIAPI
+WinNtWndKeySetState (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
+ IN EFI_KEY_TOGGLE_STATE *KeyToggleState
+ );
+
+EFI_STATUS
+EFIAPI
+WinNtWndRegisterKeyNotify (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
+ IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK MakeCallBack,
+ IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK BreakCallBack,
+ IN VOID *Context
+ );
+
+EFI_STATUS
+EFIAPI
+WinNtWndCheckPointer (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
+ );
+
+EFI_STATUS
+EFIAPI
+WinNtWndGetPointerState (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
+ IN EFI_SIMPLE_POINTER_STATE *State
+ );
+EFI_STATUS
+GopPrivateCreateQ (
+ IN GRAPHICS_PRIVATE_DATA *Private,
+ IN GOP_QUEUE_FIXED *Queue
+ );
+
+
+/**
+ TODO: Add function description
+
+ @param Private TODO: add argument description
+
+ @retval EFI_SUCCESS TODO: Add description for return value
+
+**/
+EFI_STATUS
+GopPrivateDestroyQ (
+ IN GRAPHICS_PRIVATE_DATA *Private,
+ IN GOP_QUEUE_FIXED *Queue
+ );
+#endif
+
diff --git a/EmulatorPkg/Win/Host/WinGopInput.c b/EmulatorPkg/Win/Host/WinGopInput.c new file mode 100644 index 0000000..6c218ab --- /dev/null +++ b/EmulatorPkg/Win/Host/WinGopInput.c @@ -0,0 +1,417 @@ +/** @file
+
+Copyright (c) 2006 - 2018, Intel Corporation. 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:
+
+ WinGopInput.c
+
+Abstract:
+
+ This file produces the Simple Text In for an Gop window.
+
+ This stuff is linked at the hip to the Window, since the window
+ processing is done in a thread kicked off in WinNtGopImplementation.c
+
+ Since the window information is processed in an other thread we need
+ a keyboard Queue to pass data about. The Simple Text In code just
+ takes data off the Queue. The WinProc message loop takes keyboard input
+ and places it in the Queue.
+
+
+**/
+
+
+#include "WinGop.h"
+
+
+/**
+ TODO: Add function description
+
+ @param Private TODO: add argument description
+
+ @retval EFI_SUCCESS TODO: Add description for return value
+
+**/
+EFI_STATUS
+GopPrivateCreateQ (
+ IN GRAPHICS_PRIVATE_DATA *Private,
+ IN GOP_QUEUE_FIXED *Queue
+ )
+{
+ InitializeCriticalSection (&Queue->Cs);
+ Queue->Front = 0;
+ Queue->Rear = 0;
+ return EFI_SUCCESS;
+}
+
+
+/**
+ TODO: Add function description
+
+ @param Private TODO: add argument description
+
+ @retval EFI_SUCCESS TODO: Add description for return value
+
+**/
+EFI_STATUS
+GopPrivateDestroyQ (
+ IN GRAPHICS_PRIVATE_DATA *Private,
+ IN GOP_QUEUE_FIXED *Queue
+ )
+{
+ Queue->Front = 0;
+ Queue->Rear = 0;
+ DeleteCriticalSection (&Queue->Cs);
+ return EFI_SUCCESS;
+}
+
+
+/**
+ TODO: Add function description
+
+ @param Private TODO: add argument description
+ @param Key TODO: add argument description
+
+ @retval EFI_NOT_READY TODO: Add description for return value
+ @retval EFI_SUCCESS TODO: Add description for return value
+
+**/
+EFI_STATUS
+GopPrivateAddQ (
+ IN GRAPHICS_PRIVATE_DATA *Private,
+ IN GOP_QUEUE_FIXED *Queue,
+ IN EFI_KEY_DATA *KeyData
+ )
+{
+ EnterCriticalSection (&Queue->Cs);
+
+ if ((Queue->Rear + 1) % MAX_Q == Queue->Front) {
+ LeaveCriticalSection (&Queue->Cs);
+ return EFI_NOT_READY;
+ }
+
+ CopyMem (&Queue->Q[Queue->Rear], KeyData, sizeof (EFI_KEY_DATA));
+ Queue->Rear = (Queue->Rear + 1) % MAX_Q;
+
+ LeaveCriticalSection (&Queue->Cs);
+ return EFI_SUCCESS;
+}
+
+
+/**
+ TODO: Add function description
+
+ @param Private TODO: add argument description
+ @param Key TODO: add argument description
+
+ @retval EFI_NOT_READY TODO: Add description for return value
+ @retval EFI_SUCCESS TODO: Add description for return value
+
+**/
+EFI_STATUS
+GopPrivateDeleteQ (
+ IN GRAPHICS_PRIVATE_DATA *Private,
+ IN GOP_QUEUE_FIXED *Queue,
+ OUT EFI_KEY_DATA *Key
+ )
+{
+ EnterCriticalSection (&Queue->Cs);
+
+ if (Queue->Front == Queue->Rear) {
+ LeaveCriticalSection (&Queue->Cs);
+ return EFI_NOT_READY;
+ }
+
+ CopyMem (Key, &Queue->Q[Queue->Front], sizeof (EFI_KEY_DATA));
+ Queue->Front = (Queue->Front + 1) % MAX_Q;
+
+ if (Key->Key.ScanCode == SCAN_NULL && Key->Key.UnicodeChar == CHAR_NULL) {
+ if (!Private->IsPartialKeySupport) {
+ //
+ // If partial keystrok is not enabled, don't return the partial keystroke.
+ //
+ LeaveCriticalSection (&Queue->Cs);
+ ZeroMem (Key, sizeof (EFI_KEY_DATA));
+ return EFI_NOT_READY;
+ }
+ }
+ LeaveCriticalSection (&Queue->Cs);
+ return EFI_SUCCESS;
+}
+
+
+/**
+ TODO: Add function description
+
+ @param Private TODO: add argument description
+
+ @retval EFI_NOT_READY TODO: Add description for return value
+ @retval EFI_SUCCESS TODO: Add description for return value
+
+**/
+EFI_STATUS
+GopPrivateCheckQ (
+ IN GOP_QUEUE_FIXED *Queue
+ )
+{
+ if (Queue->Front == Queue->Rear) {
+ return EFI_NOT_READY;
+ }
+
+ return EFI_SUCCESS;
+}
+
+/**
+ Initialize the key state.
+
+ @param Private The GOP_PRIVATE_DATA instance.
+ @param KeyState A pointer to receive the key state information.
+**/
+VOID
+InitializeKeyState (
+ IN GRAPHICS_PRIVATE_DATA *Private,
+ IN EFI_KEY_STATE *KeyState
+ )
+{
+ KeyState->KeyShiftState = EFI_SHIFT_STATE_VALID;
+ KeyState->KeyToggleState = EFI_TOGGLE_STATE_VALID;
+
+ //
+ // Record Key shift state and toggle state
+ //
+ if (Private->LeftCtrl) {
+ KeyState->KeyShiftState |= EFI_LEFT_CONTROL_PRESSED;
+ }
+ if (Private->RightCtrl) {
+ KeyState->KeyShiftState |= EFI_RIGHT_CONTROL_PRESSED;
+ }
+ if (Private->LeftAlt) {
+ KeyState->KeyShiftState |= EFI_LEFT_ALT_PRESSED;
+ }
+ if (Private->RightAlt) {
+ KeyState->KeyShiftState |= EFI_RIGHT_ALT_PRESSED;
+ }
+ if (Private->LeftShift) {
+ KeyState->KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;
+ }
+ if (Private->RightShift) {
+ KeyState->KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED;
+ }
+ if (Private->LeftLogo) {
+ KeyState->KeyShiftState |= EFI_LEFT_LOGO_PRESSED;
+ }
+ if (Private->RightLogo) {
+ KeyState->KeyShiftState |= EFI_RIGHT_LOGO_PRESSED;
+ }
+ if (Private->Menu) {
+ KeyState->KeyShiftState |= EFI_MENU_KEY_PRESSED;
+ }
+ if (Private->SysReq) {
+ KeyState->KeyShiftState |= EFI_SYS_REQ_PRESSED;
+ }
+ if (Private->CapsLock) {
+ KeyState->KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;
+ }
+ if (Private->NumLock) {
+ KeyState->KeyToggleState |= EFI_NUM_LOCK_ACTIVE;
+ }
+ if (Private->ScrollLock) {
+ KeyState->KeyToggleState |= EFI_SCROLL_LOCK_ACTIVE;
+ }
+ if (Private->IsPartialKeySupport) {
+ KeyState->KeyToggleState |= EFI_KEY_STATE_EXPOSED;
+ }
+}
+
+/**
+ TODO: Add function description
+
+ @param Private TODO: add argument description
+ @param Key TODO: add argument description
+
+ @retval EFI_NOT_READY TODO: Add description for return value
+ @retval EFI_SUCCESS TODO: Add description for return value
+
+**/
+EFI_STATUS
+GopPrivateAddKey (
+ IN GRAPHICS_PRIVATE_DATA *Private,
+ IN EFI_INPUT_KEY Key
+ )
+{
+ EFI_KEY_DATA KeyData;
+
+ KeyData.Key = Key;
+ InitializeKeyState (Private, &KeyData.KeyState);
+
+ //
+ // Convert Ctrl+[1-26] to Ctrl+[A-Z]
+ //
+ if ((Private->LeftCtrl || Private->RightCtrl) &&
+ (KeyData.Key.UnicodeChar >= 1) && (KeyData.Key.UnicodeChar <= 26)
+ ) {
+ if ((Private->LeftShift || Private->RightShift) == Private->CapsLock) {
+ KeyData.Key.UnicodeChar = (CHAR16)(KeyData.Key.UnicodeChar + L'a' - 1);
+ } else {
+ KeyData.Key.UnicodeChar = (CHAR16)(KeyData.Key.UnicodeChar + L'A' - 1);
+ }
+ }
+
+ //
+ // Unmask the Shift bit for printable char
+ //
+ if (((KeyData.Key.UnicodeChar >= L'a') && (KeyData.Key.UnicodeChar <= L'z')) ||
+ ((KeyData.Key.UnicodeChar >= L'A') && (KeyData.Key.UnicodeChar <= L'Z'))
+ ) {
+ KeyData.KeyState.KeyShiftState &= ~(EFI_LEFT_SHIFT_PRESSED | EFI_RIGHT_SHIFT_PRESSED);
+ }
+
+ GopPrivateAddQ (Private, &Private->QueueForRead, &KeyData);
+ if (Private->MakeRegisterdKeyCallback != NULL) {
+ Private->MakeRegisterdKeyCallback (Private->RegisterdKeyCallbackContext, &KeyData);
+ }
+
+ return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+EFIAPI
+WinNtWndCheckKey (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
+ )
+{
+ GRAPHICS_PRIVATE_DATA *Private;
+
+ Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
+
+ return GopPrivateCheckQ (&Private->QueueForRead);
+
+}
+EFI_STATUS
+EFIAPI
+WinNtWndGetKey (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
+ IN 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:
+ Private - The private structure of WinNt Gop device.
+ 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;
+ GRAPHICS_PRIVATE_DATA *Private;
+
+ Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
+
+ ZeroMem (&KeyData->Key, sizeof (KeyData->Key));
+ InitializeKeyState (Private, &KeyData->KeyState);
+
+ Status = GopPrivateCheckQ (&Private->QueueForRead);
+ if (!EFI_ERROR (Status)) {
+ //
+ // If a Key press exists try and read it.
+ //
+ Status = GopPrivateDeleteQ (Private, &Private->QueueForRead, KeyData);
+ if (!EFI_ERROR (Status)) {
+ //
+ // If partial keystroke is not enabled, check whether it is value key. If not return
+ // EFI_NOT_READY.
+ //
+ if (!Private->IsPartialKeySupport) {
+ if (KeyData->Key.ScanCode == SCAN_NULL && KeyData->Key.UnicodeChar == CHAR_NULL) {
+ Status = EFI_NOT_READY;
+ }
+ }
+ }
+ }
+
+ return Status;
+
+}
+
+EFI_STATUS
+EFIAPI
+WinNtWndKeySetState (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
+ IN EFI_KEY_TOGGLE_STATE *KeyToggleState
+ )
+{
+ GRAPHICS_PRIVATE_DATA *Private;
+
+ Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
+ Private->KeyState.KeyToggleState = *KeyToggleState;
+ return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+EFIAPI
+WinNtWndRegisterKeyNotify (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
+ IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK MakeCallBack,
+ IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK BreakCallBack,
+ IN VOID *Context
+ )
+{
+ GRAPHICS_PRIVATE_DATA *Private;
+
+ Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
+
+ Private->MakeRegisterdKeyCallback = MakeCallBack;
+ Private->BreakRegisterdKeyCallback = BreakCallBack;
+ Private->RegisterdKeyCallbackContext = Context;
+
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+EFIAPI
+WinNtWndCheckPointer (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
+ )
+{
+ GRAPHICS_PRIVATE_DATA *Private;
+
+ Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
+
+ return EFI_NOT_READY;
+}
+
+
+EFI_STATUS
+EFIAPI
+WinNtWndGetPointerState (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
+ IN EFI_SIMPLE_POINTER_STATE *State
+ )
+{
+ GRAPHICS_PRIVATE_DATA *Private;
+
+ Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
+
+ return EFI_NOT_READY;
+}
diff --git a/EmulatorPkg/Win/Host/WinGopScreen.c b/EmulatorPkg/Win/Host/WinGopScreen.c new file mode 100644 index 0000000..2ca51d2 --- /dev/null +++ b/EmulatorPkg/Win/Host/WinGopScreen.c @@ -0,0 +1,872 @@ +/** @file
+
+Copyright (c) 2006 - 2013, Intel Corporation. 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:
+
+ WinGopScreen.c
+
+Abstract:
+
+ This file produces the graphics abstration of GOP. It is called by
+ WinNtGopDriver.c file which deals with the UEFI 2.0 driver model.
+ This file just does graphics.
+
+
+**/
+
+#include "WinGop.h"
+
+DWORD mTlsIndex = TLS_OUT_OF_INDEXES;
+DWORD mTlsIndexUseCount = 0; // lets us know when we can free mTlsIndex.
+
+BOOLEAN
+WinNtGopConvertParamToEfiKeyShiftState (
+ IN GRAPHICS_PRIVATE_DATA *Private,
+ IN WPARAM *wParam,
+ IN LPARAM *lParam,
+ IN BOOLEAN Flag
+ )
+{
+ switch (*wParam) {
+ //
+ // BUGBUG: Only GetAsyncKeyState() and GetKeyState() can distinguish
+ // left and right Ctrl, and Shift key.
+ // Neither of the two is defined in EFI_WIN_NT_THUNK_PROTOCOL.
+ // Therefor, we can not set the correct Shift state here.
+ //
+ case VK_SHIFT:
+ if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
+ Private->RightShift = Flag;
+ } else {
+ Private->LeftShift = Flag;
+ }
+ return TRUE;
+
+ case VK_LSHIFT:
+ Private->LeftShift = Flag;
+ return TRUE;
+
+ case VK_RSHIFT:
+ Private->RightShift = Flag;
+ return TRUE;
+
+ case VK_CONTROL:
+ if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
+ Private->RightCtrl= Flag;
+ } else {
+ Private->LeftCtrl = Flag;
+ }
+ return TRUE;
+
+ case VK_LCONTROL:
+ Private->LeftCtrl = Flag;
+ return TRUE;
+
+ case VK_RCONTROL:
+ Private->RightCtrl = Flag;
+ return TRUE;
+
+ case VK_LWIN:
+ Private->LeftLogo = Flag;
+ return TRUE;
+
+ case VK_RWIN:
+ Private->RightLogo = Flag;
+ return TRUE;
+
+ case VK_APPS:
+ Private->Menu = Flag;
+ return TRUE;
+ //
+ // BUGBUG: PrintScreen/SysRq can not trigger WM_KEYDOWN message,
+ // so SySReq shift state is not supported here.
+ //
+ case VK_PRINT:
+ Private->SysReq = Flag;
+ return TRUE;
+ //
+ // For Alt Keystroke.
+ //
+ case VK_MENU:
+ if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
+ Private->RightAlt = Flag;
+ } else {
+ Private->LeftAlt = Flag;
+ }
+ return TRUE;
+
+ default:
+ return FALSE;
+ }
+}
+
+BOOLEAN
+WinNtGopConvertParamToEfiKey (
+ IN GRAPHICS_PRIVATE_DATA *Private,
+ IN WPARAM *wParam,
+ IN LPARAM *lParam,
+ IN EFI_INPUT_KEY *Key
+ )
+{
+ BOOLEAN Flag;
+ Flag = FALSE;
+ switch (*wParam) {
+ case VK_HOME: Key->ScanCode = SCAN_HOME; Flag = TRUE; break;
+ case VK_END: Key->ScanCode = SCAN_END; Flag = TRUE; break;
+ case VK_LEFT: Key->ScanCode = SCAN_LEFT; Flag = TRUE; break;
+ case VK_RIGHT: Key->ScanCode = SCAN_RIGHT; Flag = TRUE; break;
+ case VK_UP: Key->ScanCode = SCAN_UP; Flag = TRUE; break;
+ case VK_DOWN: Key->ScanCode = SCAN_DOWN; Flag = TRUE; break;
+ case VK_DELETE: Key->ScanCode = SCAN_DELETE; Flag = TRUE; break;
+ case VK_INSERT: Key->ScanCode = SCAN_INSERT; Flag = TRUE; break;
+ case VK_PRIOR: Key->ScanCode = SCAN_PAGE_UP; Flag = TRUE; break;
+ case VK_NEXT: Key->ScanCode = SCAN_PAGE_DOWN; Flag = TRUE; break;
+ case VK_ESCAPE: Key->ScanCode = SCAN_ESC; Flag = TRUE; break;
+
+ case VK_F1: Key->ScanCode = SCAN_F1; Flag = TRUE; break;
+ case VK_F2: Key->ScanCode = SCAN_F2; Flag = TRUE; break;
+ case VK_F3: Key->ScanCode = SCAN_F3; Flag = TRUE; break;
+ case VK_F4: Key->ScanCode = SCAN_F4; Flag = TRUE; break;
+ case VK_F5: Key->ScanCode = SCAN_F5; Flag = TRUE; break;
+ case VK_F6: Key->ScanCode = SCAN_F6; Flag = TRUE; break;
+ case VK_F7: Key->ScanCode = SCAN_F7; Flag = TRUE; break;
+ case VK_F8: Key->ScanCode = SCAN_F8; Flag = TRUE; break;
+ case VK_F9: Key->ScanCode = SCAN_F9; Flag = TRUE; break;
+ case VK_F11: Key->ScanCode = SCAN_F11; Flag = TRUE; break;
+ case VK_F12: Key->ScanCode = SCAN_F12; Flag = TRUE; break;
+
+ case VK_F13: Key->ScanCode = SCAN_F13; Flag = TRUE; break;
+ case VK_F14: Key->ScanCode = SCAN_F14; Flag = TRUE; break;
+ case VK_F15: Key->ScanCode = SCAN_F15; Flag = TRUE; break;
+ case VK_F16: Key->ScanCode = SCAN_F16; Flag = TRUE; break;
+ case VK_F17: Key->ScanCode = SCAN_F17; Flag = TRUE; break;
+ case VK_F18: Key->ScanCode = SCAN_F18; Flag = TRUE; break;
+ case VK_F19: Key->ScanCode = SCAN_F19; Flag = TRUE; break;
+ case VK_F20: Key->ScanCode = SCAN_F20; Flag = TRUE; break;
+ case VK_F21: Key->ScanCode = SCAN_F21; Flag = TRUE; break;
+ case VK_F22: Key->ScanCode = SCAN_F22; Flag = TRUE; break;
+ case VK_F23: Key->ScanCode = SCAN_F23; Flag = TRUE; break;
+ case VK_F24: Key->ScanCode = SCAN_F24; Flag = TRUE; break;
+ case VK_PAUSE: Key->ScanCode = SCAN_PAUSE; Flag = TRUE; break;
+
+ //
+ // Set toggle state
+ //
+ case VK_NUMLOCK:
+ Private->NumLock = (BOOLEAN)(!Private->NumLock);
+ Flag = TRUE;
+ break;
+ case VK_SCROLL:
+ Private->ScrollLock = (BOOLEAN)(!Private->ScrollLock);
+ Flag = TRUE;
+ break;
+ case VK_CAPITAL:
+ Private->CapsLock = (BOOLEAN)(!Private->CapsLock);
+ Flag = TRUE;
+ break;
+ }
+
+ return (WinNtGopConvertParamToEfiKeyShiftState (Private, wParam, lParam, TRUE)) == TRUE ? TRUE : Flag;
+}
+
+
+//
+// GOP Protocol Member Functions
+//
+
+/**
+ Change the resolution and resize of the window
+**/
+EFI_STATUS
+EFIAPI
+WinNtWndSize (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
+ IN UINT32 Width,
+ IN UINT32 Height
+)
+{
+ UINT32 Size;
+ GRAPHICS_PRIVATE_DATA *Private;
+ RECT Rect;
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL *NewFillLine;
+
+ Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
+ Private->Width = Width;
+ Private->Height = Height;
+
+
+ //
+ // Free the old buffer. We do not save the content of the old buffer since the
+ // screen is to be cleared anyway. Clearing the screen is required by the EFI spec.
+ // See UEFI spec -EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode()
+ //
+ if (Private->VirtualScreenInfo != NULL) {
+ HeapFree (GetProcessHeap (), 0, Private->VirtualScreenInfo);
+ }
+
+ //
+ // Allocate DIB frame buffer directly from NT for performance enhancement
+ // This buffer is the virtual screen/frame buffer. This buffer is not the
+ // same a a frame buffer. The first row of this buffer will be the bottom
+ // line of the image. This is an artifact of the way we draw to the screen.
+ //
+ Size = Private->Width * Private->Height * sizeof (RGBQUAD) + sizeof (BITMAPV4HEADER);
+ Private->VirtualScreenInfo = HeapAlloc (
+ GetProcessHeap (),
+ HEAP_ZERO_MEMORY,
+ Size
+ );
+
+ //
+ // Update the virtual screen info data structure
+ //
+ Private->VirtualScreenInfo->bV4Size = sizeof (BITMAPV4HEADER);
+ Private->VirtualScreenInfo->bV4Width = Private->Width;
+ Private->VirtualScreenInfo->bV4Height = Private->Height;
+ Private->VirtualScreenInfo->bV4Planes = 1;
+ Private->VirtualScreenInfo->bV4BitCount = 32;
+ //
+ // uncompressed
+ //
+ Private->VirtualScreenInfo->bV4V4Compression = BI_RGB;
+
+ //
+ // The rest of the allocated memory block is the virtual screen buffer
+ //
+ Private->VirtualScreen = (RGBQUAD *)(Private->VirtualScreenInfo + 1);
+
+ //
+ // Use the AdjuctWindowRect fuction to calculate the real width and height
+ // of the new window including the border and caption
+ //
+ Rect.left = 0;
+ Rect.top = 0;
+ Rect.right = Private->Width;
+ Rect.bottom = Private->Height;
+
+ AdjustWindowRect (&Rect, WS_OVERLAPPEDWINDOW, 0);
+
+ Width = Rect.right - Rect.left;
+ Height = Rect.bottom - Rect.top;
+
+ //
+ // Retrieve the original window position information
+ //
+ GetWindowRect (Private->WindowHandle, &Rect);
+
+ //
+ // Adjust the window size
+ //
+ MoveWindow (Private->WindowHandle, Rect.left, Rect.top, (INT32)Width, (INT32)Height, TRUE);
+
+ NewFillLine = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * Private->Width);
+ if (NewFillLine == NULL) {
+ return EFI_DEVICE_ERROR;
+ }
+
+ if (Private->FillLine != NULL) {
+ FreePool (Private->FillLine);
+ }
+
+ Private->FillLine = NewFillLine;
+ return EFI_SUCCESS;
+}
+
+/**
+ Blt pixels from the rectangle (Width X Height) formed by the BltBuffer
+ onto the graphics screen starting a location (X, Y). (0, 0) is defined as
+ the upper left hand side of the screen. (X, Y) can be outside of the
+ current screen geometry and the BltBuffer will be cliped when it is
+ displayed. X and Y can be negative or positive. If Width or Height is
+ bigger than the current video screen the image will be clipped.
+
+ @param This Protocol instance pointer.
+ @param X X location on graphics screen.
+ @param Y Y location on the graphics screen.
+ @param Width Width of BltBuffer.
+ @param Height Hight of BltBuffer
+ @param BltOperation Operation to perform on BltBuffer and video memory
+ @param BltBuffer Buffer containing data to blt into video buffer.
+ This buffer has a size of
+ Width*Height*sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
+ @param SourceX If the BltOperation is a EfiCopyBlt this is the
+ source of the copy. For other BLT operations this
+ argument is not used.
+ @param SourceX If the BltOperation is a EfiCopyBlt this is the
+ source of the copy. For other BLT operations this
+ argument is not used.
+
+ @retval EFI_SUCCESS The palette is updated with PaletteArray.
+ @retval EFI_INVALID_PARAMETER BltOperation is not valid.
+ @retval EFI_DEVICE_ERROR A hardware error occured writting to the video
+ buffer.
+
+**/
+// TODO: SourceY - add argument and description to function comment
+// TODO: DestinationX - add argument and description to function comment
+// TODO: DestinationY - add argument and description to function comment
+// TODO: Delta - add argument and description to function comment
+EFI_STATUS
+WinNtWndBlt (
+ IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
+ IN EFI_UGA_PIXEL *BltBuffer OPTIONAL,
+ IN EFI_UGA_BLT_OPERATION BltOperation,
+ IN EMU_GRAPHICS_WINDOWS__BLT_ARGS *Args
+)
+{
+ GRAPHICS_PRIVATE_DATA *Private;
+ UINTN DstY;
+ UINTN SrcY;
+ RGBQUAD *VScreen;
+ RGBQUAD *VScreenSrc;
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
+ UINTN Index;
+ RECT Rect;
+ EFI_GRAPHICS_OUTPUT_BLT_PIXEL *FillPixel;
+ UINT32 VerticalResolution;
+ UINT32 HorizontalResolution;
+
+ Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
+
+ //
+ // We need to fill the Virtual Screen buffer with the blt data.
+ // The virtual screen is upside down, as the first row is the bootom row of
+ // the image.
+ //
+ VerticalResolution = Private->VirtualScreenInfo->bV4Height;
+ HorizontalResolution = Private->VirtualScreenInfo->bV4Width;
+ if (BltOperation == EfiBltVideoToBltBuffer) {
+
+ for (SrcY = Args->SourceY, DstY = Args->DestinationY; DstY < (Args->Height + Args->DestinationY); SrcY++, DstY++) {
+ Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) ((UINT8 *) BltBuffer + (DstY * Args->Delta) + Args->DestinationX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+ VScreen = &Private->VirtualScreen[(VerticalResolution - SrcY - 1) * HorizontalResolution + Args->SourceX];
+ CopyMem (Blt, VScreen, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * Args->Width);
+ }
+ } else {
+ if (BltOperation == EfiBltVideoFill) {
+ FillPixel = BltBuffer;
+ for (Index = 0; Index < Args->Width; Index++) {
+ Private->FillLine[Index] = *FillPixel;
+ }
+ }
+
+ for (Index = 0; Index < Args->Height; Index++) {
+ if (Args->DestinationY <= Args->SourceY) {
+ SrcY = Args->SourceY + Index;
+ DstY = Args->DestinationY + Index;
+ } else {
+ SrcY = Args->SourceY + Args->Height - Index - 1;
+ DstY = Args->DestinationY + Args->Height - Index - 1;
+ }
+
+ VScreen = &Private->VirtualScreen[(VerticalResolution - DstY - 1) * HorizontalResolution + Args->DestinationX];
+ switch (BltOperation) {
+ case EfiBltBufferToVideo:
+ Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) ((UINT8 *) BltBuffer + (SrcY * Args->Delta) + Args->SourceX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+ CopyMem (VScreen, Blt, Args->Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+ break;
+
+ case EfiBltVideoToVideo:
+ VScreenSrc = &Private->VirtualScreen[(VerticalResolution - SrcY - 1) * HorizontalResolution + Args->SourceX];
+ CopyMem (VScreen, VScreenSrc, Args->Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+ break;
+
+ case EfiBltVideoFill:
+ CopyMem (VScreen, Private->FillLine, Args->Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+ break;
+ }
+ }
+ }
+
+ if (BltOperation != EfiBltVideoToBltBuffer) {
+ //
+ // Mark the area we just blted as Invalid so WM_PAINT will update.
+ //
+ Rect.left = (LONG)Args->DestinationX;
+ Rect.top = (LONG)Args->DestinationY;
+ Rect.right = (LONG)(Args->DestinationX + Args->Width);
+ Rect.bottom = (LONG)(Args->DestinationY + Args->Height);
+ InvalidateRect (Private->WindowHandle, &Rect, FALSE);
+
+ //
+ // Send the WM_PAINT message to the thread that is drawing the window. We
+ // are in the main thread and the window drawing is in a child thread.
+ // There is a child thread per window. We have no CriticalSection or Mutex
+ // since we write the data and the other thread displays the data. While
+ // we may miss some data for a short period of time this is no different than
+ // a write combining on writes to a frame buffer.
+ //
+
+ UpdateWindow (Private->WindowHandle);
+ }
+
+ return EFI_SUCCESS;
+}
+
+
+
+/**
+ Win32 Windows event handler.
+
+ See Win32 Book
+
+ @return See Win32 Book
+
+**/
+// TODO: hwnd - add argument and description to function comment
+// TODO: iMsg - add argument and description to function comment
+// TODO: wParam - add argument and description to function comment
+// TODO: lParam - add argument and description to function comment
+LRESULT
+CALLBACK
+WinNtGopThreadWindowProc (
+ IN HWND hwnd,
+ IN UINT iMsg,
+ IN WPARAM wParam,
+ IN LPARAM lParam
+ )
+{
+ GRAPHICS_PRIVATE_DATA *Private;
+ UINTN Size;
+ HDC Handle;
+ PAINTSTRUCT PaintStruct;
+ LPARAM Index;
+ EFI_INPUT_KEY Key;
+ BOOLEAN AltIsPress;
+
+ //
+ // BugBug - if there are two instances of this DLL in memory (such as is
+ // the case for ERM), the correct instance of this function may not be called.
+ // This also means that the address of the mTlsIndex value will be wrong, and
+ // the value may be wrong too.
+ //
+
+
+ //
+ // Use mTlsIndex global to get a Thread Local Storage version of Private.
+ // This works since each Gop protocol has a unique Private data instance and
+ // a unique thread.
+ //
+ AltIsPress = FALSE;
+ Private = TlsGetValue (mTlsIndex);
+ ASSERT (NULL != Private);
+
+ switch (iMsg) {
+ case WM_CREATE:
+ Size = Private->Width * Private->Height * sizeof (RGBQUAD);
+
+ //
+ // Allocate DIB frame buffer directly from NT for performance enhancement
+ // This buffer is the virtual screen/frame buffer. This buffer is not the
+ // same a a frame buffer. The first fow of this buffer will be the bottom
+ // line of the image. This is an artifact of the way we draw to the screen.
+ //
+ Private->VirtualScreenInfo = HeapAlloc (
+ GetProcessHeap (),
+ HEAP_ZERO_MEMORY,
+ Size
+ );
+
+ Private->VirtualScreenInfo->bV4Size = sizeof (BITMAPV4HEADER);
+ Private->VirtualScreenInfo->bV4Width = Private->Width;
+ Private->VirtualScreenInfo->bV4Height = Private->Height;
+ Private->VirtualScreenInfo->bV4Planes = 1;
+ Private->VirtualScreenInfo->bV4BitCount = 32;
+ //
+ // uncompressed
+ //
+ Private->VirtualScreenInfo->bV4V4Compression = BI_RGB;
+ Private->VirtualScreen = (RGBQUAD *) (Private->VirtualScreenInfo + 1);
+ return 0;
+
+ case WM_PAINT:
+ //
+ // I have not found a way to convert hwnd into a Private context. So for
+ // now we use this API to convert hwnd to Private data.
+ //
+
+ Handle = BeginPaint (hwnd, &PaintStruct);
+
+ SetDIBitsToDevice (
+ Handle, // Destination Device Context
+ 0, // Destination X - 0
+ 0, // Destination Y - 0
+ Private->Width, // Width
+ Private->Height, // Height
+ 0, // Source X
+ 0, // Source Y
+ 0, // DIB Start Scan Line
+ Private->Height, // Number of scan lines
+ Private->VirtualScreen, // Address of array of DIB bits
+ (BITMAPINFO *) Private->VirtualScreenInfo, // Address of structure with bitmap info
+ DIB_RGB_COLORS // RGB or palette indexes
+ );
+
+ EndPaint (hwnd, &PaintStruct);
+ return 0;
+
+ //
+ // F10 and the ALT key do not create a WM_KEYDOWN message, thus this special case
+ // WM_SYSKEYDOWN is posted when F10 is pressed or
+ // holds down ALT key and then presses another key.
+ //
+ case WM_SYSKEYDOWN:
+
+ Key.ScanCode = 0;
+ Key.UnicodeChar = CHAR_NULL;
+ switch (wParam) {
+ case VK_F10:
+ Key.ScanCode = SCAN_F10;
+ Key.UnicodeChar = CHAR_NULL;
+ GopPrivateAddKey (Private, Key);
+ return 0;
+ }
+
+ //
+ // If ALT or ALT + modifier key is pressed.
+ //
+ if (WinNtGopConvertParamToEfiKey (Private, &wParam, &lParam, &Key)) {
+ if (Key.ScanCode != 0){
+ //
+ // If ALT is pressed with other ScanCode.
+ // Always revers the left Alt for simple.
+ //
+ Private->LeftAlt = TRUE;
+ }
+ GopPrivateAddKey (Private, Key);
+ //
+ // When Alt is released there is no windoes message, so
+ // clean it after using it.
+ //
+ Private->RightAlt = FALSE;
+ Private->LeftAlt = FALSE;
+ return 0;
+ }
+ AltIsPress = TRUE;
+
+ case WM_CHAR:
+ //
+ // The ESC key also generate WM_CHAR.
+ //
+ if (wParam == 0x1B) {
+ return 0;
+ }
+
+ if (AltIsPress == TRUE) {
+ //
+ // If AltIsPress is true that means the Alt key is pressed.
+ //
+ Private->LeftAlt = TRUE;
+ }
+ for (Index = 0; Index < (lParam & 0xffff); Index++) {
+ if (wParam != 0) {
+ Key.UnicodeChar = (CHAR16) wParam;
+ Key.ScanCode = SCAN_NULL;
+ GopPrivateAddKey (Private, Key);
+ }
+ }
+ if (AltIsPress == TRUE) {
+ //
+ // When Alt is released there is no windoes message, so
+ // clean it after using it.
+ //
+ Private->LeftAlt = FALSE;
+ Private->RightAlt = FALSE;
+ }
+ return 0;
+
+ case WM_SYSKEYUP:
+ //
+ // ALT is pressed with another key released
+ //
+ WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, &lParam, FALSE);
+ return 0;
+
+ case WM_KEYDOWN:
+ Key.ScanCode = SCAN_NULL;
+ Key.UnicodeChar = CHAR_NULL;
+ //
+ // A value key press will cause a WM_KEYDOWN first, then cause a WM_CHAR
+ // So if there is no modifier key updated, skip the WM_KEYDOWN even.
+ //
+ if (WinNtGopConvertParamToEfiKey (Private, &wParam, &lParam, &Key)) {
+ //
+ // Support the partial keystroke, add all keydown event into the queue.
+ //
+ GopPrivateAddKey (Private, Key);
+ }
+ return 0;
+
+ case WM_KEYUP:
+ WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, &lParam, FALSE);
+ return 0;
+
+ case WM_CLOSE:
+ //
+ // This close message is issued by user, core is not aware of this,
+ // so don't release the window display resource, just hide the window.
+ //
+ ShowWindow (Private->WindowHandle, SW_HIDE);
+ return 0;
+
+ case WM_DESTROY:
+ DestroyWindow (hwnd);
+ PostQuitMessage (0);
+
+ HeapFree (GetProcessHeap (), 0, Private->VirtualScreenInfo);
+
+ ExitThread (0);
+
+ default:
+ break;
+ };
+
+ return DefWindowProc (hwnd, iMsg, wParam, lParam);
+}
+
+
+/**
+ This thread simulates the end of WinMain () aplication. Each Winow nededs
+ to process it's events. The messages are dispatched to
+ WinNtGopThreadWindowProc ().
+ Be very careful sine WinNtGopThreadWinMain () and WinNtGopThreadWindowProc ()
+ are running in a seperate thread. We have to do this to process the events.
+
+ @param lpParameter Handle of window to manage.
+
+ @return if a WM_QUIT message is returned exit.
+
+**/
+DWORD
+WINAPI
+WinNtGopThreadWinMain (
+ LPVOID lpParameter
+ )
+{
+ MSG Message;
+ GRAPHICS_PRIVATE_DATA *Private;
+ RECT Rect;
+
+ Private = (GRAPHICS_PRIVATE_DATA *) lpParameter;
+ ASSERT (NULL != Private);
+
+ //
+ // Since each thread has unique private data, save the private data in Thread
+ // Local Storage slot. Then the shared global mTlsIndex can be used to get
+ // thread specific context.
+ //
+ TlsSetValue (mTlsIndex, Private);
+
+ Private->ThreadId = GetCurrentThreadId ();
+
+ Private->WindowsClass.cbSize = sizeof (WNDCLASSEX);
+ Private->WindowsClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
+ Private->WindowsClass.lpfnWndProc = WinNtGopThreadWindowProc;
+ Private->WindowsClass.cbClsExtra = 0;
+ Private->WindowsClass.cbWndExtra = 0;
+ Private->WindowsClass.hInstance = NULL;
+ Private->WindowsClass.hIcon = LoadIcon (NULL, IDI_APPLICATION);
+ Private->WindowsClass.hCursor = LoadCursor (NULL, IDC_ARROW);
+ Private->WindowsClass.hbrBackground = (HBRUSH)(UINTN)COLOR_WINDOW;
+ Private->WindowsClass.lpszMenuName = NULL;
+ Private->WindowsClass.lpszClassName = WIN_NT_GOP_CLASS_NAME;
+ Private->WindowsClass.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
+
+ //
+ // Use 100 x 100 as initial Window size.
+ //
+ Private->Width = 100;
+ Private->Height = 100;
+
+
+ //
+ // This call will fail after the first time, but thats O.K. since we only need
+ // WIN_NT_GOP_CLASS_NAME to exist to create the window.
+ //
+ // Note: Multiple instances of this DLL will use the same instance of this
+ // Class, including the callback function, unless the Class is unregistered and
+ // successfully registered again.
+ //
+ RegisterClassEx (&Private->WindowsClass);
+
+ //
+ // Setting Rect values to allow for the AdjustWindowRect to provide
+ // us the correct sizes for the client area when doing the CreateWindowEx
+ //
+ Rect.top = 0;
+ Rect.bottom = Private->Height;
+ Rect.left = 0;
+ Rect.right = Private->Width;
+
+ AdjustWindowRect (&Rect, WS_OVERLAPPEDWINDOW, 0);
+
+ Private->WindowHandle = CreateWindowEx (
+ 0,
+ WIN_NT_GOP_CLASS_NAME,
+ Private->WindowName,
+ WS_OVERLAPPEDWINDOW,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ Rect.right - Rect.left,
+ Rect.bottom - Rect.top,
+ NULL,
+ NULL,
+ NULL,
+ (VOID **)&Private
+ );
+
+ //
+ // The reset of this thread is the standard winows program. We need a sperate
+ // thread since we must process the message loop to make windows act like
+ // windows.
+ //
+
+ ShowWindow (Private->WindowHandle, SW_SHOW);
+ UpdateWindow (Private->WindowHandle);
+
+ //
+ // Let the main thread get some work done
+ //
+ ReleaseSemaphore (Private->ThreadInited, 1, NULL);
+
+ //
+ // This is the message loop that all Windows programs need.
+ //
+ while (GetMessage (&Message, Private->WindowHandle, 0, 0)) {
+ TranslateMessage (&Message);
+ DispatchMessage (&Message);
+ }
+
+ return (DWORD)Message.wParam;
+}
+
+
+/**
+ TODO: Add function description
+
+ @param Private TODO: add argument description
+ @param HorizontalResolution TODO: add argument description
+ @param VerticalResolution TODO: add argument description
+ @param ColorDepth TODO: add argument description
+ @param RefreshRate TODO: add argument description
+
+ @return TODO: add return values
+
+**/
+EFI_STATUS
+EFIAPI
+WinNtGraphicsWindowOpen (
+ IN EMU_IO_THUNK_PROTOCOL *This
+ )
+{
+ DWORD NewThreadId;
+ GRAPHICS_PRIVATE_DATA *Private;
+
+ Private = AllocateZeroPool (sizeof (*Private));
+
+ GopPrivateCreateQ (Private, &Private->QueueForRead);
+
+ Private->GraphicsWindowIo.Size = WinNtWndSize;
+ Private->GraphicsWindowIo.CheckKey = WinNtWndCheckKey;
+ Private->GraphicsWindowIo.GetKey = WinNtWndGetKey;
+ Private->GraphicsWindowIo.KeySetState = WinNtWndKeySetState;
+ Private->GraphicsWindowIo.RegisterKeyNotify = WinNtWndRegisterKeyNotify;
+ Private->GraphicsWindowIo.Blt = WinNtWndBlt;
+ Private->GraphicsWindowIo.CheckPointer = WinNtWndCheckPointer;
+ Private->GraphicsWindowIo.GetPointerState = WinNtWndGetPointerState;
+
+ Private->WindowName = This->ConfigString;
+ //
+ // Initialize a Thread Local Storge variable slot. We use TLS to get the
+ // correct Private data instance into the windows thread.
+ //
+ if (mTlsIndex == TLS_OUT_OF_INDEXES) {
+ ASSERT (0 == mTlsIndexUseCount);
+ mTlsIndex = TlsAlloc ();
+ }
+
+ //
+ // always increase the use count!
+ //
+ mTlsIndexUseCount++;
+
+ Private->ThreadInited = CreateSemaphore (NULL, 0, 1, NULL);
+ Private->ThreadHandle = CreateThread (
+ NULL,
+ 0,
+ WinNtGopThreadWinMain,
+ (VOID *) Private,
+ 0,
+ &NewThreadId
+ );
+
+ //
+ // The other thread has entered the windows message loop so we can
+ // continue our initialization.
+ //
+ WaitForSingleObject (Private->ThreadInited, INFINITE);
+ CloseHandle (Private->ThreadInited);
+
+ This->Private = Private;
+ This->Interface = &Private->GraphicsWindowIo;
+
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+EFIAPI
+WinNtGraphicsWindowClose (
+ IN EMU_IO_THUNK_PROTOCOL *This
+)
+{
+ GRAPHICS_PRIVATE_DATA *Private;
+
+ Private = (GRAPHICS_PRIVATE_DATA *)This->Private;
+
+ //
+ // BugBug: Shutdown GOP Hardware and any child devices.
+ //
+ SendMessage (Private->WindowHandle, WM_DESTROY, 0, 0);
+ CloseHandle (Private->ThreadHandle);
+
+ mTlsIndexUseCount--;
+
+ //
+ // The callback function for another window could still be called,
+ // so we need to make sure there are no more users of mTlsIndex.
+ //
+ if (0 == mTlsIndexUseCount) {
+ ASSERT (TLS_OUT_OF_INDEXES != mTlsIndex);
+
+ TlsFree (mTlsIndex);
+ mTlsIndex = TLS_OUT_OF_INDEXES;
+
+ UnregisterClass (
+ Private->WindowsClass.lpszClassName,
+ Private->WindowsClass.hInstance
+ );
+ }
+
+
+ GopPrivateDestroyQ (Private, &Private->QueueForRead);
+ return EFI_SUCCESS;
+}
+
+
+EMU_IO_THUNK_PROTOCOL mWinNtWndThunkIo = {
+ &gEmuGraphicsWindowProtocolGuid,
+ NULL,
+ NULL,
+ 0,
+ WinNtGraphicsWindowOpen,
+ WinNtGraphicsWindowClose,
+ NULL
+};
diff --git a/EmulatorPkg/Win/Host/WinHost.c b/EmulatorPkg/Win/Host/WinHost.c index 22399f1..f8d21d2 100644 --- a/EmulatorPkg/Win/Host/WinHost.c +++ b/EmulatorPkg/Win/Host/WinHost.c @@ -425,6 +425,11 @@ Returns: AddThunkPpi (EFI_PEI_PPI_DESCRIPTOR_PPI, &gEmuThunkPpiGuid, &mSecEmuThunkPpi);
//
+ // Emulator Bus Driver Thunks
+ //
+ AddThunkProtocol (&mWinNtWndThunkIo, (CHAR16 *)PcdGetPtr (PcdEmuGop), TRUE);
+
+ //
// Allocate space for gSystemMemory Array
//
gSystemMemoryCount = CountSeparatorsInString (MemorySizeStr, '!') + 1;
diff --git a/EmulatorPkg/Win/Host/WinHost.h b/EmulatorPkg/Win/Host/WinHost.h index c73ba17..3dc6a7e 100644 --- a/EmulatorPkg/Win/Host/WinHost.h +++ b/EmulatorPkg/Win/Host/WinHost.h @@ -197,4 +197,5 @@ SecInitializeThunk ( VOID
);
extern EMU_THUNK_PROTOCOL gEmuThunkProtocol;
+extern EMU_IO_THUNK_PROTOCOL mWinNtWndThunkIo;
#endif
\ No newline at end of file diff --git a/EmulatorPkg/Win/Host/WinHost.inf b/EmulatorPkg/Win/Host/WinHost.inf index 544e775..b62791b 100644 --- a/EmulatorPkg/Win/Host/WinHost.inf +++ b/EmulatorPkg/Win/Host/WinHost.inf @@ -30,6 +30,9 @@ [Sources]
WinMemoryAllocationLib.c
+ WinGopInput.c
+ WinGopScreen.c
+ WinGop.h
WinThunk.c
WinHost.h
WinHost.c
@@ -55,6 +58,9 @@ [Ppis]
gEmuThunkPpiGuid
+[Protocols]
+ gEmuIoThunkProtocolGuid
+ gEmuGraphicsWindowProtocolGuid
[Pcd]
gEfiMdeModulePkgTokenSpaceGuid.PcdInitValueInTempStack
@@ -62,6 +68,7 @@ gEmulatorPkgTokenSpaceGuid.PcdEmuFirmwareVolume
gEmulatorPkgTokenSpaceGuid.PcdEmuMemorySize
gEmulatorPkgTokenSpaceGuid.PcdEmuFdBaseAddress
+ gEmulatorPkgTokenSpaceGuid.PcdEmuGop|L"GOP Window"
gEmulatorPkgTokenSpaceGuid.PcdPeiServicesTablePage
[BuildOptions]
|