1. Add Partial Keystroke Support in Nt32 WinNTGopDxe driver. See the Uefi2.3.1a chapter 11.2

2. Fix the bug of "NT32 Keyboard driver don't support the ALT+ValueKey".

Signed-off-by: qianouyang
Reviewed-by: niruiyu vanjeff


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

3 files changed, 343 insertions, 240 deletions

diff --git a/Nt32Pkg/WinNtGopDxe/WinNtGop.h b/Nt32Pkg/WinNtGopDxe/WinNtGop.h
index 3490de06ca..dd53591041 100644
--- a/Nt32Pkg/WinNtGopDxe/WinNtGop.h
+++ b/Nt32Pkg/WinNtGopDxe/WinNtGop.h
@@ -46,13 +46,13 @@ Abstract:
 //

 // 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. 

+// 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 

+// 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)

@@ -132,7 +132,7 @@ typedef struct {
   EFI_GRAPHICS_OUTPUT_BLT_PIXEL *FillLine;

 

   //

-  // Keyboard Queue used by Simple Text In. 

+  // Keyboard Queue used by Simple Text In.

   // QueueForRead:   WinProc thread adds, and main thread removes.

   // QueueForNotify: WinProc thread adds, and timer thread removes.

   //

@@ -143,7 +143,7 @@ typedef struct {
   EFI_KEY_STATE                     KeyState;

   LIST_ENTRY                        NotifyList;

   BOOLEAN                           LeftShift;

-  BOOLEAN                           RightShift;  

+  BOOLEAN                           RightShift;

   BOOLEAN                           LeftAlt;

   BOOLEAN                           RightAlt;

   BOOLEAN                           LeftCtrl;

@@ -151,10 +151,11 @@ typedef struct {
   BOOLEAN                           LeftLogo;

   BOOLEAN                           RightLogo;

   BOOLEAN                           Menu;

-  BOOLEAN                           SysReq;  

+  BOOLEAN                           SysReq;

   BOOLEAN                           NumLock;

   BOOLEAN                           ScrollLock;

   BOOLEAN                           CapsLock;

+  BOOLEAN                           IsPartialKeySupport;

   EFI_EVENT                         TimerEvent;

 } GOP_PRIVATE_DATA;

 

diff --git a/Nt32Pkg/WinNtGopDxe/WinNtGopInput.c b/Nt32Pkg/WinNtGopDxe/WinNtGopInput.c
index 5defc1601c..cc05a5d1b8 100644
--- a/Nt32Pkg/WinNtGopDxe/WinNtGopInput.c
+++ b/Nt32Pkg/WinNtGopDxe/WinNtGopInput.c
@@ -133,6 +133,16 @@ GopPrivateDeleteQ (
   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.

+      //

+      Private->WinNtThunk->LeaveCriticalSection (&Queue->Cs);

+      ZeroMem (Key, sizeof (EFI_KEY_DATA));

+      return EFI_NOT_READY;

+    }

+  }

   Private->WinNtThunk->LeaveCriticalSection (&Queue->Cs);

   return EFI_SUCCESS;

 }

@@ -170,36 +180,36 @@ Routine Description:
 

 Arguments:

 

-  RegsiteredData    - A pointer to a buffer that is filled in with the keystroke 

+  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 

+  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. 

-  

+  FLASE             - Match failed.

+

 --*/

 {

   ASSERT (RegsiteredData != NULL && InputData != NULL);

-  

+

   if ((RegsiteredData->Key.ScanCode    != InputData->Key.ScanCode) ||

       (RegsiteredData->Key.UnicodeChar != InputData->Key.UnicodeChar)) {

-    return FALSE;  

-  }      

-  

+    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;    

-  }   

+    return FALSE;

+  }

   if (RegsiteredData->KeyState.KeyToggleState != 0 &&

       RegsiteredData->KeyState.KeyToggleState != InputData->KeyState.KeyToggleState) {

-    return FALSE;    

-  }     

-  

+    return FALSE;

+  }

+

   return TRUE;

 

 }

@@ -219,29 +229,29 @@ Routine Description:
 Arguments:

 

   Private       - The private structure of WinNt Gop device.

-  KeyData       - A pointer to a buffer that is filled in with the keystroke 

+  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 status light is updated successfully.

 

---*/  

-{ 

+--*/

+{

   LIST_ENTRY                          *Link;

   WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY  *CurrentNotify;

-  

+

   for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) {

     CurrentNotify = CR (

-                      Link, 

-                      WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY, 

-                      NotifyEntry, 

+                      Link,

+                      WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY,

+                      NotifyEntry,

                       WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE

                       );

     if (GopPrivateIsKeyRegistered (&CurrentNotify->KeyData, KeyData)) {

       CurrentNotify->KeyNotificationFn (KeyData);

     }

-  }    

+  }

 }

 

 VOID

@@ -299,7 +309,7 @@ GopPrivateAddKey (
   }

   if (Private->LeftShift) {

     KeyData.KeyState.KeyShiftState  |= EFI_LEFT_SHIFT_PRESSED;

-  }                                    

+  }

   if (Private->RightShift) {

     KeyData.KeyState.KeyShiftState  |= EFI_RIGHT_SHIFT_PRESSED;

   }

@@ -314,7 +324,7 @@ GopPrivateAddKey (
   }

   if (Private->SysReq) {

     KeyData.KeyState.KeyShiftState  |= EFI_SYS_REQ_PRESSED;

-  }  

+  }

   if (Private->CapsLock) {

     KeyData.KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;

   }

@@ -324,11 +334,14 @@ GopPrivateAddKey (
   if (Private->ScrollLock) {

     KeyData.KeyState.KeyToggleState |= EFI_SCROLL_LOCK_ACTIVE;

   }

-  

+  if (Private->IsPartialKeySupport) {

+    KeyData.KeyState.KeyToggleState |= EFI_KEY_STATE_EXPOSED;

+  }

+

   //

   // Convert Ctrl+[1-26] to Ctrl+[A-Z]

   //

-  if ((Private->LeftCtrl || Private->RightCtrl) && 

+  if ((Private->LeftCtrl || Private->RightCtrl) &&

       (KeyData.Key.UnicodeChar >= 1) && (KeyData.Key.UnicodeChar <= 26)

      ) {

     if ((Private->LeftShift || Private->RightShift) == Private->CapsLock) {

@@ -382,16 +395,16 @@ Returns:
 

   EFI_SUCCESS   - The status light is updated successfully.

 

---*/  

-{ 

+--*/

+{

   //

-  // BUGBUG:Only SendInput/keybd_event function can toggle 

+  // BUGBUG:Only SendInput/keybd_event function can toggle

   // NumLock, CapsLock and ScrollLock keys.

   // Neither of these functions is included in EFI_WIN_NT_THUNK_PROTOCOL.

   // Thus, return immediately without operation.

   //

   return EFI_SUCCESS;

-  

+

 }

 

 

@@ -441,11 +454,12 @@ Returns:
   Private->RightLogo               = FALSE;

   Private->Menu                    = FALSE;

   Private->SysReq                  = FALSE;

-  

+

   Private->CapsLock                = FALSE;

   Private->NumLock                 = FALSE;

   Private->ScrollLock              = FALSE;

- 

+  Private->IsPartialKeySupport     = FALSE;

+

   Private->KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID;

   Private->KeyState.KeyToggleState = EFI_TOGGLE_STATE_VALID;

 

@@ -465,25 +479,25 @@ GopPrivateReadKeyStrokeWorker (
 /*++

 

   Routine Description:

-    Reads the next keystroke from the input device. The WaitForKey Event can 

+    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 

+    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 

+    EFI_DEVICE_ERROR      - The keystroke information was not returned due to

                             hardware errors.

-    EFI_INVALID_PARAMETER - KeyData is NULL.                        

+    EFI_INVALID_PARAMETER - KeyData is NULL.

 

 --*/

 {

   EFI_STATUS                      Status;

-  EFI_TPL                         OldTpl;  

+  EFI_TPL                         OldTpl;

 

   if (KeyData == NULL) {

     return EFI_INVALID_PARAMETER;

@@ -507,10 +521,14 @@ GopPrivateReadKeyStrokeWorker (
     Status = GopPrivateDeleteQ (Private, &Private->QueueForRead, KeyData);

     if (!EFI_ERROR (Status)) {

       //

-      // Leave critical section and return

+      // If partial keystroke is not enabled, check whether it is value key. If not return

+      // EFI_NOT_READY.

       //

-      gBS->RestoreTPL (OldTpl);

-      return EFI_SUCCESS;

+      if (!Private->IsPartialKeySupport) {

+        if (KeyData->Key.ScanCode == SCAN_NULL && KeyData->Key.UnicodeChar == CHAR_NULL) {

+          Status = EFI_NOT_READY;

+        }

+      }

     }

   }

 

@@ -574,15 +592,22 @@ WinNtGopSimpleTextInReadKeyStroke (
   EFI_KEY_DATA      KeyData;

 

   Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This);

-

-  Status = GopPrivateReadKeyStrokeWorker (Private, &KeyData);

-  if (EFI_ERROR (Status)) {

-    return Status;

-  }

-

-  CopyMem (Key, &KeyData.Key, sizeof (EFI_INPUT_KEY));

-  

-  return EFI_SUCCESS;  

+  //

+  // Considering if the partial keystroke is enabled, there maybe a partial

+  // keystroke in the queue, so here skip the partial keystroke and get the

+  // next key from the queue

+  //

+  while (1) {

+    Status = GopPrivateReadKeyStrokeWorker (Private, &KeyData);

+    if (EFI_ERROR (Status)) {

+      return Status;

+    }

+    if (KeyData.Key.ScanCode == SCAN_NULL && KeyData.Key.UnicodeChar == CHAR_NULL) {

+      continue;

+    }

+    CopyMem (Key, &KeyData.Key, sizeof (EFI_INPUT_KEY));

+    return EFI_SUCCESS;

+  }  

 }

 

 

@@ -605,6 +630,7 @@ WinNtGopSimpleTextInWaitForKey (
   GOP_PRIVATE_DATA  *Private;

   EFI_STATUS        Status;

   EFI_TPL           OldTpl;

+  EFI_KEY_DATA      KeyData;

 

   Private = (GOP_PRIVATE_DATA *) Context;

 

@@ -612,26 +638,40 @@ WinNtGopSimpleTextInWaitForKey (
   // Enter critical section

   //

   OldTpl  = gBS->RaiseTPL (TPL_NOTIFY);

-  

+

   //

   // Call hot key callback before telling caller there is a key available

   //

   WinNtGopSimpleTextInTimerHandler (NULL, Private);

-

-  Status  = GopPrivateCheckQ (&Private->QueueForRead);

-  if (!EFI_ERROR (Status)) {

-    //

-    // If a there is a key in the queue signal our event.

-    //

-    gBS->SignalEvent (Event);

-  } else {

-    //

-    // We need to sleep or NT will schedule this thread with such high

-    // priority that WinProc thread will never run and we will not see

-    // keyboard input. This Sleep makes the syste run 10x faster, so don't

-    // remove it.

-    //

-    Private->WinNtThunk->Sleep (1);

+  

+  //

+  // WaitforKey doesn't suppor the partial key.

+  // Considering if the partial keystroke is enabled, there maybe a partial

+  // keystroke in the queue, so here skip the partial keystroke and get the

+  // next key from the queue

+  //

+  while (1) {

+    Status  = GopPrivateCheckQ (&Private->QueueForRead);

+    if (!EFI_ERROR (Status)) {

+      //

+      // If a there is a key in the queue and it is not partial keystroke,  signal event.

+      //

+      if (Private->QueueForRead.Q[Private->QueueForRead.Front].Key.ScanCode == SCAN_NULL &&

+        Private->QueueForRead.Q[Private->QueueForRead.Front].Key.UnicodeChar == CHAR_NULL) {

+        GopPrivateDeleteQ (Private,&Private->QueueForRead,&KeyData);

+        continue;

+      }

+      gBS->SignalEvent (Event);

+    } else {

+      //

+      // We need to sleep or NT will schedule this thread with such high

+      // priority that WinProc thread will never run and we will not see

+      // keyboard input. This Sleep makes the syste run 10x faster, so don't

+      // remove it.

+      //

+      Private->WinNtThunk->Sleep (1);

+    }

+    break;

   }

 

   //

@@ -667,7 +707,7 @@ WinNtGopSimpleTextInExResetEx (
   GOP_PRIVATE_DATA *Private;

 

   Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This);

-  

+

   return GopPrivateResetWorker (Private);

 }

 

@@ -680,20 +720,20 @@ WinNtGopSimpleTextInExReadKeyStrokeEx (
 /*++

 

   Routine Description:

-    Reads the next keystroke from the input device. The WaitForKey Event can 

+    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 

+    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 

+    EFI_DEVICE_ERROR      - The keystroke information was not returned due to

                             hardware errors.

-    EFI_INVALID_PARAMETER - KeyData is NULL.                        

+    EFI_INVALID_PARAMETER - KeyData is NULL.

 

 --*/

 {

@@ -704,7 +744,7 @@ WinNtGopSimpleTextInExReadKeyStrokeEx (
   }

 

   Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This);

-  

+

   return GopPrivateReadKeyStrokeWorker (Private, KeyData);

 

 }

@@ -722,17 +762,17 @@ WinNtGopSimpleTextInExSetState (
 

   Arguments:

     This                  - Protocol instance pointer.

-    KeyToggleState        - A pointer to the EFI_KEY_TOGGLE_STATE to set the 

+    KeyToggleState        - A pointer to the EFI_KEY_TOGGLE_STATE to set the

                             state for the input device.

-                          

-  Returns:                

+

+  Returns:

     EFI_SUCCESS           - The device state was set successfully.

-    EFI_DEVICE_ERROR      - The device is not functioning correctly and could 

+    EFI_DEVICE_ERROR      - The device is not functioning correctly and could

                             not have the setting adjusted.

     EFI_UNSUPPORTED       - The device does not have the ability to set its state.

-    EFI_INVALID_PARAMETER - KeyToggleState is NULL.                       

+    EFI_INVALID_PARAMETER - KeyToggleState is NULL.

 

---*/   

+--*/

 {

   EFI_STATUS                      Status;

   GOP_PRIVATE_DATA                *Private;

@@ -745,31 +785,35 @@ WinNtGopSimpleTextInExSetState (
 

   if (((Private->KeyState.KeyToggleState & EFI_TOGGLE_STATE_VALID) != EFI_TOGGLE_STATE_VALID) ||

       ((*KeyToggleState & EFI_TOGGLE_STATE_VALID) != EFI_TOGGLE_STATE_VALID)) {

-    return EFI_UNSUPPORTED;  

+    return EFI_UNSUPPORTED;

   }

 

-  Private->ScrollLock = FALSE;

-  Private->NumLock    = FALSE;

-  Private->CapsLock   = FALSE;

+  Private->ScrollLock          = FALSE;

+  Private->NumLock             = FALSE;

+  Private->CapsLock            = FALSE;

+  Private->IsPartialKeySupport = FALSE;

 

   if ((*KeyToggleState & EFI_SCROLL_LOCK_ACTIVE) == EFI_SCROLL_LOCK_ACTIVE) {

     Private->ScrollLock = TRUE;

-  } 

+  }

   if ((*KeyToggleState & EFI_NUM_LOCK_ACTIVE) == EFI_NUM_LOCK_ACTIVE) {

     Private->NumLock = TRUE;

   }

   if ((*KeyToggleState & EFI_CAPS_LOCK_ACTIVE) == EFI_CAPS_LOCK_ACTIVE) {

     Private->CapsLock = TRUE;

   }

+  if ((*KeyToggleState & EFI_KEY_STATE_EXPOSED) == EFI_KEY_STATE_EXPOSED) {

+    Private->IsPartialKeySupport = TRUE;

+  }

 

-  Status = GopPrivateUpdateStatusLight (Private);  

+  Status = GopPrivateUpdateStatusLight (Private);

   if (EFI_ERROR (Status)) {

     return EFI_DEVICE_ERROR;

   }

 

   Private->KeyState.KeyToggleState = *KeyToggleState;

   return EFI_SUCCESS;

-  

+

 }

 

 EFI_STATUS

@@ -787,23 +831,23 @@ WinNtGopSimpleTextInExRegisterKeyNotify (
 

   Arguments:

     This                    - Protocol instance pointer.

-    KeyData                 - A pointer to a buffer that is filled in with the keystroke 

+    KeyData                 - A pointer to a buffer that is filled in with the keystroke

                               information data for the key that was pressed.

-    KeyNotificationFunction - Points to the function to be called when the key 

-                              sequence is typed specified by KeyData.                        

-    NotifyHandle            - Points to the unique handle assigned to the registered notification.                          

+    KeyNotificationFunction - Points to the function to be called when the key

+                              sequence is typed specified by KeyData.

+    NotifyHandle            - Points to the unique handle assigned to the registered notification.

 

   Returns:

     EFI_SUCCESS             - The notification function was registered successfully.

     EFI_OUT_OF_RESOURCES    - Unable to allocate resources for necesssary data structures.

-    EFI_INVALID_PARAMETER   - KeyData or NotifyHandle is NULL.                       

-                              

---*/   

+    EFI_INVALID_PARAMETER   - KeyData or NotifyHandle is NULL.

+

+--*/

 {

   GOP_PRIVATE_DATA                   *Private;

   WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *CurrentNotify;

   LIST_ENTRY                         *Link;

-  WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *NewNotify;      

+  WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *NewNotify;

 

   if (KeyData == NULL || KeyNotificationFunction == NULL || NotifyHandle == NULL) {

     return EFI_INVALID_PARAMETER;

@@ -816,37 +860,37 @@ WinNtGopSimpleTextInExRegisterKeyNotify (
   //

   for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) {

     CurrentNotify = CR (

-                      Link, 

-                      WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY, 

-                      NotifyEntry, 

+                      Link,

+                      WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY,

+                      NotifyEntry,

                       WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE

                       );

-    if (GopPrivateIsKeyRegistered (&CurrentNotify->KeyData, KeyData)) { 

+    if (GopPrivateIsKeyRegistered (&CurrentNotify->KeyData, KeyData)) {

       if (CurrentNotify->KeyNotificationFn == KeyNotificationFunction) {

         *NotifyHandle = CurrentNotify->NotifyHandle;

         return EFI_SUCCESS;

       }

     }

-  }    

-  

+  }

+

   //

   // Allocate resource to save the notification function

-  //  

+  //

   NewNotify = (WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *) AllocateZeroPool (sizeof (WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY));

   if (NewNotify == NULL) {

     return EFI_OUT_OF_RESOURCES;

   }

 

-  NewNotify->Signature         = WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE;     

+  NewNotify->Signature         = WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE;

   NewNotify->KeyNotificationFn = KeyNotificationFunction;

   NewNotify->NotifyHandle      = (EFI_HANDLE) NewNotify;

   CopyMem (&NewNotify->KeyData, KeyData, sizeof (EFI_KEY_DATA));

   InsertTailList (&Private->NotifyList, &NewNotify->NotifyEntry);

 

-  *NotifyHandle = NewNotify->NotifyHandle;  

-  

+  *NotifyHandle = NewNotify->NotifyHandle;

+

   return EFI_SUCCESS;

-  

+

 }

 

 EFI_STATUS

@@ -861,14 +905,14 @@ WinNtGopSimpleTextInExUnregisterKeyNotify (
     Remove a registered notification function from a particular keystroke.

 

   Arguments:

-    This                    - Protocol instance pointer.    

+    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;

@@ -876,28 +920,28 @@ WinNtGopSimpleTextInExUnregisterKeyNotify (
 

   if (NotificationHandle == NULL) {

     return EFI_INVALID_PARAMETER;

-  } 

+  }

 

   if (((WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *) NotificationHandle)->Signature != WIN_NT_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, 

-                      WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY, 

-                      NotifyEntry, 

+                      Link,

+                      WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY,

+                      NotifyEntry,

                       WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE

-                      );       

+                      );

     if (CurrentNotify->NotifyHandle == NotificationHandle) {

       //

       // Remove the notification function from NotifyList and free resources

       //

-      RemoveEntryList (&CurrentNotify->NotifyEntry);      

+      RemoveEntryList (&CurrentNotify->NotifyEntry);

 

-      gBS->FreePool (CurrentNotify);            

+      gBS->FreePool (CurrentNotify);

       return EFI_SUCCESS;

     }

   }

@@ -941,7 +985,7 @@ WinNtGopInitializeSimpleTextInForWindow (
                   &Private->SimpleTextIn.WaitForKey

                   );

 

-  

+

   Private->SimpleTextInEx.Reset               = WinNtGopSimpleTextInExResetEx;

   Private->SimpleTextInEx.ReadKeyStrokeEx     = WinNtGopSimpleTextInExReadKeyStrokeEx;

   Private->SimpleTextInEx.SetState            = WinNtGopSimpleTextInExSetState;

@@ -949,7 +993,7 @@ WinNtGopInitializeSimpleTextInForWindow (
   Private->SimpleTextInEx.UnregisterKeyNotify = WinNtGopSimpleTextInExUnregisterKeyNotify;

 

   Private->SimpleTextInEx.Reset (&Private->SimpleTextInEx, FALSE);

-  

+

   InitializeListHead (&Private->NotifyList);

 

   Status = gBS->CreateEvent (

@@ -972,7 +1016,7 @@ WinNtGopInitializeSimpleTextInForWindow (
                   &Private->TimerEvent

                   );

   ASSERT_EFI_ERROR (Status);

-  

+

   Status = gBS->SetTimer (

                   Private->TimerEvent,

                   TimerPeriodic,

diff --git a/Nt32Pkg/WinNtGopDxe/WinNtGopScreen.c b/Nt32Pkg/WinNtGopDxe/WinNtGopScreen.c
index f9f2e0dd0c..85848aa6ce 100644
--- a/Nt32Pkg/WinNtGopDxe/WinNtGopScreen.c
+++ b/Nt32Pkg/WinNtGopDxe/WinNtGopScreen.c
@@ -52,106 +52,154 @@ KillNtGopThread (
   IN VOID       *Context

   );

 

-VOID

+BOOLEAN

 WinNtGopConvertParamToEfiKeyShiftState (

   IN  GOP_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. 

+  // 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:  

-    Private->LeftShift  = Flag;

-    break;  

+  //

+  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:

-    Private->LeftCtrl   = Flag;

-    break;

-  case VK_LWIN:      

+    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;

-    break;

-  case VK_RWIN:      

+    return TRUE;

+

+  case VK_RWIN:

     Private->RightLogo  = Flag;

-    break;

-  case VK_APPS:      

+    return TRUE;

+

+  case VK_APPS:

     Private->Menu       = Flag;

-    break;

+    return TRUE;

   //

   // BUGBUG: PrintScreen/SysRq can not trigger WM_KEYDOWN message,

   // so SySReq shift state is not supported here.

   //

-  case VK_PRINT:  

+  case VK_PRINT:

     Private->SysReq     = Flag;

-    break;

+    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;

   }

 }

 

-VOID

+BOOLEAN

 WinNtGopConvertParamToEfiKey (

   IN  GOP_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;       break;

-  case VK_END:        Key->ScanCode = SCAN_END;        break;

-  case VK_LEFT:       Key->ScanCode = SCAN_LEFT;       break;

-  case VK_RIGHT:      Key->ScanCode = SCAN_RIGHT;      break;

-  case VK_UP:         Key->ScanCode = SCAN_UP;         break;

-  case VK_DOWN:       Key->ScanCode = SCAN_DOWN;       break;

-  case VK_DELETE:     Key->ScanCode = SCAN_DELETE;     break;

-  case VK_INSERT:     Key->ScanCode = SCAN_INSERT;     break;

-  case VK_PRIOR:      Key->ScanCode = SCAN_PAGE_UP;    break;

-  case VK_NEXT:       Key->ScanCode = SCAN_PAGE_DOWN;  break;

-  case VK_ESCAPE:     Key->ScanCode = SCAN_ESC;        break;

-                         

-  case VK_F1:         Key->ScanCode = SCAN_F1;         break;

-  case VK_F2:         Key->ScanCode = SCAN_F2;         break;

-  case VK_F3:         Key->ScanCode = SCAN_F3;         break;

-  case VK_F4:         Key->ScanCode = SCAN_F4;         break;

-  case VK_F5:         Key->ScanCode = SCAN_F5;         break;

-  case VK_F6:         Key->ScanCode = SCAN_F6;         break;

-  case VK_F7:         Key->ScanCode = SCAN_F7;         break;

-  case VK_F8:         Key->ScanCode = SCAN_F8;         break;

-  case VK_F9:         Key->ScanCode = SCAN_F9;         break;

-  case VK_F11:        Key->ScanCode = SCAN_F11;        break;

-  case VK_F12:        Key->ScanCode = SCAN_F12;        break;

-

-  case VK_F13:        Key->ScanCode = SCAN_F13;        break;

-  case VK_F14:        Key->ScanCode = SCAN_F14;        break;

-  case VK_F15:        Key->ScanCode = SCAN_F15;        break;

-  case VK_F16:        Key->ScanCode = SCAN_F16;        break;

-  case VK_F17:        Key->ScanCode = SCAN_F17;        break;

-  case VK_F18:        Key->ScanCode = SCAN_F18;        break;

-  case VK_F19:        Key->ScanCode = SCAN_F19;        break;

-  case VK_F20:        Key->ScanCode = SCAN_F20;        break;

-  case VK_F21:        Key->ScanCode = SCAN_F21;        break;

-  case VK_F22:        Key->ScanCode = SCAN_F22;        break;

-  case VK_F23:        Key->ScanCode = SCAN_F23;        break;

-  case VK_F24:        Key->ScanCode = SCAN_F24;        break;

-  case VK_PAUSE:      Key->ScanCode = SCAN_PAUSE;      break;

+  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:     

+  //

+  case VK_NUMLOCK:

     Private->NumLock    = (BOOLEAN)(!Private->NumLock);

+    Flag = TRUE;

     break;

   case VK_SCROLL:

     Private->ScrollLock = (BOOLEAN)(!Private->ScrollLock);

-    break;  

+    Flag = TRUE;

+    break;

   case VK_CAPITAL:

     Private->CapsLock   = (BOOLEAN)(!Private->CapsLock);

-    break;  

+    Flag = TRUE;

+    break;

   }

   

-  WinNtGopConvertParamToEfiKeyShiftState (Private, wParam, TRUE);  

+  return (WinNtGopConvertParamToEfiKeyShiftState (Private, wParam, lParam, TRUE)) == TRUE ? TRUE : Flag;

 }

 

 

@@ -616,6 +664,7 @@ WinNtGopThreadWindowProc (
   PAINTSTRUCT       PaintStruct;

   LPARAM            Index;

   EFI_INPUT_KEY     Key;

+  BOOLEAN           AltIsPress;

 

   //

   // BugBug - if there are two instances of this DLL in memory (such as is

@@ -630,6 +679,7 @@ WinNtGopThreadWindowProc (
   // This works since each Gop protocol has a unique Private data instance and

   // a unique thread.

   //

+  AltIsPress = FALSE;

   Private = mWinNt->TlsGetValue (mTlsIndex);

   ASSERT (NULL != Private);

 

@@ -689,92 +739,100 @@ WinNtGopThreadWindowProc (
 

   //

   // 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 

+  // 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.ScanCode    = 0;

+    Key.UnicodeChar = CHAR_NULL;

     switch (wParam) {

     case VK_F10:

       Key.ScanCode    = SCAN_F10;

-      Key.UnicodeChar = 0;

+      Key.UnicodeChar = CHAR_NULL;

       GopPrivateAddKey (Private, Key);

       return 0;

     }

 

-    if ((lParam & GOP_ALT_KEY_PRESSED) == GOP_ALT_KEY_PRESSED) {

-      //

-      // ALT is pressed with another key pressed

-      //

-      WinNtGopConvertParamToEfiKey (Private, &wParam, &Key);

-

-      if ((lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {

-        Private->RightAlt = TRUE;

-      } else {

+    //

+    // 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;

       }

-

-      if (Private->RightAlt && Private->LeftAlt) {

-        Private->LeftAlt = FALSE;

-      }

-    }

-

-    if (Key.ScanCode != 0) {

-      Key.UnicodeChar = 0;

       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;

 

-    return 0;

+  case WM_CHAR:    

+    //

+    // The ESC key also generate WM_CHAR.

+    //

+    if (wParam == 0x1B) {

+	  return 0;

+    }    

 

-  case WM_SYSKEYUP:

-    if ((lParam & GOP_ALT_KEY_PRESSED) == GOP_ALT_KEY_PRESSED) {

+    if (AltIsPress == TRUE) {

       //

-      // ALT is pressed with another key released

+      // If AltIsPress is true that means the Alt key is pressed.

       //

-      WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, FALSE);  

+      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) {

       //

-      // Actually ALT key is still held down here.

-      // Change the ALT key state when another key is released

-      // by user because we did not find a better solution to

-      // get a released ALT key. 

+      // When Alt is released there is no windoes message, so 

+      // clean it after using it.

       //

+      Private->LeftAlt  = FALSE;

       Private->RightAlt = FALSE;

-      Private->LeftAlt = FALSE;

     }

-

     return 0;

 

-

-  case WM_KEYDOWN:

-    Key.ScanCode = 0;

-    WinNtGopConvertParamToEfiKey (Private, &wParam, &Key);

-    if (Key.ScanCode != 0) {

-      Key.UnicodeChar = 0;

-      GopPrivateAddKey (Private, Key);

-    }

-

-    return 0;

-

-  case WM_KEYUP:

-    WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, FALSE);  

+  case WM_SYSKEYUP:

+    //

+    // ALT is pressed with another key released

+    //

+    WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, &lParam, FALSE);

     return 0;

 

-  case WM_CHAR:

+  case WM_KEYDOWN:

+    Key.ScanCode = SCAN_NULL;

     //

-    // The ESC key also generate WM_CHAR.

+    // 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 (wParam == 0x1B) {

-      return 0;

-    }

-

-    for (Index = 0; Index < (lParam & 0xffff); Index++) {

-      if (wParam != 0) {

-        Key.UnicodeChar = (CHAR16) wParam;

-        Key.ScanCode    = 0;

-        GopPrivateAddKey (Private, Key);

+    if (WinNtGopConvertParamToEfiKey (Private, &wParam, &lParam, &Key)) {

+      if (Key.ScanCode != SCAN_NULL) {

+        Key.UnicodeChar = CHAR_NULL;

       }

+      //

+      // 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: