hw/display/xenfb.c

   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/hw.h"
  39 #include "ui/console.h"
  40 #include "sysemu/char.h"
  41 #include "hw/xen/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     QemuConsole       *con;
  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     DisplaySurface *surface = qemu_console_surface(xenfb->c.con);
 322     int dw = surface_width(surface);
 323     int dh = surface_height(surface);
 324     int i;
 325
 326     if (xenfb->abs_pointer_wanted)
 327         xenfb_send_position(xenfb,
 328                             dx * (dw - 1) / 0x7fff,
 329                             dy * (dh - 1) / 0x7fff,
 330                             dz);
 331     else
 332         xenfb_send_motion(xenfb, dx, dy, dz);
 333
 334     for (i = 0 ; i < 8 ; i++) {
 335         int lastDown = xenfb->button_state & (1 << i);
 336         int down = button_state & (1 << i);
 337         if (down == lastDown)
 338             continue;
 339
 340         if (xenfb_send_key(xenfb, down, BTN_LEFT+i) < 0)
 341             return;
 342     }
 343     xenfb->button_state = button_state;
 344 }
 345
 346 static int input_init(struct XenDevice *xendev)
 347 {
 348     xenstore_write_be_int(xendev, "feature-abs-pointer", 1);
 349     return 0;
 350 }
 351
 352 static int input_initialise(struct XenDevice *xendev)
 353 {
 354     struct XenInput *in = container_of(xendev, struct XenInput, c.xendev);
 355     int rc;
 356
 357     if (!in->c.con) {
 358         xen_be_printf(xendev, 1, "ds not set (yet)\n");
 359         return -1;
 360     }
 361
 362     rc = common_bind(&in->c);
 363     if (rc != 0)
 364         return rc;
 365
 366     qemu_add_kbd_event_handler(xenfb_key_event, in);
 367     return 0;
 368 }
 369
 370 static void input_connected(struct XenDevice *xendev)
 371 {
 372     struct XenInput *in = container_of(xendev, struct XenInput, c.xendev);
 373
 374     if (xenstore_read_fe_int(xendev, "request-abs-pointer",
 375                              &in->abs_pointer_wanted) == -1) {
 376         in->abs_pointer_wanted = 0;
 377     }
 378
 379     if (in->qmouse) {
 380         qemu_remove_mouse_event_handler(in->qmouse);
 381     }
 382     in->qmouse = qemu_add_mouse_event_handler(xenfb_mouse_event, in,
 383                                               in->abs_pointer_wanted,
 384                                               "Xen PVFB Mouse");
 385 }
 386
 387 static void input_disconnect(struct XenDevice *xendev)
 388 {
 389     struct XenInput *in = container_of(xendev, struct XenInput, c.xendev);
 390
 391     if (in->qmouse) {
 392         qemu_remove_mouse_event_handler(in->qmouse);
 393         in->qmouse = NULL;
 394     }
 395     qemu_add_kbd_event_handler(NULL, NULL);
 396     common_unbind(&in->c);
 397 }
 398
 399 static void input_event(struct XenDevice *xendev)
 400 {
 401     struct XenInput *xenfb = container_of(xendev, struct XenInput, c.xendev);
 402     struct xenkbd_page *page = xenfb->c.page;
 403
 404     /* We don't understand any keyboard events, so just ignore them. */
 405     if (page->out_prod == page->out_cons)
 406         return;
 407     page->out_cons = page->out_prod;
 408     xen_be_send_notify(&xenfb->c.xendev);
 409 }
 410
 411 /* -------------------------------------------------------------------- */
 412
 413 static void xenfb_copy_mfns(int mode, int count, unsigned long *dst, void *src)
 414 {
 415     uint32_t *src32 = src;
 416     uint64_t *src64 = src;
 417     int i;
 418
 419     for (i = 0; i < count; i++)
 420         dst[i] = (mode == 32) ? src32[i] : src64[i];
 421 }
 422
 423 static int xenfb_map_fb(struct XenFB *xenfb)
 424 {
 425     struct xenfb_page *page = xenfb->c.page;
 426     char *protocol = xenfb->c.xendev.protocol;
 427     int n_fbdirs;
 428     unsigned long *pgmfns = NULL;
 429     unsigned long *fbmfns = NULL;
 430     void *map, *pd;
 431     int mode, ret = -1;
 432
 433     /* default to native */
 434     pd = page->pd;
 435     mode = sizeof(unsigned long) * 8;
 436
 437     if (!protocol) {
 438         /*
 439          * Undefined protocol, some guesswork needed.
 440          *
 441          * Old frontends which don't set the protocol use
 442          * one page directory only, thus pd[1] must be zero.
 443          * pd[1] of the 32bit struct layout and the lower
 444          * 32 bits of pd[0] of the 64bit struct layout have
 445          * the same location, so we can check that ...
 446          */
 447         uint32_t *ptr32 = NULL;
 448         uint32_t *ptr64 = NULL;
 449 #if defined(__i386__)
 450         ptr32 = (void*)page->pd;
 451         ptr64 = ((void*)page->pd) + 4;
 452 #elif defined(__x86_64__)
 453         ptr32 = ((void*)page->pd) - 4;
 454         ptr64 = (void*)page->pd;
 455 #endif
 456         if (ptr32) {
 457             if (ptr32[1] == 0) {
 458                 mode = 32;
 459                 pd   = ptr32;
 460             } else {
 461                 mode = 64;
 462                 pd   = ptr64;
 463             }
 464         }
 465 #if defined(__x86_64__)
 466     } else if (strcmp(protocol, XEN_IO_PROTO_ABI_X86_32) == 0) {
 467         /* 64bit dom0, 32bit domU */
 468         mode = 32;
 469         pd   = ((void*)page->pd) - 4;
 470 #elif defined(__i386__)
 471     } else if (strcmp(protocol, XEN_IO_PROTO_ABI_X86_64) == 0) {
 472         /* 32bit dom0, 64bit domU */
 473         mode = 64;
 474         pd   = ((void*)page->pd) + 4;
 475 #endif
 476     }
 477
 478     if (xenfb->pixels) {
 479         munmap(xenfb->pixels, xenfb->fbpages * XC_PAGE_SIZE);
 480         xenfb->pixels = NULL;
 481     }
 482
 483     xenfb->fbpages = (xenfb->fb_len + (XC_PAGE_SIZE - 1)) / XC_PAGE_SIZE;
 484     n_fbdirs = xenfb->fbpages * mode / 8;
 485     n_fbdirs = (n_fbdirs + (XC_PAGE_SIZE - 1)) / XC_PAGE_SIZE;
 486
 487     pgmfns = g_malloc0(sizeof(unsigned long) * n_fbdirs);
 488     fbmfns = g_malloc0(sizeof(unsigned long) * xenfb->fbpages);
 489
 490     xenfb_copy_mfns(mode, n_fbdirs, pgmfns, pd);
 491     map = xc_map_foreign_pages(xen_xc, xenfb->c.xendev.dom,
 492                                PROT_READ, pgmfns, n_fbdirs);
 493     if (map == NULL)
 494         goto out;
 495     xenfb_copy_mfns(mode, xenfb->fbpages, fbmfns, map);
 496     munmap(map, n_fbdirs * XC_PAGE_SIZE);
 497
 498     xenfb->pixels = xc_map_foreign_pages(xen_xc, xenfb->c.xendev.dom,
 499                                          PROT_READ | PROT_WRITE, fbmfns, xenfb->fbpages);
 500     if (xenfb->pixels == NULL)
 501         goto out;
 502
 503     ret = 0; /* all is fine */
 504
 505 out:
 506     g_free(pgmfns);
 507     g_free(fbmfns);
 508     return ret;
 509 }
 510
 511 static int xenfb_configure_fb(struct XenFB *xenfb, size_t fb_len_lim,
 512                               int width, int height, int depth,
 513                               size_t fb_len, int offset, int row_stride)
 514 {
 515     size_t mfn_sz = sizeof(*((struct xenfb_page *)0)->pd);
 516     size_t pd_len = sizeof(((struct xenfb_page *)0)->pd) / mfn_sz;
 517     size_t fb_pages = pd_len * XC_PAGE_SIZE / mfn_sz;
 518     size_t fb_len_max = fb_pages * XC_PAGE_SIZE;
 519     int max_width, max_height;
 520
 521     if (fb_len_lim > fb_len_max) {
 522         xen_be_printf(&xenfb->c.xendev, 0, "fb size limit %zu exceeds %zu, corrected\n",
 523                       fb_len_lim, fb_len_max);
 524         fb_len_lim = fb_len_max;
 525     }
 526     if (fb_len_lim && fb_len > fb_len_lim) {
 527         xen_be_printf(&xenfb->c.xendev, 0, "frontend fb size %zu limited to %zu\n",
 528                       fb_len, fb_len_lim);
 529         fb_len = fb_len_lim;
 530     }
 531     if (depth != 8 && depth != 16 && depth != 24 && depth != 32) {
 532         xen_be_printf(&xenfb->c.xendev, 0, "can't handle frontend fb depth %d\n",
 533                       depth);
 534         return -1;
 535     }
 536     if (row_stride <= 0 || row_stride > fb_len) {
 537         xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend stride %d\n", row_stride);
 538         return -1;
 539     }
 540     max_width = row_stride / (depth / 8);
 541     if (width < 0 || width > max_width) {
 542         xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend width %d limited to %d\n",
 543                       width, max_width);
 544         width = max_width;
 545     }
 546     if (offset < 0 || offset >= fb_len) {
 547         xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend offset %d (max %zu)\n",
 548                       offset, fb_len - 1);
 549         return -1;
 550     }
 551     max_height = (fb_len - offset) / row_stride;
 552     if (height < 0 || height > max_height) {
 553         xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend height %d limited to %d\n",
 554                       height, max_height);
 555         height = max_height;
 556     }
 557     xenfb->fb_len = fb_len;
 558     xenfb->row_stride = row_stride;
 559     xenfb->depth = depth;
 560     xenfb->width = width;
 561     xenfb->height = height;
 562     xenfb->offset = offset;
 563     xenfb->up_fullscreen = 1;
 564     xenfb->do_resize = 1;
 565     xen_be_printf(&xenfb->c.xendev, 1, "framebuffer %dx%dx%d offset %d stride %d\n",
 566                   width, height, depth, offset, row_stride);
 567     return 0;
 568 }
 569
 570 /* A convenient function for munging pixels between different depths */
 571 #define BLT(SRC_T,DST_T,RSB,GSB,BSB,RDB,GDB,BDB)                        \
 572     for (line = y ; line < (y+h) ; line++) {                            \
 573         SRC_T *src = (SRC_T *)(xenfb->pixels                            \
 574                                + xenfb->offset                          \
 575                                + (line * xenfb->row_stride)             \
 576                                + (x * xenfb->depth / 8));               \
 577         DST_T *dst = (DST_T *)(data                                     \
 578                                + (line * linesize)                      \
 579                                + (x * bpp / 8));                        \
 580         int col;                                                        \
 581         const int RSS = 32 - (RSB + GSB + BSB);                         \
 582         const int GSS = 32 - (GSB + BSB);                               \
 583         const int BSS = 32 - (BSB);                                     \
 584         const uint32_t RSM = (~0U) << (32 - RSB);                       \
 585         const uint32_t GSM = (~0U) << (32 - GSB);                       \
 586         const uint32_t BSM = (~0U) << (32 - BSB);                       \
 587         const int RDS = 32 - (RDB + GDB + BDB);                         \
 588         const int GDS = 32 - (GDB + BDB);                               \
 589         const int BDS = 32 - (BDB);                                     \
 590         const uint32_t RDM = (~0U) << (32 - RDB);                       \
 591         const uint32_t GDM = (~0U) << (32 - GDB);                       \
 592         const uint32_t BDM = (~0U) << (32 - BDB);                       \
 593         for (col = x ; col < (x+w) ; col++) {                           \
 594             uint32_t spix = *src;                                       \
 595             *dst = (((spix << RSS) & RSM & RDM) >> RDS) |               \
 596                 (((spix << GSS) & GSM & GDM) >> GDS) |                  \
 597                 (((spix << BSS) & BSM & BDM) >> BDS);                   \
 598             src = (SRC_T *) ((unsigned long) src + xenfb->depth / 8);   \
 599             dst = (DST_T *) ((unsigned long) dst + bpp / 8);            \
 600         }                                                               \
 601     }
 602
 603
 604 /*
 605  * This copies data from the guest framebuffer region, into QEMU's
 606  * displaysurface. qemu uses 16 or 32 bpp.  In case the pv framebuffer
 607  * uses something else we must convert and copy, otherwise we can
 608  * supply the buffer directly and no thing here.
 609  */
 610 static void xenfb_guest_copy(struct XenFB *xenfb, int x, int y, int w, int h)
 611 {
 612     DisplaySurface *surface = qemu_console_surface(xenfb->c.con);
 613     int line, oops = 0;
 614     int bpp = surface_bits_per_pixel(surface);
 615     int linesize = surface_stride(surface);
 616     uint8_t *data = surface_data(surface);
 617
 618     if (!is_buffer_shared(surface)) {
 619         switch (xenfb->depth) {
 620         case 8:
 621             if (bpp == 16) {
 622                 BLT(uint8_t, uint16_t,   3, 3, 2,   5, 6, 5);
 623             } else if (bpp == 32) {
 624                 BLT(uint8_t, uint32_t,   3, 3, 2,   8, 8, 8);
 625             } else {
 626                 oops = 1;
 627             }
 628             break;
 629         case 24:
 630             if (bpp == 16) {
 631                 BLT(uint32_t, uint16_t,  8, 8, 8,   5, 6, 5);
 632             } else if (bpp == 32) {
 633                 BLT(uint32_t, uint32_t,  8, 8, 8,   8, 8, 8);
 634             } else {
 635                 oops = 1;
 636             }
 637             break;
 638         default:
 639             oops = 1;
 640         }
 641     }
 642     if (oops) /* should not happen */
 643         xen_be_printf(&xenfb->c.xendev, 0, "%s: oops: convert %d -> %d bpp?\n",
 644                       __FUNCTION__, xenfb->depth, bpp);
 645
 646     dpy_gfx_update(xenfb->c.con, x, y, w, h);
 647 }
 648
 649 #if 0 /* def XENFB_TYPE_REFRESH_PERIOD */
 650 static int xenfb_queue_full(struct XenFB *xenfb)
 651 {
 652     struct xenfb_page *page = xenfb->c.page;
 653     uint32_t cons, prod;
 654
 655     if (!page)
 656         return 1;
 657
 658     prod = page->in_prod;
 659     cons = page->in_cons;
 660     return prod - cons == XENFB_IN_RING_LEN;
 661 }
 662
 663 static void xenfb_send_event(struct XenFB *xenfb, union xenfb_in_event *event)
 664 {
 665     uint32_t prod;
 666     struct xenfb_page *page = xenfb->c.page;
 667
 668     prod = page->in_prod;
 669     /* caller ensures !xenfb_queue_full() */
 670     xen_mb();                   /* ensure ring space available */
 671     XENFB_IN_RING_REF(page, prod) = *event;
 672     xen_wmb();                  /* ensure ring contents visible */
 673     page->in_prod = prod + 1;
 674
 675     xen_be_send_notify(&xenfb->c.xendev);
 676 }
 677
 678 static void xenfb_send_refresh_period(struct XenFB *xenfb, int period)
 679 {
 680     union xenfb_in_event event;
 681
 682     memset(&event, 0, sizeof(event));
 683     event.type = XENFB_TYPE_REFRESH_PERIOD;
 684     event.refresh_period.period = period;
 685     xenfb_send_event(xenfb, &event);
 686 }
 687 #endif
 688
 689 /*
 690  * Periodic update of display.
 691  * Also transmit the refresh interval to the frontend.
 692  *
 693  * Never ever do any qemu display operations
 694  * (resize, screen update) outside this function.
 695  * Our screen might be inactive.  When asked for
 696  * an update we know it is active.
 697  */
 698 static void xenfb_update(void *opaque)
 699 {
 700     struct XenFB *xenfb = opaque;
 701     DisplaySurface *surface;
 702     int i;
 703
 704     if (xenfb->c.xendev.be_state != XenbusStateConnected)
 705         return;
 706
 707     if (xenfb->feature_update) {
 708 #if 0 /* XENFB_TYPE_REFRESH_PERIOD */
 709         struct DisplayChangeListener *l;
 710         int period = 99999999;
 711         int idle = 1;
 712
 713         if (xenfb_queue_full(xenfb))
 714             return;
 715
 716         QLIST_FOREACH(l, &xenfb->c.ds->listeners, next) {
 717             if (l->idle)
 718                 continue;
 719             idle = 0;
 720             if (!l->gui_timer_interval) {
 721                 if (period > GUI_REFRESH_INTERVAL)
 722                     period = GUI_REFRESH_INTERVAL;
 723             } else {
 724                 if (period > l->gui_timer_interval)
 725                     period = l->gui_timer_interval;
 726             }
 727         }
 728         if (idle)
 729             period = XENFB_NO_REFRESH;
 730
 731         if (xenfb->refresh_period != period) {
 732             xenfb_send_refresh_period(xenfb, period);
 733             xenfb->refresh_period = period;
 734             xen_be_printf(&xenfb->c.xendev, 1, "refresh period: %d\n", period);
 735         }
 736 #else
 737         ; /* nothing */
 738 #endif
 739     } else {
 740         /* we don't get update notifications, thus use the
 741          * sledge hammer approach ... */
 742         xenfb->up_fullscreen = 1;
 743     }
 744
 745     /* resize if needed */
 746     if (xenfb->do_resize) {
 747         xenfb->do_resize = 0;
 748         switch (xenfb->depth) {
 749         case 16:
 750         case 32:
 751             /* console.c supported depth -> buffer can be used directly */
 752             surface = qemu_create_displaysurface_from
 753                 (xenfb->width, xenfb->height, xenfb->depth,
 754                  xenfb->row_stride, xenfb->pixels + xenfb->offset,
 755                  false);
 756             break;
 757         default:
 758             /* we must convert stuff */
 759             surface = qemu_create_displaysurface(xenfb->width, xenfb->height);
 760             break;
 761         }
 762         dpy_gfx_replace_surface(xenfb->c.con, surface);
 763         xen_be_printf(&xenfb->c.xendev, 1, "update: resizing: %dx%d @ %d bpp%s\n",
 764                       xenfb->width, xenfb->height, xenfb->depth,
 765                       is_buffer_shared(surface) ? " (shared)" : "");
 766         xenfb->up_fullscreen = 1;
 767     }
 768
 769     /* run queued updates */
 770     if (xenfb->up_fullscreen) {
 771         xen_be_printf(&xenfb->c.xendev, 3, "update: fullscreen\n");
 772         xenfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height);
 773     } else if (xenfb->up_count) {
 774         xen_be_printf(&xenfb->c.xendev, 3, "update: %d rects\n", xenfb->up_count);
 775         for (i = 0; i < xenfb->up_count; i++)
 776             xenfb_guest_copy(xenfb,
 777                              xenfb->up_rects[i].x,
 778                              xenfb->up_rects[i].y,
 779                              xenfb->up_rects[i].w,
 780                              xenfb->up_rects[i].h);
 781     } else {
 782         xen_be_printf(&xenfb->c.xendev, 3, "update: nothing\n");
 783     }
 784     xenfb->up_count = 0;
 785     xenfb->up_fullscreen = 0;
 786 }
 787
 788 /* QEMU display state changed, so refresh the framebuffer copy */
 789 static void xenfb_invalidate(void *opaque)
 790 {
 791     struct XenFB *xenfb = opaque;
 792     xenfb->up_fullscreen = 1;
 793 }
 794
 795 static void xenfb_handle_events(struct XenFB *xenfb)
 796 {
 797     uint32_t prod, cons;
 798     struct xenfb_page *page = xenfb->c.page;
 799
 800     prod = page->out_prod;
 801     if (prod == page->out_cons)
 802         return;
 803     xen_rmb();          /* ensure we see ring contents up to prod */
 804     for (cons = page->out_cons; cons != prod; cons++) {
 805         union xenfb_out_event *event = &XENFB_OUT_RING_REF(page, cons);
 806         int x, y, w, h;
 807
 808         switch (event->type) {
 809         case XENFB_TYPE_UPDATE:
 810             if (xenfb->up_count == UP_QUEUE)
 811                 xenfb->up_fullscreen = 1;
 812             if (xenfb->up_fullscreen)
 813                 break;
 814             x = MAX(event->update.x, 0);
 815             y = MAX(event->update.y, 0);
 816             w = MIN(event->update.width, xenfb->width - x);
 817             h = MIN(event->update.height, xenfb->height - y);
 818             if (w < 0 || h < 0) {
 819                 xen_be_printf(&xenfb->c.xendev, 1, "bogus update ignored\n");
 820                 break;
 821             }
 822             if (x != event->update.x ||
 823                 y != event->update.y ||
 824                 w != event->update.width ||
 825                 h != event->update.height) {
 826                 xen_be_printf(&xenfb->c.xendev, 1, "bogus update clipped\n");
 827             }
 828             if (w == xenfb->width && h > xenfb->height / 2) {
 829                 /* scroll detector: updated more than 50% of the lines,
 830                  * don't bother keeping track of the rectangles then */
 831                 xenfb->up_fullscreen = 1;
 832             } else {
 833                 xenfb->up_rects[xenfb->up_count].x = x;
 834                 xenfb->up_rects[xenfb->up_count].y = y;
 835                 xenfb->up_rects[xenfb->up_count].w = w;
 836                 xenfb->up_rects[xenfb->up_count].h = h;
 837                 xenfb->up_count++;
 838             }
 839             break;
 840 #ifdef XENFB_TYPE_RESIZE
 841         case XENFB_TYPE_RESIZE:
 842             if (xenfb_configure_fb(xenfb, xenfb->fb_len,
 843                                    event->resize.width,
 844                                    event->resize.height,
 845                                    event->resize.depth,
 846                                    xenfb->fb_len,
 847                                    event->resize.offset,
 848                                    event->resize.stride) < 0)
 849                 break;
 850             xenfb_invalidate(xenfb);
 851             break;
 852 #endif
 853         }
 854     }
 855     xen_mb();           /* ensure we're done with ring contents */
 856     page->out_cons = cons;
 857 }
 858
 859 static int fb_init(struct XenDevice *xendev)
 860 {
 861     struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev);
 862
 863     fb->refresh_period = -1;
 864
 865 #ifdef XENFB_TYPE_RESIZE
 866     xenstore_write_be_int(xendev, "feature-resize", 1);
 867 #endif
 868     return 0;
 869 }
 870
 871 static int fb_initialise(struct XenDevice *xendev)
 872 {
 873     struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev);
 874     struct xenfb_page *fb_page;
 875     int videoram;
 876     int rc;
 877
 878     if (xenstore_read_fe_int(xendev, "videoram", &videoram) == -1)
 879         videoram = 0;
 880
 881     rc = common_bind(&fb->c);
 882     if (rc != 0)
 883         return rc;
 884
 885     fb_page = fb->c.page;
 886     rc = xenfb_configure_fb(fb, videoram * 1024 * 1024U,
 887                             fb_page->width, fb_page->height, fb_page->depth,
 888                             fb_page->mem_length, 0, fb_page->line_length);
 889     if (rc != 0)
 890         return rc;
 891
 892     rc = xenfb_map_fb(fb);
 893     if (rc != 0)
 894         return rc;
 895
 896 #if 0  /* handled in xen_init_display() for now */
 897     if (!fb->have_console) {
 898         fb->c.ds = graphic_console_init(xenfb_update,
 899                                         xenfb_invalidate,
 900                                         NULL,
 901                                         NULL,
 902                                         fb);
 903         fb->have_console = 1;
 904     }
 905 #endif
 906
 907     if (xenstore_read_fe_int(xendev, "feature-update", &fb->feature_update) == -1)
 908         fb->feature_update = 0;
 909     if (fb->feature_update)
 910         xenstore_write_be_int(xendev, "request-update", 1);
 911
 912     xen_be_printf(xendev, 1, "feature-update=%d, videoram=%d\n",
 913                   fb->feature_update, videoram);
 914     return 0;
 915 }
 916
 917 static void fb_disconnect(struct XenDevice *xendev)
 918 {
 919     struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev);
 920
 921     /*
 922      * FIXME: qemu can't un-init gfx display (yet?).
 923      *   Replacing the framebuffer with anonymous shared memory
 924      *   instead.  This releases the guest pages and keeps qemu happy.
 925      */
 926     fb->pixels = mmap(fb->pixels, fb->fbpages * XC_PAGE_SIZE,
 927                       PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON,
 928                       -1, 0);
 929     common_unbind(&fb->c);
 930     fb->feature_update = 0;
 931     fb->bug_trigger    = 0;
 932 }
 933
 934 static void fb_frontend_changed(struct XenDevice *xendev, const char *node)
 935 {
 936     struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev);
 937
 938     /*
 939      * Set state to Connected *again* once the frontend switched
 940      * to connected.  We must trigger the watch a second time to
 941      * workaround a frontend bug.
 942      */
 943     if (fb->bug_trigger == 0 && strcmp(node, "state") == 0 &&
 944         xendev->fe_state == XenbusStateConnected &&
 945         xendev->be_state == XenbusStateConnected) {
 946         xen_be_printf(xendev, 2, "re-trigger connected (frontend bug)\n");
 947         xen_be_set_state(xendev, XenbusStateConnected);
 948         fb->bug_trigger = 1; /* only once */
 949     }
 950 }
 951
 952 static void fb_event(struct XenDevice *xendev)
 953 {
 954     struct XenFB *xenfb = container_of(xendev, struct XenFB, c.xendev);
 955
 956     xenfb_handle_events(xenfb);
 957     xen_be_send_notify(&xenfb->c.xendev);
 958 }
 959
 960 /* -------------------------------------------------------------------- */
 961
 962 struct XenDevOps xen_kbdmouse_ops = {
 963     .size       = sizeof(struct XenInput),
 964     .init       = input_init,
 965     .initialise = input_initialise,
 966     .connected  = input_connected,
 967     .disconnect = input_disconnect,
 968     .event      = input_event,
 969 };
 970
 971 struct XenDevOps xen_framebuffer_ops = {
 972     .size       = sizeof(struct XenFB),
 973     .init       = fb_init,
 974     .initialise = fb_initialise,
 975     .disconnect = fb_disconnect,
 976     .event      = fb_event,
 977     .frontend_changed = fb_frontend_changed,
 978 };
 979
 980 /*
 981  * FIXME/TODO: Kill this.
 982  * Temporary needed while DisplayState reorganization is in flight.
 983  */
 984 void xen_init_display(int domid)
 985 {
 986     struct XenDevice *xfb, *xin;
 987     struct XenFB *fb;
 988     struct XenInput *in;
 989     int i = 0;
 990
 991 wait_more:
 992     i++;
 993     main_loop_wait(true);
 994     xfb = xen_be_find_xendev("vfb", domid, 0);
 995     xin = xen_be_find_xendev("vkbd", domid, 0);
 996     if (!xfb || !xin) {
 997         if (i < 256) {
 998             usleep(10000);
 999             goto wait_more;
1000         }
1001         xen_be_printf(NULL, 1, "displaystate setup failed\n");
1002         return;
1003     }
1004
1005     /* vfb */
1006     fb = container_of(xfb, struct XenFB, c.xendev);
1007     fb->c.con = graphic_console_init(xenfb_update,
1008                                      xenfb_invalidate,
1009                                      NULL,
1010                                      NULL,
1011                                      fb);
1012     fb->have_console = 1;
1013
1014     /* vkbd */
1015     in = container_of(xin, struct XenInput, c.xendev);
1016     in->c.con = fb->c.con;
1017
1018     /* retry ->init() */
1019     xen_be_check_state(xin);
1020     xen_be_check_state(xfb);
1021 }