Nt32Pkg/WinNtGopDxe/WinNtGopScreen.c

   1 /** @file
   2
   3 Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>
   4 This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14     WinNtGopScreen.c
  15
  16 Abstract:
  17
  18   This file produces the graphics abstration of GOP. It is called by
  19   WinNtGopDriver.c file which deals with the UEFI 2.0 driver model.
  20   This file just does graphics.
  21
  22
  23 **/
  24
  25 #include "WinNtGop.h"
  26
  27 EFI_WIN_NT_THUNK_PROTOCOL *mWinNt;
  28 DWORD                     mTlsIndex         = TLS_OUT_OF_INDEXES;
  29 DWORD                     mTlsIndexUseCount = 0;  // lets us know when we can free mTlsIndex.
  30 EFI_EVENT          mGopScreenExitBootServicesEvent;
  31 GOP_MODE_DATA mGopModeData[] = {
  32     {800, 600, 0, 0},
  33     {640, 480, 0, 0},
  34     {720, 400, 0, 0},
  35     {1024, 768, 0, 0},
  36     {1280, 1024, 0, 0}
  37     };
  38
  39 EFI_STATUS
  40 WinNtGopStartWindow (
  41   IN  GOP_PRIVATE_DATA    *Private,
  42   IN  UINT32              HorizontalResolution,
  43   IN  UINT32              VerticalResolution,
  44   IN  UINT32              ColorDepth,
  45   IN  UINT32              RefreshRate
  46   );
  47
  48 VOID
  49 EFIAPI
  50 KillNtGopThread (
  51   IN EFI_EVENT  Event,
  52   IN VOID       *Context
  53   );
  54
  55 BOOLEAN
  56 WinNtGopConvertParamToEfiKeyShiftState (
  57   IN  GOP_PRIVATE_DATA  *Private,
  58   IN  WPARAM            *wParam,
  59   IN  LPARAM            *lParam,
  60   IN  BOOLEAN           Flag
  61   )
  62 {
  63   switch (*wParam) {
  64   //
  65   // BUGBUG: Only GetAsyncKeyState() and GetKeyState() can distinguish
  66   // left and right Ctrl, and Shift key.
  67   // Neither of the two is defined in EFI_WIN_NT_THUNK_PROTOCOL.
  68   // Therefor, we can not set the correct Shift state here.
  69   //
  70   case VK_SHIFT:
  71     if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
  72         Private->RightShift = Flag;
  73       } else {
  74         Private->LeftShift = Flag;
  75       }
  76     return TRUE;
  77
  78   case VK_LSHIFT:
  79     Private->LeftShift = Flag;
  80     return TRUE;
  81
  82   case VK_RSHIFT:
  83     Private->RightShift = Flag;
  84     return TRUE;
  85
  86   case VK_CONTROL:
  87     if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
  88         Private->RightCtrl= Flag;
  89       } else {
  90         Private->LeftCtrl = Flag;
  91       }
  92     return TRUE;
  93
  94   case VK_LCONTROL:
  95     Private->LeftCtrl = Flag;
  96     return TRUE;
  97
  98   case VK_RCONTROL:
  99     Private->RightCtrl = Flag;
 100     return TRUE;
 101
 102   case VK_LWIN:
 103     Private->LeftLogo   = Flag;
 104     return TRUE;
 105
 106   case VK_RWIN:
 107     Private->RightLogo  = Flag;
 108     return TRUE;
 109
 110   case VK_APPS:
 111     Private->Menu       = Flag;
 112     return TRUE;
 113   //
 114   // BUGBUG: PrintScreen/SysRq can not trigger WM_KEYDOWN message,
 115   // so SySReq shift state is not supported here.
 116   //
 117   case VK_PRINT:
 118     Private->SysReq     = Flag;
 119     return TRUE;
 120   //
 121   // For Alt Keystroke.
 122   //
 123   case VK_MENU:
 124     if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
 125         Private->RightAlt = Flag;
 126       } else {
 127         Private->LeftAlt = Flag;
 128       }
 129     return TRUE;
 130
 131   default:
 132     return FALSE;
 133   }
 134 }
 135
 136 BOOLEAN
 137 WinNtGopConvertParamToEfiKey (
 138   IN  GOP_PRIVATE_DATA  *Private,
 139   IN  WPARAM            *wParam,
 140   IN  LPARAM            *lParam,
 141   IN  EFI_INPUT_KEY     *Key
 142   )
 143 {
 144   BOOLEAN Flag;
 145   Flag = FALSE;
 146   switch (*wParam) {
 147   case VK_HOME:       Key->ScanCode = SCAN_HOME;      Flag = TRUE; break;
 148   case VK_END:        Key->ScanCode = SCAN_END;       Flag = TRUE; break;
 149   case VK_LEFT:       Key->ScanCode = SCAN_LEFT;      Flag = TRUE; break;
 150   case VK_RIGHT:      Key->ScanCode = SCAN_RIGHT;     Flag = TRUE; break;
 151   case VK_UP:         Key->ScanCode = SCAN_UP;        Flag = TRUE; break;
 152   case VK_DOWN:       Key->ScanCode = SCAN_DOWN;      Flag = TRUE; break;
 153   case VK_DELETE:     Key->ScanCode = SCAN_DELETE;    Flag = TRUE; break;
 154   case VK_INSERT:     Key->ScanCode = SCAN_INSERT;    Flag = TRUE; break;
 155   case VK_PRIOR:      Key->ScanCode = SCAN_PAGE_UP;   Flag = TRUE; break;
 156   case VK_NEXT:       Key->ScanCode = SCAN_PAGE_DOWN; Flag = TRUE; break;
 157   case VK_ESCAPE:     Key->ScanCode = SCAN_ESC;       Flag = TRUE; break;
 158
 159   case VK_F1:         Key->ScanCode = SCAN_F1;    Flag = TRUE;     break;
 160   case VK_F2:         Key->ScanCode = SCAN_F2;    Flag = TRUE;     break;
 161   case VK_F3:         Key->ScanCode = SCAN_F3;    Flag = TRUE;     break;
 162   case VK_F4:         Key->ScanCode = SCAN_F4;    Flag = TRUE;     break;
 163   case VK_F5:         Key->ScanCode = SCAN_F5;    Flag = TRUE;     break;
 164   case VK_F6:         Key->ScanCode = SCAN_F6;    Flag = TRUE;     break;
 165   case VK_F7:         Key->ScanCode = SCAN_F7;    Flag = TRUE;     break;
 166   case VK_F8:         Key->ScanCode = SCAN_F8;    Flag = TRUE;     break;
 167   case VK_F9:         Key->ScanCode = SCAN_F9;    Flag = TRUE;     break;
 168   case VK_F11:        Key->ScanCode = SCAN_F11;   Flag = TRUE;     break;
 169   case VK_F12:        Key->ScanCode = SCAN_F12;   Flag = TRUE;     break;
 170
 171   case VK_F13:        Key->ScanCode = SCAN_F13;   Flag = TRUE;     break;
 172   case VK_F14:        Key->ScanCode = SCAN_F14;   Flag = TRUE;     break;
 173   case VK_F15:        Key->ScanCode = SCAN_F15;   Flag = TRUE;     break;
 174   case VK_F16:        Key->ScanCode = SCAN_F16;   Flag = TRUE;     break;
 175   case VK_F17:        Key->ScanCode = SCAN_F17;   Flag = TRUE;     break;
 176   case VK_F18:        Key->ScanCode = SCAN_F18;   Flag = TRUE;     break;
 177   case VK_F19:        Key->ScanCode = SCAN_F19;   Flag = TRUE;     break;
 178   case VK_F20:        Key->ScanCode = SCAN_F20;   Flag = TRUE;     break;
 179   case VK_F21:        Key->ScanCode = SCAN_F21;   Flag = TRUE;     break;
 180   case VK_F22:        Key->ScanCode = SCAN_F22;   Flag = TRUE;     break;
 181   case VK_F23:        Key->ScanCode = SCAN_F23;   Flag = TRUE;     break;
 182   case VK_F24:        Key->ScanCode = SCAN_F24;   Flag = TRUE;     break;
 183   case VK_PAUSE:      Key->ScanCode = SCAN_PAUSE; Flag = TRUE;     break;
 184
 185   //
 186   // Set toggle state
 187   //
 188   case VK_NUMLOCK:
 189     Private->NumLock    = (BOOLEAN)(!Private->NumLock);
 190     Flag = TRUE;
 191     break;
 192   case VK_SCROLL:
 193     Private->ScrollLock = (BOOLEAN)(!Private->ScrollLock);
 194     Flag = TRUE;
 195     break;
 196   case VK_CAPITAL:
 197     Private->CapsLock   = (BOOLEAN)(!Private->CapsLock);
 198     Flag = TRUE;
 199     break;
 200   }
 201
 202   return (WinNtGopConvertParamToEfiKeyShiftState (Private, wParam, lParam, TRUE)) == TRUE ? TRUE : Flag;
 203 }
 204
 205
 206 //
 207 // GOP Protocol Member Functions
 208 //
 209
 210
 211 /**
 212   Graphics Output protocol interface to get video mode
 213
 214   @param  This                   Protocol instance pointer.
 215   @param  ModeNumber             The mode number to return information on.
 216   @param  Info                   Caller allocated buffer that returns information
 217                                  about ModeNumber.
 218   @param  SizeOfInfo             A pointer to the size, in bytes, of the Info
 219                                  buffer.
 220
 221   @retval EFI_SUCCESS            Mode information returned.
 222   @retval EFI_BUFFER_TOO_SMALL   The Info buffer was too small.
 223   @retval EFI_DEVICE_ERROR       A hardware error occurred trying to retrieve the
 224                                  video mode.
 225   @retval EFI_NOT_STARTED        Video display is not initialized. Call SetMode ()
 226   @retval EFI_INVALID_PARAMETER  One of the input args was NULL.
 227
 228 **/
 229 EFI_STATUS
 230 EFIAPI
 231 WinNtGopQuerytMode (
 232   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL          *This,
 233   IN  UINT32                                ModeNumber,
 234   OUT UINTN                                 *SizeOfInfo,
 235   OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  **Info
 236   )
 237 {
 238   GOP_PRIVATE_DATA  *Private;
 239
 240   Private = GOP_PRIVATE_DATA_FROM_THIS (This);
 241
 242   if (Info == NULL || SizeOfInfo == NULL || (UINTN) ModeNumber >= This->Mode->MaxMode) {
 243     return EFI_INVALID_PARAMETER;
 244   }
 245
 246   *Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));
 247   if (*Info == NULL) {
 248     return EFI_OUT_OF_RESOURCES;
 249   }
 250
 251   *SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
 252
 253   (*Info)->Version = 0;
 254   (*Info)->HorizontalResolution = Private->ModeData[ModeNumber].HorizontalResolution;
 255   (*Info)->VerticalResolution   = Private->ModeData[ModeNumber].VerticalResolution;
 256   (*Info)->PixelFormat = PixelBltOnly;
 257   (*Info)->PixelsPerScanLine = (*Info)->HorizontalResolution;
 258
 259   return EFI_SUCCESS;
 260 }
 261
 262
 263 /**
 264   Graphics Output protocol interface to set video mode
 265
 266   @param  This                   Protocol instance pointer.
 267   @param  ModeNumber             The mode number to be set.
 268
 269   @retval EFI_SUCCESS            Graphics mode was changed.
 270   @retval EFI_DEVICE_ERROR       The device had an error and could not complete the
 271                                  request.
 272   @retval EFI_UNSUPPORTED        ModeNumber is not supported by this device.
 273
 274 **/
 275 EFI_STATUS
 276 EFIAPI
 277 WinNtGopSetMode (
 278   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL * This,
 279   IN  UINT32                       ModeNumber
 280   )
 281 {
 282   EFI_STATUS                    Status;
 283   GOP_PRIVATE_DATA              *Private;
 284   GOP_MODE_DATA *ModeData;
 285   EFI_GRAPHICS_OUTPUT_BLT_PIXEL Fill;
 286   EFI_GRAPHICS_OUTPUT_BLT_PIXEL *NewFillLine;
 287   RECT                          Rect;
 288   UINTN                         Size;
 289   UINTN                         Width;
 290   UINTN                         Height;
 291
 292   Private = GOP_PRIVATE_DATA_FROM_THIS (This);
 293
 294   if (ModeNumber >= This->Mode->MaxMode) {
 295     return EFI_UNSUPPORTED;
 296   }
 297
 298   ModeData = &Private->ModeData[ModeNumber];
 299   This->Mode->Mode = ModeNumber;
 300   Private->GraphicsOutput.Mode->Info->HorizontalResolution = ModeData->HorizontalResolution;
 301   Private->GraphicsOutput.Mode->Info->VerticalResolution = ModeData->VerticalResolution;
 302   Private->GraphicsOutput.Mode->Info->PixelsPerScanLine = ModeData->HorizontalResolution;
 303
 304   if (Private->HardwareNeedsStarting) {
 305     Status = WinNtGopStartWindow (
 306               Private,
 307               ModeData->HorizontalResolution,
 308               ModeData->VerticalResolution,
 309               ModeData->ColorDepth,
 310               ModeData->RefreshRate
 311               );
 312     if (EFI_ERROR (Status)) {
 313       return EFI_DEVICE_ERROR;
 314     }
 315
 316     Private->HardwareNeedsStarting = FALSE;
 317   } else {
 318     //
 319     // Change the resolution and resize of the window
 320     //
 321
 322     //
 323     // Free the old buffer. We do not save the content of the old buffer since the
 324     // screen is to be cleared anyway. Clearing the screen is required by the EFI spec.
 325     // See UEFI spec -EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode()
 326     //
 327     Private->WinNtThunk->HeapFree (Private->WinNtThunk->GetProcessHeap (), 0, Private->VirtualScreenInfo);
 328
 329     //
 330     // Allocate DIB frame buffer directly from NT for performance enhancement
 331     // This buffer is the virtual screen/frame buffer. This buffer is not the
 332     // same a a frame buffer. The first row of this buffer will be the bottom
 333     // line of the image. This is an artifact of the way we draw to the screen.
 334     //
 335     Size = ModeData->HorizontalResolution * ModeData->VerticalResolution * sizeof (RGBQUAD) + sizeof (BITMAPV4HEADER);
 336     Private->VirtualScreenInfo = Private->WinNtThunk->HeapAlloc (
 337                                                         Private->WinNtThunk->GetProcessHeap (),
 338                                                         HEAP_ZERO_MEMORY,
 339                                                         Size
 340                                                         );
 341
 342     //
 343     // Update the virtual screen info data structure
 344     //
 345     Private->VirtualScreenInfo->bV4Size           = sizeof (BITMAPV4HEADER);
 346     Private->VirtualScreenInfo->bV4Width          = ModeData->HorizontalResolution;
 347     Private->VirtualScreenInfo->bV4Height         = ModeData->VerticalResolution;
 348     Private->VirtualScreenInfo->bV4Planes         = 1;
 349     Private->VirtualScreenInfo->bV4BitCount       = 32;
 350     //
 351     // uncompressed
 352     //
 353     Private->VirtualScreenInfo->bV4V4Compression  = BI_RGB;
 354
 355     //
 356     // The rest of the allocated memory block is the virtual screen buffer
 357     //
 358     Private->VirtualScreen = (RGBQUAD *) (Private->VirtualScreenInfo + 1);
 359
 360     //
 361     // Use the AdjuctWindowRect fuction to calculate the real width and height
 362     // of the new window including the border and caption
 363     //
 364     Rect.left   = 0;
 365     Rect.top    = 0;
 366     Rect.right  = ModeData->HorizontalResolution;
 367     Rect.bottom = ModeData->VerticalResolution;
 368
 369     Private->WinNtThunk->AdjustWindowRect (&Rect, WS_OVERLAPPEDWINDOW, 0);
 370
 371     Width   = Rect.right - Rect.left;
 372     Height  = Rect.bottom - Rect.top;
 373
 374     //
 375     // Retrieve the original window position information
 376     //
 377     Private->WinNtThunk->GetWindowRect (Private->WindowHandle, &Rect);
 378
 379     //
 380     // Adjust the window size
 381     //
 382     Private->WinNtThunk->MoveWindow (Private->WindowHandle, Rect.left, Rect.top, (INT32)Width, (INT32)Height, TRUE);
 383
 384   }
 385
 386   NewFillLine = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * ModeData->HorizontalResolution);
 387   if (NewFillLine == NULL) {
 388     return EFI_DEVICE_ERROR;
 389   }
 390
 391   if (Private->FillLine != NULL) {
 392     FreePool (Private->FillLine);
 393   }
 394
 395   Private->FillLine             = NewFillLine;
 396
 397   Fill.Red                      = 0x00;
 398   Fill.Green                    = 0x00;
 399   Fill.Blue                     = 0x00;
 400   This->Blt (
 401           This,
 402           &Fill,
 403           EfiBltVideoFill,
 404           0,
 405           0,
 406           0,
 407           0,
 408           ModeData->HorizontalResolution,
 409           ModeData->VerticalResolution,
 410           ModeData->HorizontalResolution * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
 411           );
 412   return EFI_SUCCESS;
 413 }
 414
 415
 416 /**
 417   Blt pixels from the rectangle (Width X Height) formed by the BltBuffer
 418   onto the graphics screen starting a location (X, Y). (0, 0) is defined as
 419   the upper left hand side of the screen. (X, Y) can be outside of the
 420   current screen geometry and the BltBuffer will be cliped when it is
 421   displayed. X and Y can be negative or positive. If Width or Height is
 422   bigger than the current video screen the image will be clipped.
 423
 424   @param  This                   Protocol instance pointer.
 425   @param  X                      X location on graphics screen.
 426   @param  Y                      Y location on the graphics screen.
 427   @param  Width                  Width of BltBuffer.
 428   @param  Height                 Hight of BltBuffer
 429   @param  BltOperation           Operation to perform on BltBuffer and video memory
 430   @param  BltBuffer              Buffer containing data to blt into video buffer.
 431                                  This  buffer has a size of
 432                                  Width*Height*sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
 433   @param  SourceX                If the BltOperation is a EfiCopyBlt this is the
 434                                  source of the copy. For other BLT operations this
 435                                  argument is not used.
 436   @param  SourceX                If the BltOperation is a EfiCopyBlt this is the
 437                                  source of the copy. For other BLT operations this
 438                                  argument is not used.
 439
 440   @retval EFI_SUCCESS            The palette is updated with PaletteArray.
 441   @retval EFI_INVALID_PARAMETER  BltOperation is not valid.
 442   @retval EFI_DEVICE_ERROR       A hardware error occured writting to the video
 443                                  buffer.
 444
 445 **/
 446 // TODO:    SourceY - add argument and description to function comment
 447 // TODO:    DestinationX - add argument and description to function comment
 448 // TODO:    DestinationY - add argument and description to function comment
 449 // TODO:    Delta - add argument and description to function comment
 450 EFI_STATUS
 451 EFIAPI
 452 WinNtGopBlt (
 453   IN  EFI_GRAPHICS_OUTPUT_PROTOCOL                   *This,
 454   IN  EFI_GRAPHICS_OUTPUT_BLT_PIXEL                           *BltBuffer, OPTIONAL
 455   IN  EFI_GRAPHICS_OUTPUT_BLT_OPERATION                   BltOperation,
 456   IN  UINTN                                   SourceX,
 457   IN  UINTN                                   SourceY,
 458   IN  UINTN                                   DestinationX,
 459   IN  UINTN                                   DestinationY,
 460   IN  UINTN                                   Width,
 461   IN  UINTN                                   Height,
 462   IN  UINTN                                   Delta         OPTIONAL
 463   )
 464 {
 465   GOP_PRIVATE_DATA              *Private;
 466   EFI_TPL                       OriginalTPL;
 467   UINTN                         DstY;
 468   UINTN                         SrcY;
 469   RGBQUAD                       *VScreen;
 470   RGBQUAD                       *VScreenSrc;
 471   EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
 472   UINTN                         Index;
 473   RECT                          Rect;
 474   EFI_GRAPHICS_OUTPUT_BLT_PIXEL *FillPixel;
 475   UINT32                        VerticalResolution;
 476   UINT32                        HorizontalResolution;
 477
 478   Private = GOP_PRIVATE_DATA_FROM_THIS (This);
 479
 480   if ((BltOperation < 0) || (BltOperation >= EfiGraphicsOutputBltOperationMax)) {
 481     return EFI_INVALID_PARAMETER;
 482   }
 483
 484   if (Width == 0 || Height == 0) {
 485     return EFI_INVALID_PARAMETER;
 486   }
 487   //
 488   // If Delta is zero, then the entire BltBuffer is being used, so Delta
 489   // is the number of bytes in each row of BltBuffer.  Since BltBuffer is Width pixels size,
 490   // the number of bytes in each row can be computed.
 491   //
 492   if (Delta == 0) {
 493     Delta = Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
 494   }
 495
 496   //
 497   // We need to fill the Virtual Screen buffer with the blt data.
 498   // The virtual screen is upside down, as the first row is the bootom row of
 499   // the image.
 500   //
 501   VerticalResolution = This->Mode->Info->VerticalResolution;
 502   HorizontalResolution = This->Mode->Info->HorizontalResolution;
 503   if (BltOperation == EfiBltVideoToBltBuffer) {
 504
 505     //
 506     // Video to BltBuffer: Source is Video, destination is BltBuffer
 507     //
 508     if (SourceY + Height > VerticalResolution) {
 509       return EFI_INVALID_PARAMETER;
 510     }
 511
 512     if (SourceX + Width > HorizontalResolution) {
 513       return EFI_INVALID_PARAMETER;
 514     }
 515     //
 516     // We have to raise to TPL Notify, so we make an atomic write the frame buffer.
 517     // We would not want a timer based event (Cursor, ...) to come in while we are
 518     // doing this operation.
 519     //
 520     OriginalTPL = gBS->RaiseTPL (TPL_NOTIFY);
 521
 522     for (SrcY = SourceY, DstY = DestinationY; DstY < (Height + DestinationY); SrcY++, DstY++) {
 523       Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) ((UINT8 *) BltBuffer + (DstY * Delta) + DestinationX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
 524       VScreen = &Private->VirtualScreen[(VerticalResolution - SrcY - 1) * HorizontalResolution + SourceX];
 525       CopyMem (Blt, VScreen, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * Width);
 526     }
 527   } else {
 528     //
 529     // BltBuffer to Video: Source is BltBuffer, destination is Video
 530     //
 531     if (DestinationY + Height > VerticalResolution) {
 532       return EFI_INVALID_PARAMETER;
 533     }
 534
 535     if (DestinationX + Width > HorizontalResolution) {
 536       return EFI_INVALID_PARAMETER;
 537     }
 538
 539     //
 540     // We have to raise to TPL Notify, so we make an atomic write the frame buffer.
 541     // We would not want a timer based event (Cursor, ...) to come in while we are
 542     // doing this operation.
 543     //
 544     OriginalTPL = gBS->RaiseTPL (TPL_NOTIFY);
 545
 546     if (BltOperation == EfiBltVideoFill) {
 547       FillPixel = BltBuffer;
 548       for (Index = 0; Index < Width; Index++) {
 549         Private->FillLine[Index] = *FillPixel;
 550       }
 551     }
 552
 553     for (Index = 0; Index < Height; Index++) {
 554       if (DestinationY <= SourceY) {
 555         SrcY  = SourceY + Index;
 556         DstY  = DestinationY + Index;
 557       } else {
 558         SrcY  = SourceY + Height - Index - 1;
 559         DstY  = DestinationY + Height - Index - 1;
 560       }
 561
 562       VScreen = &Private->VirtualScreen[(VerticalResolution - DstY - 1) * HorizontalResolution + DestinationX];
 563       switch (BltOperation) {
 564       case EfiBltBufferToVideo:
 565         Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) ((UINT8 *) BltBuffer + (SrcY * Delta) + SourceX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
 566         CopyMem (VScreen, Blt, Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
 567         break;
 568
 569       case EfiBltVideoToVideo:
 570         VScreenSrc = &Private->VirtualScreen[(VerticalResolution - SrcY - 1) * HorizontalResolution + SourceX];
 571         CopyMem (VScreen, VScreenSrc, Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
 572         break;
 573
 574       case EfiBltVideoFill:
 575         CopyMem (VScreen, Private->FillLine, Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
 576         break;
 577       }
 578     }
 579   }
 580
 581   if (BltOperation != EfiBltVideoToBltBuffer) {
 582     //
 583     // Mark the area we just blted as Invalid so WM_PAINT will update.
 584     //
 585     Rect.left   = (LONG)DestinationX;
 586     Rect.top    = (LONG)DestinationY;
 587     Rect.right  = (LONG)(DestinationX + Width);
 588     Rect.bottom = (LONG)(DestinationY + Height);
 589     Private->WinNtThunk->InvalidateRect (Private->WindowHandle, &Rect, FALSE);
 590
 591     //
 592     // Send the WM_PAINT message to the thread that is drawing the window. We
 593     // are in the main thread and the window drawing is in a child thread.
 594     // There is a child thread per window. We have no CriticalSection or Mutex
 595     // since we write the data and the other thread displays the data. While
 596     // we may miss some data for a short period of time this is no different than
 597     // a write combining on writes to a frame buffer.
 598     //
 599
 600     Private->WinNtThunk->UpdateWindow (Private->WindowHandle);
 601   }
 602
 603   gBS->RestoreTPL (OriginalTPL);
 604
 605   return EFI_SUCCESS;
 606 }
 607
 608 //
 609 // Construction and Destruction functions
 610 //
 611
 612
 613 /**
 614
 615
 616   @return None
 617
 618 **/
 619 // TODO:    WinNtIo - add argument and description to function comment
 620 // TODO:    EFI_UNSUPPORTED - add return value to function comment
 621 // TODO:    EFI_SUCCESS - add return value to function comment
 622 EFI_STATUS
 623 WinNtGopSupported (
 624   IN  EFI_WIN_NT_IO_PROTOCOL  *WinNtIo
 625   )
 626 {
 627   //
 628   // Check to see if the IO abstraction represents a device type we support.
 629   //
 630   // This would be replaced a check of PCI subsystem ID, etc.
 631   //
 632   if (!CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtGopGuid)) {
 633     return EFI_UNSUPPORTED;
 634   }
 635
 636   return EFI_SUCCESS;
 637 }
 638
 639
 640 /**
 641   Win32 Windows event handler.
 642
 643   See Win32 Book
 644
 645   @return See Win32 Book
 646
 647 **/
 648 // TODO:    hwnd - add argument and description to function comment
 649 // TODO:    iMsg - add argument and description to function comment
 650 // TODO:    wParam - add argument and description to function comment
 651 // TODO:    lParam - add argument and description to function comment
 652 LRESULT
 653 CALLBACK
 654 WinNtGopThreadWindowProc (
 655   IN  HWND    hwnd,
 656   IN  UINT    iMsg,
 657   IN  WPARAM  wParam,
 658   IN  LPARAM  lParam
 659   )
 660 {
 661   GOP_PRIVATE_DATA  *Private;
 662   UINTN             Size;
 663   HDC               Handle;
 664   PAINTSTRUCT       PaintStruct;
 665   LPARAM            Index;
 666   EFI_INPUT_KEY     Key;
 667   BOOLEAN           AltIsPress;
 668
 669   //
 670   // BugBug - if there are two instances of this DLL in memory (such as is
 671   // the case for ERM), the correct instance of this function may not be called.
 672   // This also means that the address of the mTlsIndex value will be wrong, and
 673   // the value may be wrong too.
 674   //
 675
 676
 677   //
 678   // Use mTlsIndex global to get a Thread Local Storage version of Private.
 679   // This works since each Gop protocol has a unique Private data instance and
 680   // a unique thread.
 681   //
 682   AltIsPress = FALSE;
 683   Private = mWinNt->TlsGetValue (mTlsIndex);
 684   ASSERT (NULL != Private);
 685
 686   switch (iMsg) {
 687   case WM_CREATE:
 688     Size = Private->GraphicsOutput.Mode->Info->HorizontalResolution * Private->GraphicsOutput.Mode->Info->VerticalResolution * sizeof (RGBQUAD);
 689
 690     //
 691     // Allocate DIB frame buffer directly from NT for performance enhancement
 692     // This buffer is the virtual screen/frame buffer. This buffer is not the
 693     // same a a frame buffer. The first fow of this buffer will be the bottom
 694     // line of the image. This is an artifact of the way we draw to the screen.
 695     //
 696     Private->VirtualScreenInfo = Private->WinNtThunk->HeapAlloc (
 697                                                         Private->WinNtThunk->GetProcessHeap (),
 698                                                         HEAP_ZERO_MEMORY,
 699                                                         Size
 700                                                         );
 701
 702     Private->VirtualScreenInfo->bV4Size           = sizeof (BITMAPV4HEADER);
 703     Private->VirtualScreenInfo->bV4Width          = Private->GraphicsOutput.Mode->Info->HorizontalResolution;
 704     Private->VirtualScreenInfo->bV4Height         = Private->GraphicsOutput.Mode->Info->VerticalResolution;
 705     Private->VirtualScreenInfo->bV4Planes         = 1;
 706     Private->VirtualScreenInfo->bV4BitCount       = 32;
 707     //
 708     // uncompressed
 709     //
 710     Private->VirtualScreenInfo->bV4V4Compression  = BI_RGB;
 711     Private->VirtualScreen = (RGBQUAD *) (Private->VirtualScreenInfo + 1);
 712     return 0;
 713
 714   case WM_PAINT:
 715     //
 716     // I have not found a way to convert hwnd into a Private context. So for
 717     // now we use this API to convert hwnd to Private data.
 718     //
 719
 720     Handle = mWinNt->BeginPaint (hwnd, &PaintStruct);
 721
 722     mWinNt->SetDIBitsToDevice (
 723               Handle,                                     // Destination Device Context
 724               0,                                          // Destination X - 0
 725               0,                                          // Destination Y - 0
 726               Private->GraphicsOutput.Mode->Info->HorizontalResolution,              // Width
 727               Private->GraphicsOutput.Mode->Info->VerticalResolution,                // Height
 728               0,                                          // Source X
 729               0,                                          // Source Y
 730               0,                                          // DIB Start Scan Line
 731               Private->GraphicsOutput.Mode->Info->VerticalResolution,                // Number of scan lines
 732               Private->VirtualScreen,                     // Address of array of DIB bits
 733               (BITMAPINFO *) Private->VirtualScreenInfo,  // Address of structure with bitmap info
 734               DIB_RGB_COLORS                              // RGB or palette indexes
 735               );
 736
 737     mWinNt->EndPaint (hwnd, &PaintStruct);
 738     return 0;
 739
 740   //
 741   // F10 and the ALT key do not create a WM_KEYDOWN message, thus this special case
 742   // WM_SYSKEYDOWN is posted when F10 is pressed or
 743   // holds down ALT key and then presses another key.
 744   //
 745   case WM_SYSKEYDOWN:
 746
 747     Key.ScanCode    = 0;
 748     Key.UnicodeChar = CHAR_NULL;
 749     switch (wParam) {
 750     case VK_F10:
 751       Key.ScanCode    = SCAN_F10;
 752       Key.UnicodeChar = CHAR_NULL;
 753       GopPrivateAddKey (Private, Key);
 754       return 0;
 755     }
 756
 757     //
 758     // If ALT or ALT + modifier key is pressed.
 759     //
 760     if (WinNtGopConvertParamToEfiKey (Private, &wParam, &lParam, &Key)) {
 761       if (Key.ScanCode != 0){
 762         //
 763         // If ALT is pressed with other ScanCode.
 764         // Always revers the left Alt for simple.
 765         //
 766         Private->LeftAlt = TRUE;
 767       }
 768       GopPrivateAddKey (Private, Key);
 769       //
 770       // When Alt is released there is no windoes message, so
 771       // clean it after using it.
 772       //
 773       Private->RightAlt = FALSE;
 774       Private->LeftAlt  = FALSE;
 775       return 0;
 776     }
 777     AltIsPress = TRUE;
 778
 779   case WM_CHAR:
 780     //
 781     // The ESC key also generate WM_CHAR.
 782     //
 783     if (wParam == 0x1B) {
 784             return 0;
 785     }
 786
 787     if (AltIsPress == TRUE) {
 788       //
 789       // If AltIsPress is true that means the Alt key is pressed.
 790       //
 791       Private->LeftAlt = TRUE;
 792     }
 793     for (Index = 0; Index < (lParam & 0xffff); Index++) {
 794       if (wParam != 0) {
 795         Key.UnicodeChar = (CHAR16) wParam;
 796         Key.ScanCode    = SCAN_NULL;
 797         GopPrivateAddKey (Private, Key);
 798       }
 799     }
 800     if (AltIsPress == TRUE) {
 801       //
 802       // When Alt is released there is no windoes message, so
 803       // clean it after using it.
 804       //
 805       Private->LeftAlt  = FALSE;
 806       Private->RightAlt = FALSE;
 807     }
 808     return 0;
 809
 810   case WM_SYSKEYUP:
 811     //
 812     // ALT is pressed with another key released
 813     //
 814     WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, &lParam, FALSE);
 815     return 0;
 816
 817   case WM_KEYDOWN:
 818     Key.ScanCode    = SCAN_NULL;
 819     Key.UnicodeChar = CHAR_NULL;
 820     //
 821     // A value key press will cause a WM_KEYDOWN first, then cause a WM_CHAR
 822     // So if there is no modifier key updated, skip the WM_KEYDOWN even.
 823     //
 824     if (WinNtGopConvertParamToEfiKey (Private, &wParam, &lParam, &Key)) {
 825       //
 826       // Support the partial keystroke, add all keydown event into the queue.
 827       //
 828       GopPrivateAddKey (Private, Key);
 829     }
 830     return 0;
 831
 832   case WM_KEYUP:
 833     WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, &lParam, FALSE);
 834     return 0;
 835
 836   case WM_CLOSE:
 837     //
 838     // This close message is issued by user, core is not aware of this,
 839     // so don't release the window display resource, just hide the window.
 840     //
 841     Private->WinNtThunk->ShowWindow (Private->WindowHandle, SW_HIDE);
 842     return 0;
 843
 844   case WM_DESTROY:
 845     mWinNt->DestroyWindow (hwnd);
 846     mWinNt->PostQuitMessage (0);
 847
 848     mWinNt->HeapFree (Private->WinNtThunk->GetProcessHeap (), 0, Private->VirtualScreenInfo);
 849
 850     mWinNt->ExitThread (0);
 851     return 0;
 852
 853   default:
 854     break;
 855   };
 856
 857   return mWinNt->DefWindowProc (hwnd, iMsg, wParam, lParam);
 858 }
 859
 860
 861 /**
 862   This thread simulates the end of WinMain () aplication. Each Winow nededs
 863   to process it's events. The messages are dispatched to
 864   WinNtGopThreadWindowProc ().
 865   Be very careful sine WinNtGopThreadWinMain () and WinNtGopThreadWindowProc ()
 866   are running in a seperate thread. We have to do this to process the events.
 867
 868   @param  lpParameter            Handle of window to manage.
 869
 870   @return if a WM_QUIT message is returned exit.
 871
 872 **/
 873 DWORD
 874 WINAPI
 875 WinNtGopThreadWinMain (
 876   LPVOID    lpParameter
 877   )
 878 {
 879   MSG               Message;
 880   GOP_PRIVATE_DATA  *Private;
 881   RECT              Rect;
 882
 883   Private = (GOP_PRIVATE_DATA *) lpParameter;
 884   ASSERT (NULL != Private);
 885
 886   //
 887   // Since each thread has unique private data, save the private data in Thread
 888   // Local Storage slot. Then the shared global mTlsIndex can be used to get
 889   // thread specific context.
 890   //
 891   Private->WinNtThunk->TlsSetValue (mTlsIndex, Private);
 892
 893   Private->ThreadId                   = Private->WinNtThunk->GetCurrentThreadId ();
 894
 895   Private->WindowsClass.cbSize        = sizeof (WNDCLASSEX);
 896   Private->WindowsClass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
 897   Private->WindowsClass.lpfnWndProc   = WinNtGopThreadWindowProc;
 898   Private->WindowsClass.cbClsExtra    = 0;
 899   Private->WindowsClass.cbWndExtra    = 0;
 900   Private->WindowsClass.hInstance     = NULL;
 901   Private->WindowsClass.hIcon         = Private->WinNtThunk->LoadIcon (NULL, IDI_APPLICATION);
 902   Private->WindowsClass.hCursor       = Private->WinNtThunk->LoadCursor (NULL, IDC_ARROW);
 903   Private->WindowsClass.hbrBackground = (HBRUSH)(UINTN)COLOR_WINDOW;
 904   Private->WindowsClass.lpszMenuName  = NULL;
 905   Private->WindowsClass.lpszClassName = WIN_NT_GOP_CLASS_NAME;
 906   Private->WindowsClass.hIconSm       = Private->WinNtThunk->LoadIcon (NULL, IDI_APPLICATION);
 907
 908   //
 909   // This call will fail after the first time, but thats O.K. since we only need
 910   // WIN_NT_GOP_CLASS_NAME to exist to create the window.
 911   //
 912   // Note: Multiple instances of this DLL will use the same instance of this
 913   // Class, including the callback function, unless the Class is unregistered and
 914   // successfully registered again.
 915   //
 916   Private->WinNtThunk->RegisterClassEx (&Private->WindowsClass);
 917
 918   //
 919   // Setting Rect values to allow for the AdjustWindowRect to provide
 920   // us the correct sizes for the client area when doing the CreateWindowEx
 921   //
 922   Rect.top    = 0;
 923   Rect.bottom = Private->GraphicsOutput.Mode->Info->VerticalResolution;
 924   Rect.left   = 0;
 925   Rect.right  = Private->GraphicsOutput.Mode->Info->HorizontalResolution;
 926
 927   Private->WinNtThunk->AdjustWindowRect (&Rect, WS_OVERLAPPEDWINDOW, 0);
 928
 929   Private->WindowHandle = Private->WinNtThunk->CreateWindowEx (
 930                                                 0,
 931                                                 WIN_NT_GOP_CLASS_NAME,
 932                                                 Private->WindowName,
 933                                                 WS_OVERLAPPEDWINDOW,
 934                                                 CW_USEDEFAULT,
 935                                                 CW_USEDEFAULT,
 936                                                 Rect.right - Rect.left,
 937                                                 Rect.bottom - Rect.top,
 938                                                 NULL,
 939                                                 NULL,
 940                                                 NULL,
 941                                                 (VOID **)&Private
 942                                                 );
 943
 944   //
 945   // The reset of this thread is the standard winows program. We need a sperate
 946   // thread since we must process the message loop to make windows act like
 947   // windows.
 948   //
 949
 950   Private->WinNtThunk->ShowWindow (Private->WindowHandle, SW_SHOW);
 951   Private->WinNtThunk->UpdateWindow (Private->WindowHandle);
 952
 953   //
 954   // Let the main thread get some work done
 955   //
 956   Private->WinNtThunk->ReleaseSemaphore (Private->ThreadInited, 1, NULL);
 957
 958   //
 959   // This is the message loop that all Windows programs need.
 960   //
 961   while (Private->WinNtThunk->GetMessage (&Message, Private->WindowHandle, 0, 0)) {
 962     Private->WinNtThunk->TranslateMessage (&Message);
 963     Private->WinNtThunk->DispatchMessage (&Message);
 964   }
 965
 966   return (DWORD)Message.wParam;
 967 }
 968
 969
 970 /**
 971   TODO: Add function description
 972
 973   @param  Private                TODO: add argument description
 974   @param  HorizontalResolution   TODO: add argument description
 975   @param  VerticalResolution     TODO: add argument description
 976   @param  ColorDepth             TODO: add argument description
 977   @param  RefreshRate            TODO: add argument description
 978
 979   @return TODO: add return values
 980
 981 **/
 982 EFI_STATUS
 983 WinNtGopStartWindow (
 984   IN  GOP_PRIVATE_DATA    *Private,
 985   IN  UINT32              HorizontalResolution,
 986   IN  UINT32              VerticalResolution,
 987   IN  UINT32              ColorDepth,
 988   IN  UINT32              RefreshRate
 989   )
 990 {
 991   EFI_STATUS          Status;
 992   DWORD               NewThreadId;
 993
 994   mWinNt  = Private->WinNtThunk;
 995
 996   //
 997   // Initialize a Thread Local Storge variable slot. We use TLS to get the
 998   // correct Private data instance into the windows thread.
 999   //
1000   if (mTlsIndex == TLS_OUT_OF_INDEXES) {
1001     ASSERT (0 == mTlsIndexUseCount);
1002     mTlsIndex = Private->WinNtThunk->TlsAlloc ();
1003   }
1004
1005   //
1006   // always increase the use count!
1007   //
1008   mTlsIndexUseCount++;
1009
1010   //
1011   // Register to be notified on exit boot services so we can destroy the window.
1012   //
1013   Status = gBS->CreateEventEx (
1014                   EVT_NOTIFY_SIGNAL,
1015                   TPL_CALLBACK,
1016                   KillNtGopThread,
1017                   Private,
1018                   &gEfiEventExitBootServicesGuid,
1019                   &mGopScreenExitBootServicesEvent
1020                   );
1021
1022   Private->ThreadInited = Private->WinNtThunk->CreateSemaphore (NULL, 0, 1, NULL);
1023   Private->ThreadHandle = Private->WinNtThunk->CreateThread (
1024                                                 NULL,
1025                                                 0,
1026                                                 WinNtGopThreadWinMain,
1027                                                 (VOID *) Private,
1028                                                 0,
1029                                                 &NewThreadId
1030                                                 );
1031
1032   //
1033   // The other thread has entered the windows message loop so we can
1034   // continue our initialization.
1035   //
1036   Private->WinNtThunk->WaitForSingleObject (Private->ThreadInited, INFINITE);
1037   Private->WinNtThunk->CloseHandle (Private->ThreadInited);
1038
1039   return Status;
1040 }
1041
1042
1043 /**
1044
1045
1046   @return None
1047
1048 **/
1049 // TODO:    Private - add argument and description to function comment
1050 // TODO:    EFI_SUCCESS - add return value to function comment
1051 EFI_STATUS
1052 WinNtGopConstructor (
1053   GOP_PRIVATE_DATA    *Private
1054   )
1055 {
1056   Private->ModeData = mGopModeData;
1057
1058   Private->GraphicsOutput.QueryMode = WinNtGopQuerytMode;
1059   Private->GraphicsOutput.SetMode = WinNtGopSetMode;
1060   Private->GraphicsOutput.Blt            = WinNtGopBlt;
1061
1062   //
1063   // Allocate buffer for Graphics Output Protocol mode information
1064   //
1065   Private->GraphicsOutput.Mode = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE));
1066   if (Private->GraphicsOutput.Mode == NULL) {
1067     return EFI_OUT_OF_RESOURCES;
1068   }
1069   Private->GraphicsOutput.Mode->Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));
1070   if (Private->GraphicsOutput.Mode->Info == NULL) {
1071     return EFI_OUT_OF_RESOURCES;
1072   }
1073
1074   Private->GraphicsOutput.Mode->MaxMode = sizeof(mGopModeData) / sizeof(GOP_MODE_DATA);
1075   //
1076   // Till now, we have no idea about the window size.
1077   //
1078   Private->GraphicsOutput.Mode->Mode = GRAPHICS_OUTPUT_INVALIDE_MODE_NUMBER;
1079   Private->GraphicsOutput.Mode->Info->Version = 0;
1080   Private->GraphicsOutput.Mode->Info->HorizontalResolution = 0;
1081   Private->GraphicsOutput.Mode->Info->VerticalResolution = 0;
1082   Private->GraphicsOutput.Mode->Info->PixelFormat = PixelBltOnly;
1083   Private->GraphicsOutput.Mode->SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
1084   Private->GraphicsOutput.Mode->FrameBufferBase = (EFI_PHYSICAL_ADDRESS) (UINTN) NULL;
1085   Private->GraphicsOutput.Mode->FrameBufferSize = 0;
1086
1087   Private->HardwareNeedsStarting  = TRUE;
1088   Private->FillLine               = NULL;
1089
1090   WinNtGopInitializeSimpleTextInForWindow (Private);
1091
1092   return EFI_SUCCESS;
1093 }
1094
1095
1096 /**
1097
1098
1099   @return None
1100
1101 **/
1102 // TODO:    Private - add argument and description to function comment
1103 // TODO:    EFI_SUCCESS - add return value to function comment
1104 EFI_STATUS
1105 WinNtGopDestructor (
1106   GOP_PRIVATE_DATA     *Private
1107   )
1108 {
1109   if (!Private->HardwareNeedsStarting) {
1110     //
1111     // BugBug: Shutdown GOP Hardware and any child devices.
1112     //
1113     Private->WinNtThunk->SendMessage (Private->WindowHandle, WM_DESTROY, 0, 0);
1114     Private->WinNtThunk->CloseHandle (Private->ThreadHandle);
1115
1116     mTlsIndexUseCount--;
1117
1118     //
1119     // The callback function for another window could still be called,
1120     // so we need to make sure there are no more users of mTlsIndex.
1121     //
1122     if (0 == mTlsIndexUseCount) {
1123       ASSERT (TLS_OUT_OF_INDEXES != mTlsIndex);
1124
1125       Private->WinNtThunk->TlsFree (mTlsIndex);
1126       mTlsIndex = TLS_OUT_OF_INDEXES;
1127
1128       Private->WinNtThunk->UnregisterClass (
1129                               Private->WindowsClass.lpszClassName,
1130                               Private->WindowsClass.hInstance
1131                               );
1132     }
1133
1134     WinNtGopDestroySimpleTextInForWindow (Private);
1135   }
1136
1137   //
1138   // Free graphics output protocol occupied resource
1139   //
1140   if (Private->GraphicsOutput.Mode != NULL) {
1141     if (Private->GraphicsOutput.Mode->Info != NULL) {
1142       FreePool (Private->GraphicsOutput.Mode->Info);
1143     }
1144     FreePool (Private->GraphicsOutput.Mode);
1145   }
1146
1147   return EFI_SUCCESS;
1148 }
1149
1150
1151 /**
1152   This is the GOP screen's callback notification function for exit-boot-services.
1153   All we do here is call WinNtGopDestructor().
1154
1155   @param  Event                  not used
1156   @param  Context                pointer to the Private structure.
1157
1158   @return None.
1159
1160 **/
1161 VOID
1162 EFIAPI
1163 KillNtGopThread (
1164   IN EFI_EVENT  Event,
1165   IN VOID       *Context
1166   )
1167 {
1168   WinNtGopDestructor (Context);
1169 }