1 /*++ @file
2
3 Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>
4 Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
5
6 SPDX-License-Identifier: BSD-2-Clause-Patent
7
8 **/
9
10 #include "Host.h"
11
12 #include <sys/ipc.h>
13 #include <sys/shm.h>
14
15 #include <X11/Xlib.h>
16 #include <X11/Xutil.h>
17 #include <X11/Xos.h>
18 #include <X11/extensions/XShm.h>
19 #include <X11/keysym.h>
20 #include <X11/cursorfont.h>
21
22 #define KEYSYM_LOWER 0
23 #define KEYSYM_UPPER 1
24
25
26 struct uga_drv_shift_mask {
27 unsigned char shift;
28 unsigned char size;
29 unsigned char csize;
30 };
31
32 #define NBR_KEYS 32
33 typedef struct {
34 EMU_GRAPHICS_WINDOW_PROTOCOL GraphicsIo;
35
36 Display *display;
37 int screen; // values for window_size in main
38 Window win;
39 GC gc;
40 Visual *visual;
41
42 int depth;
43 unsigned int width;
44 unsigned int height;
45 unsigned int line_bytes;
46 unsigned int pixel_shift;
47 unsigned char *image_data;
48
49 struct uga_drv_shift_mask r, g, b;
50
51 int use_shm;
52 XShmSegmentInfo xshm_info;
53 XImage *image;
54 char *Title;
55
56 unsigned int key_rd;
57 unsigned int key_wr;
58 unsigned int key_count;
59 EFI_KEY_DATA keys[NBR_KEYS];
60
61 EFI_KEY_STATE KeyState;
62
63 EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK MakeRegisterdKeyCallback;
64 EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK BreakRegisterdKeyCallback;
65 VOID *RegisterdKeyCallbackContext;
66
67 int previous_x;
68 int previous_y;
69 EFI_SIMPLE_POINTER_STATE pointer_state;
70 int pointer_state_changed;
71 } GRAPHICS_IO_PRIVATE;
72
73 void
74 HandleEvents(
75 IN GRAPHICS_IO_PRIVATE *Drv
76 );
77
78 void
fill_shift_mask(IN struct uga_drv_shift_mask * sm,IN unsigned long mask)79 fill_shift_mask (
80 IN struct uga_drv_shift_mask *sm,
81 IN unsigned long mask
82 )
83 {
84 sm->shift = 0;
85 sm->size = 0;
86 while ((mask & 1) == 0) {
87 mask >>= 1;
88 sm->shift++;
89 }
90 while (mask & 1) {
91 sm->size++;
92 mask >>= 1;
93 }
94 sm->csize = 8 - sm->size;
95 }
96
97 int
TryCreateShmImage(IN GRAPHICS_IO_PRIVATE * Drv)98 TryCreateShmImage (
99 IN GRAPHICS_IO_PRIVATE *Drv
100 )
101 {
102 Drv->image = XShmCreateImage (
103 Drv->display, Drv->visual,
104 Drv->depth, ZPixmap, NULL, &Drv->xshm_info,
105 Drv->width, Drv->height
106 );
107 if (Drv->image == NULL) {
108 return 0;
109 }
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 (
124 IPC_PRIVATE, Drv->image->bytes_per_line * Drv->image->height,
125 IPC_CREAT | 0777
126 );
127 if (Drv->xshm_info.shmid < 0) {
128 XDestroyImage(Drv->image);
129 return 0;
130 }
131
132 Drv->image_data = shmat (Drv->xshm_info.shmid, NULL, 0);
133 if(!Drv->image_data) {
134 shmctl (Drv->xshm_info.shmid, IPC_RMID, NULL);
135 XDestroyImage(Drv->image);
136 return 0;
137 }
138
139 #ifndef __APPLE__
140 //
141 // This closes shared memory in real time on OS X. Only closes after folks quit using
142 // it on Linux.
143 //
144 shmctl (Drv->xshm_info.shmid, IPC_RMID, NULL);
145 #endif
146
147 Drv->xshm_info.shmaddr = (char*)Drv->image_data;
148 Drv->image->data = (char*)Drv->image_data;
149
150 if (!XShmAttach (Drv->display, &Drv->xshm_info)) {
151 shmdt (Drv->image_data);
152 XDestroyImage(Drv->image);
153 return 0;
154 }
155 return 1;
156 }
157
158
159 EFI_STATUS
X11Size(IN EMU_GRAPHICS_WINDOW_PROTOCOL * GraphicsIo,IN UINT32 Width,IN UINT32 Height)160 X11Size (
161 IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
162 IN UINT32 Width,
163 IN UINT32 Height
164 )
165 {
166 GRAPHICS_IO_PRIVATE *Drv;
167 XSizeHints size_hints;
168
169 // Destroy current buffer if created.
170 Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
171 if (Drv->image != NULL) {
172 // Before destroy buffer, need to make sure the buffer available for access.
173 XDestroyImage (Drv->image);
174
175 if (Drv->use_shm) {
176 shmdt (Drv->image_data);
177 }
178
179 Drv->image_data = NULL;
180 Drv->image = NULL;
181 }
182
183 Drv->width = Width;
184 Drv->height = Height;
185 XResizeWindow (Drv->display, Drv->win, Width, Height);
186
187 // Allocate image.
188 if (XShmQueryExtension(Drv->display) && TryCreateShmImage(Drv)) {
189 Drv->use_shm = 1;
190 } else {
191 Drv->use_shm = 0;
192 if (Drv->depth > 16) {
193 Drv->pixel_shift = 2;
194 } else if (Drv->depth > 8) {
195 Drv->pixel_shift = 1;
196 } else {
197 Drv->pixel_shift = 0;
198 }
199
200 Drv->image_data = malloc ((Drv->width * Drv->height) << Drv->pixel_shift);
201 Drv->image = XCreateImage (
202 Drv->display, Drv->visual, Drv->depth,
203 ZPixmap, 0, (char *)Drv->image_data,
204 Drv->width, Drv->height,
205 8 << Drv->pixel_shift, 0
206 );
207 }
208
209 Drv->line_bytes = Drv->image->bytes_per_line;
210
211 fill_shift_mask (&Drv->r, Drv->image->red_mask);
212 fill_shift_mask (&Drv->g, Drv->image->green_mask);
213 fill_shift_mask (&Drv->b, Drv->image->blue_mask);
214
215 // Set WM hints.
216 size_hints.flags = PSize | PMinSize | PMaxSize;
217 size_hints.min_width = size_hints.max_width = size_hints.base_width = Width;
218 size_hints.min_height = size_hints.max_height = size_hints.base_height = Height;
219 XSetWMNormalHints (Drv->display, Drv->win, &size_hints);
220
221 XMapWindow (Drv->display, Drv->win);
222 HandleEvents (Drv);
223 return EFI_SUCCESS;
224 }
225
226 void
handleKeyEvent(IN GRAPHICS_IO_PRIVATE * Drv,IN XEvent * ev,IN BOOLEAN Make)227 handleKeyEvent (
228 IN GRAPHICS_IO_PRIVATE *Drv,
229 IN XEvent *ev,
230 IN BOOLEAN Make
231 )
232 {
233 KeySym *KeySym;
234 EFI_KEY_DATA KeyData;
235 int KeySymArraySize;
236
237 if (Make) {
238 if (Drv->key_count == NBR_KEYS) {
239 return;
240 }
241 }
242
243 // keycode is a physical key on the keyboard
244 // KeySym is a mapping of a physical key
245 // KeyboardMapping is the array of KeySym for a given keycode. key, shifted key, option key, command key, ...
246 //
247 // Returns an array of KeySymArraySize of KeySym for the keycode. [0] is lower case, [1] is upper case,
248 // [2] and [3] are based on option and command modifiers. The problem we have is command V
249 // could be mapped to a crazy Unicode character so the old scheme of returning a string.
250 //
251 KeySym = XGetKeyboardMapping (Drv->display, ev->xkey.keycode, 1, &KeySymArraySize);
252
253 KeyData.Key.ScanCode = 0;
254 KeyData.Key.UnicodeChar = 0;
255 KeyData.KeyState.KeyShiftState = 0;
256
257 //
258 // Skipping EFI_SCROLL_LOCK_ACTIVE & EFI_NUM_LOCK_ACTIVE since they are not on Macs
259 //
260 if ((ev->xkey.state & LockMask) == 0) {
261 Drv->KeyState.KeyToggleState &= ~EFI_CAPS_LOCK_ACTIVE;
262 } else {
263 if (Make) {
264 Drv->KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;
265 }
266 }
267
268 // Skipping EFI_MENU_KEY_PRESSED and EFI_SYS_REQ_PRESSED
269
270 switch (*KeySym) {
271 case XK_Control_R:
272 if (Make) {
273 Drv->KeyState.KeyShiftState |= EFI_RIGHT_CONTROL_PRESSED;
274 } else {
275 Drv->KeyState.KeyShiftState &= ~EFI_RIGHT_CONTROL_PRESSED;
276 }
277 break;
278 case XK_Control_L:
279 if (Make) {
280 Drv->KeyState.KeyShiftState |= EFI_LEFT_CONTROL_PRESSED;
281 } else {
282 Drv->KeyState.KeyShiftState &= ~EFI_LEFT_CONTROL_PRESSED;
283 }
284 break;
285
286 case XK_Shift_R:
287 if (Make) {
288 Drv->KeyState.KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED;
289 } else {
290 Drv->KeyState.KeyShiftState &= ~EFI_RIGHT_SHIFT_PRESSED;
291 }
292 break;
293 case XK_Shift_L:
294 if (Make) {
295 Drv->KeyState.KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;
296 } else {
297 Drv->KeyState.KeyShiftState &= ~EFI_LEFT_SHIFT_PRESSED;
298 }
299 break;
300
301 case XK_Mode_switch:
302 if (Make) {
303 Drv->KeyState.KeyShiftState |= EFI_LEFT_ALT_PRESSED;
304 } else {
305 Drv->KeyState.KeyShiftState &= ~EFI_LEFT_ALT_PRESSED;
306 }
307 break;
308
309 case XK_Meta_R:
310 if (Make) {
311 Drv->KeyState.KeyShiftState |= EFI_RIGHT_LOGO_PRESSED;
312 } else {
313 Drv->KeyState.KeyShiftState &= ~EFI_RIGHT_LOGO_PRESSED;
314 }
315 break;
316 case XK_Meta_L:
317 if (Make) {
318 Drv->KeyState.KeyShiftState |= EFI_LEFT_LOGO_PRESSED;
319 } else {
320 Drv->KeyState.KeyShiftState &= ~EFI_LEFT_LOGO_PRESSED;
321 }
322 break;
323
324 case XK_KP_Home:
325 case XK_Home: KeyData.Key.ScanCode = SCAN_HOME; break;
326
327 case XK_KP_End:
328 case XK_End: KeyData.Key.ScanCode = SCAN_END; break;
329
330 case XK_KP_Left:
331 case XK_Left: KeyData.Key.ScanCode = SCAN_LEFT; break;
332
333 case XK_KP_Right:
334 case XK_Right: KeyData.Key.ScanCode = SCAN_RIGHT; break;
335
336 case XK_KP_Up:
337 case XK_Up: KeyData.Key.ScanCode = SCAN_UP; break;
338
339 case XK_KP_Down:
340 case XK_Down: KeyData.Key.ScanCode = SCAN_DOWN; break;
341
342 case XK_KP_Delete:
343 case XK_Delete: KeyData.Key.ScanCode = SCAN_DELETE; break;
344
345 case XK_KP_Insert:
346 case XK_Insert: KeyData.Key.ScanCode = SCAN_INSERT; break;
347
348 case XK_KP_Page_Up:
349 case XK_Page_Up: KeyData.Key.ScanCode = SCAN_PAGE_UP; break;
350
351 case XK_KP_Page_Down:
352 case XK_Page_Down: KeyData.Key.ScanCode = SCAN_PAGE_DOWN; break;
353
354 case XK_Escape: KeyData.Key.ScanCode = SCAN_ESC; break;
355
356 case XK_Pause: KeyData.Key.ScanCode = SCAN_PAUSE; break;
357
358 case XK_KP_F1:
359 case XK_F1: KeyData.Key.ScanCode = SCAN_F1; break;
360
361 case XK_KP_F2:
362 case XK_F2: KeyData.Key.ScanCode = SCAN_F2; break;
363
364 case XK_KP_F3:
365 case XK_F3: KeyData.Key.ScanCode = SCAN_F3; break;
366
367 case XK_KP_F4:
368 case XK_F4: KeyData.Key.ScanCode = SCAN_F4; break;
369
370 case XK_F5: KeyData.Key.ScanCode = SCAN_F5; break;
371 case XK_F6: KeyData.Key.ScanCode = SCAN_F6; break;
372 case XK_F7: KeyData.Key.ScanCode = SCAN_F7; break;
373
374 // Don't map into X11 by default on a Mac
375 // System Preferences->Keyboard->Keyboard Shortcuts can be configured
376 // to not use higher function keys as shortcuts and the will show up
377 // in X11.
378 case XK_F8: KeyData.Key.ScanCode = SCAN_F8; break;
379 case XK_F9: KeyData.Key.ScanCode = SCAN_F9; break;
380 case XK_F10: KeyData.Key.ScanCode = SCAN_F10; break;
381
382 case XK_F11: KeyData.Key.ScanCode = SCAN_F11; break;
383 case XK_F12: KeyData.Key.ScanCode = SCAN_F12; break;
384
385 case XK_F13: KeyData.Key.ScanCode = SCAN_F13; break;
386 case XK_F14: KeyData.Key.ScanCode = SCAN_F14; break;
387 case XK_F15: KeyData.Key.ScanCode = SCAN_F15; break;
388 case XK_F16: KeyData.Key.ScanCode = SCAN_F16; break;
389 case XK_F17: KeyData.Key.ScanCode = SCAN_F17; break;
390 case XK_F18: KeyData.Key.ScanCode = SCAN_F18; break;
391 case XK_F19: KeyData.Key.ScanCode = SCAN_F19; break;
392 case XK_F20: KeyData.Key.ScanCode = SCAN_F20; break;
393 case XK_F21: KeyData.Key.ScanCode = SCAN_F21; break;
394 case XK_F22: KeyData.Key.ScanCode = SCAN_F22; break;
395 case XK_F23: KeyData.Key.ScanCode = SCAN_F23; break;
396 case XK_F24: KeyData.Key.ScanCode = SCAN_F24; break;
397
398 // No mapping in X11
399 //case XK_: KeyData.Key.ScanCode = SCAN_MUTE; break;
400 //case XK_: KeyData.Key.ScanCode = SCAN_VOLUME_UP; break;
401 //case XK_: KeyData.Key.ScanCode = SCAN_VOLUME_DOWN; break;
402 //case XK_: KeyData.Key.ScanCode = SCAN_BRIGHTNESS_UP; break;
403 //case XK_: KeyData.Key.ScanCode = SCAN_BRIGHTNESS_DOWN; break;
404 //case XK_: KeyData.Key.ScanCode = SCAN_SUSPEND; break;
405 //case XK_: KeyData.Key.ScanCode = SCAN_HIBERNATE; break;
406 //case XK_: KeyData.Key.ScanCode = SCAN_TOGGLE_DISPLAY; break;
407 //case XK_: KeyData.Key.ScanCode = SCAN_RECOVERY; break;
408 //case XK_: KeyData.Key.ScanCode = SCAN_EJECT; break;
409
410 case XK_BackSpace: KeyData.Key.UnicodeChar = 0x0008; break;
411
412 case XK_KP_Tab:
413 case XK_Tab: KeyData.Key.UnicodeChar = 0x0009; break;
414
415 case XK_Linefeed: KeyData.Key.UnicodeChar = 0x000a; break;
416
417 case XK_KP_Enter:
418 case XK_Return: KeyData.Key.UnicodeChar = 0x000d; break;
419
420 case XK_KP_Equal : KeyData.Key.UnicodeChar = L'='; break;
421 case XK_KP_Multiply : KeyData.Key.UnicodeChar = L'*'; break;
422 case XK_KP_Add : KeyData.Key.UnicodeChar = L'+'; break;
423 case XK_KP_Separator : KeyData.Key.UnicodeChar = L'~'; break;
424 case XK_KP_Subtract : KeyData.Key.UnicodeChar = L'-'; break;
425 case XK_KP_Decimal : KeyData.Key.UnicodeChar = L'.'; break;
426 case XK_KP_Divide : KeyData.Key.UnicodeChar = L'/'; break;
427
428 case XK_KP_0 : KeyData.Key.UnicodeChar = L'0'; break;
429 case XK_KP_1 : KeyData.Key.UnicodeChar = L'1'; break;
430 case XK_KP_2 : KeyData.Key.UnicodeChar = L'2'; break;
431 case XK_KP_3 : KeyData.Key.UnicodeChar = L'3'; break;
432 case XK_KP_4 : KeyData.Key.UnicodeChar = L'4'; break;
433 case XK_KP_5 : KeyData.Key.UnicodeChar = L'5'; break;
434 case XK_KP_6 : KeyData.Key.UnicodeChar = L'6'; break;
435 case XK_KP_7 : KeyData.Key.UnicodeChar = L'7'; break;
436 case XK_KP_8 : KeyData.Key.UnicodeChar = L'8'; break;
437 case XK_KP_9 : KeyData.Key.UnicodeChar = L'9'; break;
438
439 default:
440 ;
441 }
442
443 // The global state is our state
444 KeyData.KeyState.KeyShiftState = Drv->KeyState.KeyShiftState;
445 KeyData.KeyState.KeyToggleState = Drv->KeyState.KeyToggleState;
446
447 if (*KeySym < XK_BackSpace) {
448 if (((Drv->KeyState.KeyShiftState & (EFI_LEFT_SHIFT_PRESSED | EFI_RIGHT_SHIFT_PRESSED)) != 0) ||
449 ((Drv->KeyState.KeyToggleState & EFI_CAPS_LOCK_ACTIVE) != 0) ) {
450
451 KeyData.Key.UnicodeChar = (CHAR16)KeySym[KEYSYM_UPPER];
452
453 // Per UEFI spec since we converted the Unicode clear the shift bits we pass up
454 KeyData.KeyState.KeyShiftState &= ~(EFI_LEFT_SHIFT_PRESSED | EFI_RIGHT_SHIFT_PRESSED);
455 } else {
456 KeyData.Key.UnicodeChar = (CHAR16)KeySym[KEYSYM_LOWER];
457 }
458 } else {
459 // XK_BackSpace is the start of XK_MISCELLANY. These are the XK_? keys we process in this file
460 ;
461 }
462
463 if (Make) {
464 memcpy (&Drv->keys[Drv->key_wr], &KeyData, sizeof (EFI_KEY_DATA));
465 Drv->key_wr = (Drv->key_wr + 1) % NBR_KEYS;
466 Drv->key_count++;
467 if (Drv->MakeRegisterdKeyCallback != NULL) {
468 ReverseGasketUint64Uint64 (Drv->MakeRegisterdKeyCallback ,Drv->RegisterdKeyCallbackContext, &KeyData);
469 }
470 } else {
471 if (Drv->BreakRegisterdKeyCallback != NULL) {
472 ReverseGasketUint64Uint64 (Drv->BreakRegisterdKeyCallback ,Drv->RegisterdKeyCallbackContext, &KeyData);
473 }
474 }
475 }
476
477
478 void
handleMouseMoved(IN GRAPHICS_IO_PRIVATE * Drv,IN XEvent * ev)479 handleMouseMoved(
480 IN GRAPHICS_IO_PRIVATE *Drv,
481 IN XEvent *ev
482 )
483 {
484 if (ev->xmotion.x != Drv->previous_x) {
485 Drv->pointer_state.RelativeMovementX += ( ev->xmotion.x - Drv->previous_x );
486 Drv->previous_x = ev->xmotion.x;
487 Drv->pointer_state_changed = 1;
488 }
489
490 if (ev->xmotion.y != Drv->previous_y) {
491 Drv->pointer_state.RelativeMovementY += ( ev->xmotion.y - Drv->previous_y );
492 Drv->previous_y = ev->xmotion.y;
493 Drv->pointer_state_changed = 1;
494 }
495
496 Drv->pointer_state.RelativeMovementZ = 0;
497 }
498
499 void
handleMouseDown(IN GRAPHICS_IO_PRIVATE * Drv,IN XEvent * ev,IN BOOLEAN Pressed)500 handleMouseDown (
501 IN GRAPHICS_IO_PRIVATE *Drv,
502 IN XEvent *ev,
503 IN BOOLEAN Pressed
504 )
505 {
506 if (ev->xbutton.button == Button1) {
507 Drv->pointer_state_changed = (Drv->pointer_state.LeftButton != Pressed);
508 Drv->pointer_state.LeftButton = Pressed;
509 }
510 if ( ev->xbutton.button == Button2 ) {
511 Drv->pointer_state_changed = (Drv->pointer_state.RightButton != Pressed);
512 Drv->pointer_state.RightButton = Pressed;
513 }
514 }
515
516 void
Redraw(IN GRAPHICS_IO_PRIVATE * Drv,IN UINTN X,IN UINTN Y,IN UINTN Width,IN UINTN Height)517 Redraw (
518 IN GRAPHICS_IO_PRIVATE *Drv,
519 IN UINTN X,
520 IN UINTN Y,
521 IN UINTN Width,
522 IN UINTN Height
523 )
524 {
525 if (Drv->use_shm) {
526 XShmPutImage (
527 Drv->display, Drv->win, Drv->gc, Drv->image, X, Y, X, Y, Width, Height, False
528 );
529 } else {
530 XPutImage (
531 Drv->display, Drv->win, Drv->gc, Drv->image, X, Y, X, Y, Width, Height
532 );
533 }
534 XFlush(Drv->display);
535 }
536
537 void
HandleEvent(GRAPHICS_IO_PRIVATE * Drv,XEvent * ev)538 HandleEvent(GRAPHICS_IO_PRIVATE *Drv, XEvent *ev)
539 {
540 switch (ev->type) {
541 case Expose:
542 Redraw (Drv, ev->xexpose.x, ev->xexpose.y,
543 ev->xexpose.width, ev->xexpose.height);
544 break;
545 case GraphicsExpose:
546 Redraw (Drv, ev->xgraphicsexpose.x, ev->xgraphicsexpose.y,
547 ev->xgraphicsexpose.width, ev->xgraphicsexpose.height);
548 break;
549 case KeyPress:
550 handleKeyEvent (Drv, ev, TRUE);
551 break;
552 case KeyRelease:
553 handleKeyEvent (Drv, ev, FALSE);
554 break;
555 case MappingNotify:
556 XRefreshKeyboardMapping (&ev->xmapping);
557 break;
558 case MotionNotify:
559 handleMouseMoved (Drv, ev);
560 break;
561 case ButtonPress:
562 handleMouseDown (Drv, ev, TRUE);
563 break;
564 case ButtonRelease:
565 handleMouseDown (Drv, ev, FALSE);
566 break;
567 #if 0
568 case DestroyNotify:
569 XCloseDisplay (Drv->display);
570 exit (1);
571 break;
572 #endif
573 case NoExpose:
574 default:
575 break;
576 }
577 }
578
579 void
HandleEvents(IN GRAPHICS_IO_PRIVATE * Drv)580 HandleEvents (
581 IN GRAPHICS_IO_PRIVATE *Drv
582 )
583 {
584 XEvent ev;
585
586 while (XPending (Drv->display) != 0) {
587 XNextEvent (Drv->display, &ev);
588 HandleEvent (Drv, &ev);
589 }
590 }
591
592 unsigned long
X11PixelToColor(IN GRAPHICS_IO_PRIVATE * Drv,IN EFI_UGA_PIXEL pixel)593 X11PixelToColor (
594 IN GRAPHICS_IO_PRIVATE *Drv,
595 IN EFI_UGA_PIXEL pixel
596 )
597 {
598 return ((pixel.Red >> Drv->r.csize) << Drv->r.shift)
599 | ((pixel.Green >> Drv->g.csize) << Drv->g.shift)
600 | ((pixel.Blue >> Drv->b.csize) << Drv->b.shift);
601 }
602
603 EFI_UGA_PIXEL
X11ColorToPixel(IN GRAPHICS_IO_PRIVATE * Drv,IN unsigned long val)604 X11ColorToPixel (
605 IN GRAPHICS_IO_PRIVATE *Drv,
606 IN unsigned long val
607 )
608 {
609 EFI_UGA_PIXEL Pixel;
610
611 memset (&Pixel, 0, sizeof (EFI_UGA_PIXEL));
612
613 // Truncation not an issue since X11 and EFI are both using 8 bits per color
614 Pixel.Red = (val >> Drv->r.shift) << Drv->r.csize;
615 Pixel.Green = (val >> Drv->g.shift) << Drv->g.csize;
616 Pixel.Blue = (val >> Drv->b.shift) << Drv->b.csize;
617
618 return Pixel;
619 }
620
621
622 EFI_STATUS
X11CheckKey(IN EMU_GRAPHICS_WINDOW_PROTOCOL * GraphicsIo)623 X11CheckKey (
624 IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
625 )
626 {
627 GRAPHICS_IO_PRIVATE *Drv;
628
629 Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
630
631 HandleEvents (Drv);
632
633 if (Drv->key_count != 0) {
634 return EFI_SUCCESS;
635 }
636
637 return EFI_NOT_READY;
638 }
639
640 EFI_STATUS
X11GetKey(IN EMU_GRAPHICS_WINDOW_PROTOCOL * GraphicsIo,IN EFI_KEY_DATA * KeyData)641 X11GetKey (
642 IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
643 IN EFI_KEY_DATA *KeyData
644 )
645 {
646 EFI_STATUS EfiStatus;
647 GRAPHICS_IO_PRIVATE *Drv;
648
649 Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
650
651 EfiStatus = X11CheckKey (GraphicsIo);
652 if (EFI_ERROR (EfiStatus)) {
653 return EfiStatus;
654 }
655
656 CopyMem (KeyData, &Drv->keys[Drv->key_rd], sizeof (EFI_KEY_DATA));
657 Drv->key_rd = (Drv->key_rd + 1) % NBR_KEYS;
658 Drv->key_count--;
659
660 return EFI_SUCCESS;
661 }
662
663
664 EFI_STATUS
X11KeySetState(IN EMU_GRAPHICS_WINDOW_PROTOCOL * GraphicsIo,IN EFI_KEY_TOGGLE_STATE * KeyToggleState)665 X11KeySetState (
666 IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
667 IN EFI_KEY_TOGGLE_STATE *KeyToggleState
668 )
669 {
670 GRAPHICS_IO_PRIVATE *Drv;
671
672 Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
673
674 if (*KeyToggleState & EFI_CAPS_LOCK_ACTIVE) {
675 if ((Drv->KeyState.KeyToggleState & EFI_CAPS_LOCK_ACTIVE) == 0) {
676 //
677 // We could create an XKeyEvent and send a XK_Caps_Lock to
678 // the UGA/GOP Window
679 //
680 }
681 }
682
683 Drv->KeyState.KeyToggleState = *KeyToggleState;
684 return EFI_SUCCESS;
685 }
686
687
688 EFI_STATUS
X11RegisterKeyNotify(IN EMU_GRAPHICS_WINDOW_PROTOCOL * GraphicsIo,IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK MakeCallBack,IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK BreakCallBack,IN VOID * Context)689 X11RegisterKeyNotify (
690 IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
691 IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK MakeCallBack,
692 IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK BreakCallBack,
693 IN VOID *Context
694 )
695 {
696 GRAPHICS_IO_PRIVATE *Drv;
697
698 Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
699
700 Drv->MakeRegisterdKeyCallback = MakeCallBack;
701 Drv->BreakRegisterdKeyCallback = BreakCallBack;
702 Drv->RegisterdKeyCallbackContext = Context;
703
704 return EFI_SUCCESS;
705 }
706
707
708 EFI_STATUS
X11Blt(IN EMU_GRAPHICS_WINDOW_PROTOCOL * GraphicsIo,IN EFI_UGA_PIXEL * BltBuffer OPTIONAL,IN EFI_UGA_BLT_OPERATION BltOperation,IN EMU_GRAPHICS_WINDOWS__BLT_ARGS * Args)709 X11Blt (
710 IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
711 IN EFI_UGA_PIXEL *BltBuffer OPTIONAL,
712 IN EFI_UGA_BLT_OPERATION BltOperation,
713 IN EMU_GRAPHICS_WINDOWS__BLT_ARGS *Args
714 )
715 {
716 GRAPHICS_IO_PRIVATE *Private;
717 UINTN DstY;
718 UINTN SrcY;
719 UINTN DstX;
720 UINTN SrcX;
721 UINTN Index;
722 EFI_UGA_PIXEL *Blt;
723 UINT8 *Dst;
724 UINT8 *Src;
725 UINTN Nbr;
726 unsigned long Color;
727 XEvent ev;
728
729 Private = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
730
731
732 //
733 // Check bounds
734 //
735 if (BltOperation == EfiUgaVideoToBltBuffer
736 || BltOperation == EfiUgaVideoToVideo) {
737 //
738 // Source is Video.
739 //
740 if (Args->SourceY + Args->Height > Private->height) {
741 return EFI_INVALID_PARAMETER;
742 }
743
744 if (Args->SourceX + Args->Width > Private->width) {
745 return EFI_INVALID_PARAMETER;
746 }
747 }
748
749 if (BltOperation == EfiUgaBltBufferToVideo
750 || BltOperation == EfiUgaVideoToVideo
751 || BltOperation == EfiUgaVideoFill) {
752 //
753 // Destination is Video
754 //
755 if (Args->DestinationY + Args->Height > Private->height) {
756 return EFI_INVALID_PARAMETER;
757 }
758
759 if (Args->DestinationX + Args->Width > Private->width) {
760 return EFI_INVALID_PARAMETER;
761 }
762 }
763
764 switch (BltOperation) {
765 case EfiUgaVideoToBltBuffer:
766 Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (Args->DestinationY * Args->Delta) + Args->DestinationX * sizeof (EFI_UGA_PIXEL));
767 Args->Delta -= Args->Width * sizeof (EFI_UGA_PIXEL);
768 for (SrcY = Args->SourceY; SrcY < (Args->Height + Args->SourceY); SrcY++) {
769 for (SrcX = Args->SourceX; SrcX < (Args->Width + Args->SourceX); SrcX++) {
770 *Blt++ = X11ColorToPixel (Private, XGetPixel (Private->image, SrcX, SrcY));
771 }
772 Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Args->Delta);
773 }
774 break;
775 case EfiUgaBltBufferToVideo:
776 Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (Args->SourceY * Args->Delta) + Args->SourceX * sizeof (EFI_UGA_PIXEL));
777 Args->Delta -= Args->Width * sizeof (EFI_UGA_PIXEL);
778 for (DstY = Args->DestinationY; DstY < (Args->Height + Args->DestinationY); DstY++) {
779 for (DstX = Args->DestinationX; DstX < (Args->Width + Args->DestinationX); DstX++) {
780 XPutPixel(Private->image, DstX, DstY, X11PixelToColor(Private, *Blt));
781 Blt++;
782 }
783 Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Args->Delta);
784 }
785 break;
786 case EfiUgaVideoToVideo:
787 Dst = Private->image_data + (Args->DestinationX << Private->pixel_shift)
788 + Args->DestinationY * Private->line_bytes;
789 Src = Private->image_data + (Args->SourceX << Private->pixel_shift)
790 + Args->SourceY * Private->line_bytes;
791 Nbr = Args->Width << Private->pixel_shift;
792 if (Args->DestinationY < Args->SourceY) {
793 for (Index = 0; Index < Args->Height; Index++) {
794 memcpy (Dst, Src, Nbr);
795 Dst += Private->line_bytes;
796 Src += Private->line_bytes;
797 }
798 } else {
799 Dst += (Args->Height - 1) * Private->line_bytes;
800 Src += (Args->Height - 1) * Private->line_bytes;
801 for (Index = 0; Index < Args->Height; Index++) {
802 //
803 // Source and Destination Y may be equal, therefore Dst and Src may
804 // overlap.
805 //
806 memmove (Dst, Src, Nbr);
807 Dst -= Private->line_bytes;
808 Src -= Private->line_bytes;
809 }
810 }
811 break;
812 case EfiUgaVideoFill:
813 Color = X11PixelToColor(Private, *BltBuffer);
814 for (DstY = Args->DestinationY; DstY < (Args->Height + Args->DestinationY); DstY++) {
815 for (DstX = Args->DestinationX; DstX < (Args->Width + Args->DestinationX); DstX++) {
816 XPutPixel(Private->image, DstX, DstY, Color);
817 }
818 }
819 break;
820 default:
821 return EFI_INVALID_PARAMETER;
822 }
823
824 //
825 // Refresh screen.
826 //
827 switch (BltOperation) {
828 case EfiUgaVideoToVideo:
829 XCopyArea(
830 Private->display, Private->win, Private->win, Private->gc,
831 Args->SourceX, Args->SourceY, Args->Width, Args->Height,
832 Args->DestinationX, Args->DestinationY
833 );
834
835 while (1) {
836 XNextEvent (Private->display, &ev);
837 HandleEvent (Private, &ev);
838 if (ev.type == NoExpose || ev.type == GraphicsExpose) {
839 break;
840 }
841 }
842 break;
843 case EfiUgaVideoFill:
844 Color = X11PixelToColor (Private, *BltBuffer);
845 XSetForeground (Private->display, Private->gc, Color);
846 XFillRectangle (
847 Private->display, Private->win, Private->gc,
848 Args->DestinationX, Args->DestinationY, Args->Width, Args->Height
849 );
850 XFlush (Private->display);
851 break;
852 case EfiUgaBltBufferToVideo:
853 Redraw (Private, Args->DestinationX, Args->DestinationY, Args->Width, Args->Height);
854 break;
855 default:
856 break;
857 }
858 return EFI_SUCCESS;
859 }
860
861
862 EFI_STATUS
X11CheckPointer(IN EMU_GRAPHICS_WINDOW_PROTOCOL * GraphicsIo)863 X11CheckPointer (
864 IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
865 )
866 {
867 GRAPHICS_IO_PRIVATE *Drv;
868
869 Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
870
871 HandleEvents (Drv);
872 if (Drv->pointer_state_changed != 0) {
873 return EFI_SUCCESS;
874 }
875
876 return EFI_NOT_READY;
877 }
878
879
880 EFI_STATUS
X11GetPointerState(IN EMU_GRAPHICS_WINDOW_PROTOCOL * GraphicsIo,IN EFI_SIMPLE_POINTER_STATE * State)881 X11GetPointerState (
882 IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
883 IN EFI_SIMPLE_POINTER_STATE *State
884 )
885 {
886 EFI_STATUS EfiStatus;
887 GRAPHICS_IO_PRIVATE *Drv;
888
889 Drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
890
891 EfiStatus = X11CheckPointer (GraphicsIo);
892 if (EfiStatus != EFI_SUCCESS) {
893 return EfiStatus;
894 }
895
896 memcpy (State, &Drv->pointer_state, sizeof (EFI_SIMPLE_POINTER_STATE));
897
898 Drv->pointer_state.RelativeMovementX = 0;
899 Drv->pointer_state.RelativeMovementY = 0;
900 Drv->pointer_state.RelativeMovementZ = 0;
901 Drv->pointer_state_changed = 0;
902 return EFI_SUCCESS;
903 }
904
905
906
907 EFI_STATUS
X11GraphicsWindowOpen(IN EMU_IO_THUNK_PROTOCOL * This)908 X11GraphicsWindowOpen (
909 IN EMU_IO_THUNK_PROTOCOL *This
910 )
911 {
912 GRAPHICS_IO_PRIVATE *Drv;
913 unsigned int border_width = 0;
914 char *display_name = NULL;
915
916 Drv = (GRAPHICS_IO_PRIVATE *)calloc (1, sizeof (GRAPHICS_IO_PRIVATE));
917 if (Drv == NULL) {
918 return EFI_OUT_OF_RESOURCES;
919 }
920
921 Drv->GraphicsIo.Size = GasketX11Size;
922 Drv->GraphicsIo.CheckKey = GasketX11CheckKey;
923 Drv->GraphicsIo.GetKey = GasketX11GetKey;
924 Drv->GraphicsIo.KeySetState = GasketX11KeySetState;
925 Drv->GraphicsIo.RegisterKeyNotify = GasketX11RegisterKeyNotify;
926 Drv->GraphicsIo.Blt = GasketX11Blt;
927 Drv->GraphicsIo.CheckPointer = GasketX11CheckPointer;
928 Drv->GraphicsIo.GetPointerState = GasketX11GetPointerState;
929
930
931 Drv->key_count = 0;
932 Drv->key_rd = 0;
933 Drv->key_wr = 0;
934 Drv->KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID;
935 Drv->KeyState.KeyToggleState = EFI_TOGGLE_STATE_VALID;
936 Drv->MakeRegisterdKeyCallback = NULL;
937 Drv->BreakRegisterdKeyCallback = NULL;
938 Drv->RegisterdKeyCallbackContext = NULL;
939
940
941 Drv->display = XOpenDisplay (display_name);
942 if (Drv->display == NULL) {
943 fprintf (stderr, "uga: cannot connect to X server %s\n", XDisplayName (display_name));
944 free (Drv);
945 return EFI_DEVICE_ERROR;
946 }
947 Drv->screen = DefaultScreen (Drv->display);
948 Drv->visual = DefaultVisual (Drv->display, Drv->screen);
949 Drv->win = XCreateSimpleWindow (
950 Drv->display, RootWindow (Drv->display, Drv->screen),
951 0, 0, 4, 4, border_width,
952 WhitePixel (Drv->display, Drv->screen),
953 BlackPixel (Drv->display, Drv->screen)
954 );
955
956 Drv->depth = DefaultDepth (Drv->display, Drv->screen);
957 XDefineCursor (Drv->display, Drv->win, XCreateFontCursor (Drv->display, XC_pirate));
958
959 Drv->Title = malloc (StrSize (This->ConfigString));
960 UnicodeStrToAsciiStr (This->ConfigString, Drv->Title);
961 XStoreName (Drv->display, Drv->win, Drv->Title);
962
963 // XAutoRepeatOff (Drv->display);
964 XSelectInput (
965 Drv->display, Drv->win,
966 ExposureMask | KeyPressMask | KeyReleaseMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask
967 );
968 Drv->gc = DefaultGC (Drv->display, Drv->screen);
969
970 This->Private = (VOID *)Drv;
971 This->Interface = (VOID *)Drv;
972 return EFI_SUCCESS;
973 }
974
975
976 EFI_STATUS
X11GraphicsWindowClose(IN EMU_IO_THUNK_PROTOCOL * This)977 X11GraphicsWindowClose (
978 IN EMU_IO_THUNK_PROTOCOL *This
979 )
980 {
981 GRAPHICS_IO_PRIVATE *Drv;
982
983 Drv = (GRAPHICS_IO_PRIVATE *)This->Private;
984
985 if (Drv == NULL) {
986 return EFI_SUCCESS;
987 }
988
989 if (Drv->image != NULL) {
990 XDestroyImage(Drv->image);
991
992 if (Drv->use_shm) {
993 shmdt (Drv->image_data);
994 }
995
996 Drv->image_data = NULL;
997 Drv->image = NULL;
998 }
999 XDestroyWindow (Drv->display, Drv->win);
1000 XCloseDisplay (Drv->display);
1001
1002 #ifdef __APPLE__
1003 // Free up the shared memory
1004 shmctl (Drv->xshm_info.shmid, IPC_RMID, NULL);
1005 #endif
1006
1007 free (Drv);
1008 return EFI_SUCCESS;
1009 }
1010
1011
1012 EMU_IO_THUNK_PROTOCOL gX11ThunkIo = {
1013 &gEmuGraphicsWindowProtocolGuid,
1014 NULL,
1015 NULL,
1016 0,
1017 GasketX11GraphicsWindowOpen,
1018 GasketX11GraphicsWindowClose,
1019 NULL
1020 };
1021
1022
1023