[qemu.git] / ui / spice-display.c

/*
 * Copyright (C) 2010 Red Hat, Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 or
 * (at your option) version 3 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include <pthread.h>

#include "qemu-common.h"
#include "qemu-spice.h"
#include "qemu-timer.h"
#include "qemu-queue.h"
#include "monitor.h"
#include "console.h"
#include "sysemu.h"

#include "spice-display.h"

static int debug = 0;

static void GCC_FMT_ATTR(2, 3) dprint(int level, const char *fmt, ...)
{
    va_list args;

    if (level <= debug) {
        va_start(args, fmt);
        vfprintf(stderr, fmt, args);
        va_end(args);
    }
}

int qemu_spice_rect_is_empty(const QXLRect* r)
{
    return r->top == r->bottom || r->left == r->right;
}

void qemu_spice_rect_union(QXLRect *dest, const QXLRect *r)
{
    if (qemu_spice_rect_is_empty(r)) {
        return;
    }

    if (qemu_spice_rect_is_empty(dest)) {
        *dest = *r;
        return;
    }

    dest->top = MIN(dest->top, r->top);
    dest->left = MIN(dest->left, r->left);
    dest->bottom = MAX(dest->bottom, r->bottom);
    dest->right = MAX(dest->right, r->right);
}

/*
 * Called from spice server thread context (via interface_get_command).
 *
 * We must aquire the global qemu mutex here to make sure the
 * DisplayState (+DisplaySurface) we are accessing doesn't change
 * underneath us.
 */
SimpleSpiceUpdate *qemu_spice_create_update(SimpleSpiceDisplay *ssd)
{
    SimpleSpiceUpdate *update;
    QXLDrawable *drawable;
    QXLImage *image;
    QXLCommand *cmd;
    uint8_t *src, *dst;
    int by, bw, bh;

    qemu_mutex_lock_iothread();
    if (qemu_spice_rect_is_empty(&ssd->dirty)) {
        qemu_mutex_unlock_iothread();
        return NULL;
    };

    dprint(2, "%s: lr %d -> %d,  tb -> %d -> %d\n", __FUNCTION__,
           ssd->dirty.left, ssd->dirty.right,
           ssd->dirty.top, ssd->dirty.bottom);

    update   = qemu_mallocz(sizeof(*update));
    drawable = &update->drawable;
    image    = &update->image;
    cmd      = &update->ext.cmd;

    bw       = ssd->dirty.right - ssd->dirty.left;
    bh       = ssd->dirty.bottom - ssd->dirty.top;
    update->bitmap = qemu_malloc(bw * bh * 4);

    drawable->bbox            = ssd->dirty;
    drawable->clip.type       = SPICE_CLIP_TYPE_NONE;
    drawable->effect          = QXL_EFFECT_OPAQUE;
    drawable->release_info.id = (intptr_t)update;
    drawable->type            = QXL_DRAW_COPY;
    drawable->surfaces_dest[0] = -1;
    drawable->surfaces_dest[1] = -1;
    drawable->surfaces_dest[2] = -1;

    drawable->u.copy.rop_descriptor  = SPICE_ROPD_OP_PUT;
    drawable->u.copy.src_bitmap      = (intptr_t)image;
    drawable->u.copy.src_area.right  = bw;
    drawable->u.copy.src_area.bottom = bh;

    QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_DEVICE, ssd->unique++);
    image->descriptor.type   = SPICE_IMAGE_TYPE_BITMAP;
    image->bitmap.flags      = QXL_BITMAP_DIRECT | QXL_BITMAP_TOP_DOWN;
    image->bitmap.stride     = bw * 4;
    image->descriptor.width  = image->bitmap.x = bw;
    image->descriptor.height = image->bitmap.y = bh;
    image->bitmap.data = (intptr_t)(update->bitmap);
    image->bitmap.palette = 0;
    image->bitmap.format = SPICE_BITMAP_FMT_32BIT;

    if (ssd->conv == NULL) {
        PixelFormat dst = qemu_default_pixelformat(32);
        ssd->conv = qemu_pf_conv_get(&dst, &ssd->ds->surface->pf);
        assert(ssd->conv);
    }

    src = ds_get_data(ssd->ds) +
        ssd->dirty.top * ds_get_linesize(ssd->ds) +
        ssd->dirty.left * ds_get_bytes_per_pixel(ssd->ds);
    dst = update->bitmap;
    for (by = 0; by < bh; by++) {
        qemu_pf_conv_run(ssd->conv, dst, src, bw);
        src += ds_get_linesize(ssd->ds);
        dst += image->bitmap.stride;
    }

    cmd->type = QXL_CMD_DRAW;
    cmd->data = (intptr_t)drawable;

    memset(&ssd->dirty, 0, sizeof(ssd->dirty));
    qemu_mutex_unlock_iothread();
    return update;
}

/*
 * Called from spice server thread context (via interface_release_ressource)
 * We do *not* hold the global qemu mutex here, so extra care is needed
 * when calling qemu functions.  Qemu interfaces used:
 *    - qemu_free (underlying glibc free is re-entrant).
 */
void qemu_spice_destroy_update(SimpleSpiceDisplay *sdpy, SimpleSpiceUpdate *update)
{
    qemu_free(update->bitmap);
    qemu_free(update);
}

void qemu_spice_create_host_memslot(SimpleSpiceDisplay *ssd)
{
    QXLDevMemSlot memslot;

    dprint(1, "%s:\n", __FUNCTION__);

    memset(&memslot, 0, sizeof(memslot));
    memslot.slot_group_id = MEMSLOT_GROUP_HOST;
    memslot.virt_end = ~0;
    ssd->worker->add_memslot(ssd->worker, &memslot);
}

void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd)
{
    QXLDevSurfaceCreate surface;

    dprint(1, "%s: %dx%d\n", __FUNCTION__,
           ds_get_width(ssd->ds), ds_get_height(ssd->ds));

    surface.format     = SPICE_SURFACE_FMT_32_xRGB;
    surface.width      = ds_get_width(ssd->ds);
    surface.height     = ds_get_height(ssd->ds);
    surface.stride     = -surface.width * 4;
    surface.mouse_mode = true;
    surface.flags      = 0;
    surface.type       = 0;
    surface.mem        = (intptr_t)ssd->buf;
    surface.group_id   = MEMSLOT_GROUP_HOST;

    qemu_mutex_unlock_iothread();
    ssd->worker->create_primary_surface(ssd->worker, 0, &surface);
    qemu_mutex_lock_iothread();
}

void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
{
    dprint(1, "%s:\n", __FUNCTION__);

    qemu_mutex_unlock_iothread();
    ssd->worker->destroy_primary_surface(ssd->worker, 0);
    qemu_mutex_lock_iothread();
}

void qemu_spice_vm_change_state_handler(void *opaque, int running, int reason)
{
    SimpleSpiceDisplay *ssd = opaque;

    if (running) {
        ssd->worker->start(ssd->worker);
    } else {
        qemu_mutex_unlock_iothread();
        ssd->worker->stop(ssd->worker);
        qemu_mutex_lock_iothread();
    }
    ssd->running = running;
}

/* display listener callbacks */

void qemu_spice_display_update(SimpleSpiceDisplay *ssd,
                               int x, int y, int w, int h)
{
    QXLRect update_area;

    dprint(2, "%s: x %d y %d w %d h %d\n", __FUNCTION__, x, y, w, h);
    update_area.left = x,
    update_area.right = x + w;
    update_area.top = y;
    update_area.bottom = y + h;

    if (qemu_spice_rect_is_empty(&ssd->dirty)) {
        ssd->notify++;
    }
    qemu_spice_rect_union(&ssd->dirty, &update_area);
}

void qemu_spice_display_resize(SimpleSpiceDisplay *ssd)
{
    dprint(1, "%s:\n", __FUNCTION__);

    memset(&ssd->dirty, 0, sizeof(ssd->dirty));
    qemu_pf_conv_put(ssd->conv);
    ssd->conv = NULL;

    qemu_spice_destroy_host_primary(ssd);
    qemu_spice_create_host_primary(ssd);

    memset(&ssd->dirty, 0, sizeof(ssd->dirty));
    ssd->notify++;
}

void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)
{
    dprint(3, "%s:\n", __FUNCTION__);
    vga_hw_update();
    if (ssd->notify) {
        ssd->notify = 0;
        ssd->worker->wakeup(ssd->worker);
        dprint(2, "%s: notify\n", __FUNCTION__);
    }
}

/* spice display interface callbacks */

static void interface_attach_worker(QXLInstance *sin, QXLWorker *qxl_worker)
{
    SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);

    dprint(1, "%s:\n", __FUNCTION__);
    ssd->worker = qxl_worker;
}

static void interface_set_compression_level(QXLInstance *sin, int level)
{
    dprint(1, "%s:\n", __FUNCTION__);
    /* nothing to do */
}

static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)
{
    dprint(3, "%s:\n", __FUNCTION__);
    /* nothing to do */
}

static void interface_get_init_info(QXLInstance *sin, QXLDevInitInfo *info)
{
    SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);

    info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;
    info->memslot_id_bits  = MEMSLOT_SLOT_BITS;
    info->num_memslots = NUM_MEMSLOTS;
    info->num_memslots_groups = NUM_MEMSLOTS_GROUPS;
    info->internal_groupslot_id = 0;
    info->qxl_ram_size = ssd->bufsize;
    info->n_surfaces = NUM_SURFACES;
}

static int interface_get_command(QXLInstance *sin, struct QXLCommandExt *ext)
{
    SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
    SimpleSpiceUpdate *update;

    dprint(3, "%s:\n", __FUNCTION__);
    update = qemu_spice_create_update(ssd);
    if (update == NULL) {
        return false;
    }
    *ext = update->ext;
    return true;
}

static int interface_req_cmd_notification(QXLInstance *sin)
{
    dprint(1, "%s:\n", __FUNCTION__);
    return 1;
}

static void interface_release_resource(QXLInstance *sin,
                                       struct QXLReleaseInfoExt ext)
{
    SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
    uintptr_t id;

    dprint(2, "%s:\n", __FUNCTION__);
    id = ext.info->id;
    qemu_spice_destroy_update(ssd, (void*)id);
}

static int interface_get_cursor_command(QXLInstance *sin, struct QXLCommandExt *ext)
{
    dprint(3, "%s:\n", __FUNCTION__);
    return false;
}

static int interface_req_cursor_notification(QXLInstance *sin)
{
    dprint(1, "%s:\n", __FUNCTION__);
    return 1;
}

static void interface_notify_update(QXLInstance *sin, uint32_t update_id)
{
    fprintf(stderr, "%s: abort()\n", __FUNCTION__);
    abort();
}

static int interface_flush_resources(QXLInstance *sin)
{
    fprintf(stderr, "%s: abort()\n", __FUNCTION__);
    abort();
    return 0;
}

static const QXLInterface dpy_interface = {
    .base.type               = SPICE_INTERFACE_QXL,
    .base.description        = "qemu simple display",
    .base.major_version      = SPICE_INTERFACE_QXL_MAJOR,
    .base.minor_version      = SPICE_INTERFACE_QXL_MINOR,

    .attache_worker          = interface_attach_worker,
    .set_compression_level   = interface_set_compression_level,
    .set_mm_time             = interface_set_mm_time,
    .get_init_info           = interface_get_init_info,

    /* the callbacks below are called from spice server thread context */
    .get_command             = interface_get_command,
    .req_cmd_notification    = interface_req_cmd_notification,
    .release_resource        = interface_release_resource,
    .get_cursor_command      = interface_get_cursor_command,
    .req_cursor_notification = interface_req_cursor_notification,
    .notify_update           = interface_notify_update,
    .flush_resources         = interface_flush_resources,
};

static SimpleSpiceDisplay sdpy;

static void display_update(struct DisplayState *ds, int x, int y, int w, int h)
{
    qemu_spice_display_update(&sdpy, x, y, w, h);
}

static void display_resize(struct DisplayState *ds)
{
    qemu_spice_display_resize(&sdpy);
}

static void display_refresh(struct DisplayState *ds)
{
    qemu_spice_display_refresh(&sdpy);
}

static DisplayChangeListener display_listener = {
    .dpy_update  = display_update,
    .dpy_resize  = display_resize,
    .dpy_refresh = display_refresh,
};

void qemu_spice_display_init(DisplayState *ds)
{
    assert(sdpy.ds == NULL);
    sdpy.ds = ds;
    sdpy.bufsize = (16 * 1024 * 1024);
    sdpy.buf = qemu_malloc(sdpy.bufsize);
    register_displaychangelistener(ds, &display_listener);

    sdpy.qxl.base.sif = &dpy_interface.base;
    qemu_spice_add_interface(&sdpy.qxl.base);
    assert(sdpy.worker);

    qemu_add_vm_change_state_handler(qemu_spice_vm_change_state_handler, &sdpy);
    qemu_spice_create_host_memslot(&sdpy);
    qemu_spice_create_host_primary(&sdpy);
}
Commit	Line	Data
a3e22260 GH	1	/*
	2	* Copyright (C) 2010 Red Hat, Inc.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License as
	6	* published by the Free Software Foundation; either version 2 or
	7	* (at your option) version 3 of the License.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	16	*/
	17
	18	#include <pthread.h>
	19
	20	#include "qemu-common.h"
	21	#include "qemu-spice.h"
	22	#include "qemu-timer.h"
	23	#include "qemu-queue.h"
	24	#include "monitor.h"
	25	#include "console.h"
	26	#include "sysemu.h"
	27
	28	#include "spice-display.h"
	29
	30	static int debug = 0;
	31
2c80e423	32	static void GCC_FMT_ATTR(2, 3) dprint(int level, const char *fmt, ...)
a3e22260 GH	33	{
	34	va_list args;
	35
	36	if (level <= debug) {
	37	va_start(args, fmt);
	38	vfprintf(stderr, fmt, args);
	39	va_end(args);
	40	}
	41	}
	42
	43	int qemu_spice_rect_is_empty(const QXLRect* r)
	44	{
	45	return r->top == r->bottom \|\| r->left == r->right;
	46	}
	47
	48	void qemu_spice_rect_union(QXLRect dest, const QXLRect r)
	49	{
	50	if (qemu_spice_rect_is_empty(r)) {
	51	return;
	52	}
	53
	54	if (qemu_spice_rect_is_empty(dest)) {
	55	dest = r;
	56	return;
	57	}
	58
	59	dest->top = MIN(dest->top, r->top);
	60	dest->left = MIN(dest->left, r->left);
	61	dest->bottom = MAX(dest->bottom, r->bottom);
	62	dest->right = MAX(dest->right, r->right);
	63	}
	64
	65	/*
	66	* Called from spice server thread context (via interface_get_command).
7466bc49 GH	67	*
	68	* We must aquire the global qemu mutex here to make sure the
	69	* DisplayState (+DisplaySurface) we are accessing doesn't change
	70	* underneath us.
a3e22260 GH	71	*/
	72	SimpleSpiceUpdate qemu_spice_create_update(SimpleSpiceDisplay ssd)
	73	{
	74	SimpleSpiceUpdate *update;
	75	QXLDrawable *drawable;
	76	QXLImage *image;
	77	QXLCommand *cmd;
	78	uint8_t src, dst;
	79	int by, bw, bh;
	80
7466bc49	81	qemu_mutex_lock_iothread();
a3e22260	82	if (qemu_spice_rect_is_empty(&ssd->dirty)) {
7466bc49	83	qemu_mutex_unlock_iothread();
a3e22260 GH	84	return NULL;
	85	};
	86
a3e22260 GH	87	dprint(2, "%s: lr %d -> %d, tb -> %d -> %d\n", __FUNCTION__,
	88	ssd->dirty.left, ssd->dirty.right,
	89	ssd->dirty.top, ssd->dirty.bottom);
	90
	91	update = qemu_mallocz(sizeof(*update));
	92	drawable = &update->drawable;
	93	image = &update->image;
	94	cmd = &update->ext.cmd;
	95
	96	bw = ssd->dirty.right - ssd->dirty.left;
	97	bh = ssd->dirty.bottom - ssd->dirty.top;
	98	update->bitmap = qemu_malloc(bw * bh * 4);
	99
	100	drawable->bbox = ssd->dirty;
	101	drawable->clip.type = SPICE_CLIP_TYPE_NONE;
	102	drawable->effect = QXL_EFFECT_OPAQUE;
	103	drawable->release_info.id = (intptr_t)update;
	104	drawable->type = QXL_DRAW_COPY;
	105	drawable->surfaces_dest[0] = -1;
	106	drawable->surfaces_dest[1] = -1;
	107	drawable->surfaces_dest[2] = -1;
	108
	109	drawable->u.copy.rop_descriptor = SPICE_ROPD_OP_PUT;
	110	drawable->u.copy.src_bitmap = (intptr_t)image;
	111	drawable->u.copy.src_area.right = bw;
	112	drawable->u.copy.src_area.bottom = bh;
	113
	114	QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_DEVICE, ssd->unique++);
	115	image->descriptor.type = SPICE_IMAGE_TYPE_BITMAP;
	116	image->bitmap.flags = QXL_BITMAP_DIRECT \| QXL_BITMAP_TOP_DOWN;
	117	image->bitmap.stride = bw * 4;
	118	image->descriptor.width = image->bitmap.x = bw;
	119	image->descriptor.height = image->bitmap.y = bh;
	120	image->bitmap.data = (intptr_t)(update->bitmap);
	121	image->bitmap.palette = 0;
	122	image->bitmap.format = SPICE_BITMAP_FMT_32BIT;
	123
	124	if (ssd->conv == NULL) {
	125	PixelFormat dst = qemu_default_pixelformat(32);
	126	ssd->conv = qemu_pf_conv_get(&dst, &ssd->ds->surface->pf);
	127	assert(ssd->conv);
	128	}
	129
	130	src = ds_get_data(ssd->ds) +
	131	ssd->dirty.top * ds_get_linesize(ssd->ds) +
	132	ssd->dirty.left * ds_get_bytes_per_pixel(ssd->ds);
	133	dst = update->bitmap;
	134	for (by = 0; by < bh; by++) {
	135	qemu_pf_conv_run(ssd->conv, dst, src, bw);
	136	src += ds_get_linesize(ssd->ds);
	137	dst += image->bitmap.stride;
	138	}
	139
	140	cmd->type = QXL_CMD_DRAW;
	141	cmd->data = (intptr_t)drawable;
	142
	143	memset(&ssd->dirty, 0, sizeof(ssd->dirty));
7466bc49	144	qemu_mutex_unlock_iothread();
a3e22260 GH	145	return update;
	146	}
	147
	148	/*
	149	* Called from spice server thread context (via interface_release_ressource)
	150	* We do not hold the global qemu mutex here, so extra care is needed
	151	* when calling qemu functions. Qemu interfaces used:
	152	* - qemu_free (underlying glibc free is re-entrant).
	153	*/
	154	void qemu_spice_destroy_update(SimpleSpiceDisplay sdpy, SimpleSpiceUpdate update)
	155	{
	156	qemu_free(update->bitmap);
	157	qemu_free(update);
	158	}
	159
	160	void qemu_spice_create_host_memslot(SimpleSpiceDisplay *ssd)
	161	{
	162	QXLDevMemSlot memslot;
	163
	164	dprint(1, "%s:\n", __FUNCTION__);
	165
	166	memset(&memslot, 0, sizeof(memslot));
	167	memslot.slot_group_id = MEMSLOT_GROUP_HOST;
	168	memslot.virt_end = ~0;
	169	ssd->worker->add_memslot(ssd->worker, &memslot);
	170	}
	171
	172	void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd)
	173	{
	174	QXLDevSurfaceCreate surface;
	175
	176	dprint(1, "%s: %dx%d\n", __FUNCTION__,
	177	ds_get_width(ssd->ds), ds_get_height(ssd->ds));
	178
	179	surface.format = SPICE_SURFACE_FMT_32_xRGB;
	180	surface.width = ds_get_width(ssd->ds);
	181	surface.height = ds_get_height(ssd->ds);
	182	surface.stride = -surface.width * 4;
869564a9	183	surface.mouse_mode = true;
a3e22260 GH	184	surface.flags = 0;
	185	surface.type = 0;
	186	surface.mem = (intptr_t)ssd->buf;
	187	surface.group_id = MEMSLOT_GROUP_HOST;
7466bc49 GH	188
7466bc49 GH	189	qemu_mutex_unlock_iothread();
a3e22260	190	ssd->worker->create_primary_surface(ssd->worker, 0, &surface);
7466bc49	191	qemu_mutex_lock_iothread();
a3e22260 GH	192	}
	193
	194	void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
	195	{
	196	dprint(1, "%s:\n", __FUNCTION__);
	197
7466bc49	198	qemu_mutex_unlock_iothread();
a3e22260	199	ssd->worker->destroy_primary_surface(ssd->worker, 0);
7466bc49	200	qemu_mutex_lock_iothread();
a3e22260 GH	201	}
	202
	203	void qemu_spice_vm_change_state_handler(void *opaque, int running, int reason)
	204	{
	205	SimpleSpiceDisplay *ssd = opaque;
	206
	207	if (running) {
	208	ssd->worker->start(ssd->worker);
	209	} else {
7466bc49	210	qemu_mutex_unlock_iothread();
a3e22260	211	ssd->worker->stop(ssd->worker);
7466bc49	212	qemu_mutex_lock_iothread();
a3e22260 GH	213	}
	214	ssd->running = running;
	215	}
	216
	217	/* display listener callbacks */
	218
	219	void qemu_spice_display_update(SimpleSpiceDisplay *ssd,
	220	int x, int y, int w, int h)
	221	{
	222	QXLRect update_area;
	223
	224	dprint(2, "%s: x %d y %d w %d h %d\n", __FUNCTION__, x, y, w, h);
	225	update_area.left = x,
	226	update_area.right = x + w;
	227	update_area.top = y;
	228	update_area.bottom = y + h;
	229
a3e22260 GH	230	if (qemu_spice_rect_is_empty(&ssd->dirty)) {
	231	ssd->notify++;
	232	}
	233	qemu_spice_rect_union(&ssd->dirty, &update_area);
a3e22260 GH	234	}
	235
	236	void qemu_spice_display_resize(SimpleSpiceDisplay *ssd)
	237	{
	238	dprint(1, "%s:\n", __FUNCTION__);
	239
a3e22260 GH	240	memset(&ssd->dirty, 0, sizeof(ssd->dirty));
	241	qemu_pf_conv_put(ssd->conv);
	242	ssd->conv = NULL;
a3e22260 GH	243
	244	qemu_spice_destroy_host_primary(ssd);
	245	qemu_spice_create_host_primary(ssd);
	246
a3e22260 GH	247	memset(&ssd->dirty, 0, sizeof(ssd->dirty));
a3e22260 GH	248	ssd->notify++;
a3e22260 GH	249	}
	250
	251	void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)
	252	{
	253	dprint(3, "%s:\n", __FUNCTION__);
	254	vga_hw_update();
	255	if (ssd->notify) {
	256	ssd->notify = 0;
	257	ssd->worker->wakeup(ssd->worker);
	258	dprint(2, "%s: notify\n", __FUNCTION__);
	259	}
	260	}
	261
	262	/* spice display interface callbacks */
	263
	264	static void interface_attach_worker(QXLInstance sin, QXLWorker qxl_worker)
	265	{
	266	SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
	267
	268	dprint(1, "%s:\n", __FUNCTION__);
	269	ssd->worker = qxl_worker;
	270	}
	271
	272	static void interface_set_compression_level(QXLInstance *sin, int level)
	273	{
	274	dprint(1, "%s:\n", __FUNCTION__);
	275	/* nothing to do */
	276	}
	277
	278	static void interface_set_mm_time(QXLInstance *sin, uint32_t mm_time)
	279	{
	280	dprint(3, "%s:\n", __FUNCTION__);
	281	/* nothing to do */
	282	}
	283
	284	static void interface_get_init_info(QXLInstance sin, QXLDevInitInfo info)
	285	{
	286	SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
	287
	288	info->memslot_gen_bits = MEMSLOT_GENERATION_BITS;
	289	info->memslot_id_bits = MEMSLOT_SLOT_BITS;
	290	info->num_memslots = NUM_MEMSLOTS;
	291	info->num_memslots_groups = NUM_MEMSLOTS_GROUPS;
	292	info->internal_groupslot_id = 0;
	293	info->qxl_ram_size = ssd->bufsize;
	294	info->n_surfaces = NUM_SURFACES;
	295	}
	296
	297	static int interface_get_command(QXLInstance sin, struct QXLCommandExt ext)
	298	{
	299	SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
	300	SimpleSpiceUpdate *update;
	301
	302	dprint(3, "%s:\n", __FUNCTION__);
	303	update = qemu_spice_create_update(ssd);
	304	if (update == NULL) {
	305	return false;
	306	}
	307	*ext = update->ext;
	308	return true;
	309	}
	310
	311	static int interface_req_cmd_notification(QXLInstance *sin)
	312	{
313	dprint(1, "%s:\n", __FUNCTION__);
314	return 1;
315	}
316
317	static void interface_release_resource(QXLInstance *sin,
318	struct QXLReleaseInfoExt ext)
319	{
320	SimpleSpiceDisplay *ssd = container_of(sin, SimpleSpiceDisplay, qxl);
321	uintptr_t id;
322
323	dprint(2, "%s:\n", __FUNCTION__);
324	id = ext.info->id;
325	qemu_spice_destroy_update(ssd, (void*)id);
326	}
327
328	static int interface_get_cursor_command(QXLInstance sin, struct QXLCommandExt ext)
329	{
330	dprint(3, "%s:\n", __FUNCTION__);
331	return false;
332	}
333
334	static int interface_req_cursor_notification(QXLInstance *sin)
335	{
336	dprint(1, "%s:\n", __FUNCTION__);
337	return 1;
338	}
339
340	static void interface_notify_update(QXLInstance *sin, uint32_t update_id)
341	{
342	fprintf(stderr, "%s: abort()\n", __FUNCTION__);
343	abort();
344	}
345
346	static int interface_flush_resources(QXLInstance *sin)
347	{
348	fprintf(stderr, "%s: abort()\n", __FUNCTION__);
349	abort();
350	return 0;
351	}
352
353	static const QXLInterface dpy_interface = {
354	.base.type = SPICE_INTERFACE_QXL,
355	.base.description = "qemu simple display",
356	.base.major_version = SPICE_INTERFACE_QXL_MAJOR,
357	.base.minor_version = SPICE_INTERFACE_QXL_MINOR,
358
359	.attache_worker = interface_attach_worker,
360	.set_compression_level = interface_set_compression_level,
361	.set_mm_time = interface_set_mm_time,
362	.get_init_info = interface_get_init_info,
363
364	/* the callbacks below are called from spice server thread context */
365	.get_command = interface_get_command,
366	.req_cmd_notification = interface_req_cmd_notification,
367	.release_resource = interface_release_resource,
368	.get_cursor_command = interface_get_cursor_command,
369	.req_cursor_notification = interface_req_cursor_notification,
370	.notify_update = interface_notify_update,
371	.flush_resources = interface_flush_resources,
372	};
373
374	static SimpleSpiceDisplay sdpy;
375
376	static void display_update(struct DisplayState *ds, int x, int y, int w, int h)
377	{
378	qemu_spice_display_update(&sdpy, x, y, w, h);
379	}
380
381	static void display_resize(struct DisplayState *ds)
382	{
383	qemu_spice_display_resize(&sdpy);
384	}
385
386	static void display_refresh(struct DisplayState *ds)
387	{
388	qemu_spice_display_refresh(&sdpy);
389	}
390
391	static DisplayChangeListener display_listener = {
392	.dpy_update = display_update,
393	.dpy_resize = display_resize,
394	.dpy_refresh = display_refresh,
395	};
396
397	void qemu_spice_display_init(DisplayState *ds)
398	{
399	assert(sdpy.ds == NULL);
400	sdpy.ds = ds;
401	sdpy.bufsize = (16 * 1024 * 1024);
402	sdpy.buf = qemu_malloc(sdpy.bufsize);
a3e22260 GH	403	register_displaychangelistener(ds, &display_listener);
	404
	405	sdpy.qxl.base.sif = &dpy_interface.base;
	406	qemu_spice_add_interface(&sdpy.qxl.base);
	407	assert(sdpy.worker);
	408
	409	qemu_add_vm_change_state_handler(qemu_spice_vm_change_state_handler, &sdpy);
	410	qemu_spice_create_host_memslot(&sdpy);
	411	qemu_spice_create_host_primary(&sdpy);
	412	}