From 4cd79eae3a476fda86b67a8075735a03c1254a08 Mon Sep 17 00:00:00 2001

From: Gerd Hoffmann <kraxel@redhat.com>

Date: Tue, 27 Apr 2010 11:50:11 +0200

Subject: [PATCH 14/39] spice: add qxl device

qxl is a paravirtual graphics card.  The qxl device is the bridge

between the guest and the spice server (aka libspice-server).  The

spice server will send the rendering commands to the spice client, which

will actually render them.

The spice server is also able to render locally, which is done in case

the guest wants read something from video memory.  Local rendering is

also used to support display over vnc and sdl.

qxl is activated using "-vga qxl".  qxl supports multihead, additional

cards can be added via '-device qxl".

---

 Makefile.target |    1 +

 hw/hw.h         |   14 +

 hw/pc.c         |    8 +

 hw/qxl-logger.c |  179 +++++++

 hw/qxl-render.c |  207 ++++++++

 hw/qxl.c        | 1411 +++++++++++++++++++++++++++++++++++++++++++++++++++++++

 hw/qxl.h        |  102 ++++

 hw/vga_int.h    |    2 +-

 sysemu.h        |    3 +-

 vl.c            |    4 +-

 10 files changed, 1928 insertions(+), 3 deletions(-)

 create mode 100644 hw/qxl-logger.c

 create mode 100644 hw/qxl-render.c

 create mode 100644 hw/qxl.c

 create mode 100644 hw/qxl.h

diff --git a/Makefile.target b/Makefile.target

index 9e13d99..4da33b5 100644

--- a/Makefile.target

+++ b/Makefile.target

@@ -216,6 +216,7 @@ obj-i386-y += debugcon.o multiboot.o

 obj-i386-y += pc_piix.o

 obj-i386-y += testdev.o

 obj-i386-y += acpi.o acpi_piix4.o

+obj-i386-$(CONFIG_SPICE) += qxl.o qxl-logger.o qxl-render.o

 obj-i386-y += pcspk.o i8254.o

 obj-i386-$(CONFIG_KVM_PIT) += i8254-kvm.o

diff --git a/hw/hw.h b/hw/hw.h

index ec6985d..044ebfb 100644

--- a/hw/hw.h

+++ b/hw/hw.h

@@ -528,6 +528,17 @@ extern const VMStateInfo vmstate_info_unused_buffer;

     .start        = (_start),                                        \

 }

+#define VMSTATE_VBUFFER_UINT32(_field, _state, _version, _test, _start, _field_size) { \

+    .name         = (stringify(_field)),                             \

+    .version_id   = (_version),                                      \

+    .field_exists = (_test),                                         \

+    .size_offset  = vmstate_offset_value(_state, _field_size, uint32_t),\

+    .info         = &vmstate_info_buffer,                            \

+    .flags        = VMS_VBUFFER|VMS_POINTER,                         \

+    .offset       = offsetof(_state, _field),                        \

+    .start        = (_start),                                        \

+}

+

 #define VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, _info, _size) { \

     .name       = (stringify(_field)),                               \

     .version_id = (_version),                                        \

@@ -742,6 +753,9 @@ extern const VMStateDescription vmstate_i2c_slave;

 #define VMSTATE_PARTIAL_VBUFFER(_f, _s, _size)                        \

     VMSTATE_VBUFFER(_f, _s, 0, NULL, 0, _size)

+#define VMSTATE_PARTIAL_VBUFFER_UINT32(_f, _s, _size)                        \

+    VMSTATE_VBUFFER_UINT32(_f, _s, 0, NULL, 0, _size)

+

 #define VMSTATE_SUB_VBUFFER(_f, _s, _start, _size)                    \

     VMSTATE_VBUFFER(_f, _s, 0, NULL, _start, _size)

diff --git a/hw/pc.c b/hw/pc.c

index 77b1592..1f2df2f 100644

--- a/hw/pc.c

+++ b/hw/pc.c

@@ -41,6 +41,7 @@

 #include "sysemu.h"

 #include "device-assignment.h"

 #include "kvm.h"

+#include "qemu-spice.h"

 /* output Bochs bios info messages */

 //#define DEBUG_BIOS

@@ -1002,6 +1003,13 @@ void pc_vga_init(PCIBus *pci_bus)

             pci_vmsvga_init(pci_bus);

         else

             fprintf(stderr, "%s: vmware_vga: no PCI bus\n", __FUNCTION__);

+#ifdef CONFIG_SPICE

+    } else if (qxl_enabled) {

+        if (pci_bus)

+            pci_create_simple(pci_bus, -1, "qxl");

+        else

+            fprintf(stderr, "%s: qxl: no PCI bus\n", __FUNCTION__);

+#endif

     } else if (std_vga_enabled) {

         if (pci_bus) {

             pci_vga_init(pci_bus, 0, 0);

diff --git a/hw/qxl-logger.c b/hw/qxl-logger.c

new file mode 100644

index 0000000..d4a935a

--- /dev/null

+++ b/hw/qxl-logger.c

@@ -0,0 +1,179 @@

+/*

+ * qxl command logging -- for debug purposes

+ */

+

+#include <stdio.h>

+#include <stdbool.h>

+#include <stdint.h>

+#include <string.h>

+

+#include "qxl.h"

+

+static const char *qxl_type[] = {

+    [ QXL_CMD_NOP ]     = "nop",

+    [ QXL_CMD_DRAW ]    = "draw",

+    [ QXL_CMD_UPDATE ]  = "update",

+    [ QXL_CMD_CURSOR ]  = "cursor",

+    [ QXL_CMD_MESSAGE ] = "message",

+    [ QXL_CMD_SURFACE ] = "surface",

+};

+

+static const char *qxl_draw_type[] = {

+    [ QXL_DRAW_NOP         ] = "nop",

+    [ QXL_DRAW_FILL        ] = "fill",

+    [ QXL_DRAW_OPAQUE      ] = "opaque",

+    [ QXL_DRAW_COPY        ] = "copy",

+    [ QXL_COPY_BITS        ] = "copy-bits",

+    [ QXL_DRAW_BLEND       ] = "blend",

+    [ QXL_DRAW_BLACKNESS   ] = "blackness",

+    [ QXL_DRAW_WHITENESS   ] = "whitemess",

+    [ QXL_DRAW_INVERS      ] = "invers",

+    [ QXL_DRAW_ROP3        ] = "rop3",

+    [ QXL_DRAW_STROKE      ] = "stroke",

+    [ QXL_DRAW_TEXT        ] = "text",

+    [ QXL_DRAW_TRANSPARENT ] = "transparent",

+    [ QXL_DRAW_ALPHA_BLEND ] = "alpha-blend",

+};

+

+static const char *qxl_draw_effect[] = {

+    [ QXL_EFFECT_BLEND            ] = "blend",

+    [ QXL_EFFECT_OPAQUE           ] = "opaque",

+    [ QXL_EFFECT_REVERT_ON_DUP    ] = "revert-on-dup",

+    [ QXL_EFFECT_BLACKNESS_ON_DUP ] = "blackness-on-dup",

+    [ QXL_EFFECT_WHITENESS_ON_DUP ] = "whiteness-on-dup",

+    [ QXL_EFFECT_NOP_ON_DUP       ] = "nop-on-dup",

+    [ QXL_EFFECT_NOP              ] = "nop",

+    [ QXL_EFFECT_OPAQUE_BRUSH     ] = "opaque-brush",

+};

+

+static const char *qxl_surface_cmd[] = {

+   [ QXL_SURFACE_CMD_CREATE  ] = "create",

+   [ QXL_SURFACE_CMD_DESTROY ] = "destroy",

+};

+

+static const char *spice_surface_fmt[] = {

+   [ SPICE_SURFACE_FMT_INVALID  ] = "invalid",

+   [ SPICE_SURFACE_FMT_1_A      ] = "alpha/1",

+   [ SPICE_SURFACE_FMT_8_A      ] = "alpha/8",

+   [ SPICE_SURFACE_FMT_16_555   ] = "555/16",

+   [ SPICE_SURFACE_FMT_16_565   ] = "565/16",

+   [ SPICE_SURFACE_FMT_32_xRGB  ] = "xRGB/32",

+   [ SPICE_SURFACE_FMT_32_ARGB  ] = "ARGB/32",

+};

+

+static const char *qxl_cursor_cmd[] = {

+   [ QXL_CURSOR_SET   ] = "set",

+   [ QXL_CURSOR_MOVE  ] = "move",

+   [ QXL_CURSOR_HIDE  ] = "hide",

+   [ QXL_CURSOR_TRAIL ] = "trail",

+};

+

+static const char *spice_cursor_type[] = {

+   [ SPICE_CURSOR_TYPE_ALPHA   ] = "alpha",

+   [ SPICE_CURSOR_TYPE_MONO    ] = "mono",

+   [ SPICE_CURSOR_TYPE_COLOR4  ] = "color4",

+   [ SPICE_CURSOR_TYPE_COLOR8  ] = "color8",

+   [ SPICE_CURSOR_TYPE_COLOR16 ] = "color16",

+   [ SPICE_CURSOR_TYPE_COLOR24 ] = "color24",

+   [ SPICE_CURSOR_TYPE_COLOR32 ] = "color32",

+};

+

+static const char *qxl_v2n(const char *n[], size_t l, int v)

+{

+    if (v >= l || !n[v])

+        return "???";

+    return n[v];

+}

+#define qxl_name(_list, _value) qxl_v2n(_list, ARRAY_SIZE(_list), _value)

+

+static void qxl_log_cmd_draw(PCIQXLDevice *qxl, QXLDrawable *draw)

+{

+    fprintf(stderr, ": surface_id %d type %s effect %s",

+            draw->surface_id,

+            qxl_name(qxl_draw_type, draw->type),

+            qxl_name(qxl_draw_effect, draw->effect));

+}

+

+static void qxl_log_cmd_draw_compat(PCIQXLDevice *qxl, QXLCompatDrawable *draw)

+{

+    fprintf(stderr, ": type %s effect %s",

+            qxl_name(qxl_draw_type, draw->type),

+            qxl_name(qxl_draw_effect, draw->effect));

+}

+

+static void qxl_log_cmd_surface(PCIQXLDevice *qxl, QXLSurfaceCmd *cmd)

+{

+    fprintf(stderr, ": %s id %d",

+            qxl_name(qxl_surface_cmd, cmd->type),

+            cmd->surface_id);

+    if (cmd->type == QXL_SURFACE_CMD_CREATE) {

+        fprintf(stderr, " size %dx%d stride %d format %s (count %d, max %d)",

+                cmd->u.surface_create.width,

+                cmd->u.surface_create.height,

+                cmd->u.surface_create.stride,

+                qxl_name(spice_surface_fmt, cmd->u.surface_create.format),

+                qxl->guest_surfaces.count, qxl->guest_surfaces.max);

+    }

+    if (cmd->type == QXL_SURFACE_CMD_DESTROY) {

+        fprintf(stderr, " (count %d)", qxl->guest_surfaces.count);

+    }

+}

+

+void qxl_log_cmd_cursor(PCIQXLDevice *qxl, QXLCursorCmd *cmd, int group_id)

+{

+    QXLCursor *cursor;

+

+    fprintf(stderr, ": %s",

+            qxl_name(qxl_cursor_cmd, cmd->type));

+    switch (cmd->type) {

+    case QXL_CURSOR_SET:

+        fprintf(stderr, " +%d+%d visible %s, shape @ 0x%" PRIx64,

+                cmd->u.set.position.x,

+                cmd->u.set.position.y,

+                cmd->u.set.visible ? "yes" : "no",

+                cmd->u.set.shape);

+        cursor = qxl_phys2virt(qxl, cmd->u.set.shape, group_id);

+        fprintf(stderr, " type %s size %dx%d hot-spot +%d+%d"

+                " unique 0x%" PRIx64 " data-size %d",

+                qxl_name(spice_cursor_type, cursor->header.type),

+                cursor->header.width, cursor->header.height,

+                cursor->header.hot_spot_x, cursor->header.hot_spot_y,

+                cursor->header.unique, cursor->data_size);

+        break;

+    case QXL_CURSOR_MOVE:

+        fprintf(stderr, " +%d+%d", cmd->u.position.x, cmd->u.position.y);

+        break;

+    }

+}

+

+void qxl_log_command(PCIQXLDevice *qxl, const char *ring, QXLCommandExt *ext)

+{

+    bool compat = ext->flags & QXL_COMMAND_FLAG_COMPAT;

+    void *data;

+

+    if (!qxl->cmdlog) {

+        return;

+    }

+    fprintf(stderr, "qxl-%d/%s:", qxl->id, ring);

+    fprintf(stderr, " cmd @ 0x%" PRIx64 " %s%s", ext->cmd.data,

+            qxl_name(qxl_type, ext->cmd.type),

+            compat ? "(compat)" : "");

+

+    data = qxl_phys2virt(qxl, ext->cmd.data, ext->group_id);

+    switch (ext->cmd.type) {

+    case QXL_CMD_DRAW:

+        if (!compat) {

+            qxl_log_cmd_draw(qxl, data);

+        } else {

+            qxl_log_cmd_draw_compat(qxl, data);

+        }

+        break;

+    case QXL_CMD_SURFACE:

+        qxl_log_cmd_surface(qxl, data);

+        break;

+    case QXL_CMD_CURSOR:

+        qxl_log_cmd_cursor(qxl, data, ext->group_id);

+        break;

+    }

+    fprintf(stderr, "\n");

+}

diff --git a/hw/qxl-render.c b/hw/qxl-render.c

new file mode 100644

index 0000000..d9ebca4

--- /dev/null

+++ b/hw/qxl-render.c

@@ -0,0 +1,207 @@

+/*

+ * qxl local rendering (aka display on sdl/vnc)

+ */

+#include <stdio.h>

+#include <stdbool.h>

+#include <stdint.h>

+#include <string.h>

+

+#include "qxl.h"

+

+static void qxl_flip(PCIQXLDevice *qxl, QXLRect *rect)

+{

+    uint8_t *src = qxl->guest_primary.data;

+    uint8_t *dst = qxl->guest_primary.flipped;

+    int len, i;

+

+    src += (qxl->guest_primary.surface.height - rect->top - 1) *

+        qxl->guest_primary.stride;

+    dst += rect->top  * qxl->guest_primary.stride;

+    src += rect->left * qxl->guest_primary.bytes_pp;

+    dst += rect->left * qxl->guest_primary.bytes_pp;

+    len  = (rect->right - rect->left) * qxl->guest_primary.bytes_pp;

+

+    for (i = rect->top; i < rect->bottom; i++) {

+        memcpy(dst, src, len);

+        dst += qxl->guest_primary.stride;

+        src -= qxl->guest_primary.stride;

+    }

+}

+

+void qxl_render_resize(PCIQXLDevice *qxl)

+{

+    QXLSurfaceCreate *sc = &qxl->guest_primary.surface;

+

+    qxl->guest_primary.stride = sc->stride;

+    qxl->guest_primary.resized++;

+    switch (sc->format) {

+    case SPICE_SURFACE_FMT_16_555:

+        qxl->guest_primary.bytes_pp = 2;

+        qxl->guest_primary.bits_pp = 15;

+        break;

+    case SPICE_SURFACE_FMT_16_565:

+        qxl->guest_primary.bytes_pp = 2;

+        qxl->guest_primary.bits_pp = 16;

+        break;

+    case SPICE_SURFACE_FMT_32_xRGB:

+    case SPICE_SURFACE_FMT_32_ARGB:

+        qxl->guest_primary.bytes_pp = 4;

+        qxl->guest_primary.bits_pp = 32;

+        break;

+    default:

+        fprintf(stderr, "%s: unhandled format: %x\n", __FUNCTION__,

+                qxl->guest_primary.surface.format);

+        qxl->guest_primary.bytes_pp = 4;

+        qxl->guest_primary.bits_pp = 32;

+        break;

+    }

+}

+

+void qxl_render_update(PCIQXLDevice *qxl)

+{

+    VGACommonState *vga = &qxl->vga;

+    QXLRect dirty[32], update;

+    void *ptr;

+    int i;

+

+    if (qxl->guest_primary.resized) {

+        qxl->guest_primary.resized = 0;

+

+        if (qxl->guest_primary.flipped) {

+            qemu_free(qxl->guest_primary.flipped);

+            qxl->guest_primary.flipped = NULL;

+        }

+        qemu_free_displaysurface(vga->ds);

+

+        qxl->guest_primary.data = qemu_get_ram_ptr(qxl->vga.vram_offset);

+        if (qxl->guest_primary.stride < 0) {

+            /* spice surface is upside down -> need extra buffer to flip */

+            qxl->guest_primary.stride = -qxl->guest_primary.stride;

+            qxl->guest_primary.flipped = qemu_malloc(qxl->guest_primary.surface.width *

+                                                     qxl->guest_primary.stride);

+            ptr = qxl->guest_primary.flipped;

+        } else {

+            ptr = qxl->guest_primary.data;

+        }

+        fprintf(stderr, "%s: %dx%d, stride %d, bpp %d, depth %d, flip %s\n",

+                __FUNCTION__,

+                qxl->guest_primary.surface.width,

+                qxl->guest_primary.surface.height,

+                qxl->guest_primary.stride,

+                qxl->guest_primary.bytes_pp,

+                qxl->guest_primary.bits_pp,

+                qxl->guest_primary.flipped ? "yes" : "no");

+        vga->ds->surface =

+            qemu_create_displaysurface_from(qxl->guest_primary.surface.width,

+                                            qxl->guest_primary.surface.height,

+                                            qxl->guest_primary.bits_pp,

+                                            qxl->guest_primary.stride,

+                                            ptr);

+        dpy_resize(vga->ds);

+    }

+

+    if (!qxl->guest_primary.commands)

+        return;

+    qxl->guest_primary.commands = 0;

+

+    update.left   = 0;

+    update.right  = qxl->guest_primary.surface.width;

+    update.top    = 0;

+    update.bottom = qxl->guest_primary.surface.height;

+

+    memset(dirty, 0, sizeof(dirty));

+    qxl->ssd.worker->update_area(qxl->ssd.worker, 0, &update,

+                                 dirty, ARRAY_SIZE(dirty), 1);

+

+    for (i = 0; i < ARRAY_SIZE(dirty); i++) {

+        if (qemu_spice_rect_is_empty(dirty+i))

+            break;

+        if (qxl->guest_primary.flipped) {

+            qxl_flip(qxl, dirty+i);

+        }

+        dpy_update(vga->ds,

+                   dirty[i].left, dirty[i].top,

+                   dirty[i].right - dirty[i].left,

+                   dirty[i].bottom - dirty[i].top);

+    }

+}

+

+static QEMUCursor *qxl_cursor(PCIQXLDevice *qxl, QXLCursor *cursor)

+{

+    QEMUCursor *c;

+    uint8_t *image, *mask;

+    int size;

+

+    c = cursor_alloc(cursor->header.width, cursor->header.height);

+    c->hot_x = cursor->header.hot_spot_x;

+    c->hot_y = cursor->header.hot_spot_y;

+    switch (cursor->header.type) {

+    case SPICE_CURSOR_TYPE_ALPHA:

+        size = cursor->header.width * cursor->header.height * sizeof(uint32_t);

+        memcpy(c->data, cursor->chunk.data, size);

+        if (qxl->debug > 1)

+            cursor_print_ascii_art(c, "qxl/alpha");

+        break;

+    case SPICE_CURSOR_TYPE_MONO:

+        mask  = cursor->chunk.data;

+        image = mask + cursor_get_mono_bpl(c) * c->width;

+        cursor_set_mono(c, 0xffffff, 0x000000, image, 1, mask);

+        if (qxl->debug > 1)

+            cursor_print_ascii_art(c, "qxl/mono");

+        break;

+    default:

+        fprintf(stderr, "%s: not implemented: type %d\n",

+                __FUNCTION__, cursor->header.type);

+        goto fail;

+    }

+    return c;

+

+fail:

+    cursor_put(c);

+    return NULL;

+}

+

+

+void qxl_render_cursor(PCIQXLDevice *qxl, QXLCommandExt *ext)

+{

+    QXLCursorCmd *cmd = qxl_phys2virt(qxl, ext->cmd.data, ext->group_id);

+    QXLCursor *cursor;

+    QEMUCursor *c;

+    int x = -1, y = -1;

+

+    if (!qxl->ssd.ds->mouse_set ||

+        !qxl->ssd.ds->cursor_define)

+        return;

+

+#if 1

+    if (cmd->type != QXL_CURSOR_MOVE) {

+        fprintf(stderr, "%s", __FUNCTION__);

+        qxl_log_cmd_cursor(qxl, cmd, ext->group_id);

+        fprintf(stderr, "\n");

+    }

+#endif

+    switch (cmd->type) {

+    case QXL_CURSOR_SET:

+        x = cmd->u.set.position.x;

+        y = cmd->u.set.position.y;

+        cursor = qxl_phys2virt(qxl, cmd->u.set.shape, ext->group_id);

+        if (cursor->chunk.data_size != cursor->data_size) {

+            fprintf(stderr, "%s: multiple chunks\n", __FUNCTION__);

+            return;

+        }

+        c = qxl_cursor(qxl, cursor);

+        if (c == NULL) {

+            c = cursor_builtin_left_ptr();

+        }

+        qxl->ssd.ds->cursor_define(c);

+        cursor_put(c);

+        break;

+    case QXL_CURSOR_MOVE:

+        x = cmd->u.position.x;

+        y = cmd->u.position.y;

+        break;

+    }

+    if (x != -1 && y != -1) {

+        qxl->ssd.ds->mouse_set(x, y, 1);

+    }

+}

diff --git a/hw/qxl.c b/hw/qxl.c

new file mode 100644

index 0000000..475360c

--- /dev/null

+++ b/hw/qxl.c

@@ -0,0 +1,1411 @@

+#include <stdio.h>

+#include <stdlib.h>

+#include <stdbool.h>

+#include <stdint.h>

+#include <string.h>

+#include <pthread.h>

+

+#include "qemu-common.h"

+#include "qemu-timer.h"

+#include "qemu-queue.h"

+#include "monitor.h"

+#include "sysemu.h"

+

+#include "qxl.h"

+

+#undef SPICE_RING_PROD_ITEM

+#define SPICE_RING_PROD_ITEM(r, ret) {                                  \

+        typeof(r) start = r;                                            \

+        typeof(r) end = r + 1;                                          \

+        uint32_t prod = (r)->prod & SPICE_RING_INDEX_MASK(r);           \

+        typeof(&(r)->items[prod]) m_item = &(r)->items[prod];           \

+        if (!((uint8_t*)m_item >= (uint8_t*)(start) && (uint8_t*)(m_item + 1) <= (uint8_t*)(end))) { \

+            abort();                                                    \

+        }                                                               \

+        ret = &m_item->el;                                              \

+    }

+

+#undef SPICE_RING_CONS_ITEM

+#define SPICE_RING_CONS_ITEM(r, ret) {                                  \

+        typeof(r) start = r;                                            \

+        typeof(r) end = r + 1;                                          \

+        uint32_t cons = (r)->cons & SPICE_RING_INDEX_MASK(r);           \

+        typeof(&(r)->items[cons]) m_item = &(r)->items[cons];           \

+        if (!((uint8_t*)m_item >= (uint8_t*)(start) && (uint8_t*)(m_item + 1) <= (uint8_t*)(end))) { \

+            abort();                                                    \

+        }                                                               \

+        ret = &m_item->el;                                              \

+    }

+

+#undef ALIGN

+#define ALIGN(a, b) (((a) + ((b) - 1)) & ~((b) - 1))

+

+#define PIXEL_SIZE 0.2936875 //1280x1024 is 14.8" x 11.9" 

+

+#define QXL_MODE(_x, _y, _b, _o)                  \

+    {   .x_res = _x,                              \

+        .y_res = _y,                              \

+        .bits  = _b,                              \

+        .stride = (_x) * (_b) / 8,                \

+        .x_mili = PIXEL_SIZE * (_x),              \

+        .y_mili = PIXEL_SIZE * (_y),              \

+        .orientation = _o,                        \

+    }

+

+#define QXL_MODE_16_32(x_res, y_res, orientation) \

+    QXL_MODE(x_res, y_res, 16, orientation),      \

+    QXL_MODE(x_res, y_res, 32, orientation)

+

+#define QXL_MODE_EX(x_res, y_res)                 \

+    QXL_MODE_16_32(x_res, y_res, 0),              \

+    QXL_MODE_16_32(y_res, x_res, 1),              \

+    QXL_MODE_16_32(x_res, y_res, 2),              \

+    QXL_MODE_16_32(y_res, x_res, 3)

+

+static QXLMode qxl_modes[] = {

+    QXL_MODE_EX(640, 480),

+    QXL_MODE_EX(800, 600),

+    QXL_MODE_EX(832, 624),

+    QXL_MODE_EX(1024, 768),

+    QXL_MODE_EX(1152, 864),

+    QXL_MODE_EX(1152, 870),

+    QXL_MODE_EX(1280, 720),

+    QXL_MODE_EX(1280, 768),

+    QXL_MODE_EX(1280, 800),

+    QXL_MODE_EX(1280, 960),

+    QXL_MODE_EX(1280, 1024),

+    QXL_MODE_EX(1360, 768),

+    QXL_MODE_EX(1366, 768),

+    QXL_MODE_EX(1400, 1050),

+    QXL_MODE_EX(1440, 900),

+    QXL_MODE_EX(1600, 900),

+    QXL_MODE_EX(1600, 1200),

+    QXL_MODE_EX(1680, 1050),

+    QXL_MODE_EX(1920, 1080),

+#ifdef QXL_HIRES_MODES

+    QXL_MODE_EX(1920, 1200),

+    QXL_MODE_EX(1920, 1440),

+    QXL_MODE_EX(2048, 1536),

+    QXL_MODE_EX(2560, 1600),

+    QXL_MODE_EX(2560, 2048),

+    QXL_MODE_EX(2800, 2100),

+    QXL_MODE_EX(3200, 2400),

+#endif

+};

+

+static int device_id = 0;

+static PCIQXLDevice *qxl0;

+

+static void qxl_send_events(PCIQXLDevice *d, uint32_t events);

+static void qxl_destroy_primary(PCIQXLDevice *d);

+static void qxl_reset_memslots(PCIQXLDevice *d);

+static void qxl_reset_surfaces(PCIQXLDevice *d);

+static void qxl_ring_set_dirty(PCIQXLDevice *qxl);

+

+static inline uint32_t msb_mask(uint32_t val)

+{

+    uint32_t mask;

+

+    do {

+        mask = ~(val - 1) & val;

+        val &= ~mask;

+    } while (mask < val);

+

+    return mask;

+}

+

+static ram_addr_t qxl_rom_size(void)

+{

+    uint32_t rom_size = sizeof(QXLRom) + sizeof(QXLModes) + sizeof(qxl_modes);

+    rom_size = MAX(rom_size, TARGET_PAGE_SIZE);

+    rom_size = msb_mask(rom_size * 2 - 1);

+    return rom_size;

+}

+

+static void init_qxl_rom(PCIQXLDevice *d)

+{

+    QXLRom *rom = qemu_get_ram_ptr(d->rom_offset);

+    QXLModes *modes = (QXLModes *)(rom + 1);

+    uint32_t ram_header_size;

+    uint32_t surface0_area_size;

+    uint32_t num_pages;

+    uint32_t fb, maxfb = 0;

+    int i;

+

+    memset(rom, 0, d->rom_size);

+

+    rom->magic         = cpu_to_le32(QXL_ROM_MAGIC);

+    rom->id            = cpu_to_le32(d->id);

+    rom->modes_offset  = cpu_to_le32(sizeof(QXLRom));

+

+    rom->slot_gen_bits = MEMSLOT_GENERATION_BITS;

+    rom->slot_id_bits  = MEMSLOT_SLOT_BITS;

+    rom->slots_start   = 1;

+    rom->slots_end     = NUM_MEMSLOTS - 1;

+    rom->n_surfaces    = cpu_to_le32(NUM_SURFACES);

+

+    modes->n_modes     = cpu_to_le32(ARRAY_SIZE(qxl_modes));

+    for (i = 0; i < modes->n_modes; i++) {

+        fb = qxl_modes[i].y_res * qxl_modes[i].stride;

+        if (maxfb < fb)

+            maxfb = fb;

+        modes->modes[i].id          = cpu_to_le32(i);

+        modes->modes[i].x_res       = cpu_to_le32(qxl_modes[i].x_res);

+        modes->modes[i].y_res       = cpu_to_le32(qxl_modes[i].y_res);

+        modes->modes[i].bits        = cpu_to_le32(qxl_modes[i].bits);

+        modes->modes[i].stride      = cpu_to_le32(qxl_modes[i].stride);

+        modes->modes[i].x_mili      = cpu_to_le32(qxl_modes[i].x_mili);

+        modes->modes[i].y_mili      = cpu_to_le32(qxl_modes[i].y_mili);

+        modes->modes[i].orientation = cpu_to_le32(qxl_modes[i].orientation);

+    }

+    if (maxfb < VGA_RAM_SIZE && d->id == 0)

+        maxfb = VGA_RAM_SIZE;

+

+    ram_header_size    = ALIGN(sizeof(QXLRam), 4096);

+    surface0_area_size = ALIGN(maxfb, 4096);

+    num_pages          = d->vga.vram_size;

+    num_pages         -= ram_header_size;

+    num_pages         -= surface0_area_size;

+    num_pages          = num_pages / TARGET_PAGE_SIZE;

+

+    rom->draw_area_offset   = cpu_to_le32(0);

+    rom->surface0_area_size = cpu_to_le32(surface0_area_size);

+    rom->pages_offset       = cpu_to_le32(surface0_area_size);

+    rom->num_pages          = cpu_to_le32(num_pages);

+    rom->ram_header_offset  = cpu_to_le32(d->vga.vram_size - ram_header_size);

+

+    d->shadow_rom = *rom;

+    d->rom        = rom;

+    d->modes      = modes;

+}

+

+static void init_qxl_ram(PCIQXLDevice *d)

+{

+    uint8_t *buf;

+    uint64_t *item;

+

+    buf = d->vga.vram_ptr;

+    d->ram = (QXLRam *)(buf + le32_to_cpu(d->shadow_rom.ram_header_offset));

+    d->ram->magic       = cpu_to_le32(QXL_RAM_MAGIC);

+    d->ram->int_pending = cpu_to_le32(0);

+    d->ram->int_mask    = cpu_to_le32(0);

+    SPICE_RING_INIT(&d->ram->cmd_ring);

+    SPICE_RING_INIT(&d->ram->cursor_ring);

+    SPICE_RING_INIT(&d->ram->release_ring);

+    SPICE_RING_PROD_ITEM(&d->ram->release_ring, item);

+    *item = 0;

+    qxl_ring_set_dirty(d);

+}

+

+static void qxl_set_dirty(ram_addr_t addr, ram_addr_t end)

+{

+    while (addr < end) {

+        cpu_physical_memory_set_dirty(addr);

+        addr += TARGET_PAGE_SIZE;

+    }

+}

+

+static void qxl_rom_set_dirty(PCIQXLDevice *qxl)

+{

+    ram_addr_t addr = qxl->rom_offset;

+    qxl_set_dirty(addr, addr + qxl->rom_size);

+}

+

+static void qxl_ram_set_dirty(PCIQXLDevice *qxl, void *ptr)

+{

+    ram_addr_t addr = qxl->vga.vram_offset;

+    void *base = qxl->vga.vram_ptr;

+    intptr_t offset;

+

+    offset = ptr - base;

+    offset &= ~(TARGET_PAGE_SIZE-1);

+    assert(offset < qxl->vga.vram_size);

+    qxl_set_dirty(addr + offset, addr + offset + TARGET_PAGE_SIZE);

+}

+

+static void qxl_ring_set_dirty(PCIQXLDevice *qxl)

+{

+    ram_addr_t addr = qxl->vga.vram_offset + qxl->shadow_rom.ram_header_offset;

+    ram_addr_t end  = qxl->vga.vram_offset + qxl->vga.vram_size;

+    qxl_set_dirty(addr, end);

+}

+

+/*

+ * keep track of some command state, for savevm/loadvm.

+ */

+static void qxl_track_command(PCIQXLDevice *qxl, struct QXLCommandExt *ext)

+{

+    switch (le32_to_cpu(ext->cmd.type)) {

+    case QXL_CMD_SURFACE:

+    {

+        QXLSurfaceCmd *cmd = qxl_phys2virt(qxl, ext->cmd.data, ext->group_id);

+        uint32_t id = le32_to_cpu(cmd->surface_id);

+        PANIC_ON(id >= NUM_SURFACES);

+        if (cmd->type == QXL_SURFACE_CMD_CREATE) {

+            qxl->guest_surfaces.cmds[id] = ext->cmd.data;

+            qxl->guest_surfaces.count++;

+            if (qxl->guest_surfaces.max < qxl->guest_surfaces.count)

+                qxl->guest_surfaces.max = qxl->guest_surfaces.count;

+        }

+        if (cmd->type == QXL_SURFACE_CMD_DESTROY) {

+            qxl->guest_surfaces.cmds[id] = 0;

+            qxl->guest_surfaces.count--;

+        }

+        break;

+    }

+    case QXL_CMD_CURSOR:

+    {

+        QXLCursorCmd *cmd = qxl_phys2virt(qxl, ext->cmd.data, ext->group_id);

+        if (cmd->type == QXL_CURSOR_SET) {

+            qxl->guest_cursor = ext->cmd.data;

+        }

+        break;

+    }

+    }

+}

+

+/* spice display interface callbacks */

+

+static void interface_attach_worker(QXLInstance *sin, QXLWorker *qxl_worker)

+{

+    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);

+

+    dprintf(qxl, 1, "%s:\n", __FUNCTION__);

+    qxl->ssd.worker = qxl_worker;

+}

+

+static void interface_set_compression_level(QXLInstance *sin, int level)

+{

+    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);

+

+    dprintf(qxl, 1, "%s: %d\n", __FUNCTION__, level);

+    qxl->shadow_rom.compression_level = cpu_to_le32(level);

+    qxl->rom->compression_level = cpu_to_le32(level);

+    qxl_rom_set_dirty(qxl);

+}

+

+static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)

+{

+    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);

+

+    qxl->shadow_rom.mm_clock = cpu_to_le32(mm_time);

+    qxl->rom->mm_clock = cpu_to_le32(mm_time);

+    qxl_rom_set_dirty(qxl);

+}

+

+static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)

+{

+    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);

+

+    dprintf(qxl, 1, "%s:\n", __FUNCTION__);

+    info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;

+    info->memslot_id_bits = MEMSLOT_SLOT_BITS;

+    info->num_memslots = NUM_MEMSLOTS;

+    info->num_memslots_groups = NUM_MEMSLOTS_GROUPS;

+    info->internal_groupslot_id = 0;

+    info->qxl_ram_size = le32_to_cpu(qxl->shadow_rom.num_pages) << TARGET_PAGE_BITS;

+    info->n_surfaces = NUM_SURFACES;

+}

+

+static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)

+{

+    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);

+    SimpleSpiceUpdate *update;

+    QXLCommandRing *ring;

+    QXLCommand *cmd;

+    int notify;

+

+    switch (qxl->mode) {

+    case QXL_MODE_VGA:

+        dprintf(qxl, 2, "%s: vga\n", __FUNCTION__);

+        update = qemu_spice_create_update(&qxl->ssd);

+        if (update == NULL) {

+            return false;

+        }

+        *ext = update->ext;

+        qxl_log_command(qxl, "vga", ext);

+        return true;

+    case QXL_MODE_COMPAT:

+    case QXL_MODE_NATIVE:

+    case QXL_MODE_UNDEFINED:

+        dprintf(qxl, 2, "%s: %s\n", __FUNCTION__,

+                qxl->cmdflags ? "compat" : "native");

+        ring = &qxl->ram->cmd_ring;

+        if (SPICE_RING_IS_EMPTY(ring)) {

+            return false;

+        }

+        SPICE_RING_CONS_ITEM(ring, cmd);

+        ext->cmd      = *cmd;

+        ext->group_id = MEMSLOT_GROUP_GUEST;

+        ext->flags    = qxl->cmdflags;

+        SPICE_RING_POP(ring, notify);

+        qxl_ring_set_dirty(qxl);

+        if (notify) {

+            qxl_send_events(qxl, QXL_INTERRUPT_DISPLAY);

+        }

+        qxl->guest_primary.commands++;

+        qxl_track_command(qxl, ext);

+        qxl_log_command(qxl, "cmd", ext);

+        return true;

+    default:

+        return false;

+    }

+}

+

+static int interface_req_cmd_notification(QXLInstance *sin)

+{

+    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);

+    int wait = 1;

+

+    switch (qxl->mode) {

+    case QXL_MODE_COMPAT:

+    case QXL_MODE_NATIVE:

+    case QXL_MODE_UNDEFINED:

+        SPICE_RING_CONS_WAIT(&qxl->ram->cmd_ring, wait);

+        qxl_ring_set_dirty(qxl);

+        break;

+    default:

+        /* nothing */

+        break;

+    }

+    return wait;

+}

+