]>
Commit | Line | Data |
---|---|---|
e7151f83 AL |
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 | |
8167ee88 | 24 | * with this program; if not, see <http://www.gnu.org/licenses/>. |
e7151f83 AL |
25 | */ |
26 | ||
21cbfe5f | 27 | #include "qemu/osdep.h" |
f0353b0d | 28 | #include "qemu/units.h" |
e7151f83 | 29 | |
a1ccbafd | 30 | #include "ui/input.h" |
28ecbaee | 31 | #include "ui/console.h" |
2d0ed5e6 | 32 | #include "hw/xen/xen-legacy-backend.h" |
e7151f83 | 33 | |
a3434a2d AP |
34 | #include "hw/xen/interface/io/fbif.h" |
35 | #include "hw/xen/interface/io/kbdif.h" | |
36 | #include "hw/xen/interface/io/protocols.h" | |
b41f6719 | 37 | |
91043dad DK |
38 | #include "trace.h" |
39 | ||
e7151f83 AL |
40 | #ifndef BTN_LEFT |
41 | #define BTN_LEFT 0x110 /* from <linux/input.h> */ | |
42 | #endif | |
43 | ||
44 | /* -------------------------------------------------------------------- */ | |
45 | ||
46 | struct common { | |
2d0ed5e6 | 47 | struct XenLegacyDevice xendev; /* must be first */ |
e7151f83 | 48 | void *page; |
e7151f83 AL |
49 | }; |
50 | ||
51 | struct XenInput { | |
52 | struct common c; | |
53 | int abs_pointer_wanted; /* Whether guest supports absolute pointer */ | |
34975e53 | 54 | int raw_pointer_wanted; /* Whether guest supports raw (unscaled) pointer */ |
a1ccbafd OS |
55 | QemuInputHandlerState *qkbd; |
56 | QemuInputHandlerState *qmou; | |
57 | int axis[INPUT_AXIS__MAX]; | |
58 | int wheel; | |
e7151f83 AL |
59 | }; |
60 | ||
61 | #define UP_QUEUE 8 | |
62 | ||
63 | struct XenFB { | |
64 | struct common c; | |
9f2130f5 | 65 | QemuConsole *con; |
e7151f83 AL |
66 | size_t fb_len; |
67 | int row_stride; | |
68 | int depth; | |
69 | int width; | |
70 | int height; | |
71 | int offset; | |
72 | void *pixels; | |
73 | int fbpages; | |
74 | int feature_update; | |
e7151f83 | 75 | int bug_trigger; |
e7151f83 AL |
76 | int do_resize; |
77 | ||
78 | struct { | |
79 | int x,y,w,h; | |
80 | } up_rects[UP_QUEUE]; | |
81 | int up_count; | |
82 | int up_fullscreen; | |
83 | }; | |
9f2130f5 | 84 | static const GraphicHwOps xenfb_ops; |
e7151f83 AL |
85 | |
86 | /* -------------------------------------------------------------------- */ | |
87 | ||
88 | static int common_bind(struct common *c) | |
89 | { | |
9ed257d1 IC |
90 | uint64_t val; |
91 | xen_pfn_t mfn; | |
e7151f83 | 92 | |
9ed257d1 | 93 | if (xenstore_read_fe_uint64(&c->xendev, "page-ref", &val) == -1) |
c22e91b1 | 94 | return -1; |
9ed257d1 IC |
95 | mfn = (xen_pfn_t)val; |
96 | assert(val == mfn); | |
643f5932 | 97 | |
e7151f83 | 98 | if (xenstore_read_fe_int(&c->xendev, "event-channel", &c->xendev.remote_port) == -1) |
c22e91b1 | 99 | return -1; |
e7151f83 | 100 | |
e0cb42ae IC |
101 | c->page = xenforeignmemory_map(xen_fmem, c->xendev.dom, |
102 | PROT_READ | PROT_WRITE, 1, &mfn, NULL); | |
e7151f83 | 103 | if (c->page == NULL) |
c22e91b1 | 104 | return -1; |
e7151f83 AL |
105 | |
106 | xen_be_bind_evtchn(&c->xendev); | |
96c77dba | 107 | xen_pv_printf(&c->xendev, 1, |
c22e91b1 EC |
108 | "ring mfn %"PRI_xen_pfn", remote-port %d, local-port %d\n", |
109 | mfn, c->xendev.remote_port, c->xendev.local_port); | |
e7151f83 AL |
110 | |
111 | return 0; | |
112 | } | |
113 | ||
114 | static void common_unbind(struct common *c) | |
115 | { | |
65807f4b | 116 | xen_pv_unbind_evtchn(&c->xendev); |
e7151f83 | 117 | if (c->page) { |
e0cb42ae | 118 | xenforeignmemory_unmap(xen_fmem, c->page, 1); |
e7151f83 AL |
119 | c->page = NULL; |
120 | } | |
121 | } | |
122 | ||
123 | /* -------------------------------------------------------------------- */ | |
e7151f83 AL |
124 | /* Send an event to the keyboard frontend driver */ |
125 | static int xenfb_kbd_event(struct XenInput *xenfb, | |
126 | union xenkbd_in_event *event) | |
127 | { | |
128 | struct xenkbd_page *page = xenfb->c.page; | |
129 | uint32_t prod; | |
130 | ||
131 | if (xenfb->c.xendev.be_state != XenbusStateConnected) | |
132 | return 0; | |
133 | if (!page) | |
134 | return 0; | |
135 | ||
136 | prod = page->in_prod; | |
137 | if (prod - page->in_cons == XENKBD_IN_RING_LEN) { | |
138 | errno = EAGAIN; | |
139 | return -1; | |
140 | } | |
141 | ||
142 | xen_mb(); /* ensure ring space available */ | |
143 | XENKBD_IN_RING_REF(page, prod) = *event; | |
144 | xen_wmb(); /* ensure ring contents visible */ | |
145 | page->in_prod = prod + 1; | |
ba18fa2a | 146 | return xen_pv_send_notify(&xenfb->c.xendev); |
e7151f83 AL |
147 | } |
148 | ||
149 | /* Send a keyboard (or mouse button) event */ | |
150 | static int xenfb_send_key(struct XenInput *xenfb, bool down, int keycode) | |
151 | { | |
152 | union xenkbd_in_event event; | |
153 | ||
154 | memset(&event, 0, XENKBD_IN_EVENT_SIZE); | |
155 | event.type = XENKBD_TYPE_KEY; | |
156 | event.key.pressed = down ? 1 : 0; | |
157 | event.key.keycode = keycode; | |
158 | ||
159 | return xenfb_kbd_event(xenfb, &event); | |
160 | } | |
161 | ||
162 | /* Send a relative mouse movement event */ | |
163 | static int xenfb_send_motion(struct XenInput *xenfb, | |
164 | int rel_x, int rel_y, int rel_z) | |
165 | { | |
166 | union xenkbd_in_event event; | |
167 | ||
168 | memset(&event, 0, XENKBD_IN_EVENT_SIZE); | |
169 | event.type = XENKBD_TYPE_MOTION; | |
170 | event.motion.rel_x = rel_x; | |
171 | event.motion.rel_y = rel_y; | |
e7151f83 | 172 | event.motion.rel_z = rel_z; |
e7151f83 AL |
173 | |
174 | return xenfb_kbd_event(xenfb, &event); | |
175 | } | |
176 | ||
177 | /* Send an absolute mouse movement event */ | |
178 | static int xenfb_send_position(struct XenInput *xenfb, | |
179 | int abs_x, int abs_y, int z) | |
180 | { | |
181 | union xenkbd_in_event event; | |
182 | ||
183 | memset(&event, 0, XENKBD_IN_EVENT_SIZE); | |
184 | event.type = XENKBD_TYPE_POS; | |
185 | event.pos.abs_x = abs_x; | |
186 | event.pos.abs_y = abs_y; | |
e7151f83 | 187 | event.pos.rel_z = z; |
e7151f83 AL |
188 | |
189 | return xenfb_kbd_event(xenfb, &event); | |
190 | } | |
191 | ||
192 | /* | |
193 | * Send a key event from the client to the guest OS | |
a1ccbafd | 194 | * QEMU gives us a QCode. |
e7151f83 AL |
195 | * We have to turn this into a Linux Input layer keycode. |
196 | * | |
e7151f83 AL |
197 | * Wish we could just send scancodes straight to the guest which |
198 | * already has code for dealing with this... | |
199 | */ | |
a1ccbafd OS |
200 | static void xenfb_key_event(DeviceState *dev, QemuConsole *src, |
201 | InputEvent *evt) | |
e7151f83 | 202 | { |
a1ccbafd OS |
203 | struct XenInput *xenfb = (struct XenInput *)dev; |
204 | InputKeyEvent *key = evt->u.key.data; | |
205 | int qcode = qemu_input_key_value_to_qcode(key->key); | |
206 | int lnx; | |
207 | ||
208 | if (qcode < qemu_input_map_qcode_to_linux_len) { | |
209 | lnx = qemu_input_map_qcode_to_linux[qcode]; | |
210 | ||
211 | if (lnx) { | |
212 | trace_xenfb_key_event(xenfb, lnx, key->down); | |
213 | xenfb_send_key(xenfb, key->down, lnx); | |
214 | } | |
e7151f83 | 215 | } |
e7151f83 AL |
216 | } |
217 | ||
218 | /* | |
219 | * Send a mouse event from the client to the guest OS | |
220 | * | |
221 | * The QEMU mouse can be in either relative, or absolute mode. | |
222 | * Movement is sent separately from button state, which has to | |
223 | * be encoded as virtual key events. We also don't actually get | |
224 | * given any button up/down events, so have to track changes in | |
225 | * the button state. | |
226 | */ | |
a1ccbafd OS |
227 | static void xenfb_mouse_event(DeviceState *dev, QemuConsole *src, |
228 | InputEvent *evt) | |
e7151f83 | 229 | { |
a1ccbafd OS |
230 | struct XenInput *xenfb = (struct XenInput *)dev; |
231 | InputBtnEvent *btn; | |
232 | InputMoveEvent *move; | |
233 | QemuConsole *con; | |
9f2130f5 | 234 | DisplaySurface *surface; |
a1ccbafd OS |
235 | int scale; |
236 | ||
237 | switch (evt->type) { | |
238 | case INPUT_EVENT_KIND_BTN: | |
239 | btn = evt->u.btn.data; | |
240 | switch (btn->button) { | |
241 | case INPUT_BUTTON_LEFT: | |
242 | xenfb_send_key(xenfb, btn->down, BTN_LEFT); | |
243 | break; | |
244 | case INPUT_BUTTON_RIGHT: | |
245 | xenfb_send_key(xenfb, btn->down, BTN_LEFT + 1); | |
246 | break; | |
247 | case INPUT_BUTTON_MIDDLE: | |
248 | xenfb_send_key(xenfb, btn->down, BTN_LEFT + 2); | |
249 | break; | |
250 | case INPUT_BUTTON_WHEEL_UP: | |
251 | if (btn->down) { | |
252 | xenfb->wheel--; | |
253 | } | |
254 | break; | |
255 | case INPUT_BUTTON_WHEEL_DOWN: | |
256 | if (btn->down) { | |
257 | xenfb->wheel++; | |
258 | } | |
259 | break; | |
260 | default: | |
261 | break; | |
262 | } | |
263 | break; | |
264 | ||
265 | case INPUT_EVENT_KIND_ABS: | |
266 | move = evt->u.abs.data; | |
34975e53 OS |
267 | if (xenfb->raw_pointer_wanted) { |
268 | xenfb->axis[move->axis] = move->value; | |
269 | } else { | |
270 | con = qemu_console_lookup_by_index(0); | |
271 | if (!con) { | |
272 | xen_pv_printf(&xenfb->c.xendev, 0, "No QEMU console available"); | |
273 | return; | |
274 | } | |
275 | surface = qemu_console_surface(con); | |
276 | switch (move->axis) { | |
277 | case INPUT_AXIS_X: | |
278 | scale = surface_width(surface) - 1; | |
279 | break; | |
280 | case INPUT_AXIS_Y: | |
281 | scale = surface_height(surface) - 1; | |
282 | break; | |
283 | default: | |
284 | scale = 0x8000; | |
285 | break; | |
286 | } | |
287 | xenfb->axis[move->axis] = move->value * scale / 0x7fff; | |
a1ccbafd | 288 | } |
a1ccbafd OS |
289 | break; |
290 | ||
291 | case INPUT_EVENT_KIND_REL: | |
292 | move = evt->u.rel.data; | |
293 | xenfb->axis[move->axis] += move->value; | |
294 | break; | |
295 | ||
296 | default: | |
297 | break; | |
9f2130f5 | 298 | } |
a1ccbafd | 299 | } |
9f2130f5 | 300 | |
a1ccbafd OS |
301 | static void xenfb_mouse_sync(DeviceState *dev) |
302 | { | |
303 | struct XenInput *xenfb = (struct XenInput *)dev; | |
e7151f83 | 304 | |
a1ccbafd OS |
305 | trace_xenfb_mouse_event(xenfb, xenfb->axis[INPUT_AXIS_X], |
306 | xenfb->axis[INPUT_AXIS_Y], | |
307 | xenfb->wheel, 0, | |
91043dad | 308 | xenfb->abs_pointer_wanted); |
a1ccbafd OS |
309 | if (xenfb->abs_pointer_wanted) { |
310 | xenfb_send_position(xenfb, xenfb->axis[INPUT_AXIS_X], | |
311 | xenfb->axis[INPUT_AXIS_Y], | |
312 | xenfb->wheel); | |
313 | } else { | |
314 | xenfb_send_motion(xenfb, xenfb->axis[INPUT_AXIS_X], | |
315 | xenfb->axis[INPUT_AXIS_Y], | |
316 | xenfb->wheel); | |
317 | xenfb->axis[INPUT_AXIS_X] = 0; | |
318 | xenfb->axis[INPUT_AXIS_Y] = 0; | |
e7151f83 | 319 | } |
a1ccbafd | 320 | xenfb->wheel = 0; |
e7151f83 AL |
321 | } |
322 | ||
a1ccbafd OS |
323 | static QemuInputHandler xenfb_keyboard = { |
324 | .name = "Xen PV Keyboard", | |
325 | .mask = INPUT_EVENT_MASK_KEY, | |
326 | .event = xenfb_key_event, | |
327 | }; | |
328 | ||
329 | static QemuInputHandler xenfb_abs_mouse = { | |
330 | .name = "Xen PV Mouse", | |
331 | .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_ABS, | |
332 | .event = xenfb_mouse_event, | |
333 | .sync = xenfb_mouse_sync, | |
334 | }; | |
335 | ||
336 | static QemuInputHandler xenfb_rel_mouse = { | |
337 | .name = "Xen PV Mouse", | |
338 | .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL, | |
339 | .event = xenfb_mouse_event, | |
340 | .sync = xenfb_mouse_sync, | |
341 | }; | |
342 | ||
2d0ed5e6 | 343 | static int input_init(struct XenLegacyDevice *xendev) |
e7151f83 | 344 | { |
e7151f83 | 345 | xenstore_write_be_int(xendev, "feature-abs-pointer", 1); |
34975e53 | 346 | xenstore_write_be_int(xendev, "feature-raw-pointer", 1); |
e7151f83 AL |
347 | return 0; |
348 | } | |
349 | ||
2d0ed5e6 | 350 | static int input_initialise(struct XenLegacyDevice *xendev) |
e7151f83 AL |
351 | { |
352 | struct XenInput *in = container_of(xendev, struct XenInput, c.xendev); | |
353 | int rc; | |
354 | ||
e7151f83 AL |
355 | rc = common_bind(&in->c); |
356 | if (rc != 0) | |
357 | return rc; | |
358 | ||
6d646730 JH |
359 | return 0; |
360 | } | |
361 | ||
2d0ed5e6 | 362 | static void input_connected(struct XenLegacyDevice *xendev) |
6d646730 JH |
363 | { |
364 | struct XenInput *in = container_of(xendev, struct XenInput, c.xendev); | |
365 | ||
366 | if (xenstore_read_fe_int(xendev, "request-abs-pointer", | |
367 | &in->abs_pointer_wanted) == -1) { | |
368 | in->abs_pointer_wanted = 0; | |
369 | } | |
34975e53 OS |
370 | if (xenstore_read_fe_int(xendev, "request-raw-pointer", |
371 | &in->raw_pointer_wanted) == -1) { | |
372 | in->raw_pointer_wanted = 0; | |
373 | } | |
374 | if (in->raw_pointer_wanted && in->abs_pointer_wanted == 0) { | |
375 | xen_pv_printf(xendev, 0, "raw pointer set without abs pointer"); | |
376 | } | |
6d646730 | 377 | |
a1ccbafd OS |
378 | if (in->qkbd) { |
379 | qemu_input_handler_unregister(in->qkbd); | |
380 | } | |
381 | if (in->qmou) { | |
382 | qemu_input_handler_unregister(in->qmou); | |
6d646730 | 383 | } |
91043dad | 384 | trace_xenfb_input_connected(xendev, in->abs_pointer_wanted); |
a1ccbafd OS |
385 | |
386 | in->qkbd = qemu_input_handler_register((DeviceState *)in, &xenfb_keyboard); | |
387 | in->qmou = qemu_input_handler_register((DeviceState *)in, | |
388 | in->abs_pointer_wanted ? &xenfb_abs_mouse : &xenfb_rel_mouse); | |
d12c5b7d OS |
389 | |
390 | if (in->raw_pointer_wanted) { | |
391 | qemu_input_handler_activate(in->qkbd); | |
392 | qemu_input_handler_activate(in->qmou); | |
393 | } | |
e7151f83 AL |
394 | } |
395 | ||
2d0ed5e6 | 396 | static void input_disconnect(struct XenLegacyDevice *xendev) |
e7151f83 AL |
397 | { |
398 | struct XenInput *in = container_of(xendev, struct XenInput, c.xendev); | |
399 | ||
a1ccbafd OS |
400 | if (in->qkbd) { |
401 | qemu_input_handler_unregister(in->qkbd); | |
402 | in->qkbd = NULL; | |
403 | } | |
404 | if (in->qmou) { | |
405 | qemu_input_handler_unregister(in->qmou); | |
406 | in->qmou = NULL; | |
e7151f83 | 407 | } |
e7151f83 AL |
408 | common_unbind(&in->c); |
409 | } | |
410 | ||
2d0ed5e6 | 411 | static void input_event(struct XenLegacyDevice *xendev) |
e7151f83 AL |
412 | { |
413 | struct XenInput *xenfb = container_of(xendev, struct XenInput, c.xendev); | |
414 | struct xenkbd_page *page = xenfb->c.page; | |
415 | ||
416 | /* We don't understand any keyboard events, so just ignore them. */ | |
417 | if (page->out_prod == page->out_cons) | |
418 | return; | |
419 | page->out_cons = page->out_prod; | |
ba18fa2a | 420 | xen_pv_send_notify(&xenfb->c.xendev); |
e7151f83 AL |
421 | } |
422 | ||
423 | /* -------------------------------------------------------------------- */ | |
424 | ||
643f5932 | 425 | static void xenfb_copy_mfns(int mode, int count, xen_pfn_t *dst, void *src) |
e7151f83 AL |
426 | { |
427 | uint32_t *src32 = src; | |
428 | uint64_t *src64 = src; | |
429 | int i; | |
430 | ||
431 | for (i = 0; i < count; i++) | |
432 | dst[i] = (mode == 32) ? src32[i] : src64[i]; | |
433 | } | |
434 | ||
435 | static int xenfb_map_fb(struct XenFB *xenfb) | |
436 | { | |
437 | struct xenfb_page *page = xenfb->c.page; | |
438 | char *protocol = xenfb->c.xendev.protocol; | |
439 | int n_fbdirs; | |
643f5932 SS |
440 | xen_pfn_t *pgmfns = NULL; |
441 | xen_pfn_t *fbmfns = NULL; | |
e7151f83 AL |
442 | void *map, *pd; |
443 | int mode, ret = -1; | |
444 | ||
445 | /* default to native */ | |
446 | pd = page->pd; | |
447 | mode = sizeof(unsigned long) * 8; | |
448 | ||
449 | if (!protocol) { | |
450 | /* | |
451 | * Undefined protocol, some guesswork needed. | |
452 | * | |
453 | * Old frontends which don't set the protocol use | |
454 | * one page directory only, thus pd[1] must be zero. | |
455 | * pd[1] of the 32bit struct layout and the lower | |
456 | * 32 bits of pd[0] of the 64bit struct layout have | |
457 | * the same location, so we can check that ... | |
458 | */ | |
459 | uint32_t *ptr32 = NULL; | |
460 | uint32_t *ptr64 = NULL; | |
461 | #if defined(__i386__) | |
462 | ptr32 = (void*)page->pd; | |
463 | ptr64 = ((void*)page->pd) + 4; | |
464 | #elif defined(__x86_64__) | |
465 | ptr32 = ((void*)page->pd) - 4; | |
466 | ptr64 = (void*)page->pd; | |
467 | #endif | |
468 | if (ptr32) { | |
469 | if (ptr32[1] == 0) { | |
470 | mode = 32; | |
471 | pd = ptr32; | |
472 | } else { | |
473 | mode = 64; | |
474 | pd = ptr64; | |
475 | } | |
476 | } | |
477 | #if defined(__x86_64__) | |
478 | } else if (strcmp(protocol, XEN_IO_PROTO_ABI_X86_32) == 0) { | |
479 | /* 64bit dom0, 32bit domU */ | |
480 | mode = 32; | |
481 | pd = ((void*)page->pd) - 4; | |
482 | #elif defined(__i386__) | |
483 | } else if (strcmp(protocol, XEN_IO_PROTO_ABI_X86_64) == 0) { | |
484 | /* 32bit dom0, 64bit domU */ | |
485 | mode = 64; | |
486 | pd = ((void*)page->pd) + 4; | |
487 | #endif | |
488 | } | |
489 | ||
490 | if (xenfb->pixels) { | |
491 | munmap(xenfb->pixels, xenfb->fbpages * XC_PAGE_SIZE); | |
492 | xenfb->pixels = NULL; | |
493 | } | |
494 | ||
d0448de7 | 495 | xenfb->fbpages = DIV_ROUND_UP(xenfb->fb_len, XC_PAGE_SIZE); |
e7151f83 | 496 | n_fbdirs = xenfb->fbpages * mode / 8; |
d0448de7 | 497 | n_fbdirs = DIV_ROUND_UP(n_fbdirs, XC_PAGE_SIZE); |
e7151f83 | 498 | |
643f5932 SS |
499 | pgmfns = g_malloc0(sizeof(xen_pfn_t) * n_fbdirs); |
500 | fbmfns = g_malloc0(sizeof(xen_pfn_t) * xenfb->fbpages); | |
e7151f83 AL |
501 | |
502 | xenfb_copy_mfns(mode, n_fbdirs, pgmfns, pd); | |
e0cb42ae IC |
503 | map = xenforeignmemory_map(xen_fmem, xenfb->c.xendev.dom, |
504 | PROT_READ, n_fbdirs, pgmfns, NULL); | |
e7151f83 AL |
505 | if (map == NULL) |
506 | goto out; | |
507 | xenfb_copy_mfns(mode, xenfb->fbpages, fbmfns, map); | |
e0cb42ae | 508 | xenforeignmemory_unmap(xen_fmem, map, n_fbdirs); |
e7151f83 | 509 | |
e0cb42ae IC |
510 | xenfb->pixels = xenforeignmemory_map(xen_fmem, xenfb->c.xendev.dom, |
511 | PROT_READ, xenfb->fbpages, fbmfns, NULL); | |
e7151f83 AL |
512 | if (xenfb->pixels == NULL) |
513 | goto out; | |
514 | ||
515 | ret = 0; /* all is fine */ | |
516 | ||
517 | out: | |
7267c094 AL |
518 | g_free(pgmfns); |
519 | g_free(fbmfns); | |
e7151f83 AL |
520 | return ret; |
521 | } | |
522 | ||
523 | static int xenfb_configure_fb(struct XenFB *xenfb, size_t fb_len_lim, | |
c22e91b1 EC |
524 | int width, int height, int depth, |
525 | size_t fb_len, int offset, int row_stride) | |
e7151f83 | 526 | { |
f18793b0 SH |
527 | size_t mfn_sz = sizeof_field(struct xenfb_page, pd[0]); |
528 | size_t pd_len = sizeof_field(struct xenfb_page, pd) / mfn_sz; | |
e7151f83 AL |
529 | size_t fb_pages = pd_len * XC_PAGE_SIZE / mfn_sz; |
530 | size_t fb_len_max = fb_pages * XC_PAGE_SIZE; | |
531 | int max_width, max_height; | |
532 | ||
533 | if (fb_len_lim > fb_len_max) { | |
96c77dba | 534 | xen_pv_printf(&xenfb->c.xendev, 0, |
c22e91b1 EC |
535 | "fb size limit %zu exceeds %zu, corrected\n", |
536 | fb_len_lim, fb_len_max); | |
537 | fb_len_lim = fb_len_max; | |
e7151f83 AL |
538 | } |
539 | if (fb_len_lim && fb_len > fb_len_lim) { | |
96c77dba | 540 | xen_pv_printf(&xenfb->c.xendev, 0, |
c22e91b1 EC |
541 | "frontend fb size %zu limited to %zu\n", |
542 | fb_len, fb_len_lim); | |
543 | fb_len = fb_len_lim; | |
e7151f83 AL |
544 | } |
545 | if (depth != 8 && depth != 16 && depth != 24 && depth != 32) { | |
96c77dba | 546 | xen_pv_printf(&xenfb->c.xendev, 0, |
c22e91b1 EC |
547 | "can't handle frontend fb depth %d\n", |
548 | depth); | |
549 | return -1; | |
e7151f83 AL |
550 | } |
551 | if (row_stride <= 0 || row_stride > fb_len) { | |
96c77dba | 552 | xen_pv_printf(&xenfb->c.xendev, 0, "invalid frontend stride %d\n", |
c22e91b1 EC |
553 | row_stride); |
554 | return -1; | |
e7151f83 AL |
555 | } |
556 | max_width = row_stride / (depth / 8); | |
557 | if (width < 0 || width > max_width) { | |
96c77dba | 558 | xen_pv_printf(&xenfb->c.xendev, 0, |
c22e91b1 EC |
559 | "invalid frontend width %d limited to %d\n", |
560 | width, max_width); | |
561 | width = max_width; | |
e7151f83 AL |
562 | } |
563 | if (offset < 0 || offset >= fb_len) { | |
96c77dba | 564 | xen_pv_printf(&xenfb->c.xendev, 0, |
c22e91b1 EC |
565 | "invalid frontend offset %d (max %zu)\n", |
566 | offset, fb_len - 1); | |
567 | return -1; | |
e7151f83 AL |
568 | } |
569 | max_height = (fb_len - offset) / row_stride; | |
570 | if (height < 0 || height > max_height) { | |
96c77dba | 571 | xen_pv_printf(&xenfb->c.xendev, 0, |
c22e91b1 EC |
572 | "invalid frontend height %d limited to %d\n", |
573 | height, max_height); | |
574 | height = max_height; | |
e7151f83 AL |
575 | } |
576 | xenfb->fb_len = fb_len; | |
577 | xenfb->row_stride = row_stride; | |
578 | xenfb->depth = depth; | |
579 | xenfb->width = width; | |
580 | xenfb->height = height; | |
581 | xenfb->offset = offset; | |
582 | xenfb->up_fullscreen = 1; | |
583 | xenfb->do_resize = 1; | |
96c77dba | 584 | xen_pv_printf(&xenfb->c.xendev, 1, |
b9730c5b | 585 | "framebuffer %dx%dx%d offset %d stride %d\n", |
c22e91b1 | 586 | width, height, depth, offset, row_stride); |
e7151f83 AL |
587 | return 0; |
588 | } | |
589 | ||
590 | /* A convenient function for munging pixels between different depths */ | |
591 | #define BLT(SRC_T,DST_T,RSB,GSB,BSB,RDB,GDB,BDB) \ | |
592 | for (line = y ; line < (y+h) ; line++) { \ | |
593 | SRC_T *src = (SRC_T *)(xenfb->pixels \ | |
594 | + xenfb->offset \ | |
595 | + (line * xenfb->row_stride) \ | |
596 | + (x * xenfb->depth / 8)); \ | |
597 | DST_T *dst = (DST_T *)(data \ | |
598 | + (line * linesize) \ | |
599 | + (x * bpp / 8)); \ | |
600 | int col; \ | |
601 | const int RSS = 32 - (RSB + GSB + BSB); \ | |
602 | const int GSS = 32 - (GSB + BSB); \ | |
603 | const int BSS = 32 - (BSB); \ | |
604 | const uint32_t RSM = (~0U) << (32 - RSB); \ | |
605 | const uint32_t GSM = (~0U) << (32 - GSB); \ | |
606 | const uint32_t BSM = (~0U) << (32 - BSB); \ | |
607 | const int RDS = 32 - (RDB + GDB + BDB); \ | |
608 | const int GDS = 32 - (GDB + BDB); \ | |
609 | const int BDS = 32 - (BDB); \ | |
610 | const uint32_t RDM = (~0U) << (32 - RDB); \ | |
611 | const uint32_t GDM = (~0U) << (32 - GDB); \ | |
612 | const uint32_t BDM = (~0U) << (32 - BDB); \ | |
613 | for (col = x ; col < (x+w) ; col++) { \ | |
614 | uint32_t spix = *src; \ | |
615 | *dst = (((spix << RSS) & RSM & RDM) >> RDS) | \ | |
616 | (((spix << GSS) & GSM & GDM) >> GDS) | \ | |
617 | (((spix << BSS) & BSM & BDM) >> BDS); \ | |
618 | src = (SRC_T *) ((unsigned long) src + xenfb->depth / 8); \ | |
619 | dst = (DST_T *) ((unsigned long) dst + bpp / 8); \ | |
620 | } \ | |
621 | } | |
622 | ||
623 | ||
624 | /* | |
625 | * This copies data from the guest framebuffer region, into QEMU's | |
626 | * displaysurface. qemu uses 16 or 32 bpp. In case the pv framebuffer | |
627 | * uses something else we must convert and copy, otherwise we can | |
628 | * supply the buffer directly and no thing here. | |
629 | */ | |
630 | static void xenfb_guest_copy(struct XenFB *xenfb, int x, int y, int w, int h) | |
631 | { | |
9f2130f5 | 632 | DisplaySurface *surface = qemu_console_surface(xenfb->con); |
e7151f83 | 633 | int line, oops = 0; |
c78f7137 GH |
634 | int bpp = surface_bits_per_pixel(surface); |
635 | int linesize = surface_stride(surface); | |
636 | uint8_t *data = surface_data(surface); | |
e7151f83 | 637 | |
c78f7137 | 638 | if (!is_buffer_shared(surface)) { |
e7151f83 AL |
639 | switch (xenfb->depth) { |
640 | case 8: | |
641 | if (bpp == 16) { | |
642 | BLT(uint8_t, uint16_t, 3, 3, 2, 5, 6, 5); | |
643 | } else if (bpp == 32) { | |
644 | BLT(uint8_t, uint32_t, 3, 3, 2, 8, 8, 8); | |
645 | } else { | |
646 | oops = 1; | |
647 | } | |
648 | break; | |
649 | case 24: | |
650 | if (bpp == 16) { | |
651 | BLT(uint32_t, uint16_t, 8, 8, 8, 5, 6, 5); | |
652 | } else if (bpp == 32) { | |
653 | BLT(uint32_t, uint32_t, 8, 8, 8, 8, 8, 8); | |
654 | } else { | |
655 | oops = 1; | |
656 | } | |
657 | break; | |
658 | default: | |
659 | oops = 1; | |
660 | } | |
661 | } | |
662 | if (oops) /* should not happen */ | |
96c77dba | 663 | xen_pv_printf(&xenfb->c.xendev, 0, "%s: oops: convert %d -> %d bpp?\n", |
a89f364a | 664 | __func__, xenfb->depth, bpp); |
e7151f83 | 665 | |
9f2130f5 | 666 | dpy_gfx_update(xenfb->con, x, y, w, h); |
e7151f83 AL |
667 | } |
668 | ||
dea1b0bd | 669 | #ifdef XENFB_TYPE_REFRESH_PERIOD |
e7151f83 AL |
670 | static int xenfb_queue_full(struct XenFB *xenfb) |
671 | { | |
672 | struct xenfb_page *page = xenfb->c.page; | |
673 | uint32_t cons, prod; | |
674 | ||
675 | if (!page) | |
676 | return 1; | |
677 | ||
678 | prod = page->in_prod; | |
679 | cons = page->in_cons; | |
680 | return prod - cons == XENFB_IN_RING_LEN; | |
681 | } | |
682 | ||
683 | static void xenfb_send_event(struct XenFB *xenfb, union xenfb_in_event *event) | |
684 | { | |
685 | uint32_t prod; | |
686 | struct xenfb_page *page = xenfb->c.page; | |
687 | ||
688 | prod = page->in_prod; | |
689 | /* caller ensures !xenfb_queue_full() */ | |
690 | xen_mb(); /* ensure ring space available */ | |
691 | XENFB_IN_RING_REF(page, prod) = *event; | |
692 | xen_wmb(); /* ensure ring contents visible */ | |
693 | page->in_prod = prod + 1; | |
694 | ||
ba18fa2a | 695 | xen_pv_send_notify(&xenfb->c.xendev); |
e7151f83 AL |
696 | } |
697 | ||
698 | static void xenfb_send_refresh_period(struct XenFB *xenfb, int period) | |
699 | { | |
700 | union xenfb_in_event event; | |
701 | ||
702 | memset(&event, 0, sizeof(event)); | |
703 | event.type = XENFB_TYPE_REFRESH_PERIOD; | |
704 | event.refresh_period.period = period; | |
705 | xenfb_send_event(xenfb, &event); | |
706 | } | |
707 | #endif | |
708 | ||
709 | /* | |
710 | * Periodic update of display. | |
711 | * Also transmit the refresh interval to the frontend. | |
712 | * | |
713 | * Never ever do any qemu display operations | |
714 | * (resize, screen update) outside this function. | |
715 | * Our screen might be inactive. When asked for | |
716 | * an update we know it is active. | |
717 | */ | |
718 | static void xenfb_update(void *opaque) | |
719 | { | |
720 | struct XenFB *xenfb = opaque; | |
da229ef3 | 721 | DisplaySurface *surface; |
e7151f83 AL |
722 | int i; |
723 | ||
724 | if (xenfb->c.xendev.be_state != XenbusStateConnected) | |
725 | return; | |
726 | ||
dea1b0bd | 727 | if (!xenfb->feature_update) { |
c22e91b1 EC |
728 | /* we don't get update notifications, thus use the |
729 | * sledge hammer approach ... */ | |
730 | xenfb->up_fullscreen = 1; | |
e7151f83 AL |
731 | } |
732 | ||
733 | /* resize if needed */ | |
734 | if (xenfb->do_resize) { | |
30f1e661 GH |
735 | pixman_format_code_t format; |
736 | ||
e7151f83 AL |
737 | xenfb->do_resize = 0; |
738 | switch (xenfb->depth) { | |
739 | case 16: | |
740 | case 32: | |
741 | /* console.c supported depth -> buffer can be used directly */ | |
30f1e661 | 742 | format = qemu_default_pixman_format(xenfb->depth, true); |
da229ef3 | 743 | surface = qemu_create_displaysurface_from |
30f1e661 GH |
744 | (xenfb->width, xenfb->height, format, |
745 | xenfb->row_stride, xenfb->pixels + xenfb->offset); | |
e7151f83 AL |
746 | break; |
747 | default: | |
748 | /* we must convert stuff */ | |
da229ef3 | 749 | surface = qemu_create_displaysurface(xenfb->width, xenfb->height); |
e7151f83 AL |
750 | break; |
751 | } | |
9f2130f5 | 752 | dpy_gfx_replace_surface(xenfb->con, surface); |
96c77dba | 753 | xen_pv_printf(&xenfb->c.xendev, 1, |
b9730c5b | 754 | "update: resizing: %dx%d @ %d bpp%s\n", |
e7151f83 | 755 | xenfb->width, xenfb->height, xenfb->depth, |
c78f7137 | 756 | is_buffer_shared(surface) ? " (shared)" : ""); |
e7151f83 AL |
757 | xenfb->up_fullscreen = 1; |
758 | } | |
759 | ||
760 | /* run queued updates */ | |
761 | if (xenfb->up_fullscreen) { | |
96c77dba | 762 | xen_pv_printf(&xenfb->c.xendev, 3, "update: fullscreen\n"); |
c22e91b1 | 763 | xenfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height); |
e7151f83 | 764 | } else if (xenfb->up_count) { |
96c77dba | 765 | xen_pv_printf(&xenfb->c.xendev, 3, "update: %d rects\n", |
c22e91b1 EC |
766 | xenfb->up_count); |
767 | for (i = 0; i < xenfb->up_count; i++) | |
768 | xenfb_guest_copy(xenfb, | |
769 | xenfb->up_rects[i].x, | |
770 | xenfb->up_rects[i].y, | |
771 | xenfb->up_rects[i].w, | |
772 | xenfb->up_rects[i].h); | |
e7151f83 | 773 | } else { |
96c77dba | 774 | xen_pv_printf(&xenfb->c.xendev, 3, "update: nothing\n"); |
e7151f83 AL |
775 | } |
776 | xenfb->up_count = 0; | |
777 | xenfb->up_fullscreen = 0; | |
778 | } | |
779 | ||
dea1b0bd GH |
780 | static void xenfb_update_interval(void *opaque, uint64_t interval) |
781 | { | |
782 | struct XenFB *xenfb = opaque; | |
783 | ||
784 | if (xenfb->feature_update) { | |
785 | #ifdef XENFB_TYPE_REFRESH_PERIOD | |
786 | if (xenfb_queue_full(xenfb)) { | |
787 | return; | |
788 | } | |
789 | xenfb_send_refresh_period(xenfb, interval); | |
790 | #endif | |
791 | } | |
792 | } | |
793 | ||
e7151f83 AL |
794 | /* QEMU display state changed, so refresh the framebuffer copy */ |
795 | static void xenfb_invalidate(void *opaque) | |
796 | { | |
797 | struct XenFB *xenfb = opaque; | |
798 | xenfb->up_fullscreen = 1; | |
799 | } | |
800 | ||
801 | static void xenfb_handle_events(struct XenFB *xenfb) | |
802 | { | |
7ea11bf3 | 803 | uint32_t prod, cons, out_cons; |
e7151f83 AL |
804 | struct xenfb_page *page = xenfb->c.page; |
805 | ||
806 | prod = page->out_prod; | |
7ea11bf3 | 807 | out_cons = page->out_cons; |
4df26e88 | 808 | if (prod - out_cons > XENFB_OUT_RING_LEN) { |
ac0487e1 SS |
809 | return; |
810 | } | |
e7151f83 | 811 | xen_rmb(); /* ensure we see ring contents up to prod */ |
7ea11bf3 | 812 | for (cons = out_cons; cons != prod; cons++) { |
e7151f83 | 813 | union xenfb_out_event *event = &XENFB_OUT_RING_REF(page, cons); |
7ea11bf3 | 814 | uint8_t type = event->type; |
e7151f83 AL |
815 | int x, y, w, h; |
816 | ||
7ea11bf3 | 817 | switch (type) { |
e7151f83 AL |
818 | case XENFB_TYPE_UPDATE: |
819 | if (xenfb->up_count == UP_QUEUE) | |
820 | xenfb->up_fullscreen = 1; | |
821 | if (xenfb->up_fullscreen) | |
822 | break; | |
823 | x = MAX(event->update.x, 0); | |
824 | y = MAX(event->update.y, 0); | |
825 | w = MIN(event->update.width, xenfb->width - x); | |
826 | h = MIN(event->update.height, xenfb->height - y); | |
827 | if (w < 0 || h < 0) { | |
96c77dba | 828 | xen_pv_printf(&xenfb->c.xendev, 1, "bogus update ignored\n"); |
e7151f83 AL |
829 | break; |
830 | } | |
831 | if (x != event->update.x || | |
832 | y != event->update.y || | |
833 | w != event->update.width || | |
834 | h != event->update.height) { | |
96c77dba | 835 | xen_pv_printf(&xenfb->c.xendev, 1, "bogus update clipped\n"); |
e7151f83 AL |
836 | } |
837 | if (w == xenfb->width && h > xenfb->height / 2) { | |
838 | /* scroll detector: updated more than 50% of the lines, | |
839 | * don't bother keeping track of the rectangles then */ | |
840 | xenfb->up_fullscreen = 1; | |
841 | } else { | |
842 | xenfb->up_rects[xenfb->up_count].x = x; | |
843 | xenfb->up_rects[xenfb->up_count].y = y; | |
844 | xenfb->up_rects[xenfb->up_count].w = w; | |
845 | xenfb->up_rects[xenfb->up_count].h = h; | |
846 | xenfb->up_count++; | |
847 | } | |
848 | break; | |
849 | #ifdef XENFB_TYPE_RESIZE | |
850 | case XENFB_TYPE_RESIZE: | |
851 | if (xenfb_configure_fb(xenfb, xenfb->fb_len, | |
852 | event->resize.width, | |
853 | event->resize.height, | |
854 | event->resize.depth, | |
855 | xenfb->fb_len, | |
856 | event->resize.offset, | |
857 | event->resize.stride) < 0) | |
858 | break; | |
859 | xenfb_invalidate(xenfb); | |
860 | break; | |
861 | #endif | |
862 | } | |
863 | } | |
864 | xen_mb(); /* ensure we're done with ring contents */ | |
865 | page->out_cons = cons; | |
866 | } | |
867 | ||
2d0ed5e6 | 868 | static int fb_init(struct XenLegacyDevice *xendev) |
e7151f83 | 869 | { |
e7151f83 AL |
870 | #ifdef XENFB_TYPE_RESIZE |
871 | xenstore_write_be_int(xendev, "feature-resize", 1); | |
872 | #endif | |
873 | return 0; | |
874 | } | |
875 | ||
2d0ed5e6 | 876 | static int fb_initialise(struct XenLegacyDevice *xendev) |
e7151f83 AL |
877 | { |
878 | struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev); | |
879 | struct xenfb_page *fb_page; | |
880 | int videoram; | |
881 | int rc; | |
882 | ||
883 | if (xenstore_read_fe_int(xendev, "videoram", &videoram) == -1) | |
884 | videoram = 0; | |
885 | ||
886 | rc = common_bind(&fb->c); | |
887 | if (rc != 0) | |
888 | return rc; | |
889 | ||
890 | fb_page = fb->c.page; | |
f0353b0d | 891 | rc = xenfb_configure_fb(fb, videoram * MiB, |
e7151f83 AL |
892 | fb_page->width, fb_page->height, fb_page->depth, |
893 | fb_page->mem_length, 0, fb_page->line_length); | |
894 | if (rc != 0) | |
895 | return rc; | |
896 | ||
897 | rc = xenfb_map_fb(fb); | |
898 | if (rc != 0) | |
899 | return rc; | |
900 | ||
9f2130f5 | 901 | fb->con = graphic_console_init(NULL, 0, &xenfb_ops, fb); |
e7151f83 AL |
902 | |
903 | if (xenstore_read_fe_int(xendev, "feature-update", &fb->feature_update) == -1) | |
904 | fb->feature_update = 0; | |
905 | if (fb->feature_update) | |
906 | xenstore_write_be_int(xendev, "request-update", 1); | |
907 | ||
96c77dba | 908 | xen_pv_printf(xendev, 1, "feature-update=%d, videoram=%d\n", |
e7151f83 AL |
909 | fb->feature_update, videoram); |
910 | return 0; | |
911 | } | |
912 | ||
2d0ed5e6 | 913 | static void fb_disconnect(struct XenLegacyDevice *xendev) |
e7151f83 AL |
914 | { |
915 | struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev); | |
916 | ||
917 | /* | |
918 | * FIXME: qemu can't un-init gfx display (yet?). | |
919 | * Replacing the framebuffer with anonymous shared memory | |
920 | * instead. This releases the guest pages and keeps qemu happy. | |
921 | */ | |
e0cb42ae | 922 | xenforeignmemory_unmap(xen_fmem, fb->pixels, fb->fbpages); |
e7151f83 AL |
923 | fb->pixels = mmap(fb->pixels, fb->fbpages * XC_PAGE_SIZE, |
924 | PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, | |
925 | -1, 0); | |
0193c62c | 926 | if (fb->pixels == MAP_FAILED) { |
96c77dba | 927 | xen_pv_printf(xendev, 0, |
0193c62c SS |
928 | "Couldn't replace the framebuffer with anonymous memory errno=%d\n", |
929 | errno); | |
930 | } | |
e7151f83 AL |
931 | common_unbind(&fb->c); |
932 | fb->feature_update = 0; | |
933 | fb->bug_trigger = 0; | |
934 | } | |
935 | ||
2d0ed5e6 PD |
936 | static void fb_frontend_changed(struct XenLegacyDevice *xendev, |
937 | const char *node) | |
e7151f83 AL |
938 | { |
939 | struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev); | |
940 | ||
941 | /* | |
942 | * Set state to Connected *again* once the frontend switched | |
943 | * to connected. We must trigger the watch a second time to | |
944 | * workaround a frontend bug. | |
945 | */ | |
946 | if (fb->bug_trigger == 0 && strcmp(node, "state") == 0 && | |
947 | xendev->fe_state == XenbusStateConnected && | |
948 | xendev->be_state == XenbusStateConnected) { | |
96c77dba | 949 | xen_pv_printf(xendev, 2, "re-trigger connected (frontend bug)\n"); |
e7151f83 AL |
950 | xen_be_set_state(xendev, XenbusStateConnected); |
951 | fb->bug_trigger = 1; /* only once */ | |
952 | } | |
953 | } | |
954 | ||
2d0ed5e6 | 955 | static void fb_event(struct XenLegacyDevice *xendev) |
e7151f83 AL |
956 | { |
957 | struct XenFB *xenfb = container_of(xendev, struct XenFB, c.xendev); | |
958 | ||
959 | xenfb_handle_events(xenfb); | |
ba18fa2a | 960 | xen_pv_send_notify(&xenfb->c.xendev); |
e7151f83 AL |
961 | } |
962 | ||
963 | /* -------------------------------------------------------------------- */ | |
964 | ||
965 | struct XenDevOps xen_kbdmouse_ops = { | |
966 | .size = sizeof(struct XenInput), | |
967 | .init = input_init, | |
384087b2 | 968 | .initialise = input_initialise, |
6d646730 | 969 | .connected = input_connected, |
e7151f83 AL |
970 | .disconnect = input_disconnect, |
971 | .event = input_event, | |
972 | }; | |
973 | ||
974 | struct XenDevOps xen_framebuffer_ops = { | |
975 | .size = sizeof(struct XenFB), | |
976 | .init = fb_init, | |
384087b2 | 977 | .initialise = fb_initialise, |
e7151f83 AL |
978 | .disconnect = fb_disconnect, |
979 | .event = fb_event, | |
980 | .frontend_changed = fb_frontend_changed, | |
981 | }; | |
982 | ||
380cd056 GH |
983 | static const GraphicHwOps xenfb_ops = { |
984 | .invalidate = xenfb_invalidate, | |
985 | .gfx_update = xenfb_update, | |
dea1b0bd | 986 | .update_interval = xenfb_update_interval, |
380cd056 | 987 | }; |