drivers/gpu/drm/qxl/qxl_dev.h

   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[0];
 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[0];
 386 };
 387
 388 struct qxl_message {
 389         union qxl_release_info release_info;
 390         uint8_t data[0];
 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[0];
 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[0];
 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[0];
 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[0];
 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[0];
 872 };
 873
 874 #pragma pack(pop)
 875
 876 #endif /* _H_QXL_DEV */