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