+/*++
+
+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 <sys/dir.h>
#include <stdio.h>
#include <stdlib.h>
#include <X11/extensions/XShm.h>
#include <X11/keysym.h>
-#include <Guid/PeiPeCoffLoader.h>
#include <Ppi/StatusCode.h>
#include <Library/PeCoffLib.h>
EFI_INPUT_KEY keys[NBR_KEYS];
} UGA_IO_PRIVATE;
-static void
+void
HandleEvents(UGA_IO_PRIVATE *drv);
-static void
+void
fill_shift_mask (struct uga_drv_shift_mask *sm, unsigned long mask)
{
sm->shift = 0;
sm->csize = 8 - sm->size;
}
-static int
+int
TryCreateShmImage(UGA_IO_PRIVATE *drv)
{
drv->image = XShmCreateImage (drv->display, drv->visual,
- drv->depth, ZPixmap, NULL, &drv->xshm_info,
- drv->width, drv->height);
+ drv->depth, ZPixmap, NULL, &drv->xshm_info,
+ drv->width, drv->height);
if (drv->image == NULL)
return 0;
}
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;
- }
+ (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;
- }
+ 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;
- }
+
+ 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)
{
XDestroyImage(drv->image);
if (drv->use_shm)
- shmdt (drv->image_data);
+ 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;
}
-static
EFI_STATUS
UgaSize(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, UINT32 Width, UINT32 Height)
{
/* 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);
+ shmdt (drv->image_data);
drv->image_data = NULL;
drv->image = NULL;
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;
+ 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);
+ 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);
return EFI_SUCCESS;
}
-static void
+void
handleKeyEvent(UGA_IO_PRIVATE *drv, XEvent *ev)
{
KeySym keysym;
return;
res = XLookupString(&ev->xkey, str, sizeof(str), &keysym, NULL);
- Key.ScanCode = 0;\r
+ Key.ScanCode = 0;
Key.UnicodeChar = 0;
- switch (keysym) {\r
- case XK_Home: Key.ScanCode = SCAN_HOME; break;\r
- case XK_End: Key.ScanCode = SCAN_END; break;\r
- case XK_Left: Key.ScanCode = SCAN_LEFT; break;\r
- case XK_Right: Key.ScanCode = SCAN_RIGHT; break;\r
- case XK_Up: Key.ScanCode = SCAN_UP; break;\r
- case XK_Down: Key.ScanCode = SCAN_DOWN; break;\r
- case XK_Delete: Key.ScanCode = SCAN_DELETE; break;\r
- case XK_Insert: Key.ScanCode = SCAN_INSERT; break;\r
- case XK_Page_Up: Key.ScanCode = SCAN_PAGE_UP; break;\r
- case XK_Page_Down: Key.ScanCode = SCAN_PAGE_DOWN; break;\r
- case XK_Escape: Key.ScanCode = SCAN_ESC; break;\r
-\r
- case XK_F1: Key.ScanCode = SCAN_F1; break;\r
- case XK_F2: Key.ScanCode = SCAN_F2; break;\r
- case XK_F3: Key.ScanCode = SCAN_F3; break;\r
- case XK_F4: Key.ScanCode = SCAN_F4; break;\r
- case XK_F5: Key.ScanCode = SCAN_F5; break;\r
- case XK_F6: Key.ScanCode = SCAN_F6; break;\r
- case XK_F7: Key.ScanCode = SCAN_F7; break;\r
- case XK_F8: Key.ScanCode = SCAN_F8; break;\r
- case XK_F9: Key.ScanCode = SCAN_F9; break;\r
+ 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) {
} else {
return;
}
- }\r
-\r
+ }
+
drv->keys[drv->key_wr] = Key;
drv->key_wr = (drv->key_wr + 1) % NBR_KEYS;
drv->key_count++;
}
-static void
+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);
+ X, Y, X, Y, Width, Height, False);
else
XPutImage (drv->display, drv->win, drv->gc, drv->image,
- X, Y, X, Y, Width, Height);
+ X, Y, X, Y, Width, Height);
+ XFlush(drv->display);
}
-static void
+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);
+ ev->xexpose.width, ev->xexpose.height);
break;
case GraphicsExpose:
Redraw(drv, ev->xgraphicsexpose.x, ev->xgraphicsexpose.y,
- ev->xgraphicsexpose.width, ev->xgraphicsexpose.height);
+ ev->xgraphicsexpose.width, ev->xgraphicsexpose.height);
break;
case KeyPress:
handleKeyEvent(drv, ev);
}
}
-static void
+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)
{
| ((pixel.Blue >> drv->b.csize) << drv->b.shift);
}
-static
EFI_UGA_PIXEL
UgaColorToPixel (UGA_IO_PRIVATE *drv, unsigned long val)
{
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)
+
+ if (drv->key_count != 0) {
return EFI_SUCCESS;
- else {
+ } 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)
+UgaGetKey (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, EFI_INPUT_KEY *key)
{
UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo;
EFI_STATUS status;
return EFI_SUCCESS;
}
-EFI_STATUS\r
+EFI_STATUS
UgaBlt(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo,
- IN EFI_UGA_PIXEL *BltBuffer OPTIONAL,\r
- IN EFI_UGA_BLT_OPERATION BltOperation,\r
- IN UINTN SourceX,\r
- IN UINTN SourceY,\r
- IN UINTN DestinationX,\r
- IN UINTN DestinationY,\r
- IN UINTN Width,\r
- IN UINTN Height,\r
- IN UINTN Delta OPTIONAL\r
- )\r
+ 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;\r
- UINTN SrcY;\r
+ UINTN DstY;
+ UINTN SrcY;
UINTN DstX;
UINTN SrcX;
UINTN Index;
- EFI_UGA_PIXEL *Blt;\r
+ EFI_UGA_PIXEL *Blt;
UINT8 *Dst;
UINT8 *Src;
UINTN Nbr;
// Check bounds
//
if (BltOperation == EfiUgaVideoToBltBuffer
- || BltOperation == EfiUgaVideoToVideo) {\r
- //\r
+ || BltOperation == EfiUgaVideoToVideo) {
+ //
// Source is Video.
- //\r
- if (SourceY + Height > Private->height) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- if (SourceX + Width > Private->width) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
+ //
+ 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) {\r
- //\r
- // Destination is Video\r
- //\r
- if (DestinationY + Height > Private->height) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
-\r
- if (DestinationX + Width > Private->width) {\r
- return EFI_INVALID_PARAMETER;\r
- }\r
+ || 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) {\r
+ switch (BltOperation) {
case EfiUgaVideoToBltBuffer:
- Blt = BltBuffer;
+ 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++) {\r
+ for (SrcY = SourceY; SrcY < (Height + SourceY); SrcY++) {
for (SrcX = SourceX; SrcX < (Width + SourceX); SrcX++) {
- *Blt++ = UgaColorToPixel(Private,
- XGetPixel(Private->image, SrcX, SrcY));
+ *Blt++ = UgaColorToPixel(Private,
+ XGetPixel(Private->image, SrcX, SrcY));
}
Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Delta);
- }\r
+ }
break;
- case EfiUgaBltBufferToVideo:\r
- Blt = BltBuffer;
+ 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++) {\r
- for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) {\r
- XPutPixel(Private->image, DstX, DstY, UgaPixelToColor(Private, *Blt));
- Blt++;
+ 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:\r
+ 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) {\r
+ if (DestinationY < SourceY) {
for (Index = 0; Index < Height; Index++) {
- memcpy (Dst, Src, Nbr);
- Dst += Private->line_bytes;
- Src += Private->line_bytes;
+ 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;
+ //
+ // 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++) {\r
+ for (DstY = DestinationY; DstY < (Height + DestinationY); DstY++) {
for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) {
- XPutPixel(Private->image, DstX, DstY, Color);
+ XPutPixel(Private->image, DstX, DstY, Color);
}
- }\r
+ }
break;
default:
- return EFI_INVALID_PARAMETER;\r
+ return EFI_INVALID_PARAMETER;
}
//
// Refresh screen.
//
- switch (BltOperation) {\r
- case EfiUgaVideoToVideo:\r
+ switch (BltOperation) {
+ case EfiUgaVideoToVideo:
XCopyArea(Private->display, Private->win, Private->win, Private->gc,
- SourceX, SourceY, Width, Height, DestinationX, DestinationY);
+ 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;
}
break;
case EfiUgaVideoFill:
Color = UgaPixelToColor(Private, *BltBuffer);
XSetForeground(Private->display, Private->gc, Color);
XFillRectangle(Private->display, Private->win, Private->gc,
- DestinationX, DestinationY, Width, Height);
+ DestinationX, DestinationY, Width, Height);
+ XFlush(Private->display);
break;
- case EfiUgaBltBufferToVideo:\r
+ case EfiUgaBltBufferToVideo:
Redraw(Private, DestinationX, DestinationY, Width, Height);
break;
default:
char *display_name = NULL;
int title_len;
- drv = (UGA_IO_PRIVATE *)
- calloc (1, sizeof (UGA_IO_PRIVATE));
+ 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;
if (drv->display == NULL)
{
fprintf (stderr, "uga: cannot connect to X server %s\n",
- XDisplayName (display_name));
+ 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,
- BlackPixel (drv->display, drv->screen),
- WhitePixel (drv->display, drv->screen));
+ (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);
XStoreName (drv->display, drv->win, title);
}
- XSelectInput (drv->display, drv->win,
- ExposureMask | KeyPressMask);
+ XSelectInput (drv->display, drv->win, ExposureMask | KeyPressMask);
+
drv->gc = DefaultGC (drv->display, drv->screen);
*Uga = (EFI_UNIX_UGA_IO_PROTOCOL *)drv;
projects / mirror_edk2.git / blobdiff