1  /*
2     Copyright (C) 2009 Red Hat, Inc.
3  
4     Redistribution and use in source and binary forms, with or without
5     modification, are permitted provided that the following conditions are
6     met:
7  
8         * Redistributions of source code must retain the above copyright
9  	 notice, this list of conditions and the following disclaimer.
10         * Redistributions in binary form must reproduce the above copyright
11  	 notice, this list of conditions and the following disclaimer in
12  	 the documentation and/or other materials provided with the
13  	 distribution.
14         * Neither the name of the copyright holder nor the names of its
15  	 contributors may be used to endorse or promote products derived
16  	 from this software without specific prior written permission.
17  
18     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
19     IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
20     TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
21     PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22     HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24     LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25     DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26     THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30  
31  #ifndef H_QXL_DEV
32  #define H_QXL_DEV
33  
34  #include <linux/types.h>
35  
36  /*
37   * from spice-protocol
38   * Release 0.10.0
39   */
40  
41  /* enums.h */
42  
43  enum SpiceImageType {
44  	SPICE_IMAGE_TYPE_BITMAP,
45  	SPICE_IMAGE_TYPE_QUIC,
46  	SPICE_IMAGE_TYPE_RESERVED,
47  	SPICE_IMAGE_TYPE_LZ_PLT = 100,
48  	SPICE_IMAGE_TYPE_LZ_RGB,
49  	SPICE_IMAGE_TYPE_GLZ_RGB,
50  	SPICE_IMAGE_TYPE_FROM_CACHE,
51  	SPICE_IMAGE_TYPE_SURFACE,
52  	SPICE_IMAGE_TYPE_JPEG,
53  	SPICE_IMAGE_TYPE_FROM_CACHE_LOSSLESS,
54  	SPICE_IMAGE_TYPE_ZLIB_GLZ_RGB,
55  	SPICE_IMAGE_TYPE_JPEG_ALPHA,
56  
57  	SPICE_IMAGE_TYPE_ENUM_END
58  };
59  
60  enum SpiceBitmapFmt {
61  	SPICE_BITMAP_FMT_INVALID,
62  	SPICE_BITMAP_FMT_1BIT_LE,
63  	SPICE_BITMAP_FMT_1BIT_BE,
64  	SPICE_BITMAP_FMT_4BIT_LE,
65  	SPICE_BITMAP_FMT_4BIT_BE,
66  	SPICE_BITMAP_FMT_8BIT,
67  	SPICE_BITMAP_FMT_16BIT,
68  	SPICE_BITMAP_FMT_24BIT,
69  	SPICE_BITMAP_FMT_32BIT,
70  	SPICE_BITMAP_FMT_RGBA,
71  
72  	SPICE_BITMAP_FMT_ENUM_END
73  };
74  
75  enum SpiceSurfaceFmt {
76  	SPICE_SURFACE_FMT_INVALID,
77  	SPICE_SURFACE_FMT_1_A,
78  	SPICE_SURFACE_FMT_8_A = 8,
79  	SPICE_SURFACE_FMT_16_555 = 16,
80  	SPICE_SURFACE_FMT_32_xRGB = 32,
81  	SPICE_SURFACE_FMT_16_565 = 80,
82  	SPICE_SURFACE_FMT_32_ARGB = 96,
83  
84  	SPICE_SURFACE_FMT_ENUM_END
85  };
86  
87  enum SpiceClipType {
88  	SPICE_CLIP_TYPE_NONE,
89  	SPICE_CLIP_TYPE_RECTS,
90  
91  	SPICE_CLIP_TYPE_ENUM_END
92  };
93  
94  enum SpiceRopd {
95  	SPICE_ROPD_INVERS_SRC = (1 << 0),
96  	SPICE_ROPD_INVERS_BRUSH = (1 << 1),
97  	SPICE_ROPD_INVERS_DEST = (1 << 2),
98  	SPICE_ROPD_OP_PUT = (1 << 3),
99  	SPICE_ROPD_OP_OR = (1 << 4),
100  	SPICE_ROPD_OP_AND = (1 << 5),
101  	SPICE_ROPD_OP_XOR = (1 << 6),
102  	SPICE_ROPD_OP_BLACKNESS = (1 << 7),
103  	SPICE_ROPD_OP_WHITENESS = (1 << 8),
104  	SPICE_ROPD_OP_INVERS = (1 << 9),
105  	SPICE_ROPD_INVERS_RES = (1 << 10),
106  
107  	SPICE_ROPD_MASK = 0x7ff
108  };
109  
110  enum SpiceBrushType {
111  	SPICE_BRUSH_TYPE_NONE,
112  	SPICE_BRUSH_TYPE_SOLID,
113  	SPICE_BRUSH_TYPE_PATTERN,
114  
115  	SPICE_BRUSH_TYPE_ENUM_END
116  };
117  
118  enum SpiceCursorType {
119  	SPICE_CURSOR_TYPE_ALPHA,
120  	SPICE_CURSOR_TYPE_MONO,
121  	SPICE_CURSOR_TYPE_COLOR4,
122  	SPICE_CURSOR_TYPE_COLOR8,
123  	SPICE_CURSOR_TYPE_COLOR16,
124  	SPICE_CURSOR_TYPE_COLOR24,
125  	SPICE_CURSOR_TYPE_COLOR32,
126  
127  	SPICE_CURSOR_TYPE_ENUM_END
128  };
129  
130  /* qxl_dev.h */
131  
132  #pragma pack(push, 1)
133  
134  /* 0x100-0x11f reserved for spice, 0x1ff used for unstable work */
135  #define QXL_DEVICE_ID_STABLE 0x0100
136  
137  enum {
138  	QXL_REVISION_STABLE_V04 = 0x01,
139  	QXL_REVISION_STABLE_V06 = 0x02,
140  	QXL_REVISION_STABLE_V10 = 0x03,
141  	QXL_REVISION_STABLE_V12 = 0x04,
142  };
143  
144  #define QXL_DEVICE_ID_DEVEL 0x01ff
145  #define QXL_REVISION_DEVEL 0x01
146  
147  #define QXL_ROM_MAGIC (*(uint32_t *)"QXRO")
148  #define QXL_RAM_MAGIC (*(uint32_t *)"QXRA")
149  
150  enum {
151  	QXL_RAM_RANGE_INDEX,
152  	QXL_VRAM_RANGE_INDEX,
153  	QXL_ROM_RANGE_INDEX,
154  	QXL_IO_RANGE_INDEX,
155  
156  	QXL_PCI_RANGES
157  };
158  
159  /* qxl-1 compat: append only */
160  enum {
161  	QXL_IO_NOTIFY_CMD,
162  	QXL_IO_NOTIFY_CURSOR,
163  	QXL_IO_UPDATE_AREA,
164  	QXL_IO_UPDATE_IRQ,
165  	QXL_IO_NOTIFY_OOM,
166  	QXL_IO_RESET,
167  	QXL_IO_SET_MODE,                  /* qxl-1 */
168  	QXL_IO_LOG,
169  	/* appended for qxl-2 */
170  	QXL_IO_MEMSLOT_ADD,
171  	QXL_IO_MEMSLOT_DEL,
172  	QXL_IO_DETACH_PRIMARY,
173  	QXL_IO_ATTACH_PRIMARY,
174  	QXL_IO_CREATE_PRIMARY,
175  	QXL_IO_DESTROY_PRIMARY,
176  	QXL_IO_DESTROY_SURFACE_WAIT,
177  	QXL_IO_DESTROY_ALL_SURFACES,
178  	/* appended for qxl-3 */
179  	QXL_IO_UPDATE_AREA_ASYNC,
180  	QXL_IO_MEMSLOT_ADD_ASYNC,
181  	QXL_IO_CREATE_PRIMARY_ASYNC,
182  	QXL_IO_DESTROY_PRIMARY_ASYNC,
183  	QXL_IO_DESTROY_SURFACE_ASYNC,
184  	QXL_IO_DESTROY_ALL_SURFACES_ASYNC,
185  	QXL_IO_FLUSH_SURFACES_ASYNC,
186  	QXL_IO_FLUSH_RELEASE,
187  	/* appended for qxl-4 */
188  	QXL_IO_MONITORS_CONFIG_ASYNC,
189  
190  	QXL_IO_RANGE_SIZE
191  };
192  
193  typedef uint64_t QXLPHYSICAL;
194  typedef int32_t QXLFIXED; /* fixed 28.4 */
195  
196  struct qxl_point_fix {
197  	QXLFIXED x;
198  	QXLFIXED y;
199  };
200  
201  struct qxl_point {
202  	int32_t x;
203  	int32_t y;
204  };
205  
206  struct qxl_point_1_6 {
207  	int16_t x;
208  	int16_t y;
209  };
210  
211  struct qxl_rect {
212  	int32_t top;
213  	int32_t left;
214  	int32_t bottom;
215  	int32_t right;
216  };
217  
218  struct qxl_urect {
219  	uint32_t top;
220  	uint32_t left;
221  	uint32_t bottom;
222  	uint32_t right;
223  };
224  
225  /* qxl-1 compat: append only */
226  struct qxl_rom {
227  	uint32_t magic;
228  	uint32_t id;
229  	uint32_t update_id;
230  	uint32_t compression_level;
231  	uint32_t log_level;
232  	uint32_t mode;			  /* qxl-1 */
233  	uint32_t modes_offset;
234  	uint32_t num_io_pages;
235  	uint32_t pages_offset;		  /* qxl-1 */
236  	uint32_t draw_area_offset;	  /* qxl-1 */
237  	uint32_t surface0_area_size;	  /* qxl-1 name: draw_area_size */
238  	uint32_t ram_header_offset;
239  	uint32_t mm_clock;
240  	/* appended for qxl-2 */
241  	uint32_t n_surfaces;
242  	uint64_t flags;
243  	uint8_t slots_start;
244  	uint8_t slots_end;
245  	uint8_t slot_gen_bits;
246  	uint8_t slot_id_bits;
247  	uint8_t slot_generation;
248  	/* appended for qxl-4 */
249  	uint8_t client_present;
250  	uint8_t client_capabilities[58];
251  	uint32_t client_monitors_config_crc;
252  	struct {
253  		uint16_t count;
254  	uint16_t padding;
255  		struct qxl_urect heads[64];
256  	} client_monitors_config;
257  };
258  
259  /* qxl-1 compat: fixed */
260  struct qxl_mode {
261  	uint32_t id;
262  	uint32_t x_res;
263  	uint32_t y_res;
264  	uint32_t bits;
265  	uint32_t stride;
266  	uint32_t x_mili;
267  	uint32_t y_mili;
268  	uint32_t orientation;
269  };
270  
271  /* qxl-1 compat: fixed */
272  struct qxl_modes {
273  	uint32_t n_modes;
274  	struct qxl_mode modes[];
275  };
276  
277  /* qxl-1 compat: append only */
278  enum qxl_cmd_type {
279  	QXL_CMD_NOP,
280  	QXL_CMD_DRAW,
281  	QXL_CMD_UPDATE,
282  	QXL_CMD_CURSOR,
283  	QXL_CMD_MESSAGE,
284  	QXL_CMD_SURFACE,
285  };
286  
287  /* qxl-1 compat: fixed */
288  struct qxl_command {
289  	QXLPHYSICAL data;
290  	uint32_t type;
291  	uint32_t padding;
292  };
293  
294  #define QXL_COMMAND_FLAG_COMPAT		(1<<0)
295  #define QXL_COMMAND_FLAG_COMPAT_16BPP	(2<<0)
296  
297  struct qxl_command_ext {
298  	struct qxl_command cmd;
299  	uint32_t group_id;
300  	uint32_t flags;
301  };
302  
303  struct qxl_mem_slot {
304  	uint64_t mem_start;
305  	uint64_t mem_end;
306  };
307  
308  #define QXL_SURF_TYPE_PRIMARY	   0
309  
310  #define QXL_SURF_FLAG_KEEP_DATA	   (1 << 0)
311  
312  struct qxl_surface_create {
313  	uint32_t width;
314  	uint32_t height;
315  	int32_t stride;
316  	uint32_t format;
317  	uint32_t position;
318  	uint32_t mouse_mode;
319  	uint32_t flags;
320  	uint32_t type;
321  	QXLPHYSICAL mem;
322  };
323  
324  #define QXL_COMMAND_RING_SIZE 32
325  #define QXL_CURSOR_RING_SIZE 32
326  #define QXL_RELEASE_RING_SIZE 8
327  
328  #define QXL_LOG_BUF_SIZE 4096
329  
330  #define QXL_INTERRUPT_DISPLAY (1 << 0)
331  #define QXL_INTERRUPT_CURSOR (1 << 1)
332  #define QXL_INTERRUPT_IO_CMD (1 << 2)
333  #define QXL_INTERRUPT_ERROR  (1 << 3)
334  #define QXL_INTERRUPT_CLIENT (1 << 4)
335  #define QXL_INTERRUPT_CLIENT_MONITORS_CONFIG  (1 << 5)
336  
337  struct qxl_ring_header {
338  	uint32_t num_items;
339  	uint32_t prod;
340  	uint32_t notify_on_prod;
341  	uint32_t cons;
342  	uint32_t notify_on_cons;
343  };
344  
345  /* qxl-1 compat: append only */
346  struct qxl_ram_header {
347  	uint32_t magic;
348  	uint32_t int_pending;
349  	uint32_t int_mask;
350  	uint8_t log_buf[QXL_LOG_BUF_SIZE];
351  	struct qxl_ring_header  cmd_ring_hdr;
352  	struct qxl_command	cmd_ring[QXL_COMMAND_RING_SIZE];
353  	struct qxl_ring_header  cursor_ring_hdr;
354  	struct qxl_command	cursor_ring[QXL_CURSOR_RING_SIZE];
355  	struct qxl_ring_header  release_ring_hdr;
356  	uint64_t		release_ring[QXL_RELEASE_RING_SIZE];
357  	struct qxl_rect update_area;
358  	/* appended for qxl-2 */
359  	uint32_t update_surface;
360  	struct qxl_mem_slot mem_slot;
361  	struct qxl_surface_create create_surface;
362  	uint64_t flags;
363  
364  	/* appended for qxl-4 */
365  
366  	/* used by QXL_IO_MONITORS_CONFIG_ASYNC */
367  	QXLPHYSICAL monitors_config;
368  	uint8_t guest_capabilities[64];
369  };
370  
371  union qxl_release_info {
372  	uint64_t id;	  /* in  */
373  	uint64_t next;	  /* out */
374  };
375  
376  struct qxl_release_info_ext {
377  	union qxl_release_info *info;
378  	uint32_t group_id;
379  };
380  
381  struct qxl_data_chunk {
382  	uint32_t data_size;
383  	QXLPHYSICAL prev_chunk;
384  	QXLPHYSICAL next_chunk;
385  	uint8_t data[];
386  };
387  
388  struct qxl_message {
389  	union qxl_release_info release_info;
390  	uint8_t data[];
391  };
392  
393  struct qxl_compat_update_cmd {
394  	union qxl_release_info release_info;
395  	struct qxl_rect area;
396  	uint32_t update_id;
397  };
398  
399  struct qxl_update_cmd {
400  	union qxl_release_info release_info;
401  	struct qxl_rect area;
402  	uint32_t update_id;
403  	uint32_t surface_id;
404  };
405  
406  struct qxl_cursor_header {
407  	uint64_t unique;
408  	uint16_t type;
409  	uint16_t width;
410  	uint16_t height;
411  	uint16_t hot_spot_x;
412  	uint16_t hot_spot_y;
413  };
414  
415  struct qxl_cursor {
416  	struct qxl_cursor_header header;
417  	uint32_t data_size;
418  	struct qxl_data_chunk chunk;
419  };
420  
421  enum {
422  	QXL_CURSOR_SET,
423  	QXL_CURSOR_MOVE,
424  	QXL_CURSOR_HIDE,
425  	QXL_CURSOR_TRAIL,
426  };
427  
428  #define QXL_CURSOR_DEVICE_DATA_SIZE 128
429  
430  struct qxl_cursor_cmd {
431  	union qxl_release_info release_info;
432  	uint8_t type;
433  	union {
434  		struct {
435  			struct qxl_point_1_6 position;
436  			uint8_t visible;
437  			QXLPHYSICAL shape;
438  		} set;
439  		struct {
440  			uint16_t length;
441  			uint16_t frequency;
442  		} trail;
443  		struct qxl_point_1_6 position;
444  	} u;
445  	/* todo: dynamic size from rom */
446  	uint8_t device_data[QXL_CURSOR_DEVICE_DATA_SIZE];
447  };
448  
449  enum {
450  	QXL_DRAW_NOP,
451  	QXL_DRAW_FILL,
452  	QXL_DRAW_OPAQUE,
453  	QXL_DRAW_COPY,
454  	QXL_COPY_BITS,
455  	QXL_DRAW_BLEND,
456  	QXL_DRAW_BLACKNESS,
457  	QXL_DRAW_WHITENESS,
458  	QXL_DRAW_INVERS,
459  	QXL_DRAW_ROP3,
460  	QXL_DRAW_STROKE,
461  	QXL_DRAW_TEXT,
462  	QXL_DRAW_TRANSPARENT,
463  	QXL_DRAW_ALPHA_BLEND,
464  	QXL_DRAW_COMPOSITE
465  };
466  
467  struct qxl_raster_glyph {
468  	struct qxl_point render_pos;
469  	struct qxl_point glyph_origin;
470  	uint16_t width;
471  	uint16_t height;
472  	uint8_t data[];
473  };
474  
475  struct qxl_string {
476  	uint32_t data_size;
477  	uint16_t length;
478  	uint16_t flags;
479  	struct qxl_data_chunk chunk;
480  };
481  
482  struct qxl_copy_bits {
483  	struct qxl_point src_pos;
484  };
485  
486  enum qxl_effect_type {
487  	QXL_EFFECT_BLEND = 0,
488  	QXL_EFFECT_OPAQUE = 1,
489  	QXL_EFFECT_REVERT_ON_DUP = 2,
490  	QXL_EFFECT_BLACKNESS_ON_DUP = 3,
491  	QXL_EFFECT_WHITENESS_ON_DUP = 4,
492  	QXL_EFFECT_NOP_ON_DUP = 5,
493  	QXL_EFFECT_NOP = 6,
494  	QXL_EFFECT_OPAQUE_BRUSH = 7
495  };
496  
497  struct qxl_pattern {
498  	QXLPHYSICAL pat;
499  	struct qxl_point pos;
500  };
501  
502  struct qxl_brush {
503  	uint32_t type;
504  	union {
505  		uint32_t color;
506  		struct qxl_pattern pattern;
507  	} u;
508  };
509  
510  struct qxl_q_mask {
511  	uint8_t flags;
512  	struct qxl_point pos;
513  	QXLPHYSICAL bitmap;
514  };
515  
516  struct qxl_fill {
517  	struct qxl_brush brush;
518  	uint16_t rop_descriptor;
519  	struct qxl_q_mask mask;
520  };
521  
522  struct qxl_opaque {
523  	QXLPHYSICAL src_bitmap;
524  	struct qxl_rect src_area;
525  	struct qxl_brush brush;
526  	uint16_t rop_descriptor;
527  	uint8_t scale_mode;
528  	struct qxl_q_mask mask;
529  };
530  
531  struct qxl_copy {
532  	QXLPHYSICAL src_bitmap;
533  	struct qxl_rect src_area;
534  	uint16_t rop_descriptor;
535  	uint8_t scale_mode;
536  	struct qxl_q_mask mask;
537  };
538  
539  struct qxl_transparent {
540  	QXLPHYSICAL src_bitmap;
541  	struct qxl_rect src_area;
542  	uint32_t src_color;
543  	uint32_t true_color;
544  };
545  
546  struct qxl_alpha_blend {
547  	uint16_t alpha_flags;
548  	uint8_t alpha;
549  	QXLPHYSICAL src_bitmap;
550  	struct qxl_rect src_area;
551  };
552  
553  struct qxl_compat_alpha_blend {
554  	uint8_t alpha;
555  	QXLPHYSICAL src_bitmap;
556  	struct qxl_rect src_area;
557  };
558  
559  struct qxl_rop_3 {
560  	QXLPHYSICAL src_bitmap;
561  	struct qxl_rect src_area;
562  	struct qxl_brush brush;
563  	uint8_t rop3;
564  	uint8_t scale_mode;
565  	struct qxl_q_mask mask;
566  };
567  
568  struct qxl_line_attr {
569  	uint8_t flags;
570  	uint8_t join_style;
571  	uint8_t end_style;
572  	uint8_t style_nseg;
573  	QXLFIXED width;
574  	QXLFIXED miter_limit;
575  	QXLPHYSICAL style;
576  };
577  
578  struct qxl_stroke {
579  	QXLPHYSICAL path;
580  	struct qxl_line_attr attr;
581  	struct qxl_brush brush;
582  	uint16_t fore_mode;
583  	uint16_t back_mode;
584  };
585  
586  struct qxl_text {
587  	QXLPHYSICAL str;
588  	struct qxl_rect back_area;
589  	struct qxl_brush fore_brush;
590  	struct qxl_brush back_brush;
591  	uint16_t fore_mode;
592  	uint16_t back_mode;
593  };
594  
595  struct qxl_mask {
596  	struct qxl_q_mask mask;
597  };
598  
599  struct qxl_clip {
600  	uint32_t type;
601  	QXLPHYSICAL data;
602  };
603  
604  enum qxl_operator {
605  	QXL_OP_CLEAR			 = 0x00,
606  	QXL_OP_SOURCE			 = 0x01,
607  	QXL_OP_DST			 = 0x02,
608  	QXL_OP_OVER			 = 0x03,
609  	QXL_OP_OVER_REVERSE		 = 0x04,
610  	QXL_OP_IN			 = 0x05,
611  	QXL_OP_IN_REVERSE		 = 0x06,
612  	QXL_OP_OUT			 = 0x07,
613  	QXL_OP_OUT_REVERSE		 = 0x08,
614  	QXL_OP_ATOP			 = 0x09,
615  	QXL_OP_ATOP_REVERSE		 = 0x0a,
616  	QXL_OP_XOR			 = 0x0b,
617  	QXL_OP_ADD			 = 0x0c,
618  	QXL_OP_SATURATE			 = 0x0d,
619  	/* Note the jump here from 0x0d to 0x30 */
620  	QXL_OP_MULTIPLY			 = 0x30,
621  	QXL_OP_SCREEN			 = 0x31,
622  	QXL_OP_OVERLAY			 = 0x32,
623  	QXL_OP_DARKEN			 = 0x33,
624  	QXL_OP_LIGHTEN			 = 0x34,
625  	QXL_OP_COLOR_DODGE		 = 0x35,
626  	QXL_OP_COLOR_BURN		 = 0x36,
627  	QXL_OP_HARD_LIGHT		 = 0x37,
628  	QXL_OP_SOFT_LIGHT		 = 0x38,
629  	QXL_OP_DIFFERENCE		 = 0x39,
630  	QXL_OP_EXCLUSION		 = 0x3a,
631  	QXL_OP_HSL_HUE			 = 0x3b,
632  	QXL_OP_HSL_SATURATION		 = 0x3c,
633  	QXL_OP_HSL_COLOR		 = 0x3d,
634  	QXL_OP_HSL_LUMINOSITY		 = 0x3e
635  };
636  
637  struct qxl_transform {
638  	uint32_t	t00;
639  	uint32_t	t01;
640  	uint32_t	t02;
641  	uint32_t	t10;
642  	uint32_t	t11;
643  	uint32_t	t12;
644  };
645  
646  /* The flags field has the following bit fields:
647   *
648   *     operator:		[  0 -  7 ]
649   *     src_filter:		[  8 - 10 ]
650   *     mask_filter:		[ 11 - 13 ]
651   *     src_repeat:		[ 14 - 15 ]
652   *     mask_repeat:		[ 16 - 17 ]
653   *     component_alpha:		[ 18 - 18 ]
654   *     reserved:		[ 19 - 31 ]
655   *
656   * The repeat and filter values are those of pixman:
657   *		REPEAT_NONE =		0
658   *              REPEAT_NORMAL =		1
659   *		REPEAT_PAD =		2
660   *		REPEAT_REFLECT =	3
661   *
662   * The filter values are:
663   *		FILTER_NEAREST =	0
664   *		FILTER_BILINEAR	=	1
665   */
666  struct qxl_composite {
667  	uint32_t		flags;
668  
669  	QXLPHYSICAL			src;
670  	QXLPHYSICAL			src_transform;	/* May be NULL */
671  	QXLPHYSICAL			mask;		/* May be NULL */
672  	QXLPHYSICAL			mask_transform;	/* May be NULL */
673  	struct qxl_point_1_6	src_origin;
674  	struct qxl_point_1_6	mask_origin;
675  };
676  
677  struct qxl_compat_drawable {
678  	union qxl_release_info release_info;
679  	uint8_t effect;
680  	uint8_t type;
681  	uint16_t bitmap_offset;
682  	struct qxl_rect bitmap_area;
683  	struct qxl_rect bbox;
684  	struct qxl_clip clip;
685  	uint32_t mm_time;
686  	union {
687  		struct qxl_fill fill;
688  		struct qxl_opaque opaque;
689  		struct qxl_copy copy;
690  		struct qxl_transparent transparent;
691  		struct qxl_compat_alpha_blend alpha_blend;
692  		struct qxl_copy_bits copy_bits;
693  		struct qxl_copy blend;
694  		struct qxl_rop_3 rop3;
695  		struct qxl_stroke stroke;
696  		struct qxl_text text;
697  		struct qxl_mask blackness;
698  		struct qxl_mask invers;
699  		struct qxl_mask whiteness;
700  	} u;
701  };
702  
703  struct qxl_drawable {
704  	union qxl_release_info release_info;
705  	uint32_t surface_id;
706  	uint8_t effect;
707  	uint8_t type;
708  	uint8_t self_bitmap;
709  	struct qxl_rect self_bitmap_area;
710  	struct qxl_rect bbox;
711  	struct qxl_clip clip;
712  	uint32_t mm_time;
713  	int32_t surfaces_dest[3];
714  	struct qxl_rect surfaces_rects[3];
715  	union {
716  		struct qxl_fill fill;
717  		struct qxl_opaque opaque;
718  		struct qxl_copy copy;
719  		struct qxl_transparent transparent;
720  		struct qxl_alpha_blend alpha_blend;
721  		struct qxl_copy_bits copy_bits;
722  		struct qxl_copy blend;
723  		struct qxl_rop_3 rop3;
724  		struct qxl_stroke stroke;
725  		struct qxl_text text;
726  		struct qxl_mask blackness;
727  		struct qxl_mask invers;
728  		struct qxl_mask whiteness;
729  		struct qxl_composite composite;
730  	} u;
731  };
732  
733  enum qxl_surface_cmd_type {
734  	QXL_SURFACE_CMD_CREATE,
735  	QXL_SURFACE_CMD_DESTROY,
736  };
737  
738  struct qxl_surface {
739  	uint32_t format;
740  	uint32_t width;
741  	uint32_t height;
742  	int32_t stride;
743  	QXLPHYSICAL data;
744  };
745  
746  struct qxl_surface_cmd {
747  	union qxl_release_info release_info;
748  	uint32_t surface_id;
749  	uint8_t type;
750  	uint32_t flags;
751  	union {
752  		struct qxl_surface surface_create;
753  	} u;
754  };
755  
756  struct qxl_clip_rects {
757  	uint32_t num_rects;
758  	struct qxl_data_chunk chunk;
759  };
760  
761  enum {
762  	QXL_PATH_BEGIN = (1 << 0),
763  	QXL_PATH_END = (1 << 1),
764  	QXL_PATH_CLOSE = (1 << 3),
765  	QXL_PATH_BEZIER = (1 << 4),
766  };
767  
768  struct qxl_path_seg {
769  	uint32_t flags;
770  	uint32_t count;
771  	struct qxl_point_fix points[];
772  };
773  
774  struct qxl_path {
775  	uint32_t data_size;
776  	struct qxl_data_chunk chunk;
777  };
778  
779  enum {
780  	QXL_IMAGE_GROUP_DRIVER,
781  	QXL_IMAGE_GROUP_DEVICE,
782  	QXL_IMAGE_GROUP_RED,
783  	QXL_IMAGE_GROUP_DRIVER_DONT_CACHE,
784  };
785  
786  struct qxl_image_id {
787  	uint32_t group;
788  	uint32_t unique;
789  };
790  
791  union qxl_image_id_union {
792  	struct qxl_image_id id;
793  	uint64_t value;
794  };
795  
796  enum qxl_image_flags {
797  	QXL_IMAGE_CACHE = (1 << 0),
798  	QXL_IMAGE_HIGH_BITS_SET = (1 << 1),
799  };
800  
801  enum qxl_bitmap_flags {
802  	QXL_BITMAP_DIRECT = (1 << 0),
803  	QXL_BITMAP_UNSTABLE = (1 << 1),
804  	QXL_BITMAP_TOP_DOWN = (1 << 2), /* == SPICE_BITMAP_FLAGS_TOP_DOWN */
805  };
806  
807  #define QXL_SET_IMAGE_ID(image, _group, _unique) {              \
808  	(image)->descriptor.id = (((uint64_t)_unique) << 32) | _group;	\
809  }
810  
811  struct qxl_image_descriptor {
812  	uint64_t id;
813  	uint8_t type;
814  	uint8_t flags;
815  	uint32_t width;
816  	uint32_t height;
817  };
818  
819  struct qxl_palette {
820  	uint64_t unique;
821  	uint16_t num_ents;
822  	uint32_t ents[];
823  };
824  
825  struct qxl_bitmap {
826  	uint8_t format;
827  	uint8_t flags;
828  	uint32_t x;
829  	uint32_t y;
830  	uint32_t stride;
831  	QXLPHYSICAL palette;
832  	QXLPHYSICAL data; /* data[0] ? */
833  };
834  
835  struct qxl_surface_id {
836  	uint32_t surface_id;
837  };
838  
839  struct qxl_encoder_data {
840  	uint32_t data_size;
841  	uint8_t data[];
842  };
843  
844  struct qxl_image {
845  	struct qxl_image_descriptor descriptor;
846  	union { /* variable length */
847  		struct qxl_bitmap bitmap;
848  		struct qxl_encoder_data quic;
849  		struct qxl_surface_id surface_image;
850  	} u;
851  };
852  
853  /* A QXLHead is a single monitor output backed by a QXLSurface.
854   * x and y offsets are unsigned since they are used in relation to
855   * the given surface, not the same as the x, y coordinates in the guest
856   * screen reference frame. */
857  struct qxl_head {
858  	uint32_t id;
859  	uint32_t surface_id;
860  	uint32_t width;
861  	uint32_t height;
862  	uint32_t x;
863  	uint32_t y;
864  	uint32_t flags;
865  };
866  
867  struct qxl_monitors_config {
868  	uint16_t count;
869  	uint16_t max_allowed; /* If it is 0 no fixed limit is given by the
870  				 driver */
871  	struct qxl_head heads[];
872  };
873  
874  #pragma pack(pop)
875  
876  #endif /* _H_QXL_DEV */
877