[mirror_edk2.git] / UnixPkg / Sec / UgaX11.c

/*++

Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
This program and the accompanying materials                          
are licensed and made available under the terms and conditions of the BSD License         
which accompanies this distribution.  The full text of the license may be found at        
http://opensource.org/licenses/bsd-license.php                                            
                                                                                          
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

--*/

#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>

#include "PiPei.h"
#include "Protocol/UnixThunk.h"
#include "Protocol/SimpleTextIn.h"
#include "Protocol/UgaDraw.h"
#include "Protocol/UnixUgaIo.h"
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xos.h>
#include <X11/extensions/XShm.h>
#include <X11/keysym.h>

#include <Ppi/StatusCode.h>

#include <Library/PeCoffLib.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/PrintLib.h>
#include <Library/PcdLib.h>
#include <Library/DebugLib.h>

extern void msSleep (unsigned long Milliseconds);

/* XQueryPointer  */

struct uga_drv_shift_mask
{
  unsigned char shift;
  unsigned char size;
  unsigned char csize;
};

#define NBR_KEYS 32
typedef struct
{
  EFI_UNIX_UGA_IO_PROTOCOL UgaIo;

  Display *display;
  int screen;			/* values for window_size in main */
  Window win;
  GC gc;
  Visual *visual;

  int depth;
  unsigned int width;
  unsigned int height;
  unsigned int line_bytes;
  unsigned int pixel_shift;
  unsigned char *image_data;

  struct uga_drv_shift_mask r, g, b;

  int use_shm;
  XShmSegmentInfo xshm_info;
  XImage *image;

  unsigned int key_rd;
  unsigned int key_wr;
  unsigned int key_count;
  EFI_INPUT_KEY keys[NBR_KEYS];
} UGA_IO_PRIVATE;

void
HandleEvents(UGA_IO_PRIVATE *drv);

void
fill_shift_mask (struct uga_drv_shift_mask *sm, unsigned long mask)
{
  sm->shift = 0;
  sm->size = 0;
  while ((mask & 1) == 0)
    {
      mask >>= 1;
      sm->shift++;
    }
  while (mask & 1)
    {
      sm->size++;
      mask >>= 1;
    }
  sm->csize = 8 - sm->size;
}

int
TryCreateShmImage(UGA_IO_PRIVATE *drv)
{
  drv->image = XShmCreateImage (drv->display, drv->visual,
                 drv->depth, ZPixmap, NULL, &drv->xshm_info,
                 drv->width, drv->height);
  if (drv->image == NULL)
    return 0;

  switch (drv->image->bitmap_unit) {
  case 32:
    drv->pixel_shift = 2;
    break;
  case 16:
    drv->pixel_shift = 1;
    break;
  case 8:
    drv->pixel_shift = 0;
    break;
  }

  drv->xshm_info.shmid = shmget
                          (IPC_PRIVATE, drv->image->bytes_per_line * drv->image->height,
                          IPC_CREAT | 0777);
  if (drv->xshm_info.shmid < 0) {
    XDestroyImage(drv->image);
    return 0;
  }
      
  drv->image_data = shmat (drv->xshm_info.shmid, NULL, 0);
  if(!drv->image_data) {
    shmctl (drv->xshm_info.shmid, IPC_RMID, NULL);
    XDestroyImage(drv->image);
    return 0;
  }
  
#ifndef __APPLE__  
  //
  // This closes shared memory in real time on OS X. Only closes after folks quit using
  // it on Linux. 
  //
  /* Can this fail ?  */
  shmctl (drv->xshm_info.shmid, IPC_RMID, NULL);
#endif

  drv->xshm_info.shmaddr = (char*)drv->image_data;
  drv->image->data = (char*)drv->image_data;

  if (!XShmAttach (drv->display, &drv->xshm_info)) {
    shmdt (drv->image_data);
    XDestroyImage(drv->image);
    return 0;
  }
  return 1;
}

EFI_STATUS
UgaClose (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo)
{
  UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;

  if (drv == NULL)
    return EFI_SUCCESS;
  if (drv->image != NULL)
    {
      XDestroyImage(drv->image);

      if (drv->use_shm)
        shmdt (drv->image_data);

      drv->image_data = NULL;
      drv->image = NULL;
    }
  XDestroyWindow(drv->display, drv->win);
  XCloseDisplay(drv->display);
  
#ifdef __APPLE__
  // Free up the shared memory
  shmctl (drv->xshm_info.shmid, IPC_RMID, NULL);
#endif
  
  free(drv);
  return EFI_SUCCESS;
}

EFI_STATUS
UgaSize(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, UINT32 Width, UINT32 Height)
{
  UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
  XSizeHints size_hints;

  /* Destroy current buffer if created.  */
  if (drv->image != NULL)
    {
      /* Before destroy buffer, need to make sure the buffer available for access. */
      XDestroyImage(drv->image);

      if (drv->use_shm)
        shmdt (drv->image_data);

      drv->image_data = NULL;
      drv->image = NULL;
    }

  drv->width = Width;
  drv->height = Height;
  XResizeWindow (drv->display, drv->win, Width, Height);

  /* Allocate image.  */
  if (XShmQueryExtension(drv->display) && TryCreateShmImage(drv)) {
    drv->use_shm = 1;
  } else {
    drv->use_shm = 0;
    if (drv->depth > 16)
      drv->pixel_shift = 2;
    else if (drv->depth > 8)
      drv->pixel_shift = 1;
    else
      drv->pixel_shift = 0;
      
      drv->image_data = malloc((drv->width * drv->height) << drv->pixel_shift);
      drv->image = XCreateImage (drv->display, drv->visual, drv->depth,
                                  ZPixmap, 0, (char *)drv->image_data,
                                  drv->width, drv->height,
                                  8 << drv->pixel_shift, 0);
    }
  drv->line_bytes = drv->image->bytes_per_line;
  fill_shift_mask (&drv->r, drv->image->red_mask);
  fill_shift_mask (&drv->g, drv->image->green_mask);
  fill_shift_mask (&drv->b, drv->image->blue_mask);

  /* Set WM hints.  */
  size_hints.flags = PSize | PMinSize | PMaxSize;
  size_hints.min_width = size_hints.max_width = size_hints.base_width = Width;
  size_hints.min_height = size_hints.max_height = size_hints.base_height = Height;
  XSetWMNormalHints (drv->display, drv->win, &size_hints);

  XMapWindow (drv->display, drv->win);
  HandleEvents(drv);
  return EFI_SUCCESS;
}

void
handleKeyEvent(UGA_IO_PRIVATE *drv, XEvent *ev)
{
  KeySym keysym;
  char str[4];
  EFI_INPUT_KEY Key;
  int res;

  if (drv->key_count == NBR_KEYS)
    return;

  res = XLookupString(&ev->xkey, str, sizeof(str), &keysym, NULL);
  Key.ScanCode = 0;
  Key.UnicodeChar = 0;
  switch (keysym) {
  case XK_Home:       Key.ScanCode = SCAN_HOME;       break;
  case XK_End:        Key.ScanCode = SCAN_END;        break;
  case XK_Left:       Key.ScanCode = SCAN_LEFT;       break;
  case XK_Right:      Key.ScanCode = SCAN_RIGHT;      break;
  case XK_Up:         Key.ScanCode = SCAN_UP;         break;
  case XK_Down:       Key.ScanCode = SCAN_DOWN;       break;
  case XK_Delete:     Key.ScanCode = SCAN_DELETE;     break;
  case XK_Insert:     Key.ScanCode = SCAN_INSERT;     break;
  case XK_Page_Up:    Key.ScanCode = SCAN_PAGE_UP;    break;
  case XK_Page_Down:  Key.ScanCode = SCAN_PAGE_DOWN;  break;
  case XK_Escape:     Key.ScanCode = SCAN_ESC;        break;

  case XK_F1:   Key.ScanCode = SCAN_F1;   break;
  case XK_F2:   Key.ScanCode = SCAN_F2;   break;
  case XK_F3:   Key.ScanCode = SCAN_F3;   break;
  case XK_F4:   Key.ScanCode = SCAN_F4;   break;
  case XK_F5:   Key.ScanCode = SCAN_F5;   break;
  case XK_F6:   Key.ScanCode = SCAN_F6;   break;
  case XK_F7:   Key.ScanCode = SCAN_F7;   break;
  case XK_F8:   Key.ScanCode = SCAN_F8;   break;
  case XK_F9:   Key.ScanCode = SCAN_F9;   break;

  default:
    if (res == 1) {
      Key.UnicodeChar = str[0];
    } else {
      return;
    }
  }

  drv->keys[drv->key_wr] = Key;
  drv->key_wr = (drv->key_wr + 1) % NBR_KEYS;
  drv->key_count++;
}

void
Redraw(UGA_IO_PRIVATE *drv, UINTN X, UINTN Y, UINTN Width, UINTN Height)
{
  if (drv->use_shm)
    XShmPutImage (drv->display, drv->win, drv->gc, drv->image,
                   X, Y, X, Y, Width, Height, False);
  else
    XPutImage (drv->display, drv->win, drv->gc, drv->image,
                X, Y, X, Y, Width, Height);
  XFlush(drv->display);
}

void
HandleEvent(UGA_IO_PRIVATE *drv, XEvent *ev)
{
  switch (ev->type)
    {
    case Expose:
      Redraw(drv, ev->xexpose.x, ev->xexpose.y,
        ev->xexpose.width, ev->xexpose.height);
      break;
    case GraphicsExpose:
      Redraw(drv, ev->xgraphicsexpose.x, ev->xgraphicsexpose.y,
        ev->xgraphicsexpose.width, ev->xgraphicsexpose.height);
      break;
    case KeyPress:
      handleKeyEvent(drv, ev);
      break;
    case MappingNotify:
      XRefreshKeyboardMapping(&ev->xmapping);
      break;
#if 0
    case DestroyNotify:
      XCloseDisplay (drv->display);
      exit (1);
      break;
#endif
    case NoExpose:
    default:
      break;
    }
}

void
HandleEvents(UGA_IO_PRIVATE *drv)
{
  while (XPending(drv->display) != 0)
    {
      XEvent ev;

      XNextEvent (drv->display, &ev);
      HandleEvent(drv, &ev);
    }
}

unsigned long
UgaPixelToColor (UGA_IO_PRIVATE *drv, EFI_UGA_PIXEL pixel)
{
  return ((pixel.Red >> drv->r.csize) << drv->r.shift)
    | ((pixel.Green >> drv->g.csize) << drv->g.shift)
    | ((pixel.Blue >> drv->b.csize) << drv->b.shift);
}

EFI_UGA_PIXEL
UgaColorToPixel (UGA_IO_PRIVATE *drv, unsigned long val)
{
  EFI_UGA_PIXEL res;

  memset (&res, 0, sizeof (EFI_UGA_PIXEL));
  /* FIXME: should round instead of truncate.  */
  res.Red = (val >> drv->r.shift) << drv->r.csize;
  res.Green = (val >> drv->g.shift) << drv->g.csize;
  res.Blue = (val >> drv->b.shift) << drv->b.csize;

  return res;
}

EFI_STATUS
UgaCheckKey(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo)
{
  UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
  HandleEvents(drv);
  
  if (drv->key_count != 0) {
    return EFI_SUCCESS;
  } else {
    /* EFI is certainly polling.  Be CPU-friendly.  */
    msSleep (20);
    return EFI_NOT_READY;
  }
}

EFI_STATUS
UgaGetKey (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, EFI_INPUT_KEY *key)
{
  UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
  EFI_STATUS status;

  status = UgaCheckKey(UgaIo);
  if (status != EFI_SUCCESS)
    return status;

  *key = drv->keys[drv->key_rd];
  drv->key_rd = (drv->key_rd + 1) % NBR_KEYS;
  drv->key_count--;
  return EFI_SUCCESS;
}

EFI_STATUS
UgaBlt(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo,
       IN  EFI_UGA_PIXEL                           *BltBuffer OPTIONAL,
       IN  EFI_UGA_BLT_OPERATION                   BltOperation,
       IN  UINTN                                   SourceX,
       IN  UINTN                                   SourceY,
       IN  UINTN                                   DestinationX,
       IN  UINTN                                   DestinationY,
       IN  UINTN                                   Width,
       IN  UINTN                                   Height,
       IN  UINTN                                   Delta OPTIONAL
  )
{
  UGA_IO_PRIVATE *Private = (UGA_IO_PRIVATE *)UgaIo;
  UINTN             DstY;
  UINTN             SrcY;
  UINTN             DstX;
  UINTN             SrcX;
  UINTN             Index;
  EFI_UGA_PIXEL     *Blt;
  UINT8             *Dst;
  UINT8             *Src;
  UINTN             Nbr;
  unsigned long     Color;

  //
  //  Check bounds
  //
  if (BltOperation == EfiUgaVideoToBltBuffer
      || BltOperation == EfiUgaVideoToVideo) {
    //
    // Source is Video.
    //
    if (SourceY + Height > Private->height) {
      return EFI_INVALID_PARAMETER;
    }

    if (SourceX + Width > Private->width) {
      return EFI_INVALID_PARAMETER;
    }
  }

  if (BltOperation == EfiUgaBltBufferToVideo
      || BltOperation == EfiUgaVideoToVideo
      || BltOperation == EfiUgaVideoFill) {
    //
    // Destination is Video
    //
    if (DestinationY + Height > Private->height) {
      return EFI_INVALID_PARAMETER;
    }

    if (DestinationX + Width > Private->width) {
      return EFI_INVALID_PARAMETER;
    }
  }

  switch (BltOperation) {
  case EfiUgaVideoToBltBuffer:
    Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (DestinationY * Delta) + DestinationX * sizeof (EFI_UGA_PIXEL));
    Delta -= Width * sizeof (EFI_UGA_PIXEL);
    for (SrcY = SourceY; SrcY < (Height + SourceY); SrcY++) {
      for (SrcX = SourceX; SrcX < (Width + SourceX); SrcX++) {
        *Blt++ = UgaColorToPixel(Private,
                                  XGetPixel(Private->image, SrcX, SrcY));
      }
      Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Delta);
    }
    break;
  case EfiUgaBltBufferToVideo:
    Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (SourceY * Delta) + SourceX * sizeof (EFI_UGA_PIXEL));
    Delta -= Width * sizeof (EFI_UGA_PIXEL);
    for (DstY = DestinationY; DstY < (Height + DestinationY); DstY++) {
      for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) {
        XPutPixel(Private->image, DstX, DstY, UgaPixelToColor(Private, *Blt));
        Blt++;
      }
      Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Delta);
    }
    break;
  case EfiUgaVideoToVideo:
    Dst = Private->image_data + (DestinationX << Private->pixel_shift)
      + DestinationY * Private->line_bytes;
    Src = Private->image_data + (SourceX << Private->pixel_shift)
      + SourceY * Private->line_bytes;
    Nbr = Width << Private->pixel_shift;
    if (DestinationY < SourceY) {
      for (Index = 0; Index < Height; Index++) {
        memcpy (Dst, Src, Nbr);
        Dst += Private->line_bytes;
        Src += Private->line_bytes;
      }
    }
    else {
      Dst += (Height - 1) * Private->line_bytes;
      Src += (Height - 1) * Private->line_bytes;
      for (Index = 0; Index < Height; Index++) {
      //
      // Source and Destination Y may be equal, therefore Dst and Src may
      // overlap.
      //
      memmove (Dst, Src, Nbr);
      Dst -= Private->line_bytes;
      Src -= Private->line_bytes;
      }
    }
    break;
  case EfiUgaVideoFill:
    Color = UgaPixelToColor(Private, *BltBuffer);
    for (DstY = DestinationY; DstY < (Height + DestinationY); DstY++) {
      for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) {
        XPutPixel(Private->image, DstX, DstY, Color);
      }
    }
    break;
  default:
      return EFI_INVALID_PARAMETER;
  }

  //
  //  Refresh screen.
  //
  switch (BltOperation) {
  case EfiUgaVideoToVideo:
    XCopyArea(Private->display, Private->win, Private->win, Private->gc,
               SourceX, SourceY, Width, Height, DestinationX, DestinationY);
    while (1) {
      XEvent ev;

      XNextEvent (Private->display, &ev);
      HandleEvent(Private, &ev);
      if (ev.type == NoExpose || ev.type == GraphicsExpose)
        break;
    }
    break;
  case EfiUgaVideoFill:
    Color = UgaPixelToColor(Private, *BltBuffer);
    XSetForeground(Private->display, Private->gc, Color);
    XFillRectangle(Private->display, Private->win, Private->gc,
                    DestinationX, DestinationY, Width, Height);
    XFlush(Private->display);
    break;
  case EfiUgaBltBufferToVideo:
    Redraw(Private, DestinationX, DestinationY, Width, Height);
    break;
  default:
    break;
  }
  return EFI_SUCCESS;
}

EFI_STATUS
UgaCreate (EFI_UNIX_UGA_IO_PROTOCOL **Uga, CONST CHAR16 *Title)
{
  UGA_IO_PRIVATE *drv;
  unsigned int border_width = 0;
  char *display_name = NULL;
  int title_len;

  drv = (UGA_IO_PRIVATE *)calloc (1, sizeof (UGA_IO_PRIVATE));
  if (drv == NULL)
    return EFI_OUT_OF_RESOURCES;

#ifdef __APPLE__
//
//
//
EFI_STATUS EFIAPI GasketUgaClose (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo);
EFI_STATUS EFIAPI GasketUgaSize (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, UINT32 Width, UINT32 Height);
EFI_STATUS EFIAPI GasketUgaCheckKey (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo);
EFI_STATUS EFIAPI GasketUgaGetKey (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, EFI_INPUT_KEY *key);
EFI_STATUS EFIAPI GasketUgaBlt (
   EFI_UNIX_UGA_IO_PROTOCOL *UgaIo,
   IN  EFI_UGA_PIXEL                           *BltBuffer OPTIONAL,
   IN  EFI_UGA_BLT_OPERATION                   BltOperation,
   IN  UINTN                                   SourceX,
   IN  UINTN                                   SourceY,
   IN  UINTN                                   DestinationX,
   IN  UINTN                                   DestinationY,
   IN  UINTN                                   Width,
   IN  UINTN                                   Height,
   IN  UINTN                                   Delta OPTIONAL
   );

  drv->UgaIo.UgaClose    = GasketUgaClose; 
  drv->UgaIo.UgaSize     = GasketUgaSize;
  drv->UgaIo.UgaCheckKey = GasketUgaCheckKey;
  drv->UgaIo.UgaGetKey   = GasketUgaGetKey;
  drv->UgaIo.UgaBlt      = GasketUgaBlt;
#else
  drv->UgaIo.UgaClose = UgaClose;
  drv->UgaIo.UgaSize = UgaSize;
  drv->UgaIo.UgaCheckKey = UgaCheckKey;
  drv->UgaIo.UgaGetKey = UgaGetKey;
  drv->UgaIo.UgaBlt = UgaBlt;
#endif
  
  

  drv->key_count = 0;
  drv->key_rd = 0;
  drv->key_wr = 0;
  drv->display = XOpenDisplay (display_name);
  if (drv->display == NULL)
    {
      fprintf (stderr, "uga: cannot connect to X server %s\n",
                XDisplayName (display_name));
      free (drv);
      return EFI_DEVICE_ERROR;
    }
  drv->screen = DefaultScreen (drv->display);
  drv->visual = DefaultVisual (drv->display, drv->screen);
  drv->win = XCreateSimpleWindow
               (drv->display, RootWindow (drv->display, drv->screen),
                0, 0, 4, 4, border_width,
                WhitePixel (drv->display, drv->screen),
                BlackPixel (drv->display, drv->screen));

  drv->depth = DefaultDepth (drv->display, drv->screen);

  /* Compute title len and convert to Ascii.  */
  for (title_len = 0; Title[title_len] != 0; title_len++)
    ;
  {
    char title[title_len + 1];
    int i;
    for (i = 0; i < title_len; i++)
      title[i] = Title[i];
    title[i] = 0;
    
    XStoreName (drv->display, drv->win, title);
  }

  XSelectInput (drv->display, drv->win, ExposureMask | KeyPressMask);
  
  drv->gc = DefaultGC (drv->display, drv->screen);

  *Uga = (EFI_UNIX_UGA_IO_PROTOCOL *)drv;
  return EFI_SUCCESS;
}
Commit	Line	Data
ccd55824	1	/*++
ccd55824	2
f9b8ab56 HT	3	Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
	4	Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
	5	This program and the accompanying materials
ccd55824	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
804405e7	15	#include <sys/ipc.h>
804405e7	16	#include <sys/shm.h>
804405e7	17	#include <stdio.h>
	18	#include <stdlib.h>
	19
	20	#include "PiPei.h"
	21	#include "Protocol/UnixThunk.h"
	22	#include "Protocol/SimpleTextIn.h"
	23	#include "Protocol/UgaDraw.h"
	24	#include "Protocol/UnixUgaIo.h"
	25	#include <X11/Xlib.h>
	26	#include <X11/Xutil.h>
	27	#include <X11/Xos.h>
	28	#include <X11/extensions/XShm.h>
	29	#include <X11/keysym.h>
	30
804405e7	31	#include <Ppi/StatusCode.h>
	32
	33	#include <Library/PeCoffLib.h>
	34	#include <Library/BaseLib.h>
	35	#include <Library/BaseMemoryLib.h>
	36	#include <Library/PrintLib.h>
	37	#include <Library/PcdLib.h>
	38	#include <Library/DebugLib.h>
	39
	40	extern void msSleep (unsigned long Milliseconds);
	41
	42	/* XQueryPointer */
	43
	44	struct uga_drv_shift_mask
	45	{
	46	unsigned char shift;
	47	unsigned char size;
	48	unsigned char csize;
	49	};
	50
	51	#define NBR_KEYS 32
	52	typedef struct
	53	{
	54	EFI_UNIX_UGA_IO_PROTOCOL UgaIo;
	55
	56	Display *display;
	57	int screen; /* values for window_size in main */
	58	Window win;
	59	GC gc;
	60	Visual *visual;
	61
	62	int depth;
	63	unsigned int width;
	64	unsigned int height;
	65	unsigned int line_bytes;
	66	unsigned int pixel_shift;
	67	unsigned char *image_data;
	68
	69	struct uga_drv_shift_mask r, g, b;
	70
	71	int use_shm;
	72	XShmSegmentInfo xshm_info;
	73	XImage *image;
	74
	75	unsigned int key_rd;
	76	unsigned int key_wr;
	77	unsigned int key_count;
	78	EFI_INPUT_KEY keys[NBR_KEYS];
	79	} UGA_IO_PRIVATE;
	80
7492c63d	81	void
804405e7	82	HandleEvents(UGA_IO_PRIVATE *drv);
804405e7	83
7492c63d	84	void
804405e7	85	fill_shift_mask (struct uga_drv_shift_mask *sm, unsigned long mask)
	86	{
	87	sm->shift = 0;
	88	sm->size = 0;
	89	while ((mask & 1) == 0)
	90	{
	91	mask >>= 1;
	92	sm->shift++;
	93	}
	94	while (mask & 1)
	95	{
	96	sm->size++;
	97	mask >>= 1;
	98	}
	99	sm->csize = 8 - sm->size;
	100	}
	101
7492c63d	102	int
804405e7	103	TryCreateShmImage(UGA_IO_PRIVATE *drv)
	104	{
	105	drv->image = XShmCreateImage (drv->display, drv->visual,
288a3c98	106	drv->depth, ZPixmap, NULL, &drv->xshm_info,
288a3c98	107	drv->width, drv->height);
804405e7	108	if (drv->image == NULL)
	109	return 0;
	110
	111	switch (drv->image->bitmap_unit) {
	112	case 32:
	113	drv->pixel_shift = 2;
	114	break;
	115	case 16:
	116	drv->pixel_shift = 1;
	117	break;
	118	case 8:
	119	drv->pixel_shift = 0;
	120	break;
	121	}
	122
	123	drv->xshm_info.shmid = shmget
288a3c98	124	(IPC_PRIVATE, drv->image->bytes_per_line * drv->image->height,
288a3c98	125	IPC_CREAT \| 0777);
7ee3b613 A	126	if (drv->xshm_info.shmid < 0) {
	127	XDestroyImage(drv->image);
	128	return 0;
	129	}
804405e7	130
804405e7	131	drv->image_data = shmat (drv->xshm_info.shmid, NULL, 0);
7ee3b613 A	132	if(!drv->image_data) {
	133	shmctl (drv->xshm_info.shmid, IPC_RMID, NULL);
	134	XDestroyImage(drv->image);
	135	return 0;
	136	}
ccd55824	137
	138	#ifndef __APPLE__
	139	//
	140	// This closes shared memory in real time on OS X. Only closes after folks quit using
	141	// it on Linux.
	142	//
804405e7	143	/* Can this fail ? */
804405e7	144	shmctl (drv->xshm_info.shmid, IPC_RMID, NULL);
ccd55824	145	#endif
804405e7	146
	147	drv->xshm_info.shmaddr = (char*)drv->image_data;
	148	drv->image->data = (char*)drv->image_data;
288a3c98	149
7ee3b613 A	150	if (!XShmAttach (drv->display, &drv->xshm_info)) {
	151	shmdt (drv->image_data);
	152	XDestroyImage(drv->image);
	153	return 0;
	154	}
804405e7	155	return 1;
	156	}
	157
804405e7	158	EFI_STATUS
	159	UgaClose (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo)
	160	{
	161	UGA_IO_PRIVATE drv = (UGA_IO_PRIVATE )UgaIo;
	162
	163	if (drv == NULL)
	164	return EFI_SUCCESS;
	165	if (drv->image != NULL)
	166	{
	167	XDestroyImage(drv->image);
	168
	169	if (drv->use_shm)
288a3c98	170	shmdt (drv->image_data);
804405e7	171
	172	drv->image_data = NULL;
	173	drv->image = NULL;
	174	}
	175	XDestroyWindow(drv->display, drv->win);
	176	XCloseDisplay(drv->display);
ccd55824	177
	178	#ifdef __APPLE__
	179	// Free up the shared memory
	180	shmctl (drv->xshm_info.shmid, IPC_RMID, NULL);
	181	#endif
	182
804405e7	183	free(drv);
	184	return EFI_SUCCESS;
	185	}
	186
804405e7	187	EFI_STATUS
	188	UgaSize(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, UINT32 Width, UINT32 Height)
	189	{
	190	UGA_IO_PRIVATE drv = (UGA_IO_PRIVATE )UgaIo;
	191	XSizeHints size_hints;
	192
	193	/* Destroy current buffer if created. */
	194	if (drv->image != NULL)
	195	{
7d28e82d	196	/* Before destroy buffer, need to make sure the buffer available for access. */
804405e7	197	XDestroyImage(drv->image);
	198
	199	if (drv->use_shm)
288a3c98	200	shmdt (drv->image_data);
804405e7	201
	202	drv->image_data = NULL;
	203	drv->image = NULL;
	204	}
	205
	206	drv->width = Width;
	207	drv->height = Height;
	208	XResizeWindow (drv->display, drv->win, Width, Height);
	209
	210	/* Allocate image. */
288a3c98	211	if (XShmQueryExtension(drv->display) && TryCreateShmImage(drv)) {
	212	drv->use_shm = 1;
	213	} else {
	214	drv->use_shm = 0;
	215	if (drv->depth > 16)
	216	drv->pixel_shift = 2;
	217	else if (drv->depth > 8)
	218	drv->pixel_shift = 1;
	219	else
	220	drv->pixel_shift = 0;
804405e7	221
	222	drv->image_data = malloc((drv->width * drv->height) << drv->pixel_shift);
	223	drv->image = XCreateImage (drv->display, drv->visual, drv->depth,
288a3c98	224	ZPixmap, 0, (char *)drv->image_data,
	225	drv->width, drv->height,
	226	8 << drv->pixel_shift, 0);
804405e7	227	}
	228	drv->line_bytes = drv->image->bytes_per_line;
	229	fill_shift_mask (&drv->r, drv->image->red_mask);
	230	fill_shift_mask (&drv->g, drv->image->green_mask);
	231	fill_shift_mask (&drv->b, drv->image->blue_mask);
	232
	233	/* Set WM hints. */
	234	size_hints.flags = PSize \| PMinSize \| PMaxSize;
	235	size_hints.min_width = size_hints.max_width = size_hints.base_width = Width;
	236	size_hints.min_height = size_hints.max_height = size_hints.base_height = Height;
	237	XSetWMNormalHints (drv->display, drv->win, &size_hints);
	238
	239	XMapWindow (drv->display, drv->win);
	240	HandleEvents(drv);
	241	return EFI_SUCCESS;
	242	}
	243
7492c63d	244	void
804405e7	245	handleKeyEvent(UGA_IO_PRIVATE drv, XEvent ev)
	246	{
	247	KeySym keysym;
	248	char str[4];
	249	EFI_INPUT_KEY Key;
	250	int res;
	251
	252	if (drv->key_count == NBR_KEYS)
	253	return;
	254
	255	res = XLookupString(&ev->xkey, str, sizeof(str), &keysym, NULL);
288a3c98	256	Key.ScanCode = 0;
804405e7	257	Key.UnicodeChar = 0;
288a3c98	258	switch (keysym) {
	259	case XK_Home: Key.ScanCode = SCAN_HOME; break;
	260	case XK_End: Key.ScanCode = SCAN_END; break;
	261	case XK_Left: Key.ScanCode = SCAN_LEFT; break;
	262	case XK_Right: Key.ScanCode = SCAN_RIGHT; break;
	263	case XK_Up: Key.ScanCode = SCAN_UP; break;
	264	case XK_Down: Key.ScanCode = SCAN_DOWN; break;
	265	case XK_Delete: Key.ScanCode = SCAN_DELETE; break;
	266	case XK_Insert: Key.ScanCode = SCAN_INSERT; break;
	267	case XK_Page_Up: Key.ScanCode = SCAN_PAGE_UP; break;
	268	case XK_Page_Down: Key.ScanCode = SCAN_PAGE_DOWN; break;
	269	case XK_Escape: Key.ScanCode = SCAN_ESC; break;
	270
	271	case XK_F1: Key.ScanCode = SCAN_F1; break;
	272	case XK_F2: Key.ScanCode = SCAN_F2; break;
	273	case XK_F3: Key.ScanCode = SCAN_F3; break;
	274	case XK_F4: Key.ScanCode = SCAN_F4; break;
	275	case XK_F5: Key.ScanCode = SCAN_F5; break;
	276	case XK_F6: Key.ScanCode = SCAN_F6; break;
	277	case XK_F7: Key.ScanCode = SCAN_F7; break;
	278	case XK_F8: Key.ScanCode = SCAN_F8; break;
	279	case XK_F9: Key.ScanCode = SCAN_F9; break;
804405e7	280
	281	default:
	282	if (res == 1) {
	283	Key.UnicodeChar = str[0];
	284	} else {
	285	return;
	286	}
288a3c98	287	}
288a3c98	288
804405e7	289	drv->keys[drv->key_wr] = Key;
	290	drv->key_wr = (drv->key_wr + 1) % NBR_KEYS;
	291	drv->key_count++;
	292	}
	293
7492c63d	294	void
804405e7	295	Redraw(UGA_IO_PRIVATE *drv, UINTN X, UINTN Y, UINTN Width, UINTN Height)
	296	{
	297	if (drv->use_shm)
	298	XShmPutImage (drv->display, drv->win, drv->gc, drv->image,
288a3c98	299	X, Y, X, Y, Width, Height, False);
804405e7	300	else
804405e7	301	XPutImage (drv->display, drv->win, drv->gc, drv->image,
288a3c98	302	X, Y, X, Y, Width, Height);
288a3c98	303	XFlush(drv->display);
804405e7	304	}
804405e7	305
7492c63d	306	void
804405e7	307	HandleEvent(UGA_IO_PRIVATE drv, XEvent ev)
	308	{
	309	switch (ev->type)
	310	{
	311	case Expose:
	312	Redraw(drv, ev->xexpose.x, ev->xexpose.y,
288a3c98	313	ev->xexpose.width, ev->xexpose.height);
804405e7	314	break;
	315	case GraphicsExpose:
	316	Redraw(drv, ev->xgraphicsexpose.x, ev->xgraphicsexpose.y,
288a3c98	317	ev->xgraphicsexpose.width, ev->xgraphicsexpose.height);
804405e7	318	break;
	319	case KeyPress:
	320	handleKeyEvent(drv, ev);
	321	break;
	322	case MappingNotify:
	323	XRefreshKeyboardMapping(&ev->xmapping);
	324	break;
	325	#if 0
	326	case DestroyNotify:
	327	XCloseDisplay (drv->display);
	328	exit (1);
	329	break;
	330	#endif
	331	case NoExpose:
	332	default:
	333	break;
	334	}
	335	}
	336
7492c63d	337	void
804405e7	338	HandleEvents(UGA_IO_PRIVATE *drv)
	339	{
	340	while (XPending(drv->display) != 0)
	341	{
	342	XEvent ev;
288a3c98	343
804405e7	344	XNextEvent (drv->display, &ev);
	345	HandleEvent(drv, &ev);
	346	}
	347	}
	348
804405e7	349	unsigned long
	350	UgaPixelToColor (UGA_IO_PRIVATE *drv, EFI_UGA_PIXEL pixel)
	351	{
	352	return ((pixel.Red >> drv->r.csize) << drv->r.shift)
	353	\| ((pixel.Green >> drv->g.csize) << drv->g.shift)
	354	\| ((pixel.Blue >> drv->b.csize) << drv->b.shift);
	355	}
	356
804405e7	357	EFI_UGA_PIXEL
	358	UgaColorToPixel (UGA_IO_PRIVATE *drv, unsigned long val)
	359	{
	360	EFI_UGA_PIXEL res;
	361
	362	memset (&res, 0, sizeof (EFI_UGA_PIXEL));
	363	/* FIXME: should round instead of truncate. */
	364	res.Red = (val >> drv->r.shift) << drv->r.csize;
	365	res.Green = (val >> drv->g.shift) << drv->g.csize;
	366	res.Blue = (val >> drv->b.shift) << drv->b.csize;
	367
	368	return res;
	369	}
	370
804405e7	371	EFI_STATUS
	372	UgaCheckKey(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo)
	373	{
	374	UGA_IO_PRIVATE drv = (UGA_IO_PRIVATE )UgaIo;
	375	HandleEvents(drv);
b9c8e50e	376
b9c8e50e	377	if (drv->key_count != 0) {
804405e7	378	return EFI_SUCCESS;
b9c8e50e	379	} else {
804405e7	380	/* EFI is certainly polling. Be CPU-friendly. */
	381	msSleep (20);
	382	return EFI_NOT_READY;
	383	}
	384	}
	385
804405e7	386	EFI_STATUS
7ee3b613	387	UgaGetKey (EFI_UNIX_UGA_IO_PROTOCOL UgaIo, EFI_INPUT_KEY key)
804405e7	388	{
	389	UGA_IO_PRIVATE drv = (UGA_IO_PRIVATE )UgaIo;
	390	EFI_STATUS status;
	391
	392	status = UgaCheckKey(UgaIo);
	393	if (status != EFI_SUCCESS)
	394	return status;
	395
	396	*key = drv->keys[drv->key_rd];
	397	drv->key_rd = (drv->key_rd + 1) % NBR_KEYS;
	398	drv->key_count--;
	399	return EFI_SUCCESS;
	400	}
	401
288a3c98	402	EFI_STATUS
804405e7	403	UgaBlt(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo,
288a3c98	404	IN EFI_UGA_PIXEL *BltBuffer OPTIONAL,
	405	IN EFI_UGA_BLT_OPERATION BltOperation,
	406	IN UINTN SourceX,
	407	IN UINTN SourceY,
	408	IN UINTN DestinationX,
	409	IN UINTN DestinationY,
	410	IN UINTN Width,
	411	IN UINTN Height,
	412	IN UINTN Delta OPTIONAL
	413	)
804405e7	414	{
804405e7	415	UGA_IO_PRIVATE Private = (UGA_IO_PRIVATE )UgaIo;
288a3c98	416	UINTN DstY;
288a3c98	417	UINTN SrcY;
804405e7	418	UINTN DstX;
	419	UINTN SrcX;
	420	UINTN Index;
288a3c98	421	EFI_UGA_PIXEL *Blt;
804405e7	422	UINT8 *Dst;
	423	UINT8 *Src;
	424	UINTN Nbr;
	425	unsigned long Color;
	426
	427	//
	428	// Check bounds
	429	//
	430	if (BltOperation == EfiUgaVideoToBltBuffer
288a3c98	431	\|\| BltOperation == EfiUgaVideoToVideo) {
288a3c98	432	//
804405e7	433	// Source is Video.
288a3c98	434	//
	435	if (SourceY + Height > Private->height) {
	436	return EFI_INVALID_PARAMETER;
	437	}
	438
	439	if (SourceX + Width > Private->width) {
	440	return EFI_INVALID_PARAMETER;
	441	}
804405e7	442	}
	443
	444	if (BltOperation == EfiUgaBltBufferToVideo
	445	\|\| BltOperation == EfiUgaVideoToVideo
288a3c98	446	\|\| BltOperation == EfiUgaVideoFill) {
	447	//
	448	// Destination is Video
	449	//
	450	if (DestinationY + Height > Private->height) {
	451	return EFI_INVALID_PARAMETER;
	452	}
	453
	454	if (DestinationX + Width > Private->width) {
	455	return EFI_INVALID_PARAMETER;
	456	}
804405e7	457	}
804405e7	458
288a3c98	459	switch (BltOperation) {
804405e7	460	case EfiUgaVideoToBltBuffer:
288a3c98	461	Blt = (EFI_UGA_PIXEL )((UINT8 )BltBuffer + (DestinationY * Delta) + DestinationX * sizeof (EFI_UGA_PIXEL));
804405e7	462	Delta -= Width * sizeof (EFI_UGA_PIXEL);
288a3c98	463	for (SrcY = SourceY; SrcY < (Height + SourceY); SrcY++) {
804405e7	464	for (SrcX = SourceX; SrcX < (Width + SourceX); SrcX++) {
288a3c98	465	*Blt++ = UgaColorToPixel(Private,
288a3c98	466	XGetPixel(Private->image, SrcX, SrcY));
804405e7	467	}
804405e7	468	Blt = (EFI_UGA_PIXEL ) ((UINT8 ) Blt + Delta);
288a3c98	469	}
804405e7	470	break;
288a3c98	471	case EfiUgaBltBufferToVideo:
288a3c98	472	Blt = (EFI_UGA_PIXEL )((UINT8 )BltBuffer + (SourceY * Delta) + SourceX * sizeof (EFI_UGA_PIXEL));
804405e7	473	Delta -= Width * sizeof (EFI_UGA_PIXEL);
288a3c98	474	for (DstY = DestinationY; DstY < (Height + DestinationY); DstY++) {
	475	for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) {
	476	XPutPixel(Private->image, DstX, DstY, UgaPixelToColor(Private, *Blt));
	477	Blt++;
804405e7	478	}
	479	Blt = (EFI_UGA_PIXEL ) ((UINT8 ) Blt + Delta);
	480	}
	481	break;
288a3c98	482	case EfiUgaVideoToVideo:
804405e7	483	Dst = Private->image_data + (DestinationX << Private->pixel_shift)
	484	+ DestinationY * Private->line_bytes;
	485	Src = Private->image_data + (SourceX << Private->pixel_shift)
	486	+ SourceY * Private->line_bytes;
	487	Nbr = Width << Private->pixel_shift;
288a3c98	488	if (DestinationY < SourceY) {
804405e7	489	for (Index = 0; Index < Height; Index++) {
288a3c98	490	memcpy (Dst, Src, Nbr);
	491	Dst += Private->line_bytes;
	492	Src += Private->line_bytes;
804405e7	493	}
	494	}
	495	else {
	496	Dst += (Height - 1) * Private->line_bytes;
	497	Src += (Height - 1) * Private->line_bytes;
	498	for (Index = 0; Index < Height; Index++) {
288a3c98	499	//
	500	// Source and Destination Y may be equal, therefore Dst and Src may
	501	// overlap.
	502	//
	503	memmove (Dst, Src, Nbr);
	504	Dst -= Private->line_bytes;
	505	Src -= Private->line_bytes;
804405e7	506	}
	507	}
	508	break;
	509	case EfiUgaVideoFill:
	510	Color = UgaPixelToColor(Private, *BltBuffer);
288a3c98	511	for (DstY = DestinationY; DstY < (Height + DestinationY); DstY++) {
804405e7	512	for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) {
288a3c98	513	XPutPixel(Private->image, DstX, DstY, Color);
804405e7	514	}
288a3c98	515	}
804405e7	516	break;
804405e7	517	default:
288a3c98	518	return EFI_INVALID_PARAMETER;
804405e7	519	}
	520
	521	//
	522	// Refresh screen.
	523	//
288a3c98	524	switch (BltOperation) {
288a3c98	525	case EfiUgaVideoToVideo:
804405e7	526	XCopyArea(Private->display, Private->win, Private->win, Private->gc,
288a3c98	527	SourceX, SourceY, Width, Height, DestinationX, DestinationY);
804405e7	528	while (1) {
804405e7	529	XEvent ev;
288a3c98	530
804405e7	531	XNextEvent (Private->display, &ev);
	532	HandleEvent(Private, &ev);
	533	if (ev.type == NoExpose \|\| ev.type == GraphicsExpose)
288a3c98	534	break;
804405e7	535	}
	536	break;
	537	case EfiUgaVideoFill:
	538	Color = UgaPixelToColor(Private, *BltBuffer);
	539	XSetForeground(Private->display, Private->gc, Color);
	540	XFillRectangle(Private->display, Private->win, Private->gc,
288a3c98	541	DestinationX, DestinationY, Width, Height);
288a3c98	542	XFlush(Private->display);
804405e7	543	break;
288a3c98	544	case EfiUgaBltBufferToVideo:
804405e7	545	Redraw(Private, DestinationX, DestinationY, Width, Height);
	546	break;
	547	default:
	548	break;
	549	}
	550	return EFI_SUCCESS;
	551	}
	552
	553	EFI_STATUS
	554	UgaCreate (EFI_UNIX_UGA_IO_PROTOCOL *Uga, CONST CHAR16 Title)
	555	{
	556	UGA_IO_PRIVATE *drv;
	557	unsigned int border_width = 0;
	558	char *display_name = NULL;
	559	int title_len;
	560
ccd55824	561	drv = (UGA_IO_PRIVATE *)calloc (1, sizeof (UGA_IO_PRIVATE));
804405e7	562	if (drv == NULL)
	563	return EFI_OUT_OF_RESOURCES;
	564
ccd55824	565	#ifdef __APPLE__
	566	//
	567	//
	568	//
	569	EFI_STATUS EFIAPI GasketUgaClose (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo);
	570	EFI_STATUS EFIAPI GasketUgaSize (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, UINT32 Width, UINT32 Height);
	571	EFI_STATUS EFIAPI GasketUgaCheckKey (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo);
	572	EFI_STATUS EFIAPI GasketUgaGetKey (EFI_UNIX_UGA_IO_PROTOCOL UgaIo, EFI_INPUT_KEY key);
	573	EFI_STATUS EFIAPI GasketUgaBlt (
	574	EFI_UNIX_UGA_IO_PROTOCOL *UgaIo,
	575	IN EFI_UGA_PIXEL *BltBuffer OPTIONAL,
	576	IN EFI_UGA_BLT_OPERATION BltOperation,
	577	IN UINTN SourceX,
	578	IN UINTN SourceY,
	579	IN UINTN DestinationX,
	580	IN UINTN DestinationY,
	581	IN UINTN Width,
	582	IN UINTN Height,
	583	IN UINTN Delta OPTIONAL
	584	);
	585
	586	drv->UgaIo.UgaClose = GasketUgaClose;
	587	drv->UgaIo.UgaSize = GasketUgaSize;
	588	drv->UgaIo.UgaCheckKey = GasketUgaCheckKey;
	589	drv->UgaIo.UgaGetKey = GasketUgaGetKey;
	590	drv->UgaIo.UgaBlt = GasketUgaBlt;
	591	#else
804405e7	592	drv->UgaIo.UgaClose = UgaClose;
	593	drv->UgaIo.UgaSize = UgaSize;
	594	drv->UgaIo.UgaCheckKey = UgaCheckKey;
	595	drv->UgaIo.UgaGetKey = UgaGetKey;
	596	drv->UgaIo.UgaBlt = UgaBlt;
ccd55824	597	#endif
	598
	599
804405e7	600
	601	drv->key_count = 0;
	602	drv->key_rd = 0;
	603	drv->key_wr = 0;
	604	drv->display = XOpenDisplay (display_name);
	605	if (drv->display == NULL)
	606	{
	607	fprintf (stderr, "uga: cannot connect to X server %s\n",
288a3c98	608	XDisplayName (display_name));
804405e7	609	free (drv);
	610	return EFI_DEVICE_ERROR;
	611	}
	612	drv->screen = DefaultScreen (drv->display);
	613	drv->visual = DefaultVisual (drv->display, drv->screen);
	614	drv->win = XCreateSimpleWindow
288a3c98	615	(drv->display, RootWindow (drv->display, drv->screen),
	616	0, 0, 4, 4, border_width,
	617	WhitePixel (drv->display, drv->screen),
	618	BlackPixel (drv->display, drv->screen));
804405e7	619
	620	drv->depth = DefaultDepth (drv->display, drv->screen);
	621
	622	/* Compute title len and convert to Ascii. */
	623	for (title_len = 0; Title[title_len] != 0; title_len++)
	624	;
	625	{
	626	char title[title_len + 1];
	627	int i;
	628	for (i = 0; i < title_len; i++)
	629	title[i] = Title[i];
	630	title[i] = 0;
	631
	632	XStoreName (drv->display, drv->win, title);
	633	}
	634
b9c8e50e	635	XSelectInput (drv->display, drv->win, ExposureMask \| KeyPressMask);
b9c8e50e	636
804405e7	637	drv->gc = DefaultGC (drv->display, drv->screen);
	638
	639	Uga = (EFI_UNIX_UGA_IO_PROTOCOL )drv;
	640	return EFI_SUCCESS;
	641	}