UnixPkg/Sec/UgaX11.c

   1 /*++
   2
   3 Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
   4 Portions copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 --*/
  14 #include <Common/UnixInclude.h>
  15
  16 #include <sys/ipc.h>
  17 #include <sys/shm.h>
  18
  19 #include <PiPei.h>
  20 #include <Protocol/SimplePointer.h>
  21 #include <Protocol/SimpleTextIn.h>
  22 #include <Protocol/SimpleTextInEx.h>
  23 #include <Protocol/UgaDraw.h>
  24 #include <X11/Xlib.h>
  25 #include <X11/Xutil.h>
  26 #include <X11/Xos.h>
  27 #include <X11/extensions/XShm.h>
  28 #include <X11/keysym.h>
  29 #include <X11/cursorfont.h>
  30
  31 #include <Protocol/UnixThunk.h>
  32 #include <Protocol/UnixUgaIo.h>
  33
  34 #include <Ppi/StatusCode.h>
  35
  36 #include <Library/PeCoffLib.h>
  37 #include <Library/BaseLib.h>
  38 #include <Library/BaseMemoryLib.h>
  39 #include <Library/PrintLib.h>
  40 #include <Library/PcdLib.h>
  41 #include <Library/DebugLib.h>
  42
  43 #include "Gasket.h"
  44 #include "SecMain.h"
  45
  46
  47 extern void msSleep (unsigned long Milliseconds);
  48
  49 /* XQueryPointer  */
  50
  51 struct uga_drv_shift_mask {
  52   unsigned char shift;
  53   unsigned char size;
  54   unsigned char csize;
  55 };
  56
  57 #define NBR_KEYS 32
  58 typedef struct {
  59   EFI_UNIX_UGA_IO_PROTOCOL UgaIo;
  60
  61   Display *display;
  62   int screen;                   /* values for window_size in main */
  63   Window win;
  64   GC gc;
  65   Visual *visual;
  66
  67   int depth;
  68   unsigned int width;
  69   unsigned int height;
  70   unsigned int line_bytes;
  71   unsigned int pixel_shift;
  72   unsigned char *image_data;
  73
  74   struct uga_drv_shift_mask r, g, b;
  75
  76   int use_shm;
  77   XShmSegmentInfo xshm_info;
  78   XImage *image;
  79
  80   unsigned int key_rd;
  81   unsigned int key_wr;
  82   unsigned int key_count;
  83   EFI_KEY_DATA keys[NBR_KEYS];
  84
  85   EFI_KEY_STATE KeyState;
  86
  87   UGA_REGISTER_KEY_NOTIFY_CALLBACK RegisterdKeyCallback;
  88   VOID                             *RegisterdKeyCallbackContext;
  89
  90   int                        previous_x;
  91   int                        previous_y;
  92   EFI_SIMPLE_POINTER_STATE   pointer_state;
  93   int                        pointer_state_changed;
  94 } UGA_IO_PRIVATE;
  95
  96 void
  97 HandleEvents(UGA_IO_PRIVATE *drv);
  98
  99 void
 100 fill_shift_mask (struct uga_drv_shift_mask *sm, unsigned long mask)
 101 {
 102   sm->shift = 0;
 103   sm->size = 0;
 104   while ((mask & 1) == 0)
 105     {
 106       mask >>= 1;
 107       sm->shift++;
 108     }
 109   while (mask & 1)
 110     {
 111       sm->size++;
 112       mask >>= 1;
 113     }
 114   sm->csize = 8 - sm->size;
 115 }
 116
 117 int
 118 TryCreateShmImage(UGA_IO_PRIVATE *drv)
 119 {
 120   drv->image = XShmCreateImage (drv->display, drv->visual,
 121                  drv->depth, ZPixmap, NULL, &drv->xshm_info,
 122                  drv->width, drv->height);
 123   if (drv->image == NULL)
 124     return 0;
 125
 126   switch (drv->image->bitmap_unit) {
 127   case 32:
 128     drv->pixel_shift = 2;
 129     break;
 130   case 16:
 131     drv->pixel_shift = 1;
 132     break;
 133   case 8:
 134     drv->pixel_shift = 0;
 135     break;
 136   }
 137
 138   drv->xshm_info.shmid = shmget
 139                           (IPC_PRIVATE, drv->image->bytes_per_line * drv->image->height,
 140                           IPC_CREAT | 0777);
 141   if (drv->xshm_info.shmid < 0) {
 142     XDestroyImage(drv->image);
 143     return 0;
 144   }
 145
 146   drv->image_data = shmat (drv->xshm_info.shmid, NULL, 0);
 147   if(!drv->image_data) {
 148     shmctl (drv->xshm_info.shmid, IPC_RMID, NULL);
 149     XDestroyImage(drv->image);
 150     return 0;
 151   }
 152
 153 #ifndef __APPLE__
 154   //
 155   // This closes shared memory in real time on OS X. Only closes after folks quit using
 156   // it on Linux.
 157   //
 158   /* Can this fail ?  */
 159   shmctl (drv->xshm_info.shmid, IPC_RMID, NULL);
 160 #endif
 161
 162   drv->xshm_info.shmaddr = (char*)drv->image_data;
 163   drv->image->data = (char*)drv->image_data;
 164
 165   if (!XShmAttach (drv->display, &drv->xshm_info)) {
 166     shmdt (drv->image_data);
 167     XDestroyImage(drv->image);
 168     return 0;
 169   }
 170   return 1;
 171 }
 172
 173 EFI_STATUS
 174 UgaClose (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo)
 175 {
 176   UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
 177
 178   if (drv == NULL)
 179     return EFI_SUCCESS;
 180   if (drv->image != NULL)
 181     {
 182       XDestroyImage(drv->image);
 183
 184       if (drv->use_shm)
 185         shmdt (drv->image_data);
 186
 187       drv->image_data = NULL;
 188       drv->image = NULL;
 189     }
 190   XDestroyWindow(drv->display, drv->win);
 191   XCloseDisplay(drv->display);
 192
 193 #ifdef __APPLE__
 194   // Free up the shared memory
 195   shmctl (drv->xshm_info.shmid, IPC_RMID, NULL);
 196 #endif
 197
 198   free(drv);
 199   return EFI_SUCCESS;
 200 }
 201
 202 EFI_STATUS
 203 UgaSize(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, UINT32 Width, UINT32 Height)
 204 {
 205   UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
 206   XSizeHints size_hints;
 207
 208   /* Destroy current buffer if created.  */
 209   if (drv->image != NULL)
 210     {
 211       /* Before destroy buffer, need to make sure the buffer available for access. */
 212       XDestroyImage(drv->image);
 213
 214       if (drv->use_shm)
 215         shmdt (drv->image_data);
 216
 217       drv->image_data = NULL;
 218       drv->image = NULL;
 219     }
 220
 221   drv->width = Width;
 222   drv->height = Height;
 223   XResizeWindow (drv->display, drv->win, Width, Height);
 224
 225   /* Allocate image.  */
 226   if (XShmQueryExtension(drv->display) && TryCreateShmImage(drv)) {
 227     drv->use_shm = 1;
 228   } else {
 229     drv->use_shm = 0;
 230     if (drv->depth > 16)
 231       drv->pixel_shift = 2;
 232     else if (drv->depth > 8)
 233       drv->pixel_shift = 1;
 234     else
 235       drv->pixel_shift = 0;
 236
 237       drv->image_data = malloc((drv->width * drv->height) << drv->pixel_shift);
 238       drv->image = XCreateImage (drv->display, drv->visual, drv->depth,
 239                                   ZPixmap, 0, (char *)drv->image_data,
 240                                   drv->width, drv->height,
 241                                   8 << drv->pixel_shift, 0);
 242     }
 243   drv->line_bytes = drv->image->bytes_per_line;
 244   fill_shift_mask (&drv->r, drv->image->red_mask);
 245   fill_shift_mask (&drv->g, drv->image->green_mask);
 246   fill_shift_mask (&drv->b, drv->image->blue_mask);
 247
 248   /* Set WM hints.  */
 249   size_hints.flags = PSize | PMinSize | PMaxSize;
 250   size_hints.min_width = size_hints.max_width = size_hints.base_width = Width;
 251   size_hints.min_height = size_hints.max_height = size_hints.base_height = Height;
 252   XSetWMNormalHints (drv->display, drv->win, &size_hints);
 253
 254   XMapWindow (drv->display, drv->win);
 255   HandleEvents(drv);
 256   return EFI_SUCCESS;
 257 }
 258
 259 void
 260 handleKeyEvent(UGA_IO_PRIVATE *drv, XEvent *ev)
 261 {
 262   KeySym keysym;
 263   char str[4];
 264   EFI_KEY_DATA KeyData;
 265   int res;
 266
 267   if (drv->key_count == NBR_KEYS)
 268     return;
 269
 270   res = XLookupString(&ev->xkey, str, sizeof(str), &keysym, NULL);
 271   KeyData.Key.ScanCode = 0;
 272   KeyData.Key.UnicodeChar = 0;
 273   KeyData.KeyState.KeyShiftState = 0;
 274
 275   //
 276   // KeyRelease is not supported (on Mac) so we can not easily implement Ex functions.
 277   // If a modifier key is hit by its self we get a keysym. If a modfifier and key is hit
 278   // we get the state bit set and keysym is the modified key.
 279   //
 280   // We use lack of state bits being set to clear ToggleState and KeyShiftState. We can
 281   // also use the stat bits to set ToggleState and KeyShiftState.
 282   // Skipping EFI_SCROLL_LOCK_ACTIVE & EFI_NUM_LOCK_ACTIVE since they are not on Macs
 283   //
 284   if ((ev->xkey.state & LockMask) == 0) {
 285     drv->KeyState.KeyToggleState &= ~EFI_CAPS_LOCK_ACTIVE;
 286   } else {
 287     drv->KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;
 288   }
 289
 290   if ((ev->xkey.state & ControlMask) == 0) {
 291     drv->KeyState.KeyShiftState &= ~(EFI_RIGHT_CONTROL_PRESSED | EFI_LEFT_CONTROL_PRESSED);
 292   } else if ((drv->KeyState.KeyShiftState & EFI_RIGHT_CONTROL_PRESSED) == 0) {
 293     drv->KeyState.KeyShiftState |= EFI_LEFT_CONTROL_PRESSED;
 294   }
 295
 296   if ((ev->xkey.state & ShiftMask) == 0) {
 297     drv->KeyState.KeyShiftState &= ~(EFI_RIGHT_SHIFT_PRESSED | EFI_LEFT_SHIFT_PRESSED);
 298   } else if ((drv->KeyState.KeyShiftState & EFI_RIGHT_SHIFT_PRESSED) == 0) {
 299     drv->KeyState.KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;
 300   }
 301
 302   if ((ev->xkey.state & Mod2Mask) == 0) {
 303     drv->KeyState.KeyShiftState &= ~(EFI_RIGHT_LOGO_PRESSED | EFI_LEFT_LOGO_PRESSED);
 304   } else if ((drv->KeyState.KeyShiftState & EFI_RIGHT_LOGO_PRESSED) == 0) {
 305     drv->KeyState.KeyShiftState |= EFI_LEFT_LOGO_PRESSED;
 306   }
 307
 308   if ((ev->xkey.state & 0x2000) == 0) {
 309     drv->KeyState.KeyShiftState &= ~(EFI_LEFT_ALT_PRESSED);
 310   } else {
 311     drv->KeyState.KeyShiftState |= EFI_LEFT_ALT_PRESSED;
 312   }
 313
 314
 315   switch (keysym) {
 316   case XK_Control_R:
 317     drv->KeyState.KeyShiftState |= EFI_RIGHT_CONTROL_PRESSED;
 318     break;
 319   case XK_Control_L:
 320     drv->KeyState.KeyShiftState |= EFI_LEFT_CONTROL_PRESSED;
 321     break;
 322
 323   case XK_Shift_R:
 324     drv->KeyState.KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED;
 325     break;
 326   case XK_Shift_L:
 327     drv->KeyState.KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;
 328     break;
 329
 330   case XK_Mode_switch:
 331     drv->KeyState.KeyShiftState |= EFI_LEFT_ALT_PRESSED;
 332     break;
 333
 334   case XK_Meta_R:
 335     drv->KeyState.KeyShiftState |= EFI_RIGHT_LOGO_PRESSED;
 336     break;
 337   case XK_Meta_L:
 338     drv->KeyState.KeyShiftState |= EFI_LEFT_LOGO_PRESSED;
 339     break;
 340
 341   case XK_Home:       KeyData.Key.ScanCode = SCAN_HOME;       break;
 342   case XK_End:        KeyData.Key.ScanCode = SCAN_END;        break;
 343   case XK_Left:       KeyData.Key.ScanCode = SCAN_LEFT;       break;
 344   case XK_Right:      KeyData.Key.ScanCode = SCAN_RIGHT;      break;
 345   case XK_Up:         KeyData.Key.ScanCode = SCAN_UP;         break;
 346   case XK_Down:       KeyData.Key.ScanCode = SCAN_DOWN;       break;
 347   case XK_Delete:     KeyData.Key.ScanCode = SCAN_DELETE;     break;
 348   case XK_Insert:     KeyData.Key.ScanCode = SCAN_INSERT;     break;
 349   case XK_Page_Up:    KeyData.Key.ScanCode = SCAN_PAGE_UP;    break;
 350   case XK_Page_Down:  KeyData.Key.ScanCode = SCAN_PAGE_DOWN;  break;
 351   case XK_Escape:     KeyData.Key.ScanCode = SCAN_ESC;        break;
 352
 353   case XK_F1:   KeyData.Key.ScanCode = SCAN_F1;   break;
 354   case XK_F2:   KeyData.Key.ScanCode = SCAN_F2;   break;
 355   case XK_F3:   KeyData.Key.ScanCode = SCAN_F3;   break;
 356   case XK_F4:   KeyData.Key.ScanCode = SCAN_F4;   break;
 357   case XK_F5:   KeyData.Key.ScanCode = SCAN_F5;   break;
 358   case XK_F6:   KeyData.Key.ScanCode = SCAN_F6;   break;
 359   case XK_F7:   KeyData.Key.ScanCode = SCAN_F7;   break;
 360   case XK_F8:   KeyData.Key.ScanCode = SCAN_F8;   break;
 361   case XK_F9:   KeyData.Key.ScanCode = SCAN_F9;   break;
 362
 363   default:
 364     if (res == 1) {
 365       KeyData.Key.UnicodeChar = str[0];
 366     } else {
 367       return;
 368     }
 369   }
 370
 371   // The global state is our state
 372   KeyData.KeyState.KeyShiftState = drv->KeyState.KeyShiftState;
 373   KeyData.KeyState.KeyToggleState = drv->KeyState.KeyToggleState;
 374
 375   CopyMem (&drv->keys[drv->key_wr], &KeyData, sizeof (EFI_KEY_DATA));
 376   drv->key_wr = (drv->key_wr + 1) % NBR_KEYS;
 377   drv->key_count++;
 378
 379
 380 #if defined(__APPLE__) || defined(MDE_CPU_X64)
 381   ReverseGasketUint64Uint64 (drv->RegisterdKeyCallback ,drv->RegisterdKeyCallbackContext, &KeyData);
 382 #else
 383   drv->RegisterdKeyCallback (drv->RegisterdKeyCallbackContext, &KeyData);
 384 #endif
 385
 386
 387 }
 388
 389
 390 void
 391 handleMouseMoved(UGA_IO_PRIVATE *drv, XEvent *ev)
 392 {
 393   if ( ev->xmotion.x != drv->previous_x )
 394   {
 395     drv->pointer_state.RelativeMovementX += ( ev->xmotion.x - drv->previous_x );
 396         drv->previous_x = ev->xmotion.x;
 397         drv->pointer_state_changed = 1;
 398   }
 399
 400   if ( ev->xmotion.y != drv->previous_y )
 401   {
 402     drv->pointer_state.RelativeMovementY += ( ev->xmotion.y - drv->previous_y );
 403     drv->previous_y = ev->xmotion.y;
 404         drv->pointer_state_changed = 1;
 405   }
 406
 407   drv->pointer_state.RelativeMovementZ = 0;
 408 }
 409
 410 void
 411 handleMouseDown(UGA_IO_PRIVATE *drv, XEvent *ev, BOOLEAN Pressed)
 412 {
 413   if ( ev->xbutton.button == Button1 )
 414   {
 415     drv->pointer_state_changed = ( drv->pointer_state.LeftButton != Pressed );
 416         drv->pointer_state.LeftButton = Pressed;
 417   }
 418   if ( ev->xbutton.button == Button2 )
 419   {
 420     drv->pointer_state_changed = ( drv->pointer_state.RightButton != Pressed );
 421         drv->pointer_state.RightButton = Pressed;
 422   }
 423 }
 424
 425 void
 426 Redraw(UGA_IO_PRIVATE *drv, UINTN X, UINTN Y, UINTN Width, UINTN Height)
 427 {
 428   if (drv->use_shm)
 429     XShmPutImage (drv->display, drv->win, drv->gc, drv->image,
 430                    X, Y, X, Y, Width, Height, False);
 431   else
 432     XPutImage (drv->display, drv->win, drv->gc, drv->image,
 433                 X, Y, X, Y, Width, Height);
 434   XFlush(drv->display);
 435 }
 436
 437 void
 438 HandleEvent(UGA_IO_PRIVATE *drv, XEvent *ev)
 439 {
 440   switch (ev->type)
 441     {
 442     case Expose:
 443       Redraw(drv, ev->xexpose.x, ev->xexpose.y,
 444         ev->xexpose.width, ev->xexpose.height);
 445       break;
 446     case GraphicsExpose:
 447       Redraw(drv, ev->xgraphicsexpose.x, ev->xgraphicsexpose.y,
 448         ev->xgraphicsexpose.width, ev->xgraphicsexpose.height);
 449       break;
 450     case KeyPress:
 451       handleKeyEvent(drv, ev);
 452       break;
 453     case KeyRelease:
 454       break;
 455     case MappingNotify:
 456       XRefreshKeyboardMapping(&ev->xmapping);
 457       break;
 458     case MotionNotify:
 459       handleMouseMoved(drv, ev);
 460       break;
 461     case ButtonPress:
 462       handleMouseDown(drv, ev, TRUE);
 463           break;
 464     case ButtonRelease:
 465       handleMouseDown(drv, ev, FALSE);
 466           break;
 467 #if 0
 468     case DestroyNotify:
 469       XCloseDisplay (drv->display);
 470       exit (1);
 471       break;
 472 #endif
 473     case NoExpose:
 474     default:
 475       break;
 476     }
 477 }
 478
 479 void
 480 HandleEvents(UGA_IO_PRIVATE *drv)
 481 {
 482   while (XPending(drv->display) != 0)
 483     {
 484       XEvent ev;
 485
 486       XNextEvent (drv->display, &ev);
 487       HandleEvent(drv, &ev);
 488     }
 489 }
 490
 491 unsigned long
 492 UgaPixelToColor (UGA_IO_PRIVATE *drv, EFI_UGA_PIXEL pixel)
 493 {
 494   return ((pixel.Red >> drv->r.csize) << drv->r.shift)
 495     | ((pixel.Green >> drv->g.csize) << drv->g.shift)
 496     | ((pixel.Blue >> drv->b.csize) << drv->b.shift);
 497 }
 498
 499 EFI_UGA_PIXEL
 500 UgaColorToPixel (UGA_IO_PRIVATE *drv, unsigned long val)
 501 {
 502   EFI_UGA_PIXEL res;
 503
 504   memset (&res, 0, sizeof (EFI_UGA_PIXEL));
 505   /* FIXME: should round instead of truncate.  */
 506   res.Red = (val >> drv->r.shift) << drv->r.csize;
 507   res.Green = (val >> drv->g.shift) << drv->g.csize;
 508   res.Blue = (val >> drv->b.shift) << drv->b.csize;
 509
 510   return res;
 511 }
 512
 513 STATIC EFI_STATUS
 514 CheckKeyInternal( UGA_IO_PRIVATE *drv, BOOLEAN delay )
 515 {
 516   HandleEvents(drv);
 517   if (drv->key_count != 0)
 518     return EFI_SUCCESS;
 519   if ( delay )
 520     /* EFI is polling.  Be CPU-friendly.  */
 521     msSleep (20);
 522     return EFI_NOT_READY;
 523   }
 524
 525 EFI_STATUS
 526 UgaCheckKey(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo)
 527 {
 528   UGA_IO_PRIVATE  *drv = (UGA_IO_PRIVATE *)UgaIo;
 529   return( CheckKeyInternal( drv, TRUE ) );
 530 }
 531
 532 EFI_STATUS
 533 EFIAPI
 534 UgaGetKey (
 535   IN  EFI_UNIX_UGA_IO_PROTOCOL  *UgaIo,
 536   IN  EFI_KEY_DATA              *KeyData
 537   )
 538 {
 539   UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
 540   EFI_STATUS status;
 541
 542   status = CheckKeyInternal(drv, FALSE);
 543   if (status != EFI_SUCCESS)
 544     return status;
 545
 546   CopyMem (KeyData, &drv->keys[drv->key_rd], sizeof (EFI_KEY_DATA));
 547   drv->key_rd = (drv->key_rd + 1) % NBR_KEYS;
 548   drv->key_count--;
 549   return EFI_SUCCESS;
 550 }
 551
 552
 553 EFI_STATUS
 554 EFIAPI
 555 UgaKeySetState (
 556   IN EFI_UNIX_UGA_IO_PROTOCOL   *UgaIo,
 557   IN EFI_KEY_TOGGLE_STATE       *KeyToggleState
 558   )
 559 {
 560   UGA_IO_PRIVATE  *drv = (UGA_IO_PRIVATE *)UgaIo;
 561 //  XKeyEvent       event;
 562
 563   if (*KeyToggleState & EFI_CAPS_LOCK_ACTIVE) {
 564     if ((drv->KeyState.KeyToggleState & EFI_CAPS_LOCK_ACTIVE) == 0) {
 565       //
 566       // We could create an XKeyEvent and send a XK_Caps_Lock to
 567       // the UGA/GOP Window
 568       //
 569     }
 570   }
 571
 572   drv->KeyState.KeyToggleState = *KeyToggleState;
 573   return EFI_SUCCESS;
 574 }
 575
 576
 577 EFI_STATUS
 578 EFIAPI
 579 UgaRegisterKeyNotify (
 580   IN EFI_UNIX_UGA_IO_PROTOCOL           *UgaIo,
 581   IN UGA_REGISTER_KEY_NOTIFY_CALLBACK   CallBack,
 582   IN VOID                               *Context
 583   )
 584 {
 585   UGA_IO_PRIVATE  *drv = (UGA_IO_PRIVATE *)UgaIo;
 586
 587   drv->RegisterdKeyCallback = CallBack;
 588   drv->RegisterdKeyCallbackContext = Context;
 589
 590   return EFI_SUCCESS;
 591 }
 592
 593
 594 EFI_STATUS
 595 UgaBlt(
 596   IN EFI_UNIX_UGA_IO_PROTOCOL                 *UgaIo,
 597   IN  EFI_UGA_PIXEL                           *BltBuffer OPTIONAL,
 598   IN  EFI_UGA_BLT_OPERATION                   BltOperation,
 599   IN  UGA_BLT_ARGS                            *Args
 600   )
 601 {
 602   UGA_IO_PRIVATE *Private = (UGA_IO_PRIVATE *)UgaIo;
 603   UINTN             DstY;
 604   UINTN             SrcY;
 605   UINTN             DstX;
 606   UINTN             SrcX;
 607   UINTN             Index;
 608   EFI_UGA_PIXEL     *Blt;
 609   UINT8             *Dst;
 610   UINT8             *Src;
 611   UINTN             Nbr;
 612   unsigned long     Color;
 613
 614   //
 615   //  Check bounds
 616   //
 617   if (BltOperation == EfiUgaVideoToBltBuffer
 618       || BltOperation == EfiUgaVideoToVideo) {
 619     //
 620     // Source is Video.
 621     //
 622     if (Args->SourceY + Args->Height > Private->height) {
 623       return EFI_INVALID_PARAMETER;
 624     }
 625
 626     if (Args->SourceX + Args->Width > Private->width) {
 627       return EFI_INVALID_PARAMETER;
 628     }
 629   }
 630
 631   if (BltOperation == EfiUgaBltBufferToVideo
 632       || BltOperation == EfiUgaVideoToVideo
 633       || BltOperation == EfiUgaVideoFill) {
 634     //
 635     // Destination is Video
 636     //
 637     if (Args->DestinationY + Args->Height > Private->height) {
 638       return EFI_INVALID_PARAMETER;
 639     }
 640
 641     if (Args->DestinationX + Args->Width > Private->width) {
 642       return EFI_INVALID_PARAMETER;
 643     }
 644   }
 645
 646   switch (BltOperation) {
 647   case EfiUgaVideoToBltBuffer:
 648     Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (Args->DestinationY * Args->Delta) + Args->DestinationX * sizeof (EFI_UGA_PIXEL));
 649     Args->Delta -= Args->Width * sizeof (EFI_UGA_PIXEL);
 650     for (SrcY = Args->SourceY; SrcY < (Args->Height + Args->SourceY); SrcY++) {
 651       for (SrcX = Args->SourceX; SrcX < (Args->Width + Args->SourceX); SrcX++) {
 652         *Blt++ = UgaColorToPixel(Private,
 653                                   XGetPixel(Private->image, SrcX, SrcY));
 654       }
 655       Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Args->Delta);
 656     }
 657     break;
 658   case EfiUgaBltBufferToVideo:
 659     Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (Args->SourceY * Args->Delta) + Args->SourceX * sizeof (EFI_UGA_PIXEL));
 660     Args->Delta -= Args->Width * sizeof (EFI_UGA_PIXEL);
 661     for (DstY = Args->DestinationY; DstY < (Args->Height + Args->DestinationY); DstY++) {
 662       for (DstX = Args->DestinationX; DstX < (Args->Width + Args->DestinationX); DstX++) {
 663         XPutPixel(Private->image, DstX, DstY, UgaPixelToColor(Private, *Blt));
 664         Blt++;
 665       }
 666       Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Args->Delta);
 667     }
 668     break;
 669   case EfiUgaVideoToVideo:
 670     Dst = Private->image_data + (Args->DestinationX << Private->pixel_shift)
 671       + Args->DestinationY * Private->line_bytes;
 672     Src = Private->image_data + (Args->SourceX << Private->pixel_shift)
 673       + Args->SourceY * Private->line_bytes;
 674     Nbr = Args->Width << Private->pixel_shift;
 675     if (Args->DestinationY < Args->SourceY) {
 676       for (Index = 0; Index < Args->Height; Index++) {
 677         memcpy (Dst, Src, Nbr);
 678         Dst += Private->line_bytes;
 679         Src += Private->line_bytes;
 680       }
 681     }
 682     else {
 683       Dst += (Args->Height - 1) * Private->line_bytes;
 684       Src += (Args->Height - 1) * Private->line_bytes;
 685       for (Index = 0; Index < Args->Height; Index++) {
 686       //
 687       // Source and Destination Y may be equal, therefore Dst and Src may
 688       // overlap.
 689       //
 690       memmove (Dst, Src, Nbr);
 691       Dst -= Private->line_bytes;
 692       Src -= Private->line_bytes;
 693       }
 694     }
 695     break;
 696   case EfiUgaVideoFill:
 697     Color = UgaPixelToColor(Private, *BltBuffer);
 698     for (DstY = Args->DestinationY; DstY < (Args->Height + Args->DestinationY); DstY++) {
 699       for (DstX = Args->DestinationX; DstX < (Args->Width + Args->DestinationX); DstX++) {
 700         XPutPixel(Private->image, DstX, DstY, Color);
 701       }
 702     }
 703     break;
 704   default:
 705       return EFI_INVALID_PARAMETER;
 706   }
 707
 708   //
 709   //  Refresh screen.
 710   //
 711   switch (BltOperation) {
 712   case EfiUgaVideoToVideo:
 713     XCopyArea(Private->display, Private->win, Private->win, Private->gc,
 714                Args->SourceX, Args->SourceY, Args->Width, Args->Height, Args->DestinationX, Args->DestinationY);
 715     while (1) {
 716       XEvent ev;
 717
 718       XNextEvent (Private->display, &ev);
 719       HandleEvent(Private, &ev);
 720       if (ev.type == NoExpose || ev.type == GraphicsExpose)
 721         break;
 722     }
 723     break;
 724   case EfiUgaVideoFill:
 725     Color = UgaPixelToColor(Private, *BltBuffer);
 726     XSetForeground(Private->display, Private->gc, Color);
 727     XFillRectangle(Private->display, Private->win, Private->gc,
 728                     Args->DestinationX, Args->DestinationY, Args->Width, Args->Height);
 729     XFlush(Private->display);
 730     break;
 731   case EfiUgaBltBufferToVideo:
 732     Redraw(Private, Args->DestinationX, Args->DestinationY, Args->Width, Args->Height);
 733     break;
 734   default:
 735     break;
 736   }
 737   return EFI_SUCCESS;
 738 }
 739
 740 STATIC EFI_STATUS
 741 CheckPointerInternal( UGA_IO_PRIVATE *drv, BOOLEAN delay )
 742 {
 743   HandleEvents(drv);
 744   if (drv->pointer_state_changed != 0)
 745     return EFI_SUCCESS;
 746   if ( delay )
 747     /* EFI is polling.  Be CPU-friendly.  */
 748     msSleep (20);
 749   return EFI_NOT_READY;
 750 }
 751
 752 EFI_STATUS
 753 UgaCheckPointer(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo)
 754 {
 755   UGA_IO_PRIVATE  *drv = (UGA_IO_PRIVATE *)UgaIo;
 756   return( CheckPointerInternal( drv, TRUE ) );
 757 }
 758
 759 EFI_STATUS
 760 UgaGetPointerState (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, EFI_SIMPLE_POINTER_STATE *state)
 761 {
 762   UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
 763   EFI_STATUS status;
 764
 765   status = CheckPointerInternal( drv, FALSE );
 766   if (status != EFI_SUCCESS)
 767     return status;
 768
 769   memcpy( state, &drv->pointer_state, sizeof( EFI_SIMPLE_POINTER_STATE ) );
 770
 771   drv->pointer_state.RelativeMovementX = 0;
 772   drv->pointer_state.RelativeMovementY = 0;
 773   drv->pointer_state.RelativeMovementZ = 0;
 774   drv->pointer_state_changed = 0;
 775   return EFI_SUCCESS;
 776 }
 777
 778 EFI_STATUS
 779 UgaCreate (EFI_UNIX_UGA_IO_PROTOCOL **Uga, CONST CHAR16 *Title)
 780 {
 781   UGA_IO_PRIVATE *drv;
 782   unsigned int border_width = 0;
 783   char *display_name = NULL;
 784   int title_len;
 785
 786   drv = (UGA_IO_PRIVATE *)calloc (1, sizeof (UGA_IO_PRIVATE));
 787   if (drv == NULL)
 788     return EFI_OUT_OF_RESOURCES;
 789
 790 #if defined(__APPLE__) || defined(MDE_CPU_X64)
 791 //
 792 //
 793 //
 794   drv->UgaIo.UgaClose    = GasketUgaClose;
 795   drv->UgaIo.UgaSize     = GasketUgaSize;
 796   drv->UgaIo.UgaCheckKey = GasketUgaCheckKey;
 797   drv->UgaIo.UgaGetKey   = GasketUgaGetKey;
 798   drv->UgaIo.UgaKeySetState         = GasketUgaKeySetState;
 799   drv->UgaIo.UgaRegisterKeyNotify   = GasketUgaRegisterKeyNotify;
 800   drv->UgaIo.UgaBlt      = GasketUgaBlt;
 801   drv->UgaIo.UgaCheckPointer        = GasketUgaCheckPointer;
 802   drv->UgaIo.UgaGetPointerState     = GasketUgaGetPointerState;
 803 #else
 804   drv->UgaIo.UgaClose = UgaClose;
 805   drv->UgaIo.UgaSize = UgaSize;
 806   drv->UgaIo.UgaCheckKey = UgaCheckKey;
 807   drv->UgaIo.UgaGetKey = UgaGetKey;
 808   drv->UgaIo.UgaKeySetState         = UgaKeySetState;
 809   drv->UgaIo.UgaRegisterKeyNotify   = UgaRegisterKeyNotify;
 810   drv->UgaIo.UgaBlt = UgaBlt;
 811   drv->UgaIo.UgaCheckPointer        = UgaCheckPointer;
 812   drv->UgaIo.UgaGetPointerState     = UgaGetPointerState;
 813 #endif
 814
 815
 816
 817   drv->key_count = 0;
 818   drv->key_rd = 0;
 819   drv->key_wr = 0;
 820   drv->KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID;
 821   drv->KeyState.KeyToggleState = EFI_TOGGLE_STATE_VALID;
 822   drv->RegisterdKeyCallback = NULL;
 823   drv->RegisterdKeyCallbackContext = NULL;
 824
 825
 826   drv->display = XOpenDisplay (display_name);
 827   if (drv->display == NULL)
 828     {
 829       fprintf (stderr, "uga: cannot connect to X server %s\n",
 830                 XDisplayName (display_name));
 831       free (drv);
 832       return EFI_DEVICE_ERROR;
 833     }
 834   drv->screen = DefaultScreen (drv->display);
 835   drv->visual = DefaultVisual (drv->display, drv->screen);
 836   drv->win = XCreateSimpleWindow
 837                (drv->display, RootWindow (drv->display, drv->screen),
 838                 0, 0, 4, 4, border_width,
 839                 WhitePixel (drv->display, drv->screen),
 840                 BlackPixel (drv->display, drv->screen));
 841
 842   drv->depth = DefaultDepth (drv->display, drv->screen);
 843   XDefineCursor (drv->display, drv->win, XCreateFontCursor (drv->display, XC_pirate));
 844
 845   /* Compute title len and convert to Ascii.  */
 846   for (title_len = 0; Title[title_len] != 0; title_len++)
 847     ;
 848   {
 849     char title[title_len + 1];
 850     int i;
 851     for (i = 0; i < title_len; i++)
 852       title[i] = Title[i];
 853     title[i] = 0;
 854
 855     XStoreName (drv->display, drv->win, title);
 856   }
 857
 858   XSelectInput (drv->display, drv->win,
 859                  ExposureMask | KeyPressMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask );
 860   drv->gc = DefaultGC (drv->display, drv->screen);
 861
 862   *Uga = (EFI_UNIX_UGA_IO_PROTOCOL *)drv;
 863   return EFI_SUCCESS;
 864 }