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

#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/dir.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 <Guid/PeiPeCoffLoader.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;

static void
HandleEvents(UGA_IO_PRIVATE *drv);

static 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;
}

static 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;
    }
  /* Can this fail ?  */
  shmctl (drv->xshm_info.shmid, IPC_RMID, NULL);

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

static
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);
  free(drv);
  return EFI_SUCCESS;
}

static
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)
    {
      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;
}

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

static 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);
}

static 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;
    }
}

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

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

static
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);
}

static
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;
}

static
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;
  }
}

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

  drv->UgaIo.UgaClose = UgaClose;
  drv->UgaIo.UgaSize = UgaSize;
  drv->UgaIo.UgaCheckKey = UgaCheckKey;
  drv->UgaIo.UgaGetKey = UgaGetKey;
  drv->UgaIo.UgaBlt = UgaBlt;

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