diff --git a/hw/qxl-logger.c b/hw/qxl-logger.c
index fe2878c..de66c19 100644
--- a/hw/qxl-logger.c
+++ b/hw/qxl-logger.c
@@ -100,7 +100,7 @@ static const char *qxl_v2n(const char *n[], size_t l, int v)
 }
 #define qxl_name(_list, _value) qxl_v2n(_list, ARRAY_SIZE(_list), _value)
 
-static int qxl_log_image(PCIQXLDevice *qxl, QXLPHYSICAL addr, int group_id)
+static int qxl_log_image(QXLDevice *qxl, QXLPHYSICAL addr, int group_id)
 {
     QXLImage *image;
     QXLImageDescriptor *desc;
@@ -134,7 +134,7 @@ static void qxl_log_rect(QXLRect *rect)
             rect->left, rect->top);
 }
 
-static int qxl_log_cmd_draw_copy(PCIQXLDevice *qxl, QXLCopy *copy,
+static int qxl_log_cmd_draw_copy(QXLDevice *qxl, QXLCopy *copy,
                                  int group_id)
 {
     int ret;
@@ -151,7 +151,7 @@ static int qxl_log_cmd_draw_copy(PCIQXLDevice *qxl, QXLCopy *copy,
     return 0;
 }
 
-static int qxl_log_cmd_draw(PCIQXLDevice *qxl, QXLDrawable *draw, int group_id)
+static int qxl_log_cmd_draw(QXLDevice *qxl, QXLDrawable *draw, int group_id)
 {
     fprintf(stderr, ": surface_id %d type %s effect %s",
             draw->surface_id,
@@ -165,7 +165,7 @@ static int qxl_log_cmd_draw(PCIQXLDevice *qxl, QXLDrawable *draw, int group_id)
     return 0;
 }
 
-static int qxl_log_cmd_draw_compat(PCIQXLDevice *qxl, QXLCompatDrawable *draw,
+static int qxl_log_cmd_draw_compat(QXLDevice *qxl, QXLCompatDrawable *draw,
                                    int group_id)
 {
     fprintf(stderr, ": type %s effect %s",
@@ -184,7 +184,7 @@ static int qxl_log_cmd_draw_compat(PCIQXLDevice *qxl, QXLCompatDrawable *draw,
     return 0;
 }
 
-static void qxl_log_cmd_surface(PCIQXLDevice *qxl, QXLSurfaceCmd *cmd)
+static void qxl_log_cmd_surface(QXLDevice *qxl, QXLSurfaceCmd *cmd)
 {
     fprintf(stderr, ": %s id %d",
             qxl_name(qxl_surface_cmd, cmd->type),
@@ -202,7 +202,7 @@ static void qxl_log_cmd_surface(PCIQXLDevice *qxl, QXLSurfaceCmd *cmd)
     }
 }
 
-int qxl_log_cmd_cursor(PCIQXLDevice *qxl, QXLCursorCmd *cmd, int group_id)
+int qxl_log_cmd_cursor(QXLDevice *qxl, QXLCursorCmd *cmd, int group_id)
 {
     QXLCursor *cursor;
 
@@ -233,13 +233,13 @@ int qxl_log_cmd_cursor(PCIQXLDevice *qxl, QXLCursorCmd *cmd, int group_id)
     return 0;
 }
 
-int qxl_log_command(PCIQXLDevice *qxl, const char *ring, QXLCommandExt *ext)
+int qxl_log_command(QXLDevice *qxl, const char *ring, QXLCommandExt *ext)
 {
     bool compat = ext->flags & QXL_COMMAND_FLAG_COMPAT;
     void *data;
     int ret;
 
-    if (!qxl->cmdlog) {
+    if (!qxl->pci.cmdlog) {
         return 0;
     }
     fprintf(stderr, "%" PRId64 " qxl-%d/%s:", qemu_get_clock_ns(vm_clock),
diff --git a/hw/qxl-render.c b/hw/qxl-render.c
index e2e3fe2..243ddb9 100644
--- a/hw/qxl-render.c
+++ b/hw/qxl-render.c
@@ -21,18 +21,18 @@
 
 #include "qxl.h"
 
-static void qxl_blit(PCIQXLDevice *qxl, QXLRect *rect)
+static void qxl_blit(QXLDevice *qxl, QXLRect *rect)
 {
     uint8_t *src;
-    uint8_t *dst = qxl->vga.ds->surface->data;
+    uint8_t *dst = qxl->pci.vga.ds->surface->data;
     int len, i;
 
-    if (is_buffer_shared(qxl->vga.ds->surface)) {
+    if (is_buffer_shared(qxl->pci.vga.ds->surface)) {
         return;
     }
     if (!qxl->guest_primary.data) {
         trace_qxl_render_blit_guest_primary_initialized();
-        qxl->guest_primary.data = memory_region_get_ram_ptr(&qxl->vga.vram);
+        qxl->guest_primary.data = memory_region_get_ram_ptr(&qxl->pci.vga.vram);
     }
     trace_qxl_render_blit(qxl->guest_primary.qxl_stride,
             rect->left, rect->right, rect->top, rect->bottom);
@@ -57,7 +57,7 @@ static void qxl_blit(PCIQXLDevice *qxl, QXLRect *rect)
     }
 }
 
-void qxl_render_resize(PCIQXLDevice *qxl)
+void qxl_render_resize(QXLDevice *qxl)
 {
     QXLSurfaceCreate *sc = &qxl->guest_primary.surface;
 
@@ -87,7 +87,7 @@ void qxl_render_resize(PCIQXLDevice *qxl)
     }
 }
 
-static void qxl_set_rect_to_surface(PCIQXLDevice *qxl, QXLRect *area)
+static void qxl_set_rect_to_surface(QXLDevice *qxl, QXLRect *area)
 {
     area->left   = 0;
     area->right  = qxl->guest_primary.surface.width;
@@ -95,15 +95,16 @@ static void qxl_set_rect_to_surface(PCIQXLDevice *qxl, QXLRect *area)
     area->bottom = qxl->guest_primary.surface.height;
 }
 
-static void qxl_render_update_area_unlocked(PCIQXLDevice *qxl)
+static void qxl_render_update_area_unlocked(QXLDevice *qxl)
 {
-    VGACommonState *vga = &qxl->vga;
+    VGACommonState *vga = &qxl->pci.vga;
     int i;
     DisplaySurface *surface = vga->ds->surface;
 
     if (qxl->guest_primary.resized) {
         qxl->guest_primary.resized = 0;
-        qxl->guest_primary.data = memory_region_get_ram_ptr(&qxl->vga.vram);
+        qxl->guest_primary.data =
+            memory_region_get_ram_ptr(&qxl->pci.vga.vram);
         qxl_set_rect_to_surface(qxl, &qxl->dirty[0]);
         qxl->num_dirty_rects = 1;
         trace_qxl_render_guest_primary_resized(
@@ -148,7 +149,7 @@ static void qxl_render_update_area_unlocked(PCIQXLDevice *qxl)
  * callbacks are called by spice_server thread, defering to bh called from the
  * io thread.
  */
-void qxl_render_update(PCIQXLDevice *qxl)
+void qxl_render_update(QXLDevice *qxl)
 {
     QXLCookie *cookie;
 
@@ -172,14 +173,14 @@ void qxl_render_update(PCIQXLDevice *qxl)
 
 void qxl_render_update_area_bh(void *opaque)
 {
-    PCIQXLDevice *qxl = opaque;
+    QXLDevice *qxl = opaque;
 
     qemu_mutex_lock(&qxl->ssd.lock);
     qxl_render_update_area_unlocked(qxl);
     qemu_mutex_unlock(&qxl->ssd.lock);
 }
 
-void qxl_render_update_area_done(PCIQXLDevice *qxl, QXLCookie *cookie)
+void qxl_render_update_area_done(QXLDevice *qxl, QXLCookie *cookie)
 {
     qemu_mutex_lock(&qxl->ssd.lock);
     trace_qxl_render_update_area_done(cookie);
@@ -189,7 +190,7 @@ void qxl_render_update_area_done(PCIQXLDevice *qxl, QXLCookie *cookie)
     g_free(cookie);
 }
 
-static QEMUCursor *qxl_cursor(PCIQXLDevice *qxl, QXLCursor *cursor)
+static QEMUCursor *qxl_cursor(QXLDevice *qxl, QXLCursor *cursor)
 {
     QEMUCursor *c;
     uint8_t *image, *mask;
@@ -228,7 +229,7 @@ fail:
 
 
 /* called from spice server thread context only */
-int qxl_render_cursor(PCIQXLDevice *qxl, QXLCommandExt *ext)
+int qxl_render_cursor(QXLDevice *qxl, QXLCommandExt *ext)
 {
     QXLCursorCmd *cmd = qxl_phys2virt(qxl, ext->cmd.data, ext->group_id);
     QXLCursor *cursor;
diff --git a/hw/qxl.c b/hw/qxl.c
index c2dd3b4..c8a36aa 100644
--- a/hw/qxl.c
+++ b/hw/qxl.c
@@ -126,19 +126,19 @@ static QXLMode qxl_modes[] = {
     QXL_MODE_EX(3200, 2400),
 };
 
-static PCIQXLDevice *qxl0;
+static QXLDevice *qxl0;
 
-static void qxl_send_events(PCIQXLDevice *d, uint32_t events);
-static int qxl_destroy_primary(PCIQXLDevice *d, qxl_async_io async);
-static void qxl_reset_memslots(PCIQXLDevice *d);
-static void qxl_reset_surfaces(PCIQXLDevice *d);
-static void qxl_ring_set_dirty(PCIQXLDevice *qxl);
+static void qxl_send_events(QXLDevice *d, uint32_t events);
+static int qxl_destroy_primary(QXLDevice *d, qxl_async_io async);
+static void qxl_reset_memslots(QXLDevice *d);
+static void qxl_reset_surfaces(QXLDevice *d);
+static void qxl_ring_set_dirty(QXLDevice *qxl);
 
-void qxl_set_guest_bug(PCIQXLDevice *qxl, const char *msg, ...)
+void qxl_set_guest_bug(QXLDevice *qxl, const char *msg, ...)
 {
     qxl_send_events(qxl, QXL_INTERRUPT_ERROR);
-    qxl->guest_bug = 1;
-    if (qxl->guestdebug) {
+    qxl->pci.guest_bug = 1;
+    if (qxl->pci.guestdebug) {
         va_list ap;
         va_start(ap, msg);
         fprintf(stderr, "qxl-%d: guest bug: ", qxl->id);
@@ -148,12 +148,12 @@ void qxl_set_guest_bug(PCIQXLDevice *qxl, const char *msg, ...)
     }
 }
 
-static void qxl_clear_guest_bug(PCIQXLDevice *qxl)
+static void qxl_clear_guest_bug(QXLDevice *qxl)
 {
-    qxl->guest_bug = 0;
+    qxl->pci.guest_bug = 0;
 }
 
-void qxl_spice_update_area(PCIQXLDevice *qxl, uint32_t surface_id,
+void qxl_spice_update_area(QXLDevice *qxl, uint32_t surface_id,
                            struct QXLRect *area, struct QXLRect *dirty_rects,
                            uint32_t num_dirty_rects,
                            uint32_t clear_dirty_region,
@@ -173,7 +173,7 @@ void qxl_spice_update_area(PCIQXLDevice *qxl, uint32_t surface_id,
     }
 }
 
-static void qxl_spice_destroy_surface_wait_complete(PCIQXLDevice *qxl,
+static void qxl_spice_destroy_surface_wait_complete(QXLDevice *qxl,
                                                     uint32_t id)
 {
     trace_qxl_spice_destroy_surface_wait_complete(qxl->id, id);
@@ -183,7 +183,7 @@ static void qxl_spice_destroy_surface_wait_complete(PCIQXLDevice *qxl,
     qemu_mutex_unlock(&qxl->track_lock);
 }
 
-static void qxl_spice_destroy_surface_wait(PCIQXLDevice *qxl, uint32_t id,
+static void qxl_spice_destroy_surface_wait(QXLDevice *qxl, uint32_t id,
                                            qxl_async_io async)
 {
     QXLCookie *cookie;
@@ -199,7 +199,7 @@ static void qxl_spice_destroy_surface_wait(PCIQXLDevice *qxl, uint32_t id,
     }
 }
 
-static void qxl_spice_flush_surfaces_async(PCIQXLDevice *qxl)
+static void qxl_spice_flush_surfaces_async(QXLDevice *qxl)
 {
     trace_qxl_spice_flush_surfaces_async(qxl->id, qxl->guest_surfaces.count,
                                          qxl->num_free_res);
@@ -208,26 +208,26 @@ static void qxl_spice_flush_surfaces_async(PCIQXLDevice *qxl)
                                   QXL_IO_FLUSH_SURFACES_ASYNC));
 }
 
-void qxl_spice_loadvm_commands(PCIQXLDevice *qxl, struct QXLCommandExt *ext,
+void qxl_spice_loadvm_commands(QXLDevice *qxl, struct QXLCommandExt *ext,
                                uint32_t count)
 {
     trace_qxl_spice_loadvm_commands(qxl->id, ext, count);
     qxl->ssd.worker->loadvm_commands(qxl->ssd.worker, ext, count);
 }
 
-void qxl_spice_oom(PCIQXLDevice *qxl)
+void qxl_spice_oom(QXLDevice *qxl)
 {
     trace_qxl_spice_oom(qxl->id);
     qxl->ssd.worker->oom(qxl->ssd.worker);
 }
 
-void qxl_spice_reset_memslots(PCIQXLDevice *qxl)
+void qxl_spice_reset_memslots(QXLDevice *qxl)
 {
     trace_qxl_spice_reset_memslots(qxl->id);
     qxl->ssd.worker->reset_memslots(qxl->ssd.worker);
 }
 
-static void qxl_spice_destroy_surfaces_complete(PCIQXLDevice *qxl)
+static void qxl_spice_destroy_surfaces_complete(QXLDevice *qxl)
 {
     trace_qxl_spice_destroy_surfaces_complete(qxl->id);
     qemu_mutex_lock(&qxl->track_lock);
@@ -236,7 +236,7 @@ static void qxl_spice_destroy_surfaces_complete(PCIQXLDevice *qxl)
     qemu_mutex_unlock(&qxl->track_lock);
 }
 
-static void qxl_spice_destroy_surfaces(PCIQXLDevice *qxl, qxl_async_io async)
+static void qxl_spice_destroy_surfaces(QXLDevice *qxl, qxl_async_io async)
 {
     trace_qxl_spice_destroy_surfaces(qxl->id, async);
     if (async) {
@@ -249,13 +249,13 @@ static void qxl_spice_destroy_surfaces(PCIQXLDevice *qxl, qxl_async_io async)
     }
 }
 
-void qxl_spice_reset_image_cache(PCIQXLDevice *qxl)
+void qxl_spice_reset_image_cache(QXLDevice *qxl)
 {
     trace_qxl_spice_reset_image_cache(qxl->id);
     qxl->ssd.worker->reset_image_cache(qxl->ssd.worker);
 }
 
-void qxl_spice_reset_cursor(PCIQXLDevice *qxl)
+void qxl_spice_reset_cursor(QXLDevice *qxl)
 {
     trace_qxl_spice_reset_cursor(qxl->id);
     qxl->ssd.worker->reset_cursor(qxl->ssd.worker);
@@ -286,9 +286,10 @@ static ram_addr_t qxl_rom_size(void)
     return rom_size;
 }
 
-static void init_qxl_rom(PCIQXLDevice *d)
+static void init_qxl_rom(QXLDevice *d)
 {
-    QXLRom *rom = memory_region_get_ram_ptr(&d->rom_bar);
+    QXLRom *rom;
+    rom = memory_region_get_ram_ptr(&d->pci.rom_bar);
     QXLModes *modes = (QXLModes *)(rom + 1);
     uint32_t ram_header_size;
     uint32_t surface0_area_size;
@@ -296,11 +297,11 @@ static void init_qxl_rom(PCIQXLDevice *d)
     uint32_t fb;
     int i, n;
 
-    memset(rom, 0, d->rom_size);
+    memset(rom, 0, d->pci.rom_size);
 
     rom->magic         = cpu_to_le32(QXL_ROM_MAGIC);
     rom->id            = cpu_to_le32(d->id);
-    rom->log_level     = cpu_to_le32(d->guestdebug);
+    rom->log_level     = cpu_to_le32(d->pci.guestdebug);
     rom->modes_offset  = cpu_to_le32(sizeof(QXLRom));
 
     rom->slot_gen_bits = MEMSLOT_GENERATION_BITS;
@@ -311,7 +312,7 @@ static void init_qxl_rom(PCIQXLDevice *d)
 
     for (i = 0, n = 0; i < ARRAY_SIZE(qxl_modes); i++) {
         fb = qxl_modes[i].y_res * qxl_modes[i].stride;
-        if (fb > d->vgamem_size) {
+        if (fb > d->pci.vgamem_size) {
             continue;
         }
         modes->modes[n].id          = cpu_to_le32(i);
@@ -327,8 +328,8 @@ static void init_qxl_rom(PCIQXLDevice *d)
     modes->n_modes     = cpu_to_le32(n);
 
     ram_header_size    = ALIGN(sizeof(QXLRam), 4096);
-    surface0_area_size = ALIGN(d->vgamem_size, 4096);
-    num_pages          = d->vga.vram_size;
+    surface0_area_size = ALIGN(d->pci.vgamem_size, 4096);
+    num_pages          = d->pci.vga.vram_size;
     num_pages         -= ram_header_size;
     num_pages         -= surface0_area_size;
     num_pages          = num_pages / TARGET_PAGE_SIZE;
@@ -337,19 +338,19 @@ static void init_qxl_rom(PCIQXLDevice *d)
     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);
+    rom->ram_header_offset  = cpu_to_le32(d->pci.vga.vram_size - ram_header_size);
 
     d->shadow_rom = *rom;
     d->rom        = rom;
     d->modes      = modes;
 }
 
-static void init_qxl_ram(PCIQXLDevice *d)
+static void init_qxl_ram(QXLDevice *d)
 {
     uint8_t *buf;
     uint64_t *item;
 
-    buf = d->vga.vram_ptr;
+    buf = d->pci.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);
@@ -370,36 +371,36 @@ static void qxl_set_dirty(MemoryRegion *mr, ram_addr_t addr, ram_addr_t end)
     memory_region_set_dirty(mr, addr, end - addr);
 }
 
-static void qxl_rom_set_dirty(PCIQXLDevice *qxl)
+static void qxl_rom_set_dirty(QXLDevice *qxl)
 {
-    qxl_set_dirty(&qxl->rom_bar, 0, qxl->rom_size);
+    qxl_set_dirty(&qxl->pci.rom_bar, 0, qxl->pci.rom_size);
 }
 
 /* called from spice server thread context only */
-static void qxl_ram_set_dirty(PCIQXLDevice *qxl, void *ptr)
+static void qxl_ram_set_dirty(QXLDevice *qxl, void *ptr)
 {
-    void *base = qxl->vga.vram_ptr;
+    void *base = qxl->pci.vga.vram_ptr;
     intptr_t offset;
 
     offset = ptr - base;
     offset &= ~(TARGET_PAGE_SIZE-1);
-    assert(offset < qxl->vga.vram_size);
-    qxl_set_dirty(&qxl->vga.vram, offset, offset + TARGET_PAGE_SIZE);
+    assert(offset < qxl->pci.vga.vram_size);
+    qxl_set_dirty(&qxl->pci.vga.vram, offset, offset + TARGET_PAGE_SIZE);
 }
 
 /* can be called from spice server thread context */
-static void qxl_ring_set_dirty(PCIQXLDevice *qxl)
+static void qxl_ring_set_dirty(QXLDevice *qxl)
 {
     ram_addr_t addr = qxl->shadow_rom.ram_header_offset;
-    ram_addr_t end  = qxl->vga.vram_size;
-    qxl_set_dirty(&qxl->vga.vram, addr, end);
+    ram_addr_t end  = qxl->pci.vga.vram_size;
+    qxl_set_dirty(&qxl->pci.vga.vram, addr, end);
 }
 
 /*
  * keep track of some command state, for savevm/loadvm.
  * called from spice server thread context only
  */
-static int qxl_track_command(PCIQXLDevice *qxl, struct QXLCommandExt *ext)
+static int qxl_track_command(QXLDevice *qxl, struct QXLCommandExt *ext)
 {
     switch (le32_to_cpu(ext->cmd.type)) {
     case QXL_CMD_SURFACE:
@@ -452,35 +453,35 @@ static int qxl_track_command(PCIQXLDevice *qxl, struct QXLCommandExt *ext)
 
 static void interface_attach_worker(QXLInstance *sin, QXLWorker *qxl_worker)
 {
-    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
+    QXLDevice *qxl = container_of(sin, QXLDevice, ssd.qxl);
 
-    trace_qxl_interface_attach_worker(qxl->id);
     qxl->ssd.worker = qxl_worker;
+    trace_qxl_interface_attach_worker(qxl->id);
 }
 
 static void interface_set_compression_level(QXLInstance *sin, int level)
 {
-    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
+    QXLDevice *qxl = container_of(sin, QXLDevice, ssd.qxl);
 
     trace_qxl_interface_set_compression_level(qxl->id, level);
     qxl->shadow_rom.compression_level = cpu_to_le32(level);
-    qxl->rom->compression_level = cpu_to_le32(level);
     qxl_rom_set_dirty(qxl);
+    qxl->rom->compression_level = cpu_to_le32(level);
 }
 
 static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)
 {
-    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
+    QXLDevice *qxl = container_of(sin, QXLDevice, ssd.qxl);
 
     trace_qxl_interface_set_mm_time(qxl->id, mm_time);
     qxl->shadow_rom.mm_clock = cpu_to_le32(mm_time);
-    qxl->rom->mm_clock = cpu_to_le32(mm_time);
     qxl_rom_set_dirty(qxl);
+    qxl->rom->mm_clock = cpu_to_le32(mm_time);
 }
 
 static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)
 {
-    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
+    QXLDevice *qxl = container_of(sin, QXLDevice, ssd.qxl);
 
     trace_qxl_interface_get_init_info(qxl->id);
     info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;
@@ -542,18 +543,17 @@ static const char *io_port_to_string(uint32_t io_port)
     return io_port_to_string[io_port];
 }
 
-/* called from spice server thread context only */
 static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)
 {
-    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
+    QXLDevice *qxl = container_of(sin, QXLDevice, ssd.qxl);
     SimpleSpiceUpdate *update;
     QXLCommandRing *ring;
     QXLCommand *cmd;
     int notify, ret;
 
-    trace_qxl_ring_command_check(qxl->id, qxl_mode_to_string(qxl->mode));
+    trace_qxl_ring_command_check(qxl->id, qxl_mode_to_string(qxl->pci.mode));
 
-    switch (qxl->mode) {
+    switch (qxl->pci.mode) {
     case QXL_MODE_VGA:
         ret = false;
         qemu_mutex_lock(&qxl->ssd.lock);
@@ -565,7 +565,7 @@ static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)
         }
         qemu_mutex_unlock(&qxl->ssd.lock);
         if (ret) {
-            trace_qxl_ring_command_get(qxl->id, qxl_mode_to_string(qxl->mode));
+            trace_qxl_ring_command_get(qxl->id, qxl_mode_to_string(qxl->pci.mode));
             qxl_log_command(qxl, "vga", ext);
         }
         return ret;
@@ -573,7 +573,7 @@ static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)
     case QXL_MODE_NATIVE:
     case QXL_MODE_UNDEFINED:
         ring = &qxl->ram->cmd_ring;
-        if (qxl->guest_bug || SPICE_RING_IS_EMPTY(ring)) {
+        if (qxl->pci.guest_bug || SPICE_RING_IS_EMPTY(ring)) {
             return false;
         }
         SPICE_RING_CONS_ITEM(qxl, ring, cmd);
@@ -591,7 +591,7 @@ static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)
         qxl->guest_primary.commands++;
         qxl_track_command(qxl, ext);
         qxl_log_command(qxl, "cmd", ext);
-        trace_qxl_ring_command_get(qxl->id, qxl_mode_to_string(qxl->mode));
+        trace_qxl_ring_command_get(qxl->id, qxl_mode_to_string(qxl->pci.mode));
         return true;
     default:
         return false;
@@ -601,11 +601,11 @@ static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)
 /* called from spice server thread context only */
 static int interface_req_cmd_notification(QXLInstance *sin)
 {
-    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
+    QXLDevice *qxl = container_of(sin, QXLDevice, ssd.qxl);
     int wait = 1;
 
     trace_qxl_ring_command_req_notification(qxl->id);
-    switch (qxl->mode) {
+    switch (qxl->pci.mode) {
     case QXL_MODE_COMPAT:
     case QXL_MODE_NATIVE:
     case QXL_MODE_UNDEFINED:
@@ -620,7 +620,7 @@ static int interface_req_cmd_notification(QXLInstance *sin)
 }
 
 /* called from spice server thread context only */
-static inline void qxl_push_free_res(PCIQXLDevice *d, int flush)
+static inline void qxl_push_free_res(QXLDevice *d, int flush)
 {
     QXLReleaseRing *ring = &d->ram->release_ring;
     uint64_t *item;
@@ -642,7 +642,7 @@ static inline void qxl_push_free_res(PCIQXLDevice *d, int flush)
     }
 
     SPICE_RING_PUSH(ring, notify);
-    trace_qxl_ring_res_push(d->id, qxl_mode_to_string(d->mode),
+    trace_qxl_ring_res_push(d->id, qxl_mode_to_string(d->pci.mode),
            d->guest_surfaces.count, d->num_free_res,
            d->last_release, notify ? "yes" : "no");
     trace_qxl_ring_res_push_rest(d->id, ring->prod - ring->cons,
@@ -664,7 +664,7 @@ static inline void qxl_push_free_res(PCIQXLDevice *d, int flush)
 static void interface_release_resource(QXLInstance *sin,
                                        struct QXLReleaseInfoExt ext)
 {
-    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
+    QXLDevice *qxl = container_of(sin, QXLDevice, ssd.qxl);
     QXLReleaseRing *ring;
     uint64_t *item, id;
 
@@ -693,8 +693,8 @@ static void interface_release_resource(QXLInstance *sin,
     } else {
         /* append item to the list */
         qxl->last_release->next = ext.info->id;
-        qxl_ram_set_dirty(qxl, &qxl->last_release->next);
         ext.info->next = 0;
+        qxl_ram_set_dirty(qxl, &qxl->last_release->next);
         qxl_ram_set_dirty(qxl, &ext.info->next);
     }
     qxl->last_release = ext.info;
@@ -706,14 +706,14 @@ static void interface_release_resource(QXLInstance *sin,
 /* called from spice server thread context only */
 static int interface_get_cursor_command(QXLInstance *sin, struct QXLCommandExt *ext)
 {
-    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
+    QXLDevice *qxl = container_of(sin, QXLDevice, ssd.qxl);
     QXLCursorRing *ring;
     QXLCommand *cmd;
     int notify;
 
-    trace_qxl_ring_cursor_check(qxl->id, qxl_mode_to_string(qxl->mode));
+    trace_qxl_ring_cursor_check(qxl->id, qxl_mode_to_string(qxl->pci.mode));
 
-    switch (qxl->mode) {
+    switch (qxl->pci.mode) {
     case QXL_MODE_COMPAT:
     case QXL_MODE_NATIVE:
     case QXL_MODE_UNDEFINED:
@@ -739,7 +739,7 @@ static int interface_get_cursor_command(QXLInstance *sin, struct QXLCommandExt *
         if (qxl->id == 0) {
             qxl_render_cursor(qxl, ext);
         }
-        trace_qxl_ring_cursor_get(qxl->id, qxl_mode_to_string(qxl->mode));
+        trace_qxl_ring_cursor_get(qxl->id, qxl_mode_to_string(qxl->pci.mode));
         return true;
     default:
         return false;
@@ -749,11 +749,11 @@ static int interface_get_cursor_command(QXLInstance *sin, struct QXLCommandExt *
 /* called from spice server thread context only */
 static int interface_req_cursor_notification(QXLInstance *sin)
 {
-    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
+    QXLDevice *qxl = container_of(sin, QXLDevice, ssd.qxl);
     int wait = 1;
 
     trace_qxl_ring_cursor_req_notification(qxl->id);
-    switch (qxl->mode) {
+    switch (qxl->pci.mode) {
     case QXL_MODE_COMPAT:
     case QXL_MODE_NATIVE:
     case QXL_MODE_UNDEFINED:
@@ -782,7 +782,7 @@ static void interface_notify_update(QXLInstance *sin, uint32_t update_id)
 /* called from spice server thread context only */
 static int interface_flush_resources(QXLInstance *sin)
 {
-    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
+    QXLDevice *qxl = container_of(sin, QXLDevice, ssd.qxl);
     int ret;
 
     ret = qxl->num_free_res;
@@ -792,10 +792,10 @@ static int interface_flush_resources(QXLInstance *sin)
     return ret;
 }
 
-static void qxl_create_guest_primary_complete(PCIQXLDevice *d);
+static void qxl_create_guest_primary_complete(QXLDevice *d);
 
 /* called from spice server thread context only */
-static void interface_async_complete_io(PCIQXLDevice *qxl, QXLCookie *cookie)
+static void interface_async_complete_io(QXLDevice *qxl, QXLCookie *cookie)
 {
     uint32_t current_async;
 
@@ -841,7 +841,7 @@ static void interface_update_area_complete(QXLInstance *sin,
         uint32_t surface_id,
         QXLRect *dirty, uint32_t num_updated_rects)
 {
-    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
+    QXLDevice *qxl = container_of(sin, QXLDevice, ssd.qxl);
     int i;
     int qxl_i;
 
@@ -883,7 +883,7 @@ static void interface_update_area_complete(QXLInstance *sin,
 /* called from spice server thread context only */
 static void interface_async_complete(QXLInstance *sin, uint64_t cookie_token)
 {
-    PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
+    QXLDevice *qxl = container_of(sin, QXLDevice, ssd.qxl);
     QXLCookie *cookie = (QXLCookie *)(uintptr_t)cookie_token;
 
     switch (cookie->type) {
@@ -924,38 +924,38 @@ static const QXLInterface qxl_interface = {
     .update_area_complete    = interface_update_area_complete,
 };
 
-static void qxl_enter_vga_mode(PCIQXLDevice *d)
+static void qxl_enter_vga_mode(QXLDevice *d)
 {
-    if (d->mode == QXL_MODE_VGA) {
+    if (d->pci.mode == QXL_MODE_VGA) {
         return;
     }
     trace_qxl_enter_vga_mode(d->id);
     qemu_spice_create_host_primary(&d->ssd);
-    d->mode = QXL_MODE_VGA;
+    d->pci.mode = QXL_MODE_VGA;
     memset(&d->ssd.dirty, 0, sizeof(d->ssd.dirty));
-    vga_dirty_log_start(&d->vga);
+    vga_dirty_log_start(&d->pci.vga);
 }
 
-static void qxl_exit_vga_mode(PCIQXLDevice *d)
+static void qxl_exit_vga_mode(QXLDevice *d)
 {
-    if (d->mode != QXL_MODE_VGA) {
+    if (d->pci.mode != QXL_MODE_VGA) {
         return;
     }
     trace_qxl_exit_vga_mode(d->id);
-    vga_dirty_log_stop(&d->vga);
+    vga_dirty_log_stop(&d->pci.vga);
     qxl_destroy_primary(d, QXL_SYNC);
 }
 
-static void qxl_update_irq(PCIQXLDevice *d)
+static void qxl_update_irq(QXLDevice *d)
 {
     uint32_t pending = le32_to_cpu(d->ram->int_pending);
     uint32_t mask    = le32_to_cpu(d->ram->int_mask);
     int level = !!(pending & mask);
-    qemu_set_irq(d->pci.irq[0], level);
+    qemu_set_irq(d->pci.pci.irq[0], level);
     qxl_ring_set_dirty(d);
 }
 
-static void qxl_check_state(PCIQXLDevice *d)
+static void qxl_check_state(QXLDevice *d)
 {
     QXLRam *ram = d->ram;
 
@@ -963,7 +963,7 @@ static void qxl_check_state(PCIQXLDevice *d)
     assert(!d->ssd.running || SPICE_RING_IS_EMPTY(&ram->cursor_ring));
 }
 
-static void qxl_reset_state(PCIQXLDevice *d)
+static void qxl_reset_state(QXLDevice *d)
 {
     QXLRom *rom = d->rom;
 
@@ -977,7 +977,7 @@ static void qxl_reset_state(PCIQXLDevice *d)
     memset(&d->ssd.dirty, 0, sizeof(d->ssd.dirty));
 }
 
-static void qxl_soft_reset(PCIQXLDevice *d)
+static void qxl_soft_reset(QXLDevice *d)
 {
     trace_qxl_soft_reset(d->id);
     qxl_check_state(d);
@@ -987,11 +987,11 @@ static void qxl_soft_reset(PCIQXLDevice *d)
     if (d->id == 0) {
         qxl_enter_vga_mode(d);
     } else {
-        d->mode = QXL_MODE_UNDEFINED;
+        d->pci.mode = QXL_MODE_UNDEFINED;
     }
 }
 
-static void qxl_hard_reset(PCIQXLDevice *d, int loadvm)
+static void qxl_hard_reset(QXLDevice *d, int loadvm)
 {
     trace_qxl_hard_reset(d->id, loadvm);
 
@@ -1012,7 +1012,7 @@ static void qxl_hard_reset(PCIQXLDevice *d, int loadvm)
 
 static void qxl_reset_handler(DeviceState *dev)
 {
-    PCIQXLDevice *d = DO_UPCAST(PCIQXLDevice, pci.qdev, dev);
+    QXLDevice *d = (QXLDevice *) DO_UPCAST(PCIQXLDevice, pci.qdev, dev);
 
     qxl_hard_reset(d, 0);
 }
@@ -1020,10 +1020,10 @@ static void qxl_reset_handler(DeviceState *dev)
 static void qxl_vga_ioport_write(void *opaque, uint32_t addr, uint32_t val)
 {
     VGACommonState *vga = opaque;
-    PCIQXLDevice *qxl = container_of(vga, PCIQXLDevice, vga);
+    QXLDevice *qxl = (QXLDevice *) container_of(vga, PCIQXLDevice, vga);
 
-    trace_qxl_io_write_vga(qxl->id, qxl_mode_to_string(qxl->mode), addr, val);
-    if (qxl->mode != QXL_MODE_VGA) {
+    trace_qxl_io_write_vga(qxl->id, qxl_mode_to_string(qxl->pci.mode), addr, val);
+    if (qxl->pci.mode != QXL_MODE_VGA) {
         qxl_destroy_primary(qxl, QXL_SYNC);
         qxl_soft_reset(qxl);
     }
@@ -1044,7 +1044,7 @@ static const MemoryRegionPortio qxl_vga_portio_list[] = {
     PORTIO_END_OF_LIST(),
 };
 
-static int qxl_add_memslot(PCIQXLDevice *d, uint32_t slot_id, uint64_t delta,
+static int qxl_add_memslot(QXLDevice *d, uint32_t slot_id, uint64_t delta,
                            qxl_async_io async)
 {
     static const int regions[] = {
@@ -1079,8 +1079,8 @@ static int qxl_add_memslot(PCIQXLDevice *d, uint32_t slot_id, uint64_t delta,
 
     for (i = 0; i < ARRAY_SIZE(regions); i++) {
         pci_region = regions[i];
-        pci_start = d->pci.io_regions[pci_region].addr;
-        pci_end = pci_start + d->pci.io_regions[pci_region].size;
+        pci_start = d->pci.pci.io_regions[pci_region].addr;
+        pci_end = pci_start + d->pci.pci.io_regions[pci_region].size;
         /* mapped? */
         if (pci_start == -1) {
             continue;
@@ -1103,11 +1103,11 @@ static int qxl_add_memslot(PCIQXLDevice *d, uint32_t slot_id, uint64_t delta,
 
     switch (pci_region) {
     case QXL_RAM_RANGE_INDEX:
-        virt_start = (intptr_t)memory_region_get_ram_ptr(&d->vga.vram);
+        virt_start = (intptr_t)memory_region_get_ram_ptr(&d->pci.vga.vram);
         break;
     case QXL_VRAM_RANGE_INDEX:
     case 4 /* vram 64bit */:
-        virt_start = (intptr_t)memory_region_get_ram_ptr(&d->vram_bar);
+        virt_start = (intptr_t)memory_region_get_ram_ptr(&d->pci.vram_bar);
         break;
     default:
         /* should not happen */
@@ -1131,27 +1131,27 @@ static int qxl_add_memslot(PCIQXLDevice *d, uint32_t slot_id, uint64_t delta,
     return 0;
 }
 
-static void qxl_del_memslot(PCIQXLDevice *d, uint32_t slot_id)
+static void qxl_del_memslot(QXLDevice *d, uint32_t slot_id)
 {
     qemu_spice_del_memslot(&d->ssd, MEMSLOT_GROUP_HOST, slot_id);
     d->guest_slots[slot_id].active = 0;
 }
 
-static void qxl_reset_memslots(PCIQXLDevice *d)
+static void qxl_reset_memslots(QXLDevice *d)
 {
     qxl_spice_reset_memslots(d);
     memset(&d->guest_slots, 0, sizeof(d->guest_slots));
 }
 
-static void qxl_reset_surfaces(PCIQXLDevice *d)
+static void qxl_reset_surfaces(QXLDevice *d)
 {
     trace_qxl_reset_surfaces(d->id);
-    d->mode = QXL_MODE_UNDEFINED;
+    d->pci.mode = QXL_MODE_UNDEFINED;
     qxl_spice_destroy_surfaces(d, QXL_SYNC);
 }
 
 /* can be also called from spice server thread context */
-void *qxl_phys2virt(PCIQXLDevice *qxl, QXLPHYSICAL pqxl, int group_id)
+void *qxl_phys2virt(QXLDevice *qxl, QXLPHYSICAL pqxl, int group_id)
 {
     uint64_t phys   = le64_to_cpu(pqxl);
     uint32_t slot   = (phys >> (64 -  8)) & 0xff;
@@ -1188,13 +1188,13 @@ void *qxl_phys2virt(PCIQXLDevice *qxl, QXLPHYSICAL pqxl, int group_id)
     return NULL;
 }
 
-static void qxl_create_guest_primary_complete(PCIQXLDevice *qxl)
+static void qxl_create_guest_primary_complete(QXLDevice *qxl)
 {
     /* for local rendering */
     qxl_render_resize(qxl);
 }
 
-static void qxl_create_guest_primary(PCIQXLDevice *qxl, int loadvm,
+static void qxl_create_guest_primary(QXLDevice *qxl, int loadvm,
                                      qxl_async_io async)
 {
     QXLDevSurfaceCreate surface;
@@ -1204,13 +1204,13 @@ static void qxl_create_guest_primary(PCIQXLDevice *qxl, int loadvm,
     int requested_stride = le32_to_cpu(sc->stride);
 
     size = abs(requested_stride) * requested_height;
-    if (size > qxl->vgamem_size) {
+    if (size > qxl->pci.vgamem_size) {
         qxl_set_guest_bug(qxl, "%s: requested primary larger then framebuffer"
                                " size", __func__);
         return;
     }
 
-    if (qxl->mode == QXL_MODE_NATIVE) {
+    if (qxl->pci.mode == QXL_MODE_NATIVE) {
         qxl_set_guest_bug(qxl, "%s: nop since already in QXL_MODE_NATIVE",
                       __func__);
     }
@@ -1235,7 +1235,7 @@ static void qxl_create_guest_primary(PCIQXLDevice *qxl, int loadvm,
         surface.flags |= QXL_SURF_FLAG_KEEP_DATA;
     }
 
-    qxl->mode = QXL_MODE_NATIVE;
+    qxl->pci.mode = QXL_MODE_NATIVE;
     qxl->cmdflags = 0;
     qemu_spice_create_primary_surface(&qxl->ssd, 0, &surface, async);
 
@@ -1246,24 +1246,24 @@ static void qxl_create_guest_primary(PCIQXLDevice *qxl, int loadvm,
 
 /* return 1 if surface destoy was initiated (in QXL_ASYNC case) or
  * done (in QXL_SYNC case), 0 otherwise. */
-static int qxl_destroy_primary(PCIQXLDevice *d, qxl_async_io async)
+static int qxl_destroy_primary(QXLDevice *d, qxl_async_io async)
 {
-    if (d->mode == QXL_MODE_UNDEFINED) {
+    if (d->pci.mode == QXL_MODE_UNDEFINED) {
         return 0;
     }
     trace_qxl_destroy_primary(d->id);
-    d->mode = QXL_MODE_UNDEFINED;
+    d->pci.mode = QXL_MODE_UNDEFINED;
     qemu_spice_destroy_primary_surface(&d->ssd, 0, async);
     qxl_spice_reset_cursor(d);
     return 1;
 }
 
-static void qxl_set_mode(PCIQXLDevice *d, int modenr, int loadvm)
+static void qxl_set_mode(QXLDevice *d, int modenr, int loadvm)
 {
-    pcibus_t start = d->pci.io_regions[QXL_RAM_RANGE_INDEX].addr;
-    pcibus_t end   = d->pci.io_regions[QXL_RAM_RANGE_INDEX].size + start;
+    pcibus_t start = d->pci.pci.io_regions[QXL_RAM_RANGE_INDEX].addr;
+    pcibus_t end   = d->pci.pci.io_regions[QXL_RAM_RANGE_INDEX].size + start;
     QXLMode *mode = d->modes->modes + modenr;
-    uint64_t devmem = d->pci.io_regions[QXL_RAM_RANGE_INDEX].addr;
+    uint64_t devmem = d->pci.pci.io_regions[QXL_RAM_RANGE_INDEX].addr;
     QXLMemSlot slot = {
         .mem_start = start,
         .mem_end = end
@@ -1290,7 +1290,7 @@ static void qxl_set_mode(PCIQXLDevice *d, int modenr, int loadvm)
     d->guest_primary.surface = surface;
     qxl_create_guest_primary(d, 0, QXL_SYNC);
 
-    d->mode = QXL_MODE_COMPAT;
+    d->pci.mode = QXL_MODE_COMPAT;
     d->cmdflags = QXL_COMMAND_FLAG_COMPAT;
 #ifdef QXL_COMMAND_FLAG_COMPAT_16BPP /* new in spice 0.6.1 */
     if (mode->bits == 16) {
@@ -1305,12 +1305,12 @@ static void qxl_set_mode(PCIQXLDevice *d, int modenr, int loadvm)
 static void ioport_write(void *opaque, target_phys_addr_t addr,
                          uint64_t val, unsigned size)
 {
-    PCIQXLDevice *d = opaque;
+    QXLDevice *d = opaque;
     uint32_t io_port = addr;
     qxl_async_io async = QXL_SYNC;
     uint32_t orig_io_port = io_port;
 
-    if (d->guest_bug && !io_port == QXL_IO_RESET) {
+    if (d->pci.guest_bug && !io_port == QXL_IO_RESET) {
         return;
     }
 
@@ -1326,7 +1326,7 @@ static void ioport_write(void *opaque, target_phys_addr_t addr,
     case QXL_IO_CREATE_PRIMARY_ASYNC:
         break;
     default:
-        if (d->mode != QXL_MODE_VGA) {
+        if (d->pci.mode != QXL_MODE_VGA) {
             break;
         }
         trace_qxl_io_unexpected_vga_mode(d->id,
@@ -1376,7 +1376,7 @@ async_common:
     default:
         break;
     }
-    trace_qxl_io_write(d->id, qxl_mode_to_string(d->mode), addr, val, size,
+    trace_qxl_io_write(d->id, qxl_mode_to_string(d->pci.mode), addr, val, size,
                        async);
 
     switch (io_port) {
@@ -1416,7 +1416,7 @@ async_common:
         qxl_set_mode(d, val, 0);
         break;
     case QXL_IO_LOG:
-        if (d->guestdebug) {
+        if (d->pci.guestdebug) {
             fprintf(stderr, "qxl/guest-%d: %" PRId64 ": %s", d->id,
                     qemu_get_clock_ns(vm_clock), d->ram->log_buf);
         }
@@ -1461,7 +1461,7 @@ async_common:
         }
         if (!qxl_destroy_primary(d, async)) {
             trace_qxl_io_destroy_primary_ignored(d->id,
-                                                 qxl_mode_to_string(d->mode));
+                                                 qxl_mode_to_string(d->pci.mode));
             goto cancel_async;
         }
         break;
@@ -1487,7 +1487,7 @@ async_common:
         qxl_spice_flush_surfaces_async(d);
         break;
     case QXL_IO_DESTROY_ALL_SURFACES:
-        d->mode = QXL_MODE_UNDEFINED;
+        d->pci.mode = QXL_MODE_UNDEFINED;
         qxl_spice_destroy_surfaces(d, async);
         break;
     default:
@@ -1506,7 +1506,7 @@ cancel_async:
 static uint64_t ioport_read(void *opaque, target_phys_addr_t addr,
                             unsigned size)
 {
-    PCIQXLDevice *d = opaque;
+    QXLDevice *d = opaque;
 
     trace_qxl_io_read_unexpected(d->id);
     return 0xff;
@@ -1523,7 +1523,7 @@ static const MemoryRegionOps qxl_io_ops = {
 
 static void pipe_read(void *opaque)
 {
-    PCIQXLDevice *d = opaque;
+    QXLDevice *d = opaque;
     char dummy;
     int len;
 
@@ -1533,7 +1533,7 @@ static void pipe_read(void *opaque)
     qxl_update_irq(d);
 }
 
-static void qxl_send_events(PCIQXLDevice *d, uint32_t events)
+static void qxl_send_events(QXLDevice *d, uint32_t events)
 {
     uint32_t old_pending;
     uint32_t le_events = cpu_to_le32(events);
@@ -1552,7 +1552,7 @@ static void qxl_send_events(PCIQXLDevice *d, uint32_t events)
     }
 }
 
-static void init_pipe_signaling(PCIQXLDevice *d)
+static void init_pipe_signaling(QXLDevice *d)
 {
     if (pipe(d->pipe) < 0) {
         fprintf(stderr, "%s:%s: qxl pipe creation failed\n",
@@ -1571,10 +1571,10 @@ static void init_pipe_signaling(PCIQXLDevice *d)
 
 static void qxl_hw_update(void *opaque)
 {
-    PCIQXLDevice *qxl = opaque;
-    VGACommonState *vga = &qxl->vga;
+    QXLDevice *qxl = opaque;
+    VGACommonState *vga = &qxl->pci.vga;
 
-    switch (qxl->mode) {
+    switch (qxl->pci.mode) {
     case QXL_MODE_VGA:
         vga->update(vga);
         break;
@@ -1589,18 +1589,18 @@ static void qxl_hw_update(void *opaque)
 
 static void qxl_hw_invalidate(void *opaque)
 {
-    PCIQXLDevice *qxl = opaque;
-    VGACommonState *vga = &qxl->vga;
+    QXLDevice *qxl = opaque;
+    VGACommonState *vga = &qxl->pci.vga;
 
     vga->invalidate(vga);
 }
 
 static void qxl_hw_screen_dump(void *opaque, const char *filename, bool cswitch)
 {
-    PCIQXLDevice *qxl = opaque;
-    VGACommonState *vga = &qxl->vga;
+    QXLDevice *qxl = opaque;
+    VGACommonState *vga = &qxl->pci.vga;
 
-    switch (qxl->mode) {
+    switch (qxl->pci.mode) {
     case QXL_MODE_COMPAT:
     case QXL_MODE_NATIVE:
         qxl_render_update(qxl);
@@ -1616,29 +1616,29 @@ static void qxl_hw_screen_dump(void *opaque, const char *filename, bool cswitch)
 
 static void qxl_hw_text_update(void *opaque, console_ch_t *chardata)
 {
-    PCIQXLDevice *qxl = opaque;
-    VGACommonState *vga = &qxl->vga;
+    QXLDevice *qxl = opaque;
+    VGACommonState *vga = &qxl->pci.vga;
 
-    if (qxl->mode == QXL_MODE_VGA) {
+    if (qxl->pci.mode == QXL_MODE_VGA) {
         vga->text_update(vga, chardata);
         return;
     }
 }
 
-static void qxl_dirty_surfaces(PCIQXLDevice *qxl)
+static void qxl_dirty_surfaces(QXLDevice *qxl)
 {
     intptr_t vram_start;
     int i;
 
-    if (qxl->mode != QXL_MODE_NATIVE && qxl->mode != QXL_MODE_COMPAT) {
+    if (qxl->pci.mode != QXL_MODE_NATIVE && qxl->pci.mode != QXL_MODE_COMPAT) {
         return;
     }
 
     /* dirty the primary surface */
-    qxl_set_dirty(&qxl->vga.vram, qxl->shadow_rom.draw_area_offset,
+    qxl_set_dirty(&qxl->pci.vga.vram, qxl->shadow_rom.draw_area_offset,
                   qxl->shadow_rom.surface0_area_size);
 
-    vram_start =  (intptr_t)memory_region_get_ram_ptr(&qxl->vram_bar);
+    vram_start =  (intptr_t)memory_region_get_ram_ptr(&qxl->pci.vram_bar);
 
     /* dirty the off-screen surfaces */
     for (i = 0; i < NUM_SURFACES; i++) {
@@ -1662,14 +1662,14 @@ static void qxl_dirty_surfaces(PCIQXLDevice *qxl)
         surface_size = cmd->u.surface_create.height *
                        abs(cmd->u.surface_create.stride);
         trace_qxl_surfaces_dirty(qxl->id, i, (int)surface_offset, surface_size);
-        qxl_set_dirty(&qxl->vram_bar, surface_offset, surface_size);
+        qxl_set_dirty(&qxl->pci.vram_bar, surface_offset, surface_size);
     }
 }
 
 static void qxl_vm_change_state_handler(void *opaque, int running,
                                         RunState state)
 {
-    PCIQXLDevice *qxl = opaque;
+    QXLDevice *qxl = opaque;
     qemu_spice_vm_change_state_handler(&qxl->ssd, running, state);
 
     if (running) {
@@ -1689,21 +1689,21 @@ static void qxl_vm_change_state_handler(void *opaque, int running,
 
 static void display_update(struct DisplayState *ds, int x, int y, int w, int h)
 {
-    if (qxl0->mode == QXL_MODE_VGA) {
+    if (qxl0->pci.mode == QXL_MODE_VGA) {
         qemu_spice_display_update(&qxl0->ssd, x, y, w, h);
     }
 }
 
 static void display_resize(struct DisplayState *ds)
 {
-    if (qxl0->mode == QXL_MODE_VGA) {
+    if (qxl0->pci.mode == QXL_MODE_VGA) {
         qemu_spice_display_resize(&qxl0->ssd);
     }
 }
 
 static void display_refresh(struct DisplayState *ds)
 {
-    if (qxl0->mode == QXL_MODE_VGA) {
+    if (qxl0->pci.mode == QXL_MODE_VGA) {
         qemu_spice_display_refresh(&qxl0->ssd);
     } else {
         qemu_mutex_lock(&qxl0->ssd.lock);
@@ -1718,20 +1718,20 @@ static DisplayChangeListener display_listener = {
     .dpy_refresh = display_refresh,
 };
 
-static void qxl_init_ramsize(PCIQXLDevice *qxl)
+static void qxl_init_ramsize(QXLDevice *qxl)
 {
     /* vga mode framebuffer / primary surface (bar 0, first part) */
-    if (qxl->vgamem_size_mb < 8) {
-        qxl->vgamem_size_mb = 8;
+    if (qxl->pci.vgamem_size_mb < 8) {
+        qxl->pci.vgamem_size_mb = 8;
     }
-    qxl->vgamem_size = qxl->vgamem_size_mb * 1024 * 1024;
+    qxl->pci.vgamem_size = qxl->pci.vgamem_size_mb * 1024 * 1024;
 
     /* vga ram (bar 0, total) */
     if (qxl->ram_size_mb != -1) {
-        qxl->vga.vram_size = qxl->ram_size_mb * 1024 * 1024;
+        qxl->pci.vga.vram_size = qxl->ram_size_mb * 1024 * 1024;
     }
-    if (qxl->vga.vram_size < qxl->vgamem_size * 2) {
-        qxl->vga.vram_size = qxl->vgamem_size * 2;
+    if (qxl->pci.vga.vram_size < qxl->pci.vgamem_size * 2) {
+        qxl->pci.vga.vram_size = qxl->pci.vgamem_size * 2;
     }
 
     /* vram32 (surfaces, 32bit, bar 1) */
@@ -1750,32 +1750,32 @@ static void qxl_init_ramsize(PCIQXLDevice *qxl)
         qxl->vram_size = qxl->vram32_size;
     }
 
-    if (qxl->revision == 1) {
+    if (qxl->pci.revision == 1) {
         qxl->vram32_size = 4096;
         qxl->vram_size = 4096;
     }
-    qxl->vgamem_size = msb_mask(qxl->vgamem_size * 2 - 1);
-    qxl->vga.vram_size = msb_mask(qxl->vga.vram_size * 2 - 1);
+    qxl->pci.vgamem_size = msb_mask(qxl->pci.vgamem_size * 2 - 1);
+    qxl->pci.vga.vram_size = msb_mask(qxl->pci.vga.vram_size * 2 - 1);
     qxl->vram32_size = msb_mask(qxl->vram32_size * 2 - 1);
     qxl->vram_size = msb_mask(qxl->vram_size * 2 - 1);
 }
 
-static int qxl_init_common(PCIQXLDevice *qxl)
+static int qxl_init_common(QXLDevice *qxl)
 {
-    uint8_t* config = qxl->pci.config;
+    uint8_t* config = qxl->pci.pci.config;
     uint32_t pci_device_rev;
     uint32_t io_size;
 
-    qxl->mode = QXL_MODE_UNDEFINED;
-    qxl->generation = 1;
+    qxl->pci.mode = QXL_MODE_UNDEFINED;
+    qxl->pci.generation = 1;
     qxl->num_memslots = NUM_MEMSLOTS;
     qxl->num_surfaces = NUM_SURFACES;
     qemu_mutex_init(&qxl->track_lock);
     qemu_mutex_init(&qxl->async_lock);
     qxl->current_async = QXL_UNDEFINED_IO;
-    qxl->guest_bug = 0;
+    qxl->pci.guest_bug = 0;
 
-    switch (qxl->revision) {
+    switch (qxl->pci.revision) {
     case 1: /* spice 0.4 -- qxl-1 */
         pci_device_rev = QXL_REVISION_STABLE_V04;
         io_size = 8;
@@ -1794,52 +1794,54 @@ static int qxl_init_common(PCIQXLDevice *qxl)
     pci_set_byte(&config[PCI_REVISION_ID], pci_device_rev);
     pci_set_byte(&config[PCI_INTERRUPT_PIN], 1);
 
-    qxl->rom_size = qxl_rom_size();
-    memory_region_init_ram(&qxl->rom_bar, "qxl.vrom", qxl->rom_size);
-    vmstate_register_ram(&qxl->rom_bar, &qxl->pci.qdev);
+    qxl->pci.rom_size = qxl_rom_size();
+    memory_region_init_ram(&qxl->pci.rom_bar,"qxl-pci.vrom",
+            qxl->pci.rom_size);
+    vmstate_register_ram(&qxl->pci.rom_bar, &qxl->pci.pci.qdev);
     init_qxl_rom(qxl);
     init_qxl_ram(qxl);
 
-    memory_region_init_ram(&qxl->vram_bar, "qxl.vram", qxl->vram_size);
-    vmstate_register_ram(&qxl->vram_bar, &qxl->pci.qdev);
-    memory_region_init_alias(&qxl->vram32_bar, "qxl.vram32", &qxl->vram_bar,
-                             0, qxl->vram32_size);
+    memory_region_init_ram(&qxl->pci.vram_bar, "qxl-pci.vram",
+            qxl->vram_size);
+    vmstate_register_ram(&qxl->pci.vram_bar, &qxl->pci.pci.qdev);
+    memory_region_init_alias(&qxl->pci.vram32_bar, "qxl-pci.vram32",
+            &qxl->pci.vram_bar, 0, qxl->vram32_size);
 
-    memory_region_init_io(&qxl->io_bar, &qxl_io_ops, qxl,
-                          "qxl-ioports", io_size);
+    memory_region_init_io(&qxl->pci.io_bar, &qxl_io_ops, qxl,
+                          "qxl-pci.ioports", io_size);
     if (qxl->id == 0) {
-        vga_dirty_log_start(&qxl->vga);
+        vga_dirty_log_start(&qxl->pci.vga);
     }
 
 
-    pci_register_bar(&qxl->pci, QXL_IO_RANGE_INDEX,
-                     PCI_BASE_ADDRESS_SPACE_IO, &qxl->io_bar);
+    pci_register_bar(&qxl->pci.pci, QXL_IO_RANGE_INDEX,
+                     PCI_BASE_ADDRESS_SPACE_IO, &qxl->pci.io_bar);
 
-    pci_register_bar(&qxl->pci, QXL_ROM_RANGE_INDEX,
-                     PCI_BASE_ADDRESS_SPACE_MEMORY, &qxl->rom_bar);
+    pci_register_bar(&qxl->pci.pci, QXL_ROM_RANGE_INDEX,
+                     PCI_BASE_ADDRESS_SPACE_MEMORY, &qxl->pci.rom_bar);
 
-    pci_register_bar(&qxl->pci, QXL_RAM_RANGE_INDEX,
-                     PCI_BASE_ADDRESS_SPACE_MEMORY, &qxl->vga.vram);
+    pci_register_bar(&qxl->pci.pci, QXL_RAM_RANGE_INDEX,
+                     PCI_BASE_ADDRESS_SPACE_MEMORY, &qxl->pci.vga.vram);
 
-    pci_register_bar(&qxl->pci, QXL_VRAM_RANGE_INDEX,
-                     PCI_BASE_ADDRESS_SPACE_MEMORY, &qxl->vram32_bar);
+    pci_register_bar(&qxl->pci.pci, QXL_VRAM_RANGE_INDEX,
+                     PCI_BASE_ADDRESS_SPACE_MEMORY, &qxl->pci.vram32_bar);
 
     if (qxl->vram32_size < qxl->vram_size) {
         /*
          * Make the 64bit vram bar show up only in case it is
          * configured to be larger than the 32bit vram bar.
          */
-        pci_register_bar(&qxl->pci, QXL_VRAM64_RANGE_INDEX,
+        pci_register_bar(&qxl->pci.pci, QXL_VRAM64_RANGE_INDEX,
                          PCI_BASE_ADDRESS_SPACE_MEMORY |
                          PCI_BASE_ADDRESS_MEM_TYPE_64 |
                          PCI_BASE_ADDRESS_MEM_PREFETCH,
-                         &qxl->vram_bar);
+                         &qxl->pci.vram_bar);
     }
 
     /* print pci bar details */
     dprint(qxl, 1, "ram/%s: %d MB [region 0]\n",
            qxl->id == 0 ? "pri" : "sec",
-           qxl->vga.vram_size / (1024*1024));
+           qxl->pci.vga.vram_size / (1024*1024));
     dprint(qxl, 1, "vram/32: %d MB [region 1]\n",
            qxl->vram32_size / (1024*1024));
     dprint(qxl, 1, "vram/64: %d MB %s\n",
@@ -1861,13 +1863,13 @@ static int qxl_init_common(PCIQXLDevice *qxl)
 
 static int qxl_init_primary(PCIDevice *dev)
 {
-    PCIQXLDevice *qxl = DO_UPCAST(PCIQXLDevice, pci, dev);
-    VGACommonState *vga = &qxl->vga;
+    QXLDevice *qxl = (QXLDevice *) DO_UPCAST(PCIQXLDevice, pci, dev);
+    VGACommonState *vga = &qxl->pci.vga;
     PortioList *qxl_vga_port_list = g_new(PortioList, 1);
 
     qxl->id = 0;
     qxl_init_ramsize(qxl);
-    vga->vram_size_mb = qxl->vga.vram_size >> 20;
+    vga->vram_size_mb = qxl->pci.vga.vram_size >> 20;
     vga_common_init(vga);
     vga_init(vga, pci_address_space(dev), pci_address_space_io(dev), false);
     portio_list_init(qxl_vga_port_list, qxl_vga_portio_list, vga, "vga");
@@ -1886,21 +1888,21 @@ static int qxl_init_primary(PCIDevice *dev)
 static int qxl_init_secondary(PCIDevice *dev)
 {
     static int device_id = 1;
-    PCIQXLDevice *qxl = DO_UPCAST(PCIQXLDevice, pci, dev);
+    QXLDevice *qxl = (QXLDevice *) DO_UPCAST(PCIQXLDevice, pci, dev);
 
     qxl->id = device_id++;
     qxl_init_ramsize(qxl);
-    memory_region_init_ram(&qxl->vga.vram, "qxl.vgavram", qxl->vga.vram_size);
-    vmstate_register_ram(&qxl->vga.vram, &qxl->pci.qdev);
-    qxl->vga.vram_ptr = memory_region_get_ram_ptr(&qxl->vga.vram);
+    memory_region_init_ram(&qxl->pci.vga.vram, "qxl-pci.vgavram", qxl->pci.vga.vram_size);
+    vmstate_register_ram(&qxl->pci.vga.vram, &qxl->pci.pci.qdev);
+    qxl->pci.vga.vram_ptr = memory_region_get_ram_ptr(&qxl->pci.vga.vram);
 
     return qxl_init_common(qxl);
 }
 
 static void qxl_pre_save(void *opaque)
 {
-    PCIQXLDevice* d = opaque;
-    uint8_t *ram_start = d->vga.vram_ptr;
+    QXLDevice* d = opaque;
+    uint8_t *ram_start = d->pci.vga.vram_ptr;
 
     trace_qxl_pre_save(d->id);
     if (d->last_release == NULL) {
@@ -1908,12 +1910,12 @@ static void qxl_pre_save(void *opaque)
     } else {
         d->last_release_offset = (uint8_t *)d->last_release - ram_start;
     }
-    assert(d->last_release_offset < d->vga.vram_size);
+    assert(d->last_release_offset < d->pci.vga.vram_size);
 }
 
 static int qxl_pre_load(void *opaque)
 {
-    PCIQXLDevice* d = opaque;
+    QXLDevice* d = opaque;
 
     trace_qxl_pre_load(d->id);
     qxl_hard_reset(d, 1);
@@ -1921,7 +1923,7 @@ static int qxl_pre_load(void *opaque)
     return 0;
 }
 
-static void qxl_create_memslots(PCIQXLDevice *d)
+static void qxl_create_memslots(QXLDevice *d)
 {
     int i;
 
@@ -1935,12 +1937,12 @@ static void qxl_create_memslots(PCIQXLDevice *d)
 
 static int qxl_post_load(void *opaque, int version)
 {
-    PCIQXLDevice* d = opaque;
-    uint8_t *ram_start = d->vga.vram_ptr;
+    QXLDevice *d = opaque;
+    uint8_t *ram_start = d->pci.vga.vram_ptr;
     QXLCommandExt *cmds;
     int in, out, newmode;
 
-    assert(d->last_release_offset < d->vga.vram_size);
+    assert(d->last_release_offset < d->pci.vga.vram_size);
     if (d->last_release_offset == 0) {
         d->last_release = NULL;
     } else {
@@ -1949,9 +1951,9 @@ static int qxl_post_load(void *opaque, int version)
 
     d->modes = (QXLModes*)((uint8_t*)d->rom + d->rom->modes_offset);
 
-    trace_qxl_post_load(d->id, qxl_mode_to_string(d->mode));
-    newmode = d->mode;
-    d->mode = QXL_MODE_UNDEFINED;
+    trace_qxl_post_load(d->id, qxl_mode_to_string(d->pci.mode));
+    newmode = d->pci.mode;
+    d->pci.mode = QXL_MODE_UNDEFINED;
 
     switch (newmode) {
     case QXL_MODE_UNDEFINED:
@@ -2036,20 +2038,20 @@ static VMStateDescription qxl_vmstate = {
     .fields = (VMStateField []) {
         VMSTATE_PCI_DEVICE(pci, PCIQXLDevice),
         VMSTATE_STRUCT(vga, PCIQXLDevice, 0, vmstate_vga_common, VGACommonState),
-        VMSTATE_UINT32(shadow_rom.mode, PCIQXLDevice),
-        VMSTATE_UINT32(num_free_res, PCIQXLDevice),
-        VMSTATE_UINT32(last_release_offset, PCIQXLDevice),
+        VMSTATE_UINT32(shadow_rom.mode, QXLDevice),
+        VMSTATE_UINT32(num_free_res, QXLDevice),
+        VMSTATE_UINT32(last_release_offset, QXLDevice),
         VMSTATE_UINT32(mode, PCIQXLDevice),
-        VMSTATE_UINT32(ssd.unique, PCIQXLDevice),
-        VMSTATE_INT32_EQUAL(num_memslots, PCIQXLDevice),
-        VMSTATE_STRUCT_ARRAY(guest_slots, PCIQXLDevice, NUM_MEMSLOTS, 0,
+        VMSTATE_UINT32(ssd.unique, QXLDevice),
+        VMSTATE_INT32_EQUAL(num_memslots, QXLDevice),
+        VMSTATE_STRUCT_ARRAY(guest_slots, QXLDevice, NUM_MEMSLOTS, 0,
                              qxl_memslot, struct guest_slots),
-        VMSTATE_STRUCT(guest_primary.surface, PCIQXLDevice, 0,
+        VMSTATE_STRUCT(guest_primary.surface, QXLDevice, 0,
                        qxl_surface, QXLSurfaceCreate),
-        VMSTATE_INT32_EQUAL(num_surfaces, PCIQXLDevice),
-        VMSTATE_ARRAY(guest_surfaces.cmds, PCIQXLDevice, NUM_SURFACES, 0,
+        VMSTATE_INT32_EQUAL(num_surfaces, QXLDevice),
+        VMSTATE_ARRAY(guest_surfaces.cmds, QXLDevice, NUM_SURFACES, 0,
                       vmstate_info_uint64, uint64_t),
-        VMSTATE_UINT64(guest_cursor, PCIQXLDevice),
+        VMSTATE_UINT64(guest_cursor, QXLDevice),
         VMSTATE_END_OF_LIST()
     },
 };
@@ -2057,16 +2059,16 @@ static VMStateDescription qxl_vmstate = {
 static Property qxl_properties[] = {
         DEFINE_PROP_UINT32("ram_size", PCIQXLDevice, vga.vram_size,
                            64 * 1024 * 1024),
-        DEFINE_PROP_UINT32("vram_size", PCIQXLDevice, vram32_size,
+        DEFINE_PROP_UINT32("vram_size", QXLDevice, vram32_size,
                            64 * 1024 * 1024),
         DEFINE_PROP_UINT32("revision", PCIQXLDevice, revision,
                            QXL_DEFAULT_REVISION),
-        DEFINE_PROP_UINT32("debug", PCIQXLDevice, debug, 0),
+        DEFINE_PROP_UINT32("debug", QXLDevice, debug, 0),
         DEFINE_PROP_UINT32("guestdebug", PCIQXLDevice, guestdebug, 0),
         DEFINE_PROP_UINT32("cmdlog", PCIQXLDevice, cmdlog, 0),
-        DEFINE_PROP_UINT32("ram_size_mb",  PCIQXLDevice, ram_size_mb, -1),
-        DEFINE_PROP_UINT32("vram_size_mb", PCIQXLDevice, vram32_size_mb, -1),
-        DEFINE_PROP_UINT32("vram64_size_mb", PCIQXLDevice, vram_size_mb, -1),
+        DEFINE_PROP_UINT32("ram_size_mb",  QXLDevice, ram_size_mb, -1),
+        DEFINE_PROP_UINT32("vram_size_mb", QXLDevice, vram32_size_mb, -1),
+        DEFINE_PROP_UINT32("vram64_size_mb", QXLDevice, vram_size_mb, -1),
         DEFINE_PROP_UINT32("vgamem_mb", PCIQXLDevice, vgamem_size_mb, 16),
         DEFINE_PROP_END_OF_LIST(),
 };
@@ -2091,7 +2093,7 @@ static void qxl_primary_class_init(ObjectClass *klass, void *data)
 static TypeInfo qxl_primary_info = {
     .name          = "qxl-vga",
     .parent        = TYPE_PCI_DEVICE,
-    .instance_size = sizeof(PCIQXLDevice),
+    .instance_size = sizeof(QXLDevice),
     .class_init    = qxl_primary_class_init,
 };
 
@@ -2113,7 +2115,7 @@ static void qxl_secondary_class_init(ObjectClass *klass, void *data)
 static TypeInfo qxl_secondary_info = {
     .name          = "qxl",
     .parent        = TYPE_PCI_DEVICE,
-    .instance_size = sizeof(PCIQXLDevice),
+    .instance_size = sizeof(QXLDevice),
     .class_init    = qxl_secondary_class_init,
 };
 
diff --git a/hw/qxl.h b/hw/qxl.h
index 172baf6..f25e341 100644
--- a/hw/qxl.h
+++ b/hw/qxl.h
@@ -25,19 +25,44 @@ enum qxl_mode {
 #define QXL_NUM_DIRTY_RECTS 64
 
 typedef struct PCIQXLDevice {
-    PCIDevice          pci;
-    SimpleSpiceDisplay ssd;
-    int                id;
-    uint32_t           debug;
-    uint32_t           guestdebug;
-    uint32_t           cmdlog;
+    PCIDevice         pci;
+    int               generation;
+    uint32_t          revision;
+    uint32_t          guestdebug;
+    uint32_t          cmdlog;
+
+    uint32_t          guest_bug;
+
+    enum qxl_mode     mode;
+
+    /* ram pci bar */
+    VGACommonState    vga;
+    uint32_t          vgamem_size;
+
+    /* rom pci bar */
+    uint32_t          rom_size;
+    MemoryRegion      rom_bar;
+
+    /* vram pci bar */
+    MemoryRegion      vram_bar;
+    MemoryRegion      vram32_bar;
+
+    /* io bar */
+    MemoryRegion      io_bar;
+
+    /* user-friendly properties (in megabytes) */
+    uint32_t          vgamem_size_mb;
+} PCIQXLDevice;
+
+#define QXL_DEFAULT_REVISION QXL_REVISION_STABLE_V10
 
-    uint32_t           guest_bug;
+typedef struct QXLDevice {
+    PCIQXLDevice       pci;
 
-    enum qxl_mode      mode;
+    SimpleSpiceDisplay ssd;
+    int                id;
     uint32_t           cmdflags;
-    int                generation;
-    uint32_t           revision;
+    uint32_t           debug;
 
     int32_t            num_memslots;
     int32_t            num_surfaces;
@@ -71,49 +96,39 @@ typedef struct PCIQXLDevice {
     } guest_surfaces;
     QXLPHYSICAL        guest_cursor;
 
-    QemuMutex          track_lock;
-
     /* thread signaling */
     QemuThread         main;
     int                pipe[2];
 
+    QemuMutex          track_lock;
+
     /* ram pci bar */
-    QXLRam             *ram;
-    VGACommonState     vga;
+    QXLRam            *ram;
     uint32_t           num_free_res;
-    QXLReleaseInfo     *last_release;
+    QXLReleaseInfo    *last_release;
     uint32_t           last_release_offset;
     uint32_t           oom_running;
-    uint32_t           vgamem_size;
 
     /* rom pci bar */
     QXLRom             shadow_rom;
-    QXLRom             *rom;
-    QXLModes           *modes;
-    uint32_t           rom_size;
-    MemoryRegion       rom_bar;
+    QXLRom            *rom;
+    QXLModes          *modes;
 
     /* vram pci bar */
     uint32_t           vram_size;
-    MemoryRegion       vram_bar;
     uint32_t           vram32_size;
-    MemoryRegion       vram32_bar;
-
-    /* io bar */
-    MemoryRegion       io_bar;
-
-    /* user-friendly properties (in megabytes) */
-    uint32_t          ram_size_mb;
-    uint32_t          vram_size_mb;
-    uint32_t          vram32_size_mb;
-    uint32_t          vgamem_size_mb;
 
     /* qxl_render_update state */
     int                render_update_cookie_num;
     int                num_dirty_rects;
     QXLRect            dirty[QXL_NUM_DIRTY_RECTS];
     QEMUBH            *update_area_bh;
-} PCIQXLDevice;
+
+    /* user-friendly properties (in megabytes) */
+    uint32_t           ram_size_mb;
+    uint32_t           vram_size_mb;
+    uint32_t           vram32_size_mb;
+} QXLDevice;
 
 #define PANIC_ON(x) if ((x)) {                         \
     printf("%s: PANIC %s failed\n", __FUNCTION__, #x); \
@@ -128,32 +143,29 @@ typedef struct PCIQXLDevice {
         }                                                               \
     } while (0)
 
-#define QXL_DEFAULT_REVISION QXL_REVISION_STABLE_V10
-
 /* qxl.c */
-void *qxl_phys2virt(PCIQXLDevice *qxl, QXLPHYSICAL phys, int group_id);
-void qxl_set_guest_bug(PCIQXLDevice *qxl, const char *msg, ...)
+void *qxl_phys2virt(QXLDevice *qxl, QXLPHYSICAL phys, int group_id);
+void qxl_set_guest_bug(QXLDevice *qxl, const char *msg, ...)
     GCC_FMT_ATTR(2, 3);
-
-void qxl_spice_update_area(PCIQXLDevice *qxl, uint32_t surface_id,
+void qxl_spice_update_area(QXLDevice *qxl, uint32_t surface_id,
                            struct QXLRect *area, struct QXLRect *dirty_rects,
                            uint32_t num_dirty_rects,
                            uint32_t clear_dirty_region,
                            qxl_async_io async, QXLCookie *cookie);
-void qxl_spice_loadvm_commands(PCIQXLDevice *qxl, struct QXLCommandExt *ext,
+void qxl_spice_loadvm_commands(QXLDevice *qxl, struct QXLCommandExt *ext,
                                uint32_t count);
-void qxl_spice_oom(PCIQXLDevice *qxl);
-void qxl_spice_reset_memslots(PCIQXLDevice *qxl);
-void qxl_spice_reset_image_cache(PCIQXLDevice *qxl);
-void qxl_spice_reset_cursor(PCIQXLDevice *qxl);
+void qxl_spice_oom(QXLDevice *qxl);
+void qxl_spice_reset_memslots(QXLDevice *qxl);
+void qxl_spice_reset_image_cache(QXLDevice *qxl);
+void qxl_spice_reset_cursor(QXLDevice *qxl);
 
 /* qxl-logger.c */
-int qxl_log_cmd_cursor(PCIQXLDevice *qxl, QXLCursorCmd *cmd, int group_id);
-int qxl_log_command(PCIQXLDevice *qxl, const char *ring, QXLCommandExt *ext);
+int qxl_log_cmd_cursor(QXLDevice *qxl, QXLCursorCmd *cmd, int group_id);
+int qxl_log_command(QXLDevice *qxl, const char *ring, QXLCommandExt *ext);
 
 /* qxl-render.c */
-void qxl_render_resize(PCIQXLDevice *qxl);
-void qxl_render_update(PCIQXLDevice *qxl);
-int qxl_render_cursor(PCIQXLDevice *qxl, QXLCommandExt *ext);
-void qxl_render_update_area_done(PCIQXLDevice *qxl, QXLCookie *cookie);
+void qxl_render_resize(QXLDevice *qxl);
+void qxl_render_update(QXLDevice *qxl);
+int qxl_render_cursor(QXLDevice *qxl, QXLCommandExt *ext);
+void qxl_render_update_area_done(QXLDevice *qxl, QXLCookie *cookie);
 void qxl_render_update_area_bh(void *opaque);
