?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
configure: Default to 'cc', not 'gcc'
[qemu/pbrook.git] / hw / xenfb.c
blob442a63a320cdf9d251881652c239cabd8cff17fd
1 /*
2 * xen paravirt framebuffer backend
3 *
4 * Copyright IBM, Corp. 2005-2006
5 * Copyright Red Hat, Inc. 2006-2008
6 *
7 * Authors:
8 * Anthony Liguori <aliguori@us.ibm.com>,
9 * Markus Armbruster <armbru@redhat.com>,
10 * Daniel P. Berrange <berrange@redhat.com>,
11 * Pat Campbell <plc@novell.com>,
12 * Gerd Hoffmann <kraxel@redhat.com>
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; under version 2 of the License.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License along
24 * with this program; if not, see <http://www.gnu.org/licenses/>.
25 */
26
27 #include <stdarg.h>
28 #include <stdlib.h>
29 #include <sys/types.h>
30 #include <fcntl.h>
31 #include <unistd.h>
32 #include <sys/mman.h>
33 #include <errno.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <time.h>
37
38 #include "hw.h"
39 #include "console.h"
40 #include "qemu-char.h"
41 #include "xen_backend.h"
42
43 #include <xen/event_channel.h>
44 #include <xen/io/fbif.h>
45 #include <xen/io/kbdif.h>
46 #include <xen/io/protocols.h>
47
48 #ifndef BTN_LEFT
49 #define BTN_LEFT 0x110 /* from <linux/input.h> */
50 #endif
51
52 /* -------------------------------------------------------------------- */
53
54 struct common {
55 struct XenDevice xendev; /* must be first */
56 void *page;
57 DisplayState *ds;
58 };
59
60 struct XenInput {
61 struct common c;
62 int abs_pointer_wanted; /* Whether guest supports absolute pointer */
63 int button_state; /* Last seen pointer button state */
64 int extended;
65 QEMUPutMouseEntry *qmouse;
66 };
67
68 #define UP_QUEUE 8
69
70 struct XenFB {
71 struct common c;
72 size_t fb_len;
73 int row_stride;
74 int depth;
75 int width;
76 int height;
77 int offset;
78 void *pixels;
79 int fbpages;
80 int feature_update;
81 int refresh_period;
82 int bug_trigger;
83 int have_console;
84 int do_resize;
85
86 struct {
87 int x,y,w,h;
88 } up_rects[UP_QUEUE];
89 int up_count;
90 int up_fullscreen;
91 };
92
93 /* -------------------------------------------------------------------- */
94
95 static int common_bind(struct common *c)
96 {
97 int mfn;
98
99 if (xenstore_read_fe_int(&c->xendev, "page-ref", &mfn) == -1)
100 return -1;
101 if (xenstore_read_fe_int(&c->xendev, "event-channel", &c->xendev.remote_port) == -1)
102 return -1;
103
104 c->page = xc_map_foreign_range(xen_xc, c->xendev.dom,
105 XC_PAGE_SIZE,
106 PROT_READ | PROT_WRITE, mfn);
107 if (c->page == NULL)
108 return -1;
109
110 xen_be_bind_evtchn(&c->xendev);
111 xen_be_printf(&c->xendev, 1, "ring mfn %d, remote-port %d, local-port %d\n",
112 mfn, c->xendev.remote_port, c->xendev.local_port);
113
114 return 0;
115 }
116
117 static void common_unbind(struct common *c)
118 {
119 xen_be_unbind_evtchn(&c->xendev);
120 if (c->page) {
121 munmap(c->page, XC_PAGE_SIZE);
122 c->page = NULL;
123 }
124 }
125
126 /* -------------------------------------------------------------------- */
127
128 #if 0
129 /*
130 * These two tables are not needed any more, but left in here
131 * intentionally as documentation, to show how scancode2linux[]
132 * was generated.
133 *
134 * Tables to map from scancode to Linux input layer keycode.
135 * Scancodes are hardware-specific. These maps assumes a
136 * standard AT or PS/2 keyboard which is what QEMU feeds us.
137 */
138 const unsigned char atkbd_set2_keycode[512] = {
139
140 0, 67, 65, 63, 61, 59, 60, 88, 0, 68, 66, 64, 62, 15, 41,117,
141 0, 56, 42, 93, 29, 16, 2, 0, 0, 0, 44, 31, 30, 17, 3, 0,
142 0, 46, 45, 32, 18, 5, 4, 95, 0, 57, 47, 33, 20, 19, 6,183,
143 0, 49, 48, 35, 34, 21, 7,184, 0, 0, 50, 36, 22, 8, 9,185,
144 0, 51, 37, 23, 24, 11, 10, 0, 0, 52, 53, 38, 39, 25, 12, 0,
145 0, 89, 40, 0, 26, 13, 0, 0, 58, 54, 28, 27, 0, 43, 0, 85,
146 0, 86, 91, 90, 92, 0, 14, 94, 0, 79,124, 75, 71,121, 0, 0,
147 82, 83, 80, 76, 77, 72, 1, 69, 87, 78, 81, 74, 55, 73, 70, 99,
148
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
150 217,100,255, 0, 97,165, 0, 0,156, 0, 0, 0, 0, 0, 0,125,
151 173,114, 0,113, 0, 0, 0,126,128, 0, 0,140, 0, 0, 0,127,
152 159, 0,115, 0,164, 0, 0,116,158, 0,150,166, 0, 0, 0,142,
153 157, 0, 0, 0, 0, 0, 0, 0,155, 0, 98, 0, 0,163, 0, 0,
154 226, 0, 0, 0, 0, 0, 0, 0, 0,255, 96, 0, 0, 0,143, 0,
155 0, 0, 0, 0, 0, 0, 0, 0, 0,107, 0,105,102, 0, 0,112,
156 110,111,108,112,106,103, 0,119, 0,118,109, 0, 99,104,119, 0,
157
158 };
159
160 const unsigned char atkbd_unxlate_table[128] = {
161
162 0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
163 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
164 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
165 50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88, 5, 6, 4, 12, 3,
166 11, 2, 10, 1, 9,119,126,108,117,125,123,107,115,116,121,105,
167 114,122,112,113,127, 96, 97,120, 7, 15, 23, 31, 39, 47, 55, 63,
168 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
169 19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
170
171 };
172 #endif
173
174 /*
175 * for (i = 0; i < 128; i++) {
176 * scancode2linux[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
177 * scancode2linux[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
178 * }
179 */
180 static const unsigned char scancode2linux[512] = {
181 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
182 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
183 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
184 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
185 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
186 80, 81, 82, 83, 99, 0, 86, 87, 88,117, 0, 0, 95,183,184,185,
187 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
188 93, 0, 0, 89, 0, 0, 85, 91, 90, 92, 0, 94, 0,124,121, 0,
189
190 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
191 165, 0, 0, 0, 0, 0, 0, 0, 0,163, 0, 0, 96, 97, 0, 0,
192 113,140,164, 0,166, 0, 0, 0, 0, 0,255, 0, 0, 0,114, 0,
193 115, 0,150, 0, 0, 98,255, 99,100, 0, 0, 0, 0, 0, 0, 0,
194 0, 0, 0, 0, 0,119,119,102,103,104, 0,105,112,106,118,107,
195 108,109,110,111, 0, 0, 0, 0, 0, 0, 0,125,126,127,116,142,
196 0, 0, 0,143, 0,217,156,173,128,159,158,157,155,226, 0,112,
197 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
198 };
199
200 /* Send an event to the keyboard frontend driver */
201 static int xenfb_kbd_event(struct XenInput *xenfb,
202 union xenkbd_in_event *event)
203 {
204 struct xenkbd_page *page = xenfb->c.page;
205 uint32_t prod;
206
207 if (xenfb->c.xendev.be_state != XenbusStateConnected)
208 return 0;
209 if (!page)
210 return 0;
211
212 prod = page->in_prod;
213 if (prod - page->in_cons == XENKBD_IN_RING_LEN) {
214 errno = EAGAIN;
215 return -1;
216 }
217
218 xen_mb(); /* ensure ring space available */
219 XENKBD_IN_RING_REF(page, prod) = *event;
220 xen_wmb(); /* ensure ring contents visible */
221 page->in_prod = prod + 1;
222 return xen_be_send_notify(&xenfb->c.xendev);
223 }
224
225 /* Send a keyboard (or mouse button) event */
226 static int xenfb_send_key(struct XenInput *xenfb, bool down, int keycode)
227 {
228 union xenkbd_in_event event;
229
230 memset(&event, 0, XENKBD_IN_EVENT_SIZE);
231 event.type = XENKBD_TYPE_KEY;
232 event.key.pressed = down ? 1 : 0;
233 event.key.keycode = keycode;
234
235 return xenfb_kbd_event(xenfb, &event);
236 }
237
238 /* Send a relative mouse movement event */
239 static int xenfb_send_motion(struct XenInput *xenfb,
240 int rel_x, int rel_y, int rel_z)
241 {
242 union xenkbd_in_event event;
243
244 memset(&event, 0, XENKBD_IN_EVENT_SIZE);
245 event.type = XENKBD_TYPE_MOTION;
246 event.motion.rel_x = rel_x;
247 event.motion.rel_y = rel_y;
248 #if __XEN_LATEST_INTERFACE_VERSION__ >= 0x00030207
249 event.motion.rel_z = rel_z;
250 #endif
251
252 return xenfb_kbd_event(xenfb, &event);
253 }
254
255 /* Send an absolute mouse movement event */
256 static int xenfb_send_position(struct XenInput *xenfb,
257 int abs_x, int abs_y, int z)
258 {
259 union xenkbd_in_event event;
260
261 memset(&event, 0, XENKBD_IN_EVENT_SIZE);
262 event.type = XENKBD_TYPE_POS;
263 event.pos.abs_x = abs_x;
264 event.pos.abs_y = abs_y;
265 #if __XEN_LATEST_INTERFACE_VERSION__ == 0x00030207
266 event.pos.abs_z = z;
267 #endif
268 #if __XEN_LATEST_INTERFACE_VERSION__ >= 0x00030208
269 event.pos.rel_z = z;
270 #endif
271
272 return xenfb_kbd_event(xenfb, &event);
273 }
274
275 /*
276 * Send a key event from the client to the guest OS
277 * QEMU gives us a raw scancode from an AT / PS/2 style keyboard.
278 * We have to turn this into a Linux Input layer keycode.
279 *
280 * Extra complexity from the fact that with extended scancodes
281 * (like those produced by arrow keys) this method gets called
282 * twice, but we only want to send a single event. So we have to
283 * track the '0xe0' scancode state & collapse the extended keys
284 * as needed.
285 *
286 * Wish we could just send scancodes straight to the guest which
287 * already has code for dealing with this...
288 */
289 static void xenfb_key_event(void *opaque, int scancode)
290 {
291 struct XenInput *xenfb = opaque;
292 int down = 1;
293
294 if (scancode == 0xe0) {
295 xenfb->extended = 1;
296 return;
297 } else if (scancode & 0x80) {
298 scancode &= 0x7f;
299 down = 0;
300 }
301 if (xenfb->extended) {
302 scancode |= 0x80;
303 xenfb->extended = 0;
304 }
305 xenfb_send_key(xenfb, down, scancode2linux[scancode]);
306 }
307
308 /*
309 * Send a mouse event from the client to the guest OS
310 *
311 * The QEMU mouse can be in either relative, or absolute mode.
312 * Movement is sent separately from button state, which has to
313 * be encoded as virtual key events. We also don't actually get
314 * given any button up/down events, so have to track changes in
315 * the button state.
316 */
317 static void xenfb_mouse_event(void *opaque,
318 int dx, int dy, int dz, int button_state)
319 {
320 struct XenInput *xenfb = opaque;
321 int dw = ds_get_width(xenfb->c.ds);
322 int dh = ds_get_height(xenfb->c.ds);
323 int i;
324
325 if (xenfb->abs_pointer_wanted)
326 xenfb_send_position(xenfb,
327 dx * (dw - 1) / 0x7fff,
328 dy * (dh - 1) / 0x7fff,
329 dz);
330 else
331 xenfb_send_motion(xenfb, dx, dy, dz);
332
333 for (i = 0 ; i < 8 ; i++) {
334 int lastDown = xenfb->button_state & (1 << i);
335 int down = button_state & (1 << i);
336 if (down == lastDown)
337 continue;
338
339 if (xenfb_send_key(xenfb, down, BTN_LEFT+i) < 0)
340 return;
341 }
342 xenfb->button_state = button_state;
343 }
344
345 static int input_init(struct XenDevice *xendev)
346 {
347 xenstore_write_be_int(xendev, "feature-abs-pointer", 1);
348 return 0;
349 }
350
351 static int input_initialise(struct XenDevice *xendev)
352 {
353 struct XenInput *in = container_of(xendev, struct XenInput, c.xendev);
354 int rc;
355
356 if (!in->c.ds) {
357 char *vfb = xenstore_read_str(NULL, "device/vfb");
358 if (vfb == NULL) {
359 /* there is no vfb, run vkbd on its own */
360 in->c.ds = get_displaystate();
361 } else {
362 g_free(vfb);
363 xen_be_printf(xendev, 1, "ds not set (yet)\n");
364 return -1;
365 }
366 }
367
368 rc = common_bind(&in->c);
369 if (rc != 0)
370 return rc;
371
372 qemu_add_kbd_event_handler(xenfb_key_event, in);
373 return 0;
374 }
375
376 static void input_connected(struct XenDevice *xendev)
377 {
378 struct XenInput *in = container_of(xendev, struct XenInput, c.xendev);
379
380 if (xenstore_read_fe_int(xendev, "request-abs-pointer",
381 &in->abs_pointer_wanted) == -1) {
382 in->abs_pointer_wanted = 0;
383 }
384
385 if (in->qmouse) {
386 qemu_remove_mouse_event_handler(in->qmouse);
387 }
388 in->qmouse = qemu_add_mouse_event_handler(xenfb_mouse_event, in,
389 in->abs_pointer_wanted,
390 "Xen PVFB Mouse");
391 }
392
393 static void input_disconnect(struct XenDevice *xendev)
394 {
395 struct XenInput *in = container_of(xendev, struct XenInput, c.xendev);
396
397 if (in->qmouse) {
398 qemu_remove_mouse_event_handler(in->qmouse);
399 in->qmouse = NULL;
400 }
401 qemu_add_kbd_event_handler(NULL, NULL);
402 common_unbind(&in->c);
403 }
404
405 static void input_event(struct XenDevice *xendev)
406 {
407 struct XenInput *xenfb = container_of(xendev, struct XenInput, c.xendev);
408 struct xenkbd_page *page = xenfb->c.page;
409
410 /* We don't understand any keyboard events, so just ignore them. */
411 if (page->out_prod == page->out_cons)
412 return;
413 page->out_cons = page->out_prod;
414 xen_be_send_notify(&xenfb->c.xendev);
415 }
416
417 /* -------------------------------------------------------------------- */
418
419 static void xenfb_copy_mfns(int mode, int count, unsigned long *dst, void *src)
420 {
421 uint32_t *src32 = src;
422 uint64_t *src64 = src;
423 int i;
424
425 for (i = 0; i < count; i++)
426 dst[i] = (mode == 32) ? src32[i] : src64[i];
427 }
428
429 static int xenfb_map_fb(struct XenFB *xenfb)
430 {
431 struct xenfb_page *page = xenfb->c.page;
432 char *protocol = xenfb->c.xendev.protocol;
433 int n_fbdirs;
434 unsigned long *pgmfns = NULL;
435 unsigned long *fbmfns = NULL;
436 void *map, *pd;
437 int mode, ret = -1;
438
439 /* default to native */
440 pd = page->pd;
441 mode = sizeof(unsigned long) * 8;
442
443 if (!protocol) {
444 /*
445 * Undefined protocol, some guesswork needed.
446 *
447 * Old frontends which don't set the protocol use
448 * one page directory only, thus pd[1] must be zero.
449 * pd[1] of the 32bit struct layout and the lower
450 * 32 bits of pd[0] of the 64bit struct layout have
451 * the same location, so we can check that ...
452 */
453 uint32_t *ptr32 = NULL;
454 uint32_t *ptr64 = NULL;
455 #if defined(__i386__)
456 ptr32 = (void*)page->pd;
457 ptr64 = ((void*)page->pd) + 4;
458 #elif defined(__x86_64__)
459 ptr32 = ((void*)page->pd) - 4;
460 ptr64 = (void*)page->pd;
461 #endif
462 if (ptr32) {
463 if (ptr32[1] == 0) {
464 mode = 32;
465 pd = ptr32;
466 } else {
467 mode = 64;
468 pd = ptr64;
469 }
470 }
471 #if defined(__x86_64__)
472 } else if (strcmp(protocol, XEN_IO_PROTO_ABI_X86_32) == 0) {
473 /* 64bit dom0, 32bit domU */
474 mode = 32;
475 pd = ((void*)page->pd) - 4;
476 #elif defined(__i386__)
477 } else if (strcmp(protocol, XEN_IO_PROTO_ABI_X86_64) == 0) {
478 /* 32bit dom0, 64bit domU */
479 mode = 64;
480 pd = ((void*)page->pd) + 4;
481 #endif
482 }
483
484 if (xenfb->pixels) {
485 munmap(xenfb->pixels, xenfb->fbpages * XC_PAGE_SIZE);
486 xenfb->pixels = NULL;
487 }
488
489 xenfb->fbpages = (xenfb->fb_len + (XC_PAGE_SIZE - 1)) / XC_PAGE_SIZE;
490 n_fbdirs = xenfb->fbpages * mode / 8;
491 n_fbdirs = (n_fbdirs + (XC_PAGE_SIZE - 1)) / XC_PAGE_SIZE;
492
493 pgmfns = g_malloc0(sizeof(unsigned long) * n_fbdirs);
494 fbmfns = g_malloc0(sizeof(unsigned long) * xenfb->fbpages);
495
496 xenfb_copy_mfns(mode, n_fbdirs, pgmfns, pd);
497 map = xc_map_foreign_pages(xen_xc, xenfb->c.xendev.dom,
498 PROT_READ, pgmfns, n_fbdirs);
499 if (map == NULL)
500 goto out;
501 xenfb_copy_mfns(mode, xenfb->fbpages, fbmfns, map);
502 munmap(map, n_fbdirs * XC_PAGE_SIZE);
503
504 xenfb->pixels = xc_map_foreign_pages(xen_xc, xenfb->c.xendev.dom,
505 PROT_READ | PROT_WRITE, fbmfns, xenfb->fbpages);
506 if (xenfb->pixels == NULL)
507 goto out;
508
509 ret = 0; /* all is fine */
510
511 out:
512 g_free(pgmfns);
513 g_free(fbmfns);
514 return ret;
515 }
516
517 static int xenfb_configure_fb(struct XenFB *xenfb, size_t fb_len_lim,
518 int width, int height, int depth,
519 size_t fb_len, int offset, int row_stride)
520 {
521 size_t mfn_sz = sizeof(*((struct xenfb_page *)0)->pd);
522 size_t pd_len = sizeof(((struct xenfb_page *)0)->pd) / mfn_sz;
523 size_t fb_pages = pd_len * XC_PAGE_SIZE / mfn_sz;
524 size_t fb_len_max = fb_pages * XC_PAGE_SIZE;
525 int max_width, max_height;
526
527 if (fb_len_lim > fb_len_max) {
528 xen_be_printf(&xenfb->c.xendev, 0, "fb size limit %zu exceeds %zu, corrected\n",
529 fb_len_lim, fb_len_max);
530 fb_len_lim = fb_len_max;
531 }
532 if (fb_len_lim && fb_len > fb_len_lim) {
533 xen_be_printf(&xenfb->c.xendev, 0, "frontend fb size %zu limited to %zu\n",
534 fb_len, fb_len_lim);
535 fb_len = fb_len_lim;
536 }
537 if (depth != 8 && depth != 16 && depth != 24 && depth != 32) {
538 xen_be_printf(&xenfb->c.xendev, 0, "can't handle frontend fb depth %d\n",
539 depth);
540 return -1;
541 }
542 if (row_stride <= 0 || row_stride > fb_len) {
543 xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend stride %d\n", row_stride);
544 return -1;
545 }
546 max_width = row_stride / (depth / 8);
547 if (width < 0 || width > max_width) {
548 xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend width %d limited to %d\n",
549 width, max_width);
550 width = max_width;
551 }
552 if (offset < 0 || offset >= fb_len) {
553 xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend offset %d (max %zu)\n",
554 offset, fb_len - 1);
555 return -1;
556 }
557 max_height = (fb_len - offset) / row_stride;
558 if (height < 0 || height > max_height) {
559 xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend height %d limited to %d\n",
560 height, max_height);
561 height = max_height;
562 }
563 xenfb->fb_len = fb_len;
564 xenfb->row_stride = row_stride;
565 xenfb->depth = depth;
566 xenfb->width = width;
567 xenfb->height = height;
568 xenfb->offset = offset;
569 xenfb->up_fullscreen = 1;
570 xenfb->do_resize = 1;
571 xen_be_printf(&xenfb->c.xendev, 1, "framebuffer %dx%dx%d offset %d stride %d\n",
572 width, height, depth, offset, row_stride);
573 return 0;
574 }
575
576 /* A convenient function for munging pixels between different depths */
577 #define BLT(SRC_T,DST_T,RSB,GSB,BSB,RDB,GDB,BDB) \
578 for (line = y ; line < (y+h) ; line++) { \
579 SRC_T *src = (SRC_T *)(xenfb->pixels \
580 + xenfb->offset \
581 + (line * xenfb->row_stride) \
582 + (x * xenfb->depth / 8)); \
583 DST_T *dst = (DST_T *)(data \
584 + (line * linesize) \
585 + (x * bpp / 8)); \
586 int col; \
587 const int RSS = 32 - (RSB + GSB + BSB); \
588 const int GSS = 32 - (GSB + BSB); \
589 const int BSS = 32 - (BSB); \
590 const uint32_t RSM = (~0U) << (32 - RSB); \
591 const uint32_t GSM = (~0U) << (32 - GSB); \
592 const uint32_t BSM = (~0U) << (32 - BSB); \
593 const int RDS = 32 - (RDB + GDB + BDB); \
594 const int GDS = 32 - (GDB + BDB); \
595 const int BDS = 32 - (BDB); \
596 const uint32_t RDM = (~0U) << (32 - RDB); \
597 const uint32_t GDM = (~0U) << (32 - GDB); \
598 const uint32_t BDM = (~0U) << (32 - BDB); \
599 for (col = x ; col < (x+w) ; col++) { \
600 uint32_t spix = *src; \
601 *dst = (((spix << RSS) & RSM & RDM) >> RDS) | \
602 (((spix << GSS) & GSM & GDM) >> GDS) | \
603 (((spix << BSS) & BSM & BDM) >> BDS); \
604 src = (SRC_T *) ((unsigned long) src + xenfb->depth / 8); \
605 dst = (DST_T *) ((unsigned long) dst + bpp / 8); \
606 } \
607 }
608
609
610 /*
611 * This copies data from the guest framebuffer region, into QEMU's
612 * displaysurface. qemu uses 16 or 32 bpp. In case the pv framebuffer
613 * uses something else we must convert and copy, otherwise we can
614 * supply the buffer directly and no thing here.
615 */
616 static void xenfb_guest_copy(struct XenFB *xenfb, int x, int y, int w, int h)
617 {
618 int line, oops = 0;
619 int bpp = ds_get_bits_per_pixel(xenfb->c.ds);
620 int linesize = ds_get_linesize(xenfb->c.ds);
621 uint8_t *data = ds_get_data(xenfb->c.ds);
622
623 if (!is_buffer_shared(xenfb->c.ds->surface)) {
624 switch (xenfb->depth) {
625 case 8:
626 if (bpp == 16) {
627 BLT(uint8_t, uint16_t, 3, 3, 2, 5, 6, 5);
628 } else if (bpp == 32) {
629 BLT(uint8_t, uint32_t, 3, 3, 2, 8, 8, 8);
630 } else {
631 oops = 1;
632 }
633 break;
634 case 24:
635 if (bpp == 16) {
636 BLT(uint32_t, uint16_t, 8, 8, 8, 5, 6, 5);
637 } else if (bpp == 32) {
638 BLT(uint32_t, uint32_t, 8, 8, 8, 8, 8, 8);
639 } else {
640 oops = 1;
641 }
642 break;
643 default:
644 oops = 1;
645 }
646 }
647 if (oops) /* should not happen */
648 xen_be_printf(&xenfb->c.xendev, 0, "%s: oops: convert %d -> %d bpp?\n",
649 __FUNCTION__, xenfb->depth, bpp);
650
651 dpy_gfx_update(xenfb->c.ds, x, y, w, h);
652 }
653
654 #ifdef XENFB_TYPE_REFRESH_PERIOD
655 static int xenfb_queue_full(struct XenFB *xenfb)
656 {
657 struct xenfb_page *page = xenfb->c.page;
658 uint32_t cons, prod;
659
660 if (!page)
661 return 1;
662
663 prod = page->in_prod;
664 cons = page->in_cons;
665 return prod - cons == XENFB_IN_RING_LEN;
666 }
667
668 static void xenfb_send_event(struct XenFB *xenfb, union xenfb_in_event *event)
669 {
670 uint32_t prod;
671 struct xenfb_page *page = xenfb->c.page;
672
673 prod = page->in_prod;
674 /* caller ensures !xenfb_queue_full() */
675 xen_mb(); /* ensure ring space available */
676 XENFB_IN_RING_REF(page, prod) = *event;
677 xen_wmb(); /* ensure ring contents visible */
678 page->in_prod = prod + 1;
679
680 xen_be_send_notify(&xenfb->c.xendev);
681 }
682
683 static void xenfb_send_refresh_period(struct XenFB *xenfb, int period)
684 {
685 union xenfb_in_event event;
686
687 memset(&event, 0, sizeof(event));
688 event.type = XENFB_TYPE_REFRESH_PERIOD;
689 event.refresh_period.period = period;
690 xenfb_send_event(xenfb, &event);
691 }
692 #endif
693
694 /*
695 * Periodic update of display.
696 * Also transmit the refresh interval to the frontend.
697 *
698 * Never ever do any qemu display operations
699 * (resize, screen update) outside this function.
700 * Our screen might be inactive. When asked for
701 * an update we know it is active.
702 */
703 static void xenfb_update(void *opaque)
704 {
705 struct XenFB *xenfb = opaque;
706 int i;
707
708 if (xenfb->c.xendev.be_state != XenbusStateConnected)
709 return;
710
711 if (xenfb->feature_update) {
712 #ifdef XENFB_TYPE_REFRESH_PERIOD
713 struct DisplayChangeListener *l;
714 int period = 99999999;
715 int idle = 1;
716
717 if (xenfb_queue_full(xenfb))
718 return;
719
720 QLIST_FOREACH(l, &xenfb->c.ds->listeners, next) {
721 if (l->idle)
722 continue;
723 idle = 0;
724 if (!l->gui_timer_interval) {
725 if (period > GUI_REFRESH_INTERVAL)
726 period = GUI_REFRESH_INTERVAL;
727 } else {
728 if (period > l->gui_timer_interval)
729 period = l->gui_timer_interval;
730 }
731 }
732 if (idle)
733 period = XENFB_NO_REFRESH;
734
735 if (xenfb->refresh_period != period) {
736 xenfb_send_refresh_period(xenfb, period);
737 xenfb->refresh_period = period;
738 xen_be_printf(&xenfb->c.xendev, 1, "refresh period: %d\n", period);
739 }
740 #else
741 ; /* nothing */
742 #endif
743 } else {
744 /* we don't get update notifications, thus use the
745 * sledge hammer approach ... */
746 xenfb->up_fullscreen = 1;
747 }
748
749 /* resize if needed */
750 if (xenfb->do_resize) {
751 xenfb->do_resize = 0;
752 switch (xenfb->depth) {
753 case 16:
754 case 32:
755 /* console.c supported depth -> buffer can be used directly */
756 qemu_free_displaysurface(xenfb->c.ds);
757 xenfb->c.ds->surface = qemu_create_displaysurface_from
758 (xenfb->width, xenfb->height, xenfb->depth,
759 xenfb->row_stride, xenfb->pixels + xenfb->offset);
760 break;
761 default:
762 /* we must convert stuff */
763 qemu_resize_displaysurface(xenfb->c.ds, xenfb->width, xenfb->height);
764 break;
765 }
766 xen_be_printf(&xenfb->c.xendev, 1, "update: resizing: %dx%d @ %d bpp%s\n",
767 xenfb->width, xenfb->height, xenfb->depth,
768 is_buffer_shared(xenfb->c.ds->surface) ? " (shared)" : "");
769 dpy_gfx_resize(xenfb->c.ds);
770 xenfb->up_fullscreen = 1;
771 }
772
773 /* run queued updates */
774 if (xenfb->up_fullscreen) {
775 xen_be_printf(&xenfb->c.xendev, 3, "update: fullscreen\n");
776 xenfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height);
777 } else if (xenfb->up_count) {
778 xen_be_printf(&xenfb->c.xendev, 3, "update: %d rects\n", xenfb->up_count);
779 for (i = 0; i < xenfb->up_count; i++)
780 xenfb_guest_copy(xenfb,
781 xenfb->up_rects[i].x,
782 xenfb->up_rects[i].y,
783 xenfb->up_rects[i].w,
784 xenfb->up_rects[i].h);
785 } else {
786 xen_be_printf(&xenfb->c.xendev, 3, "update: nothing\n");
787 }
788 xenfb->up_count = 0;
789 xenfb->up_fullscreen = 0;
790 }
791
792 /* QEMU display state changed, so refresh the framebuffer copy */
793 static void xenfb_invalidate(void *opaque)
794 {
795 struct XenFB *xenfb = opaque;
796 xenfb->up_fullscreen = 1;
797 }
798
799 static void xenfb_handle_events(struct XenFB *xenfb)
800 {
801 uint32_t prod, cons;
802 struct xenfb_page *page = xenfb->c.page;
803
804 prod = page->out_prod;
805 if (prod == page->out_cons)
806 return;
807 xen_rmb(); /* ensure we see ring contents up to prod */
808 for (cons = page->out_cons; cons != prod; cons++) {
809 union xenfb_out_event *event = &XENFB_OUT_RING_REF(page, cons);
810 int x, y, w, h;
811
812 switch (event->type) {
813 case XENFB_TYPE_UPDATE:
814 if (xenfb->up_count == UP_QUEUE)
815 xenfb->up_fullscreen = 1;
816 if (xenfb->up_fullscreen)
817 break;
818 x = MAX(event->update.x, 0);
819 y = MAX(event->update.y, 0);
820 w = MIN(event->update.width, xenfb->width - x);
821 h = MIN(event->update.height, xenfb->height - y);
822 if (w < 0 || h < 0) {
823 xen_be_printf(&xenfb->c.xendev, 1, "bogus update ignored\n");
824 break;
825 }
826 if (x != event->update.x ||
827 y != event->update.y ||
828 w != event->update.width ||
829 h != event->update.height) {
830 xen_be_printf(&xenfb->c.xendev, 1, "bogus update clipped\n");
831 }
832 if (w == xenfb->width && h > xenfb->height / 2) {
833 /* scroll detector: updated more than 50% of the lines,
834 * don't bother keeping track of the rectangles then */
835 xenfb->up_fullscreen = 1;
836 } else {
837 xenfb->up_rects[xenfb->up_count].x = x;
838 xenfb->up_rects[xenfb->up_count].y = y;
839 xenfb->up_rects[xenfb->up_count].w = w;
840 xenfb->up_rects[xenfb->up_count].h = h;
841 xenfb->up_count++;
842 }
843 break;
844 #ifdef XENFB_TYPE_RESIZE
845 case XENFB_TYPE_RESIZE:
846 if (xenfb_configure_fb(xenfb, xenfb->fb_len,
847 event->resize.width,
848 event->resize.height,
849 event->resize.depth,
850 xenfb->fb_len,
851 event->resize.offset,
852 event->resize.stride) < 0)
853 break;
854 xenfb_invalidate(xenfb);
855 break;
856 #endif
857 }
858 }
859 xen_mb(); /* ensure we're done with ring contents */
860 page->out_cons = cons;
861 }
862
863 static int fb_init(struct XenDevice *xendev)
864 {
865 struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev);
866
867 fb->refresh_period = -1;
868
869 #ifdef XENFB_TYPE_RESIZE
870 xenstore_write_be_int(xendev, "feature-resize", 1);
871 #endif
872 return 0;
873 }
874
875 static int fb_initialise(struct XenDevice *xendev)
876 {
877 struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev);
878 struct xenfb_page *fb_page;
879 int videoram;
880 int rc;
881
882 if (xenstore_read_fe_int(xendev, "videoram", &videoram) == -1)
883 videoram = 0;
884
885 rc = common_bind(&fb->c);
886 if (rc != 0)
887 return rc;
888
889 fb_page = fb->c.page;
890 rc = xenfb_configure_fb(fb, videoram * 1024 * 1024U,
891 fb_page->width, fb_page->height, fb_page->depth,
892 fb_page->mem_length, 0, fb_page->line_length);
893 if (rc != 0)
894 return rc;
895
896 rc = xenfb_map_fb(fb);
897 if (rc != 0)
898 return rc;
899
900 #if 0 /* handled in xen_init_display() for now */
901 if (!fb->have_console) {
902 fb->c.ds = graphic_console_init(xenfb_update,
903 xenfb_invalidate,
904 NULL,
905 NULL,
906 fb);
907 fb->have_console = 1;
908 }
909 #endif
910
911 if (xenstore_read_fe_int(xendev, "feature-update", &fb->feature_update) == -1)
912 fb->feature_update = 0;
913 if (fb->feature_update)
914 xenstore_write_be_int(xendev, "request-update", 1);
915
916 xen_be_printf(xendev, 1, "feature-update=%d, videoram=%d\n",
917 fb->feature_update, videoram);
918 return 0;
919 }
920
921 static void fb_disconnect(struct XenDevice *xendev)
922 {
923 struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev);
924
925 /*
926 * FIXME: qemu can't un-init gfx display (yet?).
927 * Replacing the framebuffer with anonymous shared memory
928 * instead. This releases the guest pages and keeps qemu happy.
929 */
930 fb->pixels = mmap(fb->pixels, fb->fbpages * XC_PAGE_SIZE,
931 PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON,
932 -1, 0);
933 common_unbind(&fb->c);
934 fb->feature_update = 0;
935 fb->bug_trigger = 0;
936 }
937
938 static void fb_frontend_changed(struct XenDevice *xendev, const char *node)
939 {
940 struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev);
941
942 /*
943 * Set state to Connected *again* once the frontend switched
944 * to connected. We must trigger the watch a second time to
945 * workaround a frontend bug.
946 */
947 if (fb->bug_trigger == 0 && strcmp(node, "state") == 0 &&
948 xendev->fe_state == XenbusStateConnected &&
949 xendev->be_state == XenbusStateConnected) {
950 xen_be_printf(xendev, 2, "re-trigger connected (frontend bug)\n");
951 xen_be_set_state(xendev, XenbusStateConnected);
952 fb->bug_trigger = 1; /* only once */
953 }
954 }
955
956 static void fb_event(struct XenDevice *xendev)
957 {
958 struct XenFB *xenfb = container_of(xendev, struct XenFB, c.xendev);
959
960 xenfb_handle_events(xenfb);
961 xen_be_send_notify(&xenfb->c.xendev);
962 }
963
964 /* -------------------------------------------------------------------- */
965
966 struct XenDevOps xen_kbdmouse_ops = {
967 .size = sizeof(struct XenInput),
968 .init = input_init,
969 .initialise = input_initialise,
970 .connected = input_connected,
971 .disconnect = input_disconnect,
972 .event = input_event,
973 };
974
975 struct XenDevOps xen_framebuffer_ops = {
976 .size = sizeof(struct XenFB),
977 .init = fb_init,
978 .initialise = fb_initialise,
979 .disconnect = fb_disconnect,
980 .event = fb_event,
981 .frontend_changed = fb_frontend_changed,
982 };
983
984 /*
985 * FIXME/TODO: Kill this.
986 * Temporary needed while DisplayState reorganization is in flight.
987 */
988 void xen_init_display(int domid)
989 {
990 struct XenDevice *xfb, *xin;
991 struct XenFB *fb;
992 struct XenInput *in;
993 int i = 0;
994
995 wait_more:
996 i++;
997 main_loop_wait(true);
998 xfb = xen_be_find_xendev("vfb", domid, 0);
999 xin = xen_be_find_xendev("vkbd", domid, 0);
1000 if (!xfb || !xin) {
1001 if (i < 256) {
1002 usleep(10000);
1003 goto wait_more;
1004 }
1005 xen_be_printf(NULL, 1, "displaystate setup failed\n");
1006 return;
1007 }
1008
1009 /* vfb */
1010 fb = container_of(xfb, struct XenFB, c.xendev);
1011 fb->c.ds = graphic_console_init(xenfb_update,
1012 xenfb_invalidate,
1013 NULL,
1014 NULL,
1015 fb);
1016 fb->have_console = 1;
1017
1018 /* vkbd */
1019 in = container_of(xin, struct XenInput, c.xendev);
1020 in->c.ds = fb->c.ds;
1021
1022 /* retry ->init() */
1023 xen_be_check_state(xin);
1024 xen_be_check_state(xfb);
1025 }
Various patches