hw/qxl.c

   1 /*
   2  * Copyright (C) 2010 Red Hat, Inc.
   3  *
   4  * written by Yaniv Kamay, Izik Eidus, Gerd Hoffmann
   5  * maintained by Gerd Hoffmann <[email protected]>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 or
  10  * (at your option) version 3 of the License.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "qemu-common.h"
  22 #include "qemu-timer.h"
  23 #include "qemu-queue.h"
  24 #include "monitor.h"
  25 #include "sysemu.h"
  26
  27 #include "qxl.h"
  28
  29 #undef SPICE_RING_PROD_ITEM
  30 #define SPICE_RING_PROD_ITEM(r, ret) {                                  \
  31         typeof(r) start = r;                                            \
  32         typeof(r) end = r + 1;                                          \
  33         uint32_t prod = (r)->prod & SPICE_RING_INDEX_MASK(r);           \
  34         typeof(&(r)->items[prod]) m_item = &(r)->items[prod];           \
  35         if (!((uint8_t*)m_item >= (uint8_t*)(start) && (uint8_t*)(m_item + 1) <= (uint8_t*)(end))) { \
  36             abort();                                                    \
  37         }                                                               \
  38         ret = &m_item->el;                                              \
  39     }
  40
  41 #undef SPICE_RING_CONS_ITEM
  42 #define SPICE_RING_CONS_ITEM(r, ret) {                                  \
  43         typeof(r) start = r;                                            \
  44         typeof(r) end = r + 1;                                          \
  45         uint32_t cons = (r)->cons & SPICE_RING_INDEX_MASK(r);           \
  46         typeof(&(r)->items[cons]) m_item = &(r)->items[cons];           \
  47         if (!((uint8_t*)m_item >= (uint8_t*)(start) && (uint8_t*)(m_item + 1) <= (uint8_t*)(end))) { \
  48             abort();                                                    \
  49         }                                                               \
  50         ret = &m_item->el;                                              \
  51     }
  52
  53 #undef ALIGN
  54 #define ALIGN(a, b) (((a) + ((b) - 1)) & ~((b) - 1))
  55
  56 #define PIXEL_SIZE 0.2936875 //1280x1024 is 14.8" x 11.9"
  57
  58 #define QXL_MODE(_x, _y, _b, _o)                  \
  59     {   .x_res = _x,                              \
  60         .y_res = _y,                              \
  61         .bits  = _b,                              \
  62         .stride = (_x) * (_b) / 8,                \
  63         .x_mili = PIXEL_SIZE * (_x),              \
  64         .y_mili = PIXEL_SIZE * (_y),              \
  65         .orientation = _o,                        \
  66     }
  67
  68 #define QXL_MODE_16_32(x_res, y_res, orientation) \
  69     QXL_MODE(x_res, y_res, 16, orientation),      \
  70     QXL_MODE(x_res, y_res, 32, orientation)
  71
  72 #define QXL_MODE_EX(x_res, y_res)                 \
  73     QXL_MODE_16_32(x_res, y_res, 0),              \
  74     QXL_MODE_16_32(y_res, x_res, 1),              \
  75     QXL_MODE_16_32(x_res, y_res, 2),              \
  76     QXL_MODE_16_32(y_res, x_res, 3)
  77
  78 static QXLMode qxl_modes[] = {
  79     QXL_MODE_EX(640, 480),
  80     QXL_MODE_EX(800, 480),
  81     QXL_MODE_EX(800, 600),
  82     QXL_MODE_EX(832, 624),
  83     QXL_MODE_EX(960, 640),
  84     QXL_MODE_EX(1024, 600),
  85     QXL_MODE_EX(1024, 768),
  86     QXL_MODE_EX(1152, 864),
  87     QXL_MODE_EX(1152, 870),
  88     QXL_MODE_EX(1280, 720),
  89     QXL_MODE_EX(1280, 760),
  90     QXL_MODE_EX(1280, 768),
  91     QXL_MODE_EX(1280, 800),
  92     QXL_MODE_EX(1280, 960),
  93     QXL_MODE_EX(1280, 1024),
  94     QXL_MODE_EX(1360, 768),
  95     QXL_MODE_EX(1366, 768),
  96     QXL_MODE_EX(1400, 1050),
  97     QXL_MODE_EX(1440, 900),
  98     QXL_MODE_EX(1600, 900),
  99     QXL_MODE_EX(1600, 1200),
 100     QXL_MODE_EX(1680, 1050),
 101     QXL_MODE_EX(1920, 1080),
 102 #if VGA_RAM_SIZE >= (16 * 1024 * 1024)
 103     /* these modes need more than 8 MB video memory */
 104     QXL_MODE_EX(1920, 1200),
 105     QXL_MODE_EX(1920, 1440),
 106     QXL_MODE_EX(2048, 1536),
 107     QXL_MODE_EX(2560, 1440),
 108     QXL_MODE_EX(2560, 1600),
 109 #endif
 110 #if VGA_RAM_SIZE >= (32 * 1024 * 1024)
 111     /* these modes need more than 16 MB video memory */
 112     QXL_MODE_EX(2560, 2048),
 113     QXL_MODE_EX(2800, 2100),
 114     QXL_MODE_EX(3200, 2400),
 115 #endif
 116 };
 117
 118 static PCIQXLDevice *qxl0;
 119
 120 static void qxl_send_events(PCIQXLDevice *d, uint32_t events);
 121 static int qxl_destroy_primary(PCIQXLDevice *d, qxl_async_io async);
 122 static void qxl_reset_memslots(PCIQXLDevice *d);
 123 static void qxl_reset_surfaces(PCIQXLDevice *d);
 124 static void qxl_ring_set_dirty(PCIQXLDevice *qxl);
 125
 126 void qxl_guest_bug(PCIQXLDevice *qxl, const char *msg, ...)
 127 {
 128 #if SPICE_INTERFACE_QXL_MINOR >= 1
 129     qxl_send_events(qxl, QXL_INTERRUPT_ERROR);
 130 #endif
 131     if (qxl->guestdebug) {
 132         va_list ap;
 133         va_start(ap, msg);
 134         fprintf(stderr, "qxl-%d: guest bug: ", qxl->id);
 135         vfprintf(stderr, msg, ap);
 136         fprintf(stderr, "\n");
 137         va_end(ap);
 138     }
 139 }
 140
 141
 142 void qxl_spice_update_area(PCIQXLDevice *qxl, uint32_t surface_id,
 143                            struct QXLRect *area, struct QXLRect *dirty_rects,
 144                            uint32_t num_dirty_rects,
 145                            uint32_t clear_dirty_region,
 146                            qxl_async_io async)
 147 {
 148     if (async == QXL_SYNC) {
 149         qxl->ssd.worker->update_area(qxl->ssd.worker, surface_id, area,
 150                         dirty_rects, num_dirty_rects, clear_dirty_region);
 151     } else {
 152 #if SPICE_INTERFACE_QXL_MINOR >= 1
 153         spice_qxl_update_area_async(&qxl->ssd.qxl, surface_id, area,
 154                                     clear_dirty_region, 0);
 155 #else
 156         abort();
 157 #endif
 158     }
 159 }
 160
 161 static void qxl_spice_destroy_surface_wait_complete(PCIQXLDevice *qxl,
 162                                                     uint32_t id)
 163 {
 164     qemu_mutex_lock(&qxl->track_lock);
 165     qxl->guest_surfaces.cmds[id] = 0;
 166     qxl->guest_surfaces.count--;
 167     qemu_mutex_unlock(&qxl->track_lock);
 168 }
 169
 170 static void qxl_spice_destroy_surface_wait(PCIQXLDevice *qxl, uint32_t id,
 171                                            qxl_async_io async)
 172 {
 173     if (async) {
 174 #if SPICE_INTERFACE_QXL_MINOR < 1
 175         abort();
 176 #else
 177         spice_qxl_destroy_surface_async(&qxl->ssd.qxl, id,
 178                                         (uint64_t)id);
 179 #endif
 180     } else {
 181         qxl->ssd.worker->destroy_surface_wait(qxl->ssd.worker, id);
 182         qxl_spice_destroy_surface_wait_complete(qxl, id);
 183     }
 184 }
 185
 186 #if SPICE_INTERFACE_QXL_MINOR >= 1
 187 static void qxl_spice_flush_surfaces_async(PCIQXLDevice *qxl)
 188 {
 189     spice_qxl_flush_surfaces_async(&qxl->ssd.qxl, 0);
 190 }
 191 #endif
 192
 193 void qxl_spice_loadvm_commands(PCIQXLDevice *qxl, struct QXLCommandExt *ext,
 194                                uint32_t count)
 195 {
 196     qxl->ssd.worker->loadvm_commands(qxl->ssd.worker, ext, count);
 197 }
 198
 199 void qxl_spice_oom(PCIQXLDevice *qxl)
 200 {
 201     qxl->ssd.worker->oom(qxl->ssd.worker);
 202 }
 203
 204 void qxl_spice_reset_memslots(PCIQXLDevice *qxl)
 205 {
 206     qxl->ssd.worker->reset_memslots(qxl->ssd.worker);
 207 }
 208
 209 static void qxl_spice_destroy_surfaces_complete(PCIQXLDevice *qxl)
 210 {
 211     qemu_mutex_lock(&qxl->track_lock);
 212     memset(&qxl->guest_surfaces.cmds, 0, sizeof(qxl->guest_surfaces.cmds));
 213     qxl->guest_surfaces.count = 0;
 214     qemu_mutex_unlock(&qxl->track_lock);
 215 }
 216
 217 static void qxl_spice_destroy_surfaces(PCIQXLDevice *qxl, qxl_async_io async)
 218 {
 219     if (async) {
 220 #if SPICE_INTERFACE_QXL_MINOR < 1
 221         abort();
 222 #else
 223         spice_qxl_destroy_surfaces_async(&qxl->ssd.qxl, 0);
 224 #endif
 225     } else {
 226         qxl->ssd.worker->destroy_surfaces(qxl->ssd.worker);
 227         qxl_spice_destroy_surfaces_complete(qxl);
 228     }
 229 }
 230
 231 void qxl_spice_reset_image_cache(PCIQXLDevice *qxl)
 232 {
 233     qxl->ssd.worker->reset_image_cache(qxl->ssd.worker);
 234 }
 235
 236 void qxl_spice_reset_cursor(PCIQXLDevice *qxl)
 237 {
 238     qxl->ssd.worker->reset_cursor(qxl->ssd.worker);
 239     qemu_mutex_lock(&qxl->track_lock);
 240     qxl->guest_cursor = 0;
 241     qemu_mutex_unlock(&qxl->track_lock);
 242 }
 243
 244
 245 static inline uint32_t msb_mask(uint32_t val)
 246 {
 247     uint32_t mask;
 248
 249     do {
 250         mask = ~(val - 1) & val;
 251         val &= ~mask;
 252     } while (mask < val);
 253
 254     return mask;
 255 }
 256
 257 static ram_addr_t qxl_rom_size(void)
 258 {
 259     uint32_t rom_size = sizeof(QXLRom) + sizeof(QXLModes) + sizeof(qxl_modes);
 260     rom_size = MAX(rom_size, TARGET_PAGE_SIZE);
 261     rom_size = msb_mask(rom_size * 2 - 1);
 262     return rom_size;
 263 }
 264
 265 static void init_qxl_rom(PCIQXLDevice *d)
 266 {
 267     QXLRom *rom = memory_region_get_ram_ptr(&d->rom_bar);
 268     QXLModes *modes = (QXLModes *)(rom + 1);
 269     uint32_t ram_header_size;
 270     uint32_t surface0_area_size;
 271     uint32_t num_pages;
 272     uint32_t fb, maxfb = 0;
 273     int i;
 274
 275     memset(rom, 0, d->rom_size);
 276
 277     rom->magic         = cpu_to_le32(QXL_ROM_MAGIC);
 278     rom->id            = cpu_to_le32(d->id);
 279     rom->log_level     = cpu_to_le32(d->guestdebug);
 280     rom->modes_offset  = cpu_to_le32(sizeof(QXLRom));
 281
 282     rom->slot_gen_bits = MEMSLOT_GENERATION_BITS;
 283     rom->slot_id_bits  = MEMSLOT_SLOT_BITS;
 284     rom->slots_start   = 1;
 285     rom->slots_end     = NUM_MEMSLOTS - 1;
 286     rom->n_surfaces    = cpu_to_le32(NUM_SURFACES);
 287
 288     modes->n_modes     = cpu_to_le32(ARRAY_SIZE(qxl_modes));
 289     for (i = 0; i < modes->n_modes; i++) {
 290         fb = qxl_modes[i].y_res * qxl_modes[i].stride;
 291         if (maxfb < fb) {
 292             maxfb = fb;
 293         }
 294         modes->modes[i].id          = cpu_to_le32(i);
 295         modes->modes[i].x_res       = cpu_to_le32(qxl_modes[i].x_res);
 296         modes->modes[i].y_res       = cpu_to_le32(qxl_modes[i].y_res);
 297         modes->modes[i].bits        = cpu_to_le32(qxl_modes[i].bits);
 298         modes->modes[i].stride      = cpu_to_le32(qxl_modes[i].stride);
 299         modes->modes[i].x_mili      = cpu_to_le32(qxl_modes[i].x_mili);
 300         modes->modes[i].y_mili      = cpu_to_le32(qxl_modes[i].y_mili);
 301         modes->modes[i].orientation = cpu_to_le32(qxl_modes[i].orientation);
 302     }
 303     if (maxfb < VGA_RAM_SIZE && d->id == 0)
 304         maxfb = VGA_RAM_SIZE;
 305
 306     ram_header_size    = ALIGN(sizeof(QXLRam), 4096);
 307     surface0_area_size = ALIGN(maxfb, 4096);
 308     num_pages          = d->vga.vram_size;
 309     num_pages         -= ram_header_size;
 310     num_pages         -= surface0_area_size;
 311     num_pages          = num_pages / TARGET_PAGE_SIZE;
 312
 313     rom->draw_area_offset   = cpu_to_le32(0);
 314     rom->surface0_area_size = cpu_to_le32(surface0_area_size);
 315     rom->pages_offset       = cpu_to_le32(surface0_area_size);
 316     rom->num_pages          = cpu_to_le32(num_pages);
 317     rom->ram_header_offset  = cpu_to_le32(d->vga.vram_size - ram_header_size);
 318
 319     d->shadow_rom = *rom;
 320     d->rom        = rom;
 321     d->modes      = modes;
 322 }
 323
 324 static void init_qxl_ram(PCIQXLDevice *d)
 325 {
 326     uint8_t *buf;
 327     uint64_t *item;
 328
 329     buf = d->vga.vram_ptr;
 330     d->ram = (QXLRam *)(buf + le32_to_cpu(d->shadow_rom.ram_header_offset));
 331     d->ram->magic       = cpu_to_le32(QXL_RAM_MAGIC);
 332     d->ram->int_pending = cpu_to_le32(0);
 333     d->ram->int_mask    = cpu_to_le32(0);
 334     d->ram->update_surface = 0;
 335     SPICE_RING_INIT(&d->ram->cmd_ring);
 336     SPICE_RING_INIT(&d->ram->cursor_ring);
 337     SPICE_RING_INIT(&d->ram->release_ring);
 338     SPICE_RING_PROD_ITEM(&d->ram->release_ring, item);
 339     *item = 0;
 340     qxl_ring_set_dirty(d);
 341 }
 342
 343 /* can be called from spice server thread context */
 344 static void qxl_set_dirty(MemoryRegion *mr, ram_addr_t addr, ram_addr_t end)
 345 {
 346     memory_region_set_dirty(mr, addr, end - addr);
 347 }
 348
 349 static void qxl_rom_set_dirty(PCIQXLDevice *qxl)
 350 {
 351     qxl_set_dirty(&qxl->rom_bar, 0, qxl->rom_size);
 352 }
 353
 354 /* called from spice server thread context only */
 355 static void qxl_ram_set_dirty(PCIQXLDevice *qxl, void *ptr)
 356 {
 357     void *base = qxl->vga.vram_ptr;
 358     intptr_t offset;
 359
 360     offset = ptr - base;
 361     offset &= ~(TARGET_PAGE_SIZE-1);
 362     assert(offset < qxl->vga.vram_size);
 363     qxl_set_dirty(&qxl->vga.vram, offset, offset + TARGET_PAGE_SIZE);
 364 }
 365
 366 /* can be called from spice server thread context */
 367 static void qxl_ring_set_dirty(PCIQXLDevice *qxl)
 368 {
 369     ram_addr_t addr = qxl->shadow_rom.ram_header_offset;
 370     ram_addr_t end  = qxl->vga.vram_size;
 371     qxl_set_dirty(&qxl->vga.vram, addr, end);
 372 }
 373
 374 /*
 375  * keep track of some command state, for savevm/loadvm.
 376  * called from spice server thread context only
 377  */
 378 static void qxl_track_command(PCIQXLDevice *qxl, struct QXLCommandExt *ext)
 379 {
 380     switch (le32_to_cpu(ext->cmd.type)) {
 381     case QXL_CMD_SURFACE:
 382     {
 383         QXLSurfaceCmd *cmd = qxl_phys2virt(qxl, ext->cmd.data, ext->group_id);
 384         uint32_t id = le32_to_cpu(cmd->surface_id);
 385         PANIC_ON(id >= NUM_SURFACES);
 386         qemu_mutex_lock(&qxl->track_lock);
 387         if (cmd->type == QXL_SURFACE_CMD_CREATE) {
 388             qxl->guest_surfaces.cmds[id] = ext->cmd.data;
 389             qxl->guest_surfaces.count++;
 390             if (qxl->guest_surfaces.max < qxl->guest_surfaces.count)
 391                 qxl->guest_surfaces.max = qxl->guest_surfaces.count;
 392         }
 393         if (cmd->type == QXL_SURFACE_CMD_DESTROY) {
 394             qxl->guest_surfaces.cmds[id] = 0;
 395             qxl->guest_surfaces.count--;
 396         }
 397         qemu_mutex_unlock(&qxl->track_lock);
 398         break;
 399     }
 400     case QXL_CMD_CURSOR:
 401     {
 402         QXLCursorCmd *cmd = qxl_phys2virt(qxl, ext->cmd.data, ext->group_id);
 403         if (cmd->type == QXL_CURSOR_SET) {
 404             qemu_mutex_lock(&qxl->track_lock);
 405             qxl->guest_cursor = ext->cmd.data;
 406             qemu_mutex_unlock(&qxl->track_lock);
 407         }
 408         break;
 409     }
 410     }
 411 }
 412
 413 /* spice display interface callbacks */
 414
 415 static void interface_attach_worker(QXLInstance *sin, QXLWorker *qxl_worker)
 416 {
 417     PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
 418
 419     dprint(qxl, 1, "%s:\n", __FUNCTION__);
 420     qxl->ssd.worker = qxl_worker;
 421 }
 422
 423 static void interface_set_compression_level(QXLInstance *sin, int level)
 424 {
 425     PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
 426
 427     dprint(qxl, 1, "%s: %d\n", __FUNCTION__, level);
 428     qxl->shadow_rom.compression_level = cpu_to_le32(level);
 429     qxl->rom->compression_level = cpu_to_le32(level);
 430     qxl_rom_set_dirty(qxl);
 431 }
 432
 433 static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)
 434 {
 435     PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
 436
 437     qxl->shadow_rom.mm_clock = cpu_to_le32(mm_time);
 438     qxl->rom->mm_clock = cpu_to_le32(mm_time);
 439     qxl_rom_set_dirty(qxl);
 440 }
 441
 442 static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)
 443 {
 444     PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
 445
 446     dprint(qxl, 1, "%s:\n", __FUNCTION__);
 447     info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;
 448     info->memslot_id_bits = MEMSLOT_SLOT_BITS;
 449     info->num_memslots = NUM_MEMSLOTS;
 450     info->num_memslots_groups = NUM_MEMSLOTS_GROUPS;
 451     info->internal_groupslot_id = 0;
 452     info->qxl_ram_size = le32_to_cpu(qxl->shadow_rom.num_pages) << TARGET_PAGE_BITS;
 453     info->n_surfaces = NUM_SURFACES;
 454 }
 455
 456 static const char *qxl_mode_to_string(int mode)
 457 {
 458     switch (mode) {
 459     case QXL_MODE_COMPAT:
 460         return "compat";
 461     case QXL_MODE_NATIVE:
 462         return "native";
 463     case QXL_MODE_UNDEFINED:
 464         return "undefined";
 465     case QXL_MODE_VGA:
 466         return "vga";
 467     }
 468     return "INVALID";
 469 }
 470
 471 static const char *io_port_to_string(uint32_t io_port)
 472 {
 473     if (io_port >= QXL_IO_RANGE_SIZE) {
 474         return "out of range";
 475     }
 476     static const char *io_port_to_string[QXL_IO_RANGE_SIZE + 1] = {
 477         [QXL_IO_NOTIFY_CMD]             = "QXL_IO_NOTIFY_CMD",
 478         [QXL_IO_NOTIFY_CURSOR]          = "QXL_IO_NOTIFY_CURSOR",
 479         [QXL_IO_UPDATE_AREA]            = "QXL_IO_UPDATE_AREA",
 480         [QXL_IO_UPDATE_IRQ]             = "QXL_IO_UPDATE_IRQ",
 481         [QXL_IO_NOTIFY_OOM]             = "QXL_IO_NOTIFY_OOM",
 482         [QXL_IO_RESET]                  = "QXL_IO_RESET",
 483         [QXL_IO_SET_MODE]               = "QXL_IO_SET_MODE",
 484         [QXL_IO_LOG]                    = "QXL_IO_LOG",
 485         [QXL_IO_MEMSLOT_ADD]            = "QXL_IO_MEMSLOT_ADD",
 486         [QXL_IO_MEMSLOT_DEL]            = "QXL_IO_MEMSLOT_DEL",
 487         [QXL_IO_DETACH_PRIMARY]         = "QXL_IO_DETACH_PRIMARY",
 488         [QXL_IO_ATTACH_PRIMARY]         = "QXL_IO_ATTACH_PRIMARY",
 489         [QXL_IO_CREATE_PRIMARY]         = "QXL_IO_CREATE_PRIMARY",
 490         [QXL_IO_DESTROY_PRIMARY]        = "QXL_IO_DESTROY_PRIMARY",
 491         [QXL_IO_DESTROY_SURFACE_WAIT]   = "QXL_IO_DESTROY_SURFACE_WAIT",
 492         [QXL_IO_DESTROY_ALL_SURFACES]   = "QXL_IO_DESTROY_ALL_SURFACES",
 493 #if SPICE_INTERFACE_QXL_MINOR >= 1
 494         [QXL_IO_UPDATE_AREA_ASYNC]      = "QXL_IO_UPDATE_AREA_ASYNC",
 495         [QXL_IO_MEMSLOT_ADD_ASYNC]      = "QXL_IO_MEMSLOT_ADD_ASYNC",
 496         [QXL_IO_CREATE_PRIMARY_ASYNC]   = "QXL_IO_CREATE_PRIMARY_ASYNC",
 497         [QXL_IO_DESTROY_PRIMARY_ASYNC]  = "QXL_IO_DESTROY_PRIMARY_ASYNC",
 498         [QXL_IO_DESTROY_SURFACE_ASYNC]  = "QXL_IO_DESTROY_SURFACE_ASYNC",
 499         [QXL_IO_DESTROY_ALL_SURFACES_ASYNC]
 500                                         = "QXL_IO_DESTROY_ALL_SURFACES_ASYNC",
 501         [QXL_IO_FLUSH_SURFACES_ASYNC]   = "QXL_IO_FLUSH_SURFACES_ASYNC",
 502         [QXL_IO_FLUSH_RELEASE]          = "QXL_IO_FLUSH_RELEASE",
 503 #endif
 504     };
 505     return io_port_to_string[io_port];
 506 }
 507
 508 /* called from spice server thread context only */
 509 static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)
 510 {
 511     PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
 512     SimpleSpiceUpdate *update;
 513     QXLCommandRing *ring;
 514     QXLCommand *cmd;
 515     int notify, ret;
 516
 517     switch (qxl->mode) {
 518     case QXL_MODE_VGA:
 519         dprint(qxl, 2, "%s: vga\n", __FUNCTION__);
 520         ret = false;
 521         qemu_mutex_lock(&qxl->ssd.lock);
 522         if (qxl->ssd.update != NULL) {
 523             update = qxl->ssd.update;
 524             qxl->ssd.update = NULL;
 525             *ext = update->ext;
 526             ret = true;
 527         }
 528         qemu_mutex_unlock(&qxl->ssd.lock);
 529         if (ret) {
 530             dprint(qxl, 2, "%s %s\n", __FUNCTION__, qxl_mode_to_string(qxl->mode));
 531             qxl_log_command(qxl, "vga", ext);
 532         }
 533         return ret;
 534     case QXL_MODE_COMPAT:
 535     case QXL_MODE_NATIVE:
 536     case QXL_MODE_UNDEFINED:
 537         dprint(qxl, 4, "%s: %s\n", __FUNCTION__, qxl_mode_to_string(qxl->mode));
 538         ring = &qxl->ram->cmd_ring;
 539         if (SPICE_RING_IS_EMPTY(ring)) {
 540             return false;
 541         }
 542         dprint(qxl, 2, "%s: %s\n", __FUNCTION__, qxl_mode_to_string(qxl->mode));
 543         SPICE_RING_CONS_ITEM(ring, cmd);
 544         ext->cmd      = *cmd;
 545         ext->group_id = MEMSLOT_GROUP_GUEST;
 546         ext->flags    = qxl->cmdflags;
 547         SPICE_RING_POP(ring, notify);
 548         qxl_ring_set_dirty(qxl);
 549         if (notify) {
 550             qxl_send_events(qxl, QXL_INTERRUPT_DISPLAY);
 551         }
 552         qxl->guest_primary.commands++;
 553         qxl_track_command(qxl, ext);
 554         qxl_log_command(qxl, "cmd", ext);
 555         return true;
 556     default:
 557         return false;
 558     }
 559 }
 560
 561 /* called from spice server thread context only */
 562 static int interface_req_cmd_notification(QXLInstance *sin)
 563 {
 564     PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
 565     int wait = 1;
 566
 567     switch (qxl->mode) {
 568     case QXL_MODE_COMPAT:
 569     case QXL_MODE_NATIVE:
 570     case QXL_MODE_UNDEFINED:
 571         SPICE_RING_CONS_WAIT(&qxl->ram->cmd_ring, wait);
 572         qxl_ring_set_dirty(qxl);
 573         break;
 574     default:
 575         /* nothing */
 576         break;
 577     }
 578     return wait;
 579 }
 580
 581 /* called from spice server thread context only */
 582 static inline void qxl_push_free_res(PCIQXLDevice *d, int flush)
 583 {
 584     QXLReleaseRing *ring = &d->ram->release_ring;
 585     uint64_t *item;
 586     int notify;
 587
 588 #define QXL_FREE_BUNCH_SIZE 32
 589
 590     if (ring->prod - ring->cons + 1 == ring->num_items) {
 591         /* ring full -- can't push */
 592         return;
 593     }
 594     if (!flush && d->oom_running) {
 595         /* collect everything from oom handler before pushing */
 596         return;
 597     }
 598     if (!flush && d->num_free_res < QXL_FREE_BUNCH_SIZE) {
 599         /* collect a bit more before pushing */
 600         return;
 601     }
 602
 603     SPICE_RING_PUSH(ring, notify);
 604     dprint(d, 2, "free: push %d items, notify %s, ring %d/%d [%d,%d]\n",
 605            d->num_free_res, notify ? "yes" : "no",
 606            ring->prod - ring->cons, ring->num_items,
 607            ring->prod, ring->cons);
 608     if (notify) {
 609         qxl_send_events(d, QXL_INTERRUPT_DISPLAY);
 610     }
 611     SPICE_RING_PROD_ITEM(ring, item);
 612     *item = 0;
 613     d->num_free_res = 0;
 614     d->last_release = NULL;
 615     qxl_ring_set_dirty(d);
 616 }
 617
 618 /* called from spice server thread context only */
 619 static void interface_release_resource(QXLInstance *sin,
 620                                        struct QXLReleaseInfoExt ext)
 621 {
 622     PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
 623     QXLReleaseRing *ring;
 624     uint64_t *item, id;
 625
 626     if (ext.group_id == MEMSLOT_GROUP_HOST) {
 627         /* host group -> vga mode update request */
 628         qemu_spice_destroy_update(&qxl->ssd, (void *)(intptr_t)ext.info->id);
 629         return;
 630     }
 631
 632     /*
 633      * ext->info points into guest-visible memory
 634      * pci bar 0, $command.release_info
 635      */
 636     ring = &qxl->ram->release_ring;
 637     SPICE_RING_PROD_ITEM(ring, item);
 638     if (*item == 0) {
 639         /* stick head into the ring */
 640         id = ext.info->id;
 641         ext.info->next = 0;
 642         qxl_ram_set_dirty(qxl, &ext.info->next);
 643         *item = id;
 644         qxl_ring_set_dirty(qxl);
 645     } else {
 646         /* append item to the list */
 647         qxl->last_release->next = ext.info->id;
 648         qxl_ram_set_dirty(qxl, &qxl->last_release->next);
 649         ext.info->next = 0;
 650         qxl_ram_set_dirty(qxl, &ext.info->next);
 651     }
 652     qxl->last_release = ext.info;
 653     qxl->num_free_res++;
 654     dprint(qxl, 3, "%4d\r", qxl->num_free_res);
 655     qxl_push_free_res(qxl, 0);
 656 }
 657
 658 /* called from spice server thread context only */
 659 static int interface_get_cursor_command(QXLInstance *sin, struct QXLCommandExt *ext)
 660 {
 661     PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
 662     QXLCursorRing *ring;
 663     QXLCommand *cmd;
 664     int notify;
 665
 666     switch (qxl->mode) {
 667     case QXL_MODE_COMPAT:
 668     case QXL_MODE_NATIVE:
 669     case QXL_MODE_UNDEFINED:
 670         ring = &qxl->ram->cursor_ring;
 671         if (SPICE_RING_IS_EMPTY(ring)) {
 672             return false;
 673         }
 674         SPICE_RING_CONS_ITEM(ring, cmd);
 675         ext->cmd      = *cmd;
 676         ext->group_id = MEMSLOT_GROUP_GUEST;
 677         ext->flags    = qxl->cmdflags;
 678         SPICE_RING_POP(ring, notify);
 679         qxl_ring_set_dirty(qxl);
 680         if (notify) {
 681             qxl_send_events(qxl, QXL_INTERRUPT_CURSOR);
 682         }
 683         qxl->guest_primary.commands++;
 684         qxl_track_command(qxl, ext);
 685         qxl_log_command(qxl, "csr", ext);
 686         if (qxl->id == 0) {
 687             qxl_render_cursor(qxl, ext);
 688         }
 689         return true;
 690     default:
 691         return false;
 692     }
 693 }
 694
 695 /* called from spice server thread context only */
 696 static int interface_req_cursor_notification(QXLInstance *sin)
 697 {
 698     PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
 699     int wait = 1;
 700
 701     switch (qxl->mode) {
 702     case QXL_MODE_COMPAT:
 703     case QXL_MODE_NATIVE:
 704     case QXL_MODE_UNDEFINED:
 705         SPICE_RING_CONS_WAIT(&qxl->ram->cursor_ring, wait);
 706         qxl_ring_set_dirty(qxl);
 707         break;
 708     default:
 709         /* nothing */
 710         break;
 711     }
 712     return wait;
 713 }
 714
 715 /* called from spice server thread context */
 716 static void interface_notify_update(QXLInstance *sin, uint32_t update_id)
 717 {
 718     fprintf(stderr, "%s: abort()\n", __FUNCTION__);
 719     abort();
 720 }
 721
 722 /* called from spice server thread context only */
 723 static int interface_flush_resources(QXLInstance *sin)
 724 {
 725     PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
 726     int ret;
 727
 728     dprint(qxl, 1, "free: guest flush (have %d)\n", qxl->num_free_res);
 729     ret = qxl->num_free_res;
 730     if (ret) {
 731         qxl_push_free_res(qxl, 1);
 732     }
 733     return ret;
 734 }
 735
 736 static void qxl_create_guest_primary_complete(PCIQXLDevice *d);
 737
 738 #if SPICE_INTERFACE_QXL_MINOR >= 1
 739
 740 /* called from spice server thread context only */
 741 static void interface_async_complete(QXLInstance *sin, uint64_t cookie)
 742 {
 743     PCIQXLDevice *qxl = container_of(sin, PCIQXLDevice, ssd.qxl);
 744     uint32_t current_async;
 745
 746     qemu_mutex_lock(&qxl->async_lock);
 747     current_async = qxl->current_async;
 748     qxl->current_async = QXL_UNDEFINED_IO;
 749     qemu_mutex_unlock(&qxl->async_lock);
 750
 751     dprint(qxl, 2, "async_complete: %d (%" PRId64 ") done\n",
 752            current_async, cookie);
 753     switch (current_async) {
 754     case QXL_IO_CREATE_PRIMARY_ASYNC:
 755         qxl_create_guest_primary_complete(qxl);
 756         break;
 757     case QXL_IO_DESTROY_ALL_SURFACES_ASYNC:
 758         qxl_spice_destroy_surfaces_complete(qxl);
 759         break;
 760     case QXL_IO_DESTROY_SURFACE_ASYNC:
 761         qxl_spice_destroy_surface_wait_complete(qxl, (uint32_t)cookie);
 762         break;
 763     }
 764     qxl_send_events(qxl, QXL_INTERRUPT_IO_CMD);
 765 }
 766
 767 #endif
 768
 769 static const QXLInterface qxl_interface = {
 770     .base.type               = SPICE_INTERFACE_QXL,
 771     .base.description        = "qxl gpu",
 772     .base.major_version      = SPICE_INTERFACE_QXL_MAJOR,
 773     .base.minor_version      = SPICE_INTERFACE_QXL_MINOR,
 774
 775     .attache_worker          = interface_attach_worker,
 776     .set_compression_level   = interface_set_compression_level,
 777     .set_mm_time             = interface_set_mm_time,
 778     .get_init_info           = interface_get_init_info,
 779
 780     /* the callbacks below are called from spice server thread context */
 781     .get_command             = interface_get_command,
 782     .req_cmd_notification    = interface_req_cmd_notification,
 783     .release_resource        = interface_release_resource,
 784     .get_cursor_command      = interface_get_cursor_command,
 785     .req_cursor_notification = interface_req_cursor_notification,
 786     .notify_update           = interface_notify_update,
 787     .flush_resources         = interface_flush_resources,
 788 #if SPICE_INTERFACE_QXL_MINOR >= 1
 789     .async_complete          = interface_async_complete,
 790 #endif
 791 };
 792
 793 static void qxl_enter_vga_mode(PCIQXLDevice *d)
 794 {
 795     if (d->mode == QXL_MODE_VGA) {
 796         return;
 797     }
 798     dprint(d, 1, "%s\n", __FUNCTION__);
 799     qemu_spice_create_host_primary(&d->ssd);
 800     d->mode = QXL_MODE_VGA;
 801     memset(&d->ssd.dirty, 0, sizeof(d->ssd.dirty));
 802 }
 803
 804 static void qxl_exit_vga_mode(PCIQXLDevice *d)
 805 {
 806     if (d->mode != QXL_MODE_VGA) {
 807         return;
 808     }
 809     dprint(d, 1, "%s\n", __FUNCTION__);
 810     qxl_destroy_primary(d, QXL_SYNC);
 811 }
 812
 813 static void qxl_update_irq(PCIQXLDevice *d)
 814 {
 815     uint32_t pending = le32_to_cpu(d->ram->int_pending);
 816     uint32_t mask    = le32_to_cpu(d->ram->int_mask);
 817     int level = !!(pending & mask);
 818     qemu_set_irq(d->pci.irq[0], level);
 819     qxl_ring_set_dirty(d);
 820 }
 821
 822 static void qxl_check_state(PCIQXLDevice *d)
 823 {
 824     QXLRam *ram = d->ram;
 825
 826     assert(!d->ssd.running || SPICE_RING_IS_EMPTY(&ram->cmd_ring));
 827     assert(!d->ssd.running || SPICE_RING_IS_EMPTY(&ram->cursor_ring));
 828 }
 829
 830 static void qxl_reset_state(PCIQXLDevice *d)
 831 {
 832     QXLRom *rom = d->rom;
 833
 834     qxl_check_state(d);
 835     d->shadow_rom.update_id = cpu_to_le32(0);
 836     *rom = d->shadow_rom;
 837     qxl_rom_set_dirty(d);
 838     init_qxl_ram(d);
 839     d->num_free_res = 0;
 840     d->last_release = NULL;
 841     memset(&d->ssd.dirty, 0, sizeof(d->ssd.dirty));
 842 }
 843
 844 static void qxl_soft_reset(PCIQXLDevice *d)
 845 {
 846     dprint(d, 1, "%s:\n", __FUNCTION__);
 847     qxl_check_state(d);
 848
 849     if (d->id == 0) {
 850         qxl_enter_vga_mode(d);
 851     } else {
 852         d->mode = QXL_MODE_UNDEFINED;
 853     }
 854 }
 855
 856 static void qxl_hard_reset(PCIQXLDevice *d, int loadvm)
 857 {
 858     dprint(d, 1, "%s: start%s\n", __FUNCTION__,
 859            loadvm ? " (loadvm)" : "");
 860
 861     qxl_spice_reset_cursor(d);
 862     qxl_spice_reset_image_cache(d);
 863     qxl_reset_surfaces(d);
 864     qxl_reset_memslots(d);
 865
 866     /* pre loadvm reset must not touch QXLRam.  This lives in
 867      * device memory, is migrated together with RAM and thus
 868      * already loaded at this point */
 869     if (!loadvm) {
 870         qxl_reset_state(d);
 871     }
 872     qemu_spice_create_host_memslot(&d->ssd);
 873     qxl_soft_reset(d);
 874
 875     dprint(d, 1, "%s: done\n", __FUNCTION__);
 876 }
 877
 878 static void qxl_reset_handler(DeviceState *dev)
 879 {
 880     PCIQXLDevice *d = DO_UPCAST(PCIQXLDevice, pci.qdev, dev);
 881     qxl_hard_reset(d, 0);
 882 }
 883
 884 static void qxl_vga_ioport_write(void *opaque, uint32_t addr, uint32_t val)
 885 {
 886     VGACommonState *vga = opaque;
 887     PCIQXLDevice *qxl = container_of(vga, PCIQXLDevice, vga);
 888
 889     if (qxl->mode != QXL_MODE_VGA) {
 890         dprint(qxl, 1, "%s\n", __FUNCTION__);
 891         qxl_destroy_primary(qxl, QXL_SYNC);
 892         qxl_soft_reset(qxl);
 893     }
 894     vga_ioport_write(opaque, addr, val);
 895 }
 896
 897 static const MemoryRegionPortio qxl_vga_portio_list[] = {
 898     { 0x04,  2, 1, .read  = vga_ioport_read,
 899                    .write = qxl_vga_ioport_write }, /* 3b4 */
 900     { 0x0a,  1, 1, .read  = vga_ioport_read,
 901                    .write = qxl_vga_ioport_write }, /* 3ba */
 902     { 0x10, 16, 1, .read  = vga_ioport_read,
 903                    .write = qxl_vga_ioport_write }, /* 3c0 */
 904     { 0x24,  2, 1, .read  = vga_ioport_read,
 905                    .write = qxl_vga_ioport_write }, /* 3d4 */
 906     { 0x2a,  1, 1, .read  = vga_ioport_read,
 907                    .write = qxl_vga_ioport_write }, /* 3da */
 908     PORTIO_END_OF_LIST(),
 909 };
 910
 911 static void qxl_add_memslot(PCIQXLDevice *d, uint32_t slot_id, uint64_t delta,
 912                             qxl_async_io async)
 913 {
 914     static const int regions[] = {
 915         QXL_RAM_RANGE_INDEX,
 916         QXL_VRAM_RANGE_INDEX,
 917     };
 918     uint64_t guest_start;
 919     uint64_t guest_end;
 920     int pci_region;
 921     pcibus_t pci_start;
 922     pcibus_t pci_end;
 923     intptr_t virt_start;
 924     QXLDevMemSlot memslot;
 925     int i;
 926
 927     guest_start = le64_to_cpu(d->guest_slots[slot_id].slot.mem_start);
 928     guest_end   = le64_to_cpu(d->guest_slots[slot_id].slot.mem_end);
 929
 930     dprint(d, 1, "%s: slot %d: guest phys 0x%" PRIx64 " - 0x%" PRIx64 "\n",
 931            __FUNCTION__, slot_id,
 932            guest_start, guest_end);
 933
 934     PANIC_ON(slot_id >= NUM_MEMSLOTS);
 935     PANIC_ON(guest_start > guest_end);
 936
 937     for (i = 0; i < ARRAY_SIZE(regions); i++) {
 938         pci_region = regions[i];
 939         pci_start = d->pci.io_regions[pci_region].addr;
 940         pci_end = pci_start + d->pci.io_regions[pci_region].size;
 941         /* mapped? */
 942         if (pci_start == -1) {
 943             continue;
 944         }
 945         /* start address in range ? */
 946         if (guest_start < pci_start || guest_start > pci_end) {
 947             continue;
 948         }
 949         /* end address in range ? */
 950         if (guest_end > pci_end) {
 951             continue;
 952         }
 953         /* passed */
 954         break;
 955     }
 956     PANIC_ON(i == ARRAY_SIZE(regions)); /* finished loop without match */
 957
 958     switch (pci_region) {
 959     case QXL_RAM_RANGE_INDEX:
 960         virt_start = (intptr_t)memory_region_get_ram_ptr(&d->vga.vram);
 961         break;
 962     case QXL_VRAM_RANGE_INDEX:
 963         virt_start = (intptr_t)memory_region_get_ram_ptr(&d->vram_bar);
 964         break;
 965     default:
 966         /* should not happen */
 967         abort();
 968     }
 969
 970     memslot.slot_id = slot_id;
 971     memslot.slot_group_id = MEMSLOT_GROUP_GUEST; /* guest group */
 972     memslot.virt_start = virt_start + (guest_start - pci_start);
 973     memslot.virt_end   = virt_start + (guest_end   - pci_start);
 974     memslot.addr_delta = memslot.virt_start - delta;
 975     memslot.generation = d->rom->slot_generation = 0;
 976     qxl_rom_set_dirty(d);
 977
 978     dprint(d, 1, "%s: slot %d: host virt 0x%lx - 0x%lx\n",
 979            __FUNCTION__, memslot.slot_id,
 980            memslot.virt_start, memslot.virt_end);
 981
 982     qemu_spice_add_memslot(&d->ssd, &memslot, async);
 983     d->guest_slots[slot_id].ptr = (void*)memslot.virt_start;
 984     d->guest_slots[slot_id].size = memslot.virt_end - memslot.virt_start;
 985     d->guest_slots[slot_id].delta = delta;
 986     d->guest_slots[slot_id].active = 1;
 987 }
 988
 989 static void qxl_del_memslot(PCIQXLDevice *d, uint32_t slot_id)
 990 {
 991     dprint(d, 1, "%s: slot %d\n", __FUNCTION__, slot_id);
 992     qemu_spice_del_memslot(&d->ssd, MEMSLOT_GROUP_HOST, slot_id);
 993     d->guest_slots[slot_id].active = 0;
 994 }
 995
 996 static void qxl_reset_memslots(PCIQXLDevice *d)
 997 {
 998     dprint(d, 1, "%s:\n", __FUNCTION__);
 999     qxl_spice_reset_memslots(d);
1000     memset(&d->guest_slots, 0, sizeof(d->guest_slots));
1001 }
1002
1003 static void qxl_reset_surfaces(PCIQXLDevice *d)
1004 {
1005     dprint(d, 1, "%s:\n", __FUNCTION__);
1006     d->mode = QXL_MODE_UNDEFINED;
1007     qxl_spice_destroy_surfaces(d, QXL_SYNC);
1008 }
1009
1010 /* can be also called from spice server thread context */
1011 void *qxl_phys2virt(PCIQXLDevice *qxl, QXLPHYSICAL pqxl, int group_id)
1012 {
1013     uint64_t phys   = le64_to_cpu(pqxl);
1014     uint32_t slot   = (phys >> (64 -  8)) & 0xff;
1015     uint64_t offset = phys & 0xffffffffffff;
1016
1017     switch (group_id) {
1018     case MEMSLOT_GROUP_HOST:
1019         return (void *)(intptr_t)offset;
1020     case MEMSLOT_GROUP_GUEST:
1021         PANIC_ON(slot >= NUM_MEMSLOTS);
1022         PANIC_ON(!qxl->guest_slots[slot].active);
1023         PANIC_ON(offset < qxl->guest_slots[slot].delta);
1024         offset -= qxl->guest_slots[slot].delta;
1025         PANIC_ON(offset > qxl->guest_slots[slot].size)
1026         return qxl->guest_slots[slot].ptr + offset;
1027     default:
1028         PANIC_ON(1);
1029     }
1030 }
1031
1032 static void qxl_create_guest_primary_complete(PCIQXLDevice *qxl)
1033 {
1034     /* for local rendering */
1035     qxl_render_resize(qxl);
1036 }
1037
1038 static void qxl_create_guest_primary(PCIQXLDevice *qxl, int loadvm,
1039                                      qxl_async_io async)
1040 {
1041     QXLDevSurfaceCreate surface;
1042     QXLSurfaceCreate *sc = &qxl->guest_primary.surface;
1043
1044     assert(qxl->mode != QXL_MODE_NATIVE);
1045     qxl_exit_vga_mode(qxl);
1046
1047     dprint(qxl, 1, "%s: %dx%d\n", __FUNCTION__,
1048            le32_to_cpu(sc->width), le32_to_cpu(sc->height));
1049
1050     surface.format     = le32_to_cpu(sc->format);
1051     surface.height     = le32_to_cpu(sc->height);
1052     surface.mem        = le64_to_cpu(sc->mem);
1053     surface.position   = le32_to_cpu(sc->position);
1054     surface.stride     = le32_to_cpu(sc->stride);
1055     surface.width      = le32_to_cpu(sc->width);
1056     surface.type       = le32_to_cpu(sc->type);
1057     surface.flags      = le32_to_cpu(sc->flags);
1058
1059     surface.mouse_mode = true;
1060     surface.group_id   = MEMSLOT_GROUP_GUEST;
1061     if (loadvm) {
1062         surface.flags |= QXL_SURF_FLAG_KEEP_DATA;
1063     }
1064
1065     qxl->mode = QXL_MODE_NATIVE;
1066     qxl->cmdflags = 0;
1067     qemu_spice_create_primary_surface(&qxl->ssd, 0, &surface, async);
1068
1069     if (async == QXL_SYNC) {
1070         qxl_create_guest_primary_complete(qxl);
1071     }
1072 }
1073
1074 /* return 1 if surface destoy was initiated (in QXL_ASYNC case) or
1075  * done (in QXL_SYNC case), 0 otherwise. */
1076 static int qxl_destroy_primary(PCIQXLDevice *d, qxl_async_io async)
1077 {
1078     if (d->mode == QXL_MODE_UNDEFINED) {
1079         return 0;
1080     }
1081
1082     dprint(d, 1, "%s\n", __FUNCTION__);
1083
1084     d->mode = QXL_MODE_UNDEFINED;
1085     qemu_spice_destroy_primary_surface(&d->ssd, 0, async);
1086     qxl_spice_reset_cursor(d);
1087     return 1;
1088 }
1089
1090 static void qxl_set_mode(PCIQXLDevice *d, int modenr, int loadvm)
1091 {
1092     pcibus_t start = d->pci.io_regions[QXL_RAM_RANGE_INDEX].addr;
1093     pcibus_t end   = d->pci.io_regions[QXL_RAM_RANGE_INDEX].size + start;
1094     QXLMode *mode = d->modes->modes + modenr;
1095     uint64_t devmem = d->pci.io_regions[QXL_RAM_RANGE_INDEX].addr;
1096     QXLMemSlot slot = {
1097         .mem_start = start,
1098         .mem_end = end
1099     };
1100     QXLSurfaceCreate surface = {
1101         .width      = mode->x_res,
1102         .height     = mode->y_res,
1103         .stride     = -mode->x_res * 4,
1104         .format     = SPICE_SURFACE_FMT_32_xRGB,
1105         .flags      = loadvm ? QXL_SURF_FLAG_KEEP_DATA : 0,
1106         .mouse_mode = true,
1107         .mem        = devmem + d->shadow_rom.draw_area_offset,
1108     };
1109
1110     dprint(d, 1, "%s: mode %d  [ %d x %d @ %d bpp devmem 0x%" PRIx64 " ]\n",
1111            __func__, modenr, mode->x_res, mode->y_res, mode->bits, devmem);
1112     if (!loadvm) {
1113         qxl_hard_reset(d, 0);
1114     }
1115
1116     d->guest_slots[0].slot = slot;
1117     qxl_add_memslot(d, 0, devmem, QXL_SYNC);
1118
1119     d->guest_primary.surface = surface;
1120     qxl_create_guest_primary(d, 0, QXL_SYNC);
1121
1122     d->mode = QXL_MODE_COMPAT;
1123     d->cmdflags = QXL_COMMAND_FLAG_COMPAT;
1124 #ifdef QXL_COMMAND_FLAG_COMPAT_16BPP /* new in spice 0.6.1 */
1125     if (mode->bits == 16) {
1126         d->cmdflags |= QXL_COMMAND_FLAG_COMPAT_16BPP;
1127     }
1128 #endif
1129     d->shadow_rom.mode = cpu_to_le32(modenr);
1130     d->rom->mode = cpu_to_le32(modenr);
1131     qxl_rom_set_dirty(d);
1132 }
1133
1134 static void ioport_write(void *opaque, target_phys_addr_t addr,
1135                          uint64_t val, unsigned size)
1136 {
1137     PCIQXLDevice *d = opaque;
1138     uint32_t io_port = addr;
1139     qxl_async_io async = QXL_SYNC;
1140 #if SPICE_INTERFACE_QXL_MINOR >= 1
1141     uint32_t orig_io_port = io_port;
1142 #endif
1143
1144     switch (io_port) {
1145     case QXL_IO_RESET:
1146     case QXL_IO_SET_MODE:
1147     case QXL_IO_MEMSLOT_ADD:
1148     case QXL_IO_MEMSLOT_DEL:
1149     case QXL_IO_CREATE_PRIMARY:
1150     case QXL_IO_UPDATE_IRQ:
1151     case QXL_IO_LOG:
1152 #if SPICE_INTERFACE_QXL_MINOR >= 1
1153     case QXL_IO_MEMSLOT_ADD_ASYNC:
1154     case QXL_IO_CREATE_PRIMARY_ASYNC:
1155 #endif
1156         break;
1157     default:
1158         if (d->mode != QXL_MODE_VGA) {
1159             break;
1160         }
1161         dprint(d, 1, "%s: unexpected port 0x%x (%s) in vga mode\n",
1162             __func__, io_port, io_port_to_string(io_port));
1163 #if SPICE_INTERFACE_QXL_MINOR >= 1
1164         /* be nice to buggy guest drivers */
1165         if (io_port >= QXL_IO_UPDATE_AREA_ASYNC &&
1166             io_port <= QXL_IO_DESTROY_ALL_SURFACES_ASYNC) {
1167             qxl_send_events(d, QXL_INTERRUPT_IO_CMD);
1168         }
1169 #endif
1170         return;
1171     }
1172
1173 #if SPICE_INTERFACE_QXL_MINOR >= 1
1174     /* we change the io_port to avoid ifdeffery in the main switch */
1175     orig_io_port = io_port;
1176     switch (io_port) {
1177     case QXL_IO_UPDATE_AREA_ASYNC:
1178         io_port = QXL_IO_UPDATE_AREA;
1179         goto async_common;
1180     case QXL_IO_MEMSLOT_ADD_ASYNC:
1181         io_port = QXL_IO_MEMSLOT_ADD;
1182         goto async_common;
1183     case QXL_IO_CREATE_PRIMARY_ASYNC:
1184         io_port = QXL_IO_CREATE_PRIMARY;
1185         goto async_common;
1186     case QXL_IO_DESTROY_PRIMARY_ASYNC:
1187         io_port = QXL_IO_DESTROY_PRIMARY;
1188         goto async_common;
1189     case QXL_IO_DESTROY_SURFACE_ASYNC:
1190         io_port = QXL_IO_DESTROY_SURFACE_WAIT;
1191         goto async_common;
1192     case QXL_IO_DESTROY_ALL_SURFACES_ASYNC:
1193         io_port = QXL_IO_DESTROY_ALL_SURFACES;
1194         goto async_common;
1195     case QXL_IO_FLUSH_SURFACES_ASYNC:
1196 async_common:
1197         async = QXL_ASYNC;
1198         qemu_mutex_lock(&d->async_lock);
1199         if (d->current_async != QXL_UNDEFINED_IO) {
1200             qxl_guest_bug(d, "%d async started before last (%d) complete",
1201                 io_port, d->current_async);
1202             qemu_mutex_unlock(&d->async_lock);
1203             return;
1204         }
1205         d->current_async = orig_io_port;
1206         qemu_mutex_unlock(&d->async_lock);
1207         dprint(d, 2, "start async %d (%"PRId64")\n", io_port, val);
1208         break;
1209     default:
1210         break;
1211     }
1212 #endif
1213
1214     switch (io_port) {
1215     case QXL_IO_UPDATE_AREA:
1216     {
1217         QXLRect update = d->ram->update_area;
1218         qxl_spice_update_area(d, d->ram->update_surface,
1219                               &update, NULL, 0, 0, async);
1220         break;
1221     }
1222     case QXL_IO_NOTIFY_CMD:
1223         qemu_spice_wakeup(&d->ssd);
1224         break;
1225     case QXL_IO_NOTIFY_CURSOR:
1226         qemu_spice_wakeup(&d->ssd);
1227         break;
1228     case QXL_IO_UPDATE_IRQ:
1229         qxl_update_irq(d);
1230         break;
1231     case QXL_IO_NOTIFY_OOM:
1232         if (!SPICE_RING_IS_EMPTY(&d->ram->release_ring)) {
1233             break;
1234         }
1235         d->oom_running = 1;
1236         qxl_spice_oom(d);
1237         d->oom_running = 0;
1238         break;
1239     case QXL_IO_SET_MODE:
1240         dprint(d, 1, "QXL_SET_MODE %d\n", (int)val);
1241         qxl_set_mode(d, val, 0);
1242         break;
1243     case QXL_IO_LOG:
1244         if (d->guestdebug) {
1245             fprintf(stderr, "qxl/guest-%d: %" PRId64 ": %s", d->id,
1246                     qemu_get_clock_ns(vm_clock), d->ram->log_buf);
1247         }
1248         break;
1249     case QXL_IO_RESET:
1250         dprint(d, 1, "QXL_IO_RESET\n");
1251         qxl_hard_reset(d, 0);
1252         break;
1253     case QXL_IO_MEMSLOT_ADD:
1254         if (val >= NUM_MEMSLOTS) {
1255             qxl_guest_bug(d, "QXL_IO_MEMSLOT_ADD: val out of range");
1256             break;
1257         }
1258         if (d->guest_slots[val].active) {
1259             qxl_guest_bug(d, "QXL_IO_MEMSLOT_ADD: memory slot already active");
1260             break;
1261         }
1262         d->guest_slots[val].slot = d->ram->mem_slot;
1263         qxl_add_memslot(d, val, 0, async);
1264         break;
1265     case QXL_IO_MEMSLOT_DEL:
1266         if (val >= NUM_MEMSLOTS) {
1267             qxl_guest_bug(d, "QXL_IO_MEMSLOT_DEL: val out of range");
1268             break;
1269         }
1270         qxl_del_memslot(d, val);
1271         break;
1272     case QXL_IO_CREATE_PRIMARY:
1273         if (val != 0) {
1274             qxl_guest_bug(d, "QXL_IO_CREATE_PRIMARY (async=%d): val != 0",
1275                           async);
1276             goto cancel_async;
1277         }
1278         dprint(d, 1, "QXL_IO_CREATE_PRIMARY async=%d\n", async);
1279         d->guest_primary.surface = d->ram->create_surface;
1280         qxl_create_guest_primary(d, 0, async);
1281         break;
1282     case QXL_IO_DESTROY_PRIMARY:
1283         if (val != 0) {
1284             qxl_guest_bug(d, "QXL_IO_DESTROY_PRIMARY (async=%d): val != 0",
1285                           async);
1286             goto cancel_async;
1287         }
1288         dprint(d, 1, "QXL_IO_DESTROY_PRIMARY (async=%d) (%s)\n", async,
1289                qxl_mode_to_string(d->mode));
1290         if (!qxl_destroy_primary(d, async)) {
1291             dprint(d, 1, "QXL_IO_DESTROY_PRIMARY_ASYNC in %s, ignored\n",
1292                     qxl_mode_to_string(d->mode));
1293             goto cancel_async;
1294         }
1295         break;
1296     case QXL_IO_DESTROY_SURFACE_WAIT:
1297         if (val >= NUM_SURFACES) {
1298             qxl_guest_bug(d, "QXL_IO_DESTROY_SURFACE (async=%d):"
1299                              "%d >= NUM_SURFACES", async, val);
1300             goto cancel_async;
1301         }
1302         qxl_spice_destroy_surface_wait(d, val, async);
1303         break;
1304 #if SPICE_INTERFACE_QXL_MINOR >= 1
1305     case QXL_IO_FLUSH_RELEASE: {
1306         QXLReleaseRing *ring = &d->ram->release_ring;
1307         if (ring->prod - ring->cons + 1 == ring->num_items) {
1308             fprintf(stderr,
1309                 "ERROR: no flush, full release ring [p%d,%dc]\n",
1310                 ring->prod, ring->cons);
1311         }
1312         qxl_push_free_res(d, 1 /* flush */);
1313         dprint(d, 1, "QXL_IO_FLUSH_RELEASE exit (%s, s#=%d, res#=%d,%p)\n",
1314             qxl_mode_to_string(d->mode), d->guest_surfaces.count,
1315             d->num_free_res, d->last_release);
1316         break;
1317     }
1318     case QXL_IO_FLUSH_SURFACES_ASYNC:
1319         dprint(d, 1, "QXL_IO_FLUSH_SURFACES_ASYNC"
1320                      " (%"PRId64") (%s, s#=%d, res#=%d)\n",
1321                val, qxl_mode_to_string(d->mode), d->guest_surfaces.count,
1322                d->num_free_res);
1323         qxl_spice_flush_surfaces_async(d);
1324         break;
1325 #endif
1326     case QXL_IO_DESTROY_ALL_SURFACES:
1327         d->mode = QXL_MODE_UNDEFINED;
1328         qxl_spice_destroy_surfaces(d, async);
1329         break;
1330     default:
1331         fprintf(stderr, "%s: ioport=0x%x, abort()\n", __FUNCTION__, io_port);
1332         abort();
1333     }
1334     return;
1335 cancel_async:
1336 #if SPICE_INTERFACE_QXL_MINOR >= 1
1337     if (async) {
1338         qxl_send_events(d, QXL_INTERRUPT_IO_CMD);
1339         qemu_mutex_lock(&d->async_lock);
1340         d->current_async = QXL_UNDEFINED_IO;
1341         qemu_mutex_unlock(&d->async_lock);
1342     }
1343 #else
1344     return;
1345 #endif
1346 }
1347
1348 static uint64_t ioport_read(void *opaque, target_phys_addr_t addr,
1349                             unsigned size)
1350 {
1351     PCIQXLDevice *d = opaque;
1352
1353     dprint(d, 1, "%s: unexpected\n", __FUNCTION__);
1354     return 0xff;
1355 }
1356
1357 static const MemoryRegionOps qxl_io_ops = {
1358     .read = ioport_read,
1359     .write = ioport_write,
1360     .valid = {
1361         .min_access_size = 1,
1362         .max_access_size = 1,
1363     },
1364 };
1365
1366 static void pipe_read(void *opaque)
1367 {
1368     PCIQXLDevice *d = opaque;
1369     char dummy;
1370     int len;
1371
1372     do {
1373         len = read(d->pipe[0], &dummy, sizeof(dummy));
1374     } while (len == sizeof(dummy));
1375     qxl_update_irq(d);
1376 }
1377
1378 static void qxl_send_events(PCIQXLDevice *d, uint32_t events)
1379 {
1380     uint32_t old_pending;
1381     uint32_t le_events = cpu_to_le32(events);
1382
1383     assert(d->ssd.running);
1384     old_pending = __sync_fetch_and_or(&d->ram->int_pending, le_events);
1385     if ((old_pending & le_events) == le_events) {
1386         return;
1387     }
1388     if (qemu_thread_is_self(&d->main)) {
1389         qxl_update_irq(d);
1390     } else {
1391         if (write(d->pipe[1], d, 1) != 1) {
1392             dprint(d, 1, "%s: write to pipe failed\n", __FUNCTION__);
1393         }
1394     }
1395 }
1396
1397 static void init_pipe_signaling(PCIQXLDevice *d)
1398 {
1399    if (pipe(d->pipe) < 0) {
1400        dprint(d, 1, "%s: pipe creation failed\n", __FUNCTION__);
1401        return;
1402    }
1403    fcntl(d->pipe[0], F_SETFL, O_NONBLOCK);
1404    fcntl(d->pipe[1], F_SETFL, O_NONBLOCK);
1405    fcntl(d->pipe[0], F_SETOWN, getpid());
1406
1407    qemu_thread_get_self(&d->main);
1408    qemu_set_fd_handler(d->pipe[0], pipe_read, NULL, d);
1409 }
1410
1411 /* graphics console */
1412
1413 static void qxl_hw_update(void *opaque)
1414 {
1415     PCIQXLDevice *qxl = opaque;
1416     VGACommonState *vga = &qxl->vga;
1417
1418     switch (qxl->mode) {
1419     case QXL_MODE_VGA:
1420         vga->update(vga);
1421         break;
1422     case QXL_MODE_COMPAT:
1423     case QXL_MODE_NATIVE:
1424         qxl_render_update(qxl);
1425         break;
1426     default:
1427         break;
1428     }
1429 }
1430
1431 static void qxl_hw_invalidate(void *opaque)
1432 {
1433     PCIQXLDevice *qxl = opaque;
1434     VGACommonState *vga = &qxl->vga;
1435
1436     vga->invalidate(vga);
1437 }
1438
1439 static void qxl_hw_screen_dump(void *opaque, const char *filename, bool cswitch)
1440 {
1441     PCIQXLDevice *qxl = opaque;
1442     VGACommonState *vga = &qxl->vga;
1443
1444     switch (qxl->mode) {
1445     case QXL_MODE_COMPAT:
1446     case QXL_MODE_NATIVE:
1447         qxl_render_update(qxl);
1448         ppm_save(filename, qxl->ssd.ds->surface);
1449         break;
1450     case QXL_MODE_VGA:
1451         vga->screen_dump(vga, filename, cswitch);
1452         break;
1453     default:
1454         break;
1455     }
1456 }
1457
1458 static void qxl_hw_text_update(void *opaque, console_ch_t *chardata)
1459 {
1460     PCIQXLDevice *qxl = opaque;
1461     VGACommonState *vga = &qxl->vga;
1462
1463     if (qxl->mode == QXL_MODE_VGA) {
1464         vga->text_update(vga, chardata);
1465         return;
1466     }
1467 }
1468
1469 static void qxl_dirty_surfaces(PCIQXLDevice *qxl)
1470 {
1471     intptr_t vram_start;
1472     int i;
1473
1474     if (qxl->mode != QXL_MODE_NATIVE && qxl->mode != QXL_MODE_COMPAT) {
1475         return;
1476     }
1477
1478     /* dirty the primary surface */
1479     qxl_set_dirty(&qxl->vga.vram, qxl->shadow_rom.draw_area_offset,
1480                   qxl->shadow_rom.surface0_area_size);
1481
1482     vram_start =  (intptr_t)memory_region_get_ram_ptr(&qxl->vram_bar);
1483
1484     /* dirty the off-screen surfaces */
1485     for (i = 0; i < NUM_SURFACES; i++) {
1486         QXLSurfaceCmd *cmd;
1487         intptr_t surface_offset;
1488         int surface_size;
1489
1490         if (qxl->guest_surfaces.cmds[i] == 0) {
1491             continue;
1492         }
1493
1494         cmd = qxl_phys2virt(qxl, qxl->guest_surfaces.cmds[i],
1495                             MEMSLOT_GROUP_GUEST);
1496         assert(cmd->type == QXL_SURFACE_CMD_CREATE);
1497         surface_offset = (intptr_t)qxl_phys2virt(qxl,
1498                                                  cmd->u.surface_create.data,
1499                                                  MEMSLOT_GROUP_GUEST);
1500         surface_offset -= vram_start;
1501         surface_size = cmd->u.surface_create.height *
1502                        abs(cmd->u.surface_create.stride);
1503         dprint(qxl, 3, "%s: dirty surface %d, offset %d, size %d\n", __func__,
1504                i, (int)surface_offset, surface_size);
1505         qxl_set_dirty(&qxl->vram_bar, surface_offset, surface_size);
1506     }
1507 }
1508
1509 static void qxl_vm_change_state_handler(void *opaque, int running,
1510                                         RunState state)
1511 {
1512     PCIQXLDevice *qxl = opaque;
1513     qemu_spice_vm_change_state_handler(&qxl->ssd, running, state);
1514
1515     if (running) {
1516         /*
1517          * if qxl_send_events was called from spice server context before
1518          * migration ended, qxl_update_irq for these events might not have been
1519          * called
1520          */
1521          qxl_update_irq(qxl);
1522     } else {
1523         /* make sure surfaces are saved before migration */
1524         qxl_dirty_surfaces(qxl);
1525     }
1526 }
1527
1528 /* display change listener */
1529
1530 static void display_update(struct DisplayState *ds, int x, int y, int w, int h)
1531 {
1532     if (qxl0->mode == QXL_MODE_VGA) {
1533         qemu_spice_display_update(&qxl0->ssd, x, y, w, h);
1534     }
1535 }
1536
1537 static void display_resize(struct DisplayState *ds)
1538 {
1539     if (qxl0->mode == QXL_MODE_VGA) {
1540         qemu_spice_display_resize(&qxl0->ssd);
1541     }
1542 }
1543
1544 static void display_refresh(struct DisplayState *ds)
1545 {
1546     if (qxl0->mode == QXL_MODE_VGA) {
1547         qemu_spice_display_refresh(&qxl0->ssd);
1548     }
1549 }
1550
1551 static DisplayChangeListener display_listener = {
1552     .dpy_update  = display_update,
1553     .dpy_resize  = display_resize,
1554     .dpy_refresh = display_refresh,
1555 };
1556
1557 static void qxl_init_ramsize(PCIQXLDevice *qxl, uint32_t ram_min_mb)
1558 {
1559     /* vga ram (bar 0) */
1560     if (qxl->ram_size_mb != -1) {
1561         qxl->vga.vram_size = qxl->ram_size_mb * 1024 * 1024;
1562     }
1563     if (qxl->vga.vram_size < ram_min_mb * 1024 * 1024) {
1564         qxl->vga.vram_size = ram_min_mb * 1024 * 1024;
1565     }
1566
1567     /* vram (surfaces, bar 1) */
1568     if (qxl->vram_size_mb != -1) {
1569         qxl->vram_size = qxl->vram_size_mb * 1024 * 1024;
1570     }
1571     if (qxl->vram_size < 4096) {
1572         qxl->vram_size = 4096;
1573     }
1574     if (qxl->revision == 1) {
1575         qxl->vram_size = 4096;
1576     }
1577
1578     qxl->vga.vram_size = msb_mask(qxl->vga.vram_size * 2 - 1);
1579     qxl->vram_size = msb_mask(qxl->vram_size * 2 - 1);
1580 }
1581
1582 static int qxl_init_common(PCIQXLDevice *qxl)
1583 {
1584     uint8_t* config = qxl->pci.config;
1585     uint32_t pci_device_rev;
1586     uint32_t io_size;
1587
1588     qxl->mode = QXL_MODE_UNDEFINED;
1589     qxl->generation = 1;
1590     qxl->num_memslots = NUM_MEMSLOTS;
1591     qxl->num_surfaces = NUM_SURFACES;
1592     qemu_mutex_init(&qxl->track_lock);
1593     qemu_mutex_init(&qxl->async_lock);
1594     qxl->current_async = QXL_UNDEFINED_IO;
1595
1596     switch (qxl->revision) {
1597     case 1: /* spice 0.4 -- qxl-1 */
1598         pci_device_rev = QXL_REVISION_STABLE_V04;
1599         break;
1600     case 2: /* spice 0.6 -- qxl-2 */
1601         pci_device_rev = QXL_REVISION_STABLE_V06;
1602         break;
1603 #if SPICE_INTERFACE_QXL_MINOR >= 1
1604     case 3: /* qxl-3 */
1605 #endif
1606     default:
1607         pci_device_rev = QXL_DEFAULT_REVISION;
1608         break;
1609     }
1610
1611     pci_set_byte(&config[PCI_REVISION_ID], pci_device_rev);
1612     pci_set_byte(&config[PCI_INTERRUPT_PIN], 1);
1613
1614     qxl->rom_size = qxl_rom_size();
1615     memory_region_init_ram(&qxl->rom_bar, "qxl.vrom", qxl->rom_size);
1616     vmstate_register_ram(&qxl->rom_bar, &qxl->pci.qdev);
1617     init_qxl_rom(qxl);
1618     init_qxl_ram(qxl);
1619
1620     memory_region_init_ram(&qxl->vram_bar, "qxl.vram", qxl->vram_size);
1621     vmstate_register_ram(&qxl->vram_bar, &qxl->pci.qdev);
1622
1623     io_size = msb_mask(QXL_IO_RANGE_SIZE * 2 - 1);
1624     if (qxl->revision == 1) {
1625         io_size = 8;
1626     }
1627
1628     memory_region_init_io(&qxl->io_bar, &qxl_io_ops, qxl,
1629                           "qxl-ioports", io_size);
1630     if (qxl->id == 0) {
1631         vga_dirty_log_start(&qxl->vga);
1632     }
1633
1634
1635     pci_register_bar(&qxl->pci, QXL_IO_RANGE_INDEX,
1636                      PCI_BASE_ADDRESS_SPACE_IO, &qxl->io_bar);
1637
1638     pci_register_bar(&qxl->pci, QXL_ROM_RANGE_INDEX,
1639                      PCI_BASE_ADDRESS_SPACE_MEMORY, &qxl->rom_bar);
1640
1641     pci_register_bar(&qxl->pci, QXL_RAM_RANGE_INDEX,
1642                      PCI_BASE_ADDRESS_SPACE_MEMORY, &qxl->vga.vram);
1643
1644     pci_register_bar(&qxl->pci, QXL_VRAM_RANGE_INDEX,
1645                      PCI_BASE_ADDRESS_SPACE_MEMORY, &qxl->vram_bar);
1646
1647     qxl->ssd.qxl.base.sif = &qxl_interface.base;
1648     qxl->ssd.qxl.id = qxl->id;
1649     qemu_spice_add_interface(&qxl->ssd.qxl.base);
1650     qemu_add_vm_change_state_handler(qxl_vm_change_state_handler, qxl);
1651
1652     init_pipe_signaling(qxl);
1653     qxl_reset_state(qxl);
1654
1655     return 0;
1656 }
1657
1658 static int qxl_init_primary(PCIDevice *dev)
1659 {
1660     PCIQXLDevice *qxl = DO_UPCAST(PCIQXLDevice, pci, dev);
1661     VGACommonState *vga = &qxl->vga;
1662     PortioList *qxl_vga_port_list = g_new(PortioList, 1);
1663
1664     qxl->id = 0;
1665     qxl_init_ramsize(qxl, 32);
1666     vga_common_init(vga, qxl->vga.vram_size);
1667     vga_init(vga, pci_address_space(dev), pci_address_space_io(dev), false);
1668     portio_list_init(qxl_vga_port_list, qxl_vga_portio_list, vga, "vga");
1669     portio_list_add(qxl_vga_port_list, pci_address_space_io(dev), 0x3b0);
1670
1671     vga->ds = graphic_console_init(qxl_hw_update, qxl_hw_invalidate,
1672                                    qxl_hw_screen_dump, qxl_hw_text_update, qxl);
1673     qemu_spice_display_init_common(&qxl->ssd, vga->ds);
1674
1675     qxl0 = qxl;
1676     register_displaychangelistener(vga->ds, &display_listener);
1677
1678     return qxl_init_common(qxl);
1679 }
1680
1681 static int qxl_init_secondary(PCIDevice *dev)
1682 {
1683     static int device_id = 1;
1684     PCIQXLDevice *qxl = DO_UPCAST(PCIQXLDevice, pci, dev);
1685
1686     qxl->id = device_id++;
1687     qxl_init_ramsize(qxl, 16);
1688     memory_region_init_ram(&qxl->vga.vram, "qxl.vgavram", qxl->vga.vram_size);
1689     vmstate_register_ram(&qxl->vga.vram, &qxl->pci.qdev);
1690     qxl->vga.vram_ptr = memory_region_get_ram_ptr(&qxl->vga.vram);
1691
1692     return qxl_init_common(qxl);
1693 }
1694
1695 static void qxl_pre_save(void *opaque)
1696 {
1697     PCIQXLDevice* d = opaque;
1698     uint8_t *ram_start = d->vga.vram_ptr;
1699
1700     dprint(d, 1, "%s:\n", __FUNCTION__);
1701     if (d->last_release == NULL) {
1702         d->last_release_offset = 0;
1703     } else {
1704         d->last_release_offset = (uint8_t *)d->last_release - ram_start;
1705     }
1706     assert(d->last_release_offset < d->vga.vram_size);
1707 }
1708
1709 static int qxl_pre_load(void *opaque)
1710 {
1711     PCIQXLDevice* d = opaque;
1712
1713     dprint(d, 1, "%s: start\n", __FUNCTION__);
1714     qxl_hard_reset(d, 1);
1715     qxl_exit_vga_mode(d);
1716     dprint(d, 1, "%s: done\n", __FUNCTION__);
1717     return 0;
1718 }
1719
1720 static void qxl_create_memslots(PCIQXLDevice *d)
1721 {
1722     int i;
1723
1724     for (i = 0; i < NUM_MEMSLOTS; i++) {
1725         if (!d->guest_slots[i].active) {
1726             continue;
1727         }
1728         dprint(d, 1, "%s: restoring guest slot %d\n", __func__, i);
1729         qxl_add_memslot(d, i, 0, QXL_SYNC);
1730     }
1731 }
1732
1733 static int qxl_post_load(void *opaque, int version)
1734 {
1735     PCIQXLDevice* d = opaque;
1736     uint8_t *ram_start = d->vga.vram_ptr;
1737     QXLCommandExt *cmds;
1738     int in, out, newmode;
1739
1740     dprint(d, 1, "%s: start\n", __FUNCTION__);
1741
1742     assert(d->last_release_offset < d->vga.vram_size);
1743     if (d->last_release_offset == 0) {
1744         d->last_release = NULL;
1745     } else {
1746         d->last_release = (QXLReleaseInfo *)(ram_start + d->last_release_offset);
1747     }
1748
1749     d->modes = (QXLModes*)((uint8_t*)d->rom + d->rom->modes_offset);
1750
1751     dprint(d, 1, "%s: restore mode (%s)\n", __FUNCTION__,
1752         qxl_mode_to_string(d->mode));
1753     newmode = d->mode;
1754     d->mode = QXL_MODE_UNDEFINED;
1755
1756     switch (newmode) {
1757     case QXL_MODE_UNDEFINED:
1758         break;
1759     case QXL_MODE_VGA:
1760         qxl_create_memslots(d);
1761         qxl_enter_vga_mode(d);
1762         break;
1763     case QXL_MODE_NATIVE:
1764         qxl_create_memslots(d);
1765         qxl_create_guest_primary(d, 1, QXL_SYNC);
1766
1767         /* replay surface-create and cursor-set commands */
1768         cmds = g_malloc0(sizeof(QXLCommandExt) * (NUM_SURFACES + 1));
1769         for (in = 0, out = 0; in < NUM_SURFACES; in++) {
1770             if (d->guest_surfaces.cmds[in] == 0) {
1771                 continue;
1772             }
1773             cmds[out].cmd.data = d->guest_surfaces.cmds[in];
1774             cmds[out].cmd.type = QXL_CMD_SURFACE;
1775             cmds[out].group_id = MEMSLOT_GROUP_GUEST;
1776             out++;
1777         }
1778         if (d->guest_cursor) {
1779             cmds[out].cmd.data = d->guest_cursor;
1780             cmds[out].cmd.type = QXL_CMD_CURSOR;
1781             cmds[out].group_id = MEMSLOT_GROUP_GUEST;
1782             out++;
1783         }
1784         qxl_spice_loadvm_commands(d, cmds, out);
1785         g_free(cmds);
1786
1787         break;
1788     case QXL_MODE_COMPAT:
1789         /* note: no need to call qxl_create_memslots, qxl_set_mode
1790          * creates the mem slot. */
1791         qxl_set_mode(d, d->shadow_rom.mode, 1);
1792         break;
1793     }
1794     dprint(d, 1, "%s: done\n", __FUNCTION__);
1795
1796     return 0;
1797 }
1798
1799 #define QXL_SAVE_VERSION 21
1800
1801 static VMStateDescription qxl_memslot = {
1802     .name               = "qxl-memslot",
1803     .version_id         = QXL_SAVE_VERSION,
1804     .minimum_version_id = QXL_SAVE_VERSION,
1805     .fields = (VMStateField[]) {
1806         VMSTATE_UINT64(slot.mem_start, struct guest_slots),
1807         VMSTATE_UINT64(slot.mem_end,   struct guest_slots),
1808         VMSTATE_UINT32(active,         struct guest_slots),
1809         VMSTATE_END_OF_LIST()
1810     }
1811 };
1812
1813 static VMStateDescription qxl_surface = {
1814     .name               = "qxl-surface",
1815     .version_id         = QXL_SAVE_VERSION,
1816     .minimum_version_id = QXL_SAVE_VERSION,
1817     .fields = (VMStateField[]) {
1818         VMSTATE_UINT32(width,      QXLSurfaceCreate),
1819         VMSTATE_UINT32(height,     QXLSurfaceCreate),
1820         VMSTATE_INT32(stride,      QXLSurfaceCreate),
1821         VMSTATE_UINT32(format,     QXLSurfaceCreate),
1822         VMSTATE_UINT32(position,   QXLSurfaceCreate),
1823         VMSTATE_UINT32(mouse_mode, QXLSurfaceCreate),
1824         VMSTATE_UINT32(flags,      QXLSurfaceCreate),
1825         VMSTATE_UINT32(type,       QXLSurfaceCreate),
1826         VMSTATE_UINT64(mem,        QXLSurfaceCreate),
1827         VMSTATE_END_OF_LIST()
1828     }
1829 };
1830
1831 static VMStateDescription qxl_vmstate = {
1832     .name               = "qxl",
1833     .version_id         = QXL_SAVE_VERSION,
1834     .minimum_version_id = QXL_SAVE_VERSION,
1835     .pre_save           = qxl_pre_save,
1836     .pre_load           = qxl_pre_load,
1837     .post_load          = qxl_post_load,
1838     .fields = (VMStateField []) {
1839         VMSTATE_PCI_DEVICE(pci, PCIQXLDevice),
1840         VMSTATE_STRUCT(vga, PCIQXLDevice, 0, vmstate_vga_common, VGACommonState),
1841         VMSTATE_UINT32(shadow_rom.mode, PCIQXLDevice),
1842         VMSTATE_UINT32(num_free_res, PCIQXLDevice),
1843         VMSTATE_UINT32(last_release_offset, PCIQXLDevice),
1844         VMSTATE_UINT32(mode, PCIQXLDevice),
1845         VMSTATE_UINT32(ssd.unique, PCIQXLDevice),
1846         VMSTATE_INT32_EQUAL(num_memslots, PCIQXLDevice),
1847         VMSTATE_STRUCT_ARRAY(guest_slots, PCIQXLDevice, NUM_MEMSLOTS, 0,
1848                              qxl_memslot, struct guest_slots),
1849         VMSTATE_STRUCT(guest_primary.surface, PCIQXLDevice, 0,
1850                        qxl_surface, QXLSurfaceCreate),
1851         VMSTATE_INT32_EQUAL(num_surfaces, PCIQXLDevice),
1852         VMSTATE_ARRAY(guest_surfaces.cmds, PCIQXLDevice, NUM_SURFACES, 0,
1853                       vmstate_info_uint64, uint64_t),
1854         VMSTATE_UINT64(guest_cursor, PCIQXLDevice),
1855         VMSTATE_END_OF_LIST()
1856     },
1857 };
1858
1859 static Property qxl_properties[] = {
1860         DEFINE_PROP_UINT32("ram_size", PCIQXLDevice, vga.vram_size,
1861                            64 * 1024 * 1024),
1862         DEFINE_PROP_UINT32("vram_size", PCIQXLDevice, vram_size,
1863                            64 * 1024 * 1024),
1864         DEFINE_PROP_UINT32("revision", PCIQXLDevice, revision,
1865                            QXL_DEFAULT_REVISION),
1866         DEFINE_PROP_UINT32("debug", PCIQXLDevice, debug, 0),
1867         DEFINE_PROP_UINT32("guestdebug", PCIQXLDevice, guestdebug, 0),
1868         DEFINE_PROP_UINT32("cmdlog", PCIQXLDevice, cmdlog, 0),
1869         DEFINE_PROP_UINT32("ram_size_mb",  PCIQXLDevice, ram_size_mb, -1),
1870         DEFINE_PROP_UINT32("vram_size_mb", PCIQXLDevice, vram_size_mb, -1),
1871         DEFINE_PROP_END_OF_LIST(),
1872 };
1873
1874 static void qxl_primary_class_init(ObjectClass *klass, void *data)
1875 {
1876     DeviceClass *dc = DEVICE_CLASS(klass);
1877     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
1878
1879     k->no_hotplug = 1;
1880     k->init = qxl_init_primary;
1881     k->romfile = "vgabios-qxl.bin";
1882     k->vendor_id = REDHAT_PCI_VENDOR_ID;
1883     k->device_id = QXL_DEVICE_ID_STABLE;
1884     k->class_id = PCI_CLASS_DISPLAY_VGA;
1885     dc->desc = "Spice QXL GPU (primary, vga compatible)";
1886     dc->reset = qxl_reset_handler;
1887     dc->vmsd = &qxl_vmstate;
1888     dc->props = qxl_properties;
1889 }
1890
1891 static TypeInfo qxl_primary_info = {
1892     .name          = "qxl-vga",
1893     .parent        = TYPE_PCI_DEVICE,
1894     .instance_size = sizeof(PCIQXLDevice),
1895     .class_init    = qxl_primary_class_init,
1896 };
1897
1898 static void qxl_secondary_class_init(ObjectClass *klass, void *data)
1899 {
1900     DeviceClass *dc = DEVICE_CLASS(klass);
1901     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
1902
1903     k->init = qxl_init_secondary;
1904     k->vendor_id = REDHAT_PCI_VENDOR_ID;
1905     k->device_id = QXL_DEVICE_ID_STABLE;
1906     k->class_id = PCI_CLASS_DISPLAY_OTHER;
1907     dc->desc = "Spice QXL GPU (secondary)";
1908     dc->reset = qxl_reset_handler;
1909     dc->vmsd = &qxl_vmstate;
1910     dc->props = qxl_properties;
1911 }
1912
1913 static TypeInfo qxl_secondary_info = {
1914     .name          = "qxl",
1915     .parent        = TYPE_PCI_DEVICE,
1916     .instance_size = sizeof(PCIQXLDevice),
1917     .class_init    = qxl_secondary_class_init,
1918 };
1919
1920 static void qxl_register_types(void)
1921 {
1922     type_register_static(&qxl_primary_info);
1923     type_register_static(&qxl_secondary_info);
1924 }
1925
1926 type_init(qxl_register_types)