drivers/staging/vboxvideo/vboxvideo.h

   1 /* SPDX-License-Identifier: MIT */
   2 /* Copyright (C) 2006-2016 Oracle Corporation */
   3
   4 #ifndef __VBOXVIDEO_H__
   5 #define __VBOXVIDEO_H__
   6
   7 #define VBOX_VIDEO_MAX_SCREENS 64
   8
   9 /*
  10  * The last 4096 bytes of the guest VRAM contains the generic info for all
  11  * DualView chunks: sizes and offsets of chunks. This is filled by miniport.
  12  *
  13  * Last 4096 bytes of each chunk contain chunk specific data: framebuffer info,
  14  * etc. This is used exclusively by the corresponding instance of a display
  15  * driver.
  16  *
  17  * The VRAM layout:
  18  *   Last 4096 bytes - Adapter information area.
  19  *   4096 bytes aligned miniport heap (value specified in the config rouded up).
  20  *   Slack - what left after dividing the VRAM.
  21  *   4096 bytes aligned framebuffers:
  22  *     last 4096 bytes of each framebuffer is the display information area.
  23  *
  24  * The Virtual Graphics Adapter information in the guest VRAM is stored by the
  25  * guest video driver using structures prepended by VBOXVIDEOINFOHDR.
  26  *
  27  * When the guest driver writes dword 0 to the VBE_DISPI_INDEX_VBOX_VIDEO
  28  * the host starts to process the info. The first element at the start of
  29  * the 4096 bytes region should be normally be a LINK that points to
  30  * actual information chain. That way the guest driver can have some
  31  * fixed layout of the information memory block and just rewrite
  32  * the link to point to relevant memory chain.
  33  *
  34  * The processing stops at the END element.
  35  *
  36  * The host can access the memory only when the port IO is processed.
  37  * All data that will be needed later must be copied from these 4096 bytes.
  38  * But other VRAM can be used by host until the mode is disabled.
  39  *
  40  * The guest driver writes dword 0xffffffff to the VBE_DISPI_INDEX_VBOX_VIDEO
  41  * to disable the mode.
  42  *
  43  * VBE_DISPI_INDEX_VBOX_VIDEO is used to read the configuration information
  44  * from the host and issue commands to the host.
  45  *
  46  * The guest writes the VBE_DISPI_INDEX_VBOX_VIDEO index register, the the
  47  * following operations with the VBE data register can be performed:
  48  *
  49  * Operation            Result
  50  * write 16 bit value   NOP
  51  * read 16 bit value    count of monitors
  52  * write 32 bit value   set the vbox cmd value and the cmd processed by the host
  53  * read 32 bit value    result of the last vbox command is returned
  54  */
  55
  56 struct vbva_cmd_hdr {
  57         s16 x;
  58         s16 y;
  59         u16 w;
  60         u16 h;
  61 } __packed;
  62
  63 /*
  64  * The VBVA ring buffer is suitable for transferring large (< 2GB) amount of
  65  * data. For example big bitmaps which do not fit to the buffer.
  66  *
  67  * Guest starts writing to the buffer by initializing a record entry in the
  68  * records queue. VBVA_F_RECORD_PARTIAL indicates that the record is being
  69  * written. As data is written to the ring buffer, the guest increases
  70  * free_offset.
  71  *
  72  * The host reads the records on flushes and processes all completed records.
  73  * When host encounters situation when only a partial record presents and
  74  * len_and_flags & ~VBVA_F_RECORD_PARTIAL >= VBVA_RING_BUFFER_SIZE -
  75  * VBVA_RING_BUFFER_THRESHOLD, the host fetched all record data and updates
  76  * data_offset. After that on each flush the host continues fetching the data
  77  * until the record is completed.
  78  */
  79
  80 #define VBVA_RING_BUFFER_SIZE        (4194304 - 1024)
  81 #define VBVA_RING_BUFFER_THRESHOLD   (4096)
  82
  83 #define VBVA_MAX_RECORDS (64)
  84
  85 #define VBVA_F_MODE_ENABLED         0x00000001u
  86 #define VBVA_F_MODE_VRDP            0x00000002u
  87 #define VBVA_F_MODE_VRDP_RESET      0x00000004u
  88 #define VBVA_F_MODE_VRDP_ORDER_MASK 0x00000008u
  89
  90 #define VBVA_F_STATE_PROCESSING     0x00010000u
  91
  92 #define VBVA_F_RECORD_PARTIAL       0x80000000u
  93
  94 struct vbva_record {
  95         u32 len_and_flags;
  96 } __packed;
  97
  98 /*
  99  * The minimum HGSMI heap size is PAGE_SIZE (4096 bytes) and is a restriction of
 100  * the runtime heapsimple API. Use minimum 2 pages here, because the info area
 101  * also may contain other data (for example hgsmi_host_flags structure).
 102  */
 103 #define VBVA_ADAPTER_INFORMATION_SIZE 65536
 104 #define VBVA_MIN_BUFFER_SIZE          65536
 105
 106 /* The value for port IO to let the adapter to interpret the adapter memory. */
 107 #define VBOX_VIDEO_DISABLE_ADAPTER_MEMORY        0xFFFFFFFF
 108
 109 /* The value for port IO to let the adapter to interpret the adapter memory. */
 110 #define VBOX_VIDEO_INTERPRET_ADAPTER_MEMORY      0x00000000
 111
 112 /*
 113  * The value for port IO to let the adapter to interpret the display memory.
 114  * The display number is encoded in low 16 bits.
 115  */
 116 #define VBOX_VIDEO_INTERPRET_DISPLAY_MEMORY_BASE 0x00010000
 117
 118 struct vbva_host_flags {
 119         u32 host_events;
 120         u32 supported_orders;
 121 } __packed;
 122
 123 struct vbva_buffer {
 124         struct vbva_host_flags host_flags;
 125
 126         /* The offset where the data start in the buffer. */
 127         u32 data_offset;
 128         /* The offset where next data must be placed in the buffer. */
 129         u32 free_offset;
 130
 131         /* The queue of record descriptions. */
 132         struct vbva_record records[VBVA_MAX_RECORDS];
 133         u32 record_first_index;
 134         u32 record_free_index;
 135
 136         /* Space to leave free when large partial records are transferred. */
 137         u32 partial_write_tresh;
 138
 139         u32 data_len;
 140         /* variable size for the rest of the vbva_buffer area in VRAM. */
 141         u8 data[0];
 142 } __packed;
 143
 144 #define VBVA_MAX_RECORD_SIZE (128 * 1024 * 1024)
 145
 146 /* guest->host commands */
 147 #define VBVA_QUERY_CONF32                        1
 148 #define VBVA_SET_CONF32                          2
 149 #define VBVA_INFO_VIEW                           3
 150 #define VBVA_INFO_HEAP                           4
 151 #define VBVA_FLUSH                               5
 152 #define VBVA_INFO_SCREEN                         6
 153 #define VBVA_ENABLE                              7
 154 #define VBVA_MOUSE_POINTER_SHAPE                 8
 155 /* informs host about HGSMI caps. see vbva_caps below */
 156 #define VBVA_INFO_CAPS                          12
 157 /* configures scanline, see VBVASCANLINECFG below */
 158 #define VBVA_SCANLINE_CFG                       13
 159 /* requests scanline info, see VBVASCANLINEINFO below */
 160 #define VBVA_SCANLINE_INFO                      14
 161 /* inform host about VBVA Command submission */
 162 #define VBVA_CMDVBVA_SUBMIT                     16
 163 /* inform host about VBVA Command submission */
 164 #define VBVA_CMDVBVA_FLUSH                      17
 165 /* G->H DMA command */
 166 #define VBVA_CMDVBVA_CTL                        18
 167 /* Query most recent mode hints sent */
 168 #define VBVA_QUERY_MODE_HINTS                   19
 169 /*
 170  * Report the guest virtual desktop position and size for mapping host and
 171  * guest pointer positions.
 172  */
 173 #define VBVA_REPORT_INPUT_MAPPING               20
 174 /* Report the guest cursor position and query the host position. */
 175 #define VBVA_CURSOR_POSITION                    21
 176
 177 /* host->guest commands */
 178 #define VBVAHG_EVENT                            1
 179 #define VBVAHG_DISPLAY_CUSTOM                   2
 180
 181 /* vbva_conf32::index */
 182 #define VBOX_VBVA_CONF32_MONITOR_COUNT          0
 183 #define VBOX_VBVA_CONF32_HOST_HEAP_SIZE         1
 184 /*
 185  * Returns VINF_SUCCESS if the host can report mode hints via VBVA.
 186  * Set value to VERR_NOT_SUPPORTED before calling.
 187  */
 188 #define VBOX_VBVA_CONF32_MODE_HINT_REPORTING    2
 189 /*
 190  * Returns VINF_SUCCESS if the host can report guest cursor enabled status via
 191  * VBVA.  Set value to VERR_NOT_SUPPORTED before calling.
 192  */
 193 #define VBOX_VBVA_CONF32_GUEST_CURSOR_REPORTING 3
 194 /*
 195  * Returns the currently available host cursor capabilities.  Available if
 196  * VBOX_VBVA_CONF32_GUEST_CURSOR_REPORTING returns success.
 197  */
 198 #define VBOX_VBVA_CONF32_CURSOR_CAPABILITIES    4
 199 /* Returns the supported flags in vbva_infoscreen.flags. */
 200 #define VBOX_VBVA_CONF32_SCREEN_FLAGS           5
 201 /* Returns the max size of VBVA record. */
 202 #define VBOX_VBVA_CONF32_MAX_RECORD_SIZE        6
 203
 204 struct vbva_conf32 {
 205         u32 index;
 206         u32 value;
 207 } __packed;
 208
 209 /* Reserved for historical reasons. */
 210 #define VBOX_VBVA_CURSOR_CAPABILITY_RESERVED0   BIT(0)
 211 /*
 212  * Guest cursor capability: can the host show a hardware cursor at the host
 213  * pointer location?
 214  */
 215 #define VBOX_VBVA_CURSOR_CAPABILITY_HARDWARE    BIT(1)
 216 /* Reserved for historical reasons. */
 217 #define VBOX_VBVA_CURSOR_CAPABILITY_RESERVED2   BIT(2)
 218 /* Reserved for historical reasons.  Must always be unset. */
 219 #define VBOX_VBVA_CURSOR_CAPABILITY_RESERVED3   BIT(3)
 220 /* Reserved for historical reasons. */
 221 #define VBOX_VBVA_CURSOR_CAPABILITY_RESERVED4   BIT(4)
 222 /* Reserved for historical reasons. */
 223 #define VBOX_VBVA_CURSOR_CAPABILITY_RESERVED5   BIT(5)
 224
 225 struct vbva_infoview {
 226         /* Index of the screen, assigned by the guest. */
 227         u32 view_index;
 228
 229         /* The screen offset in VRAM, the framebuffer starts here. */
 230         u32 view_offset;
 231
 232         /* The size of the VRAM memory that can be used for the view. */
 233         u32 view_size;
 234
 235         /* The recommended maximum size of the VRAM memory for the screen. */
 236         u32 max_screen_size;
 237 } __packed;
 238
 239 struct vbva_flush {
 240         u32 reserved;
 241 } __packed;
 242
 243 /* vbva_infoscreen.flags */
 244 #define VBVA_SCREEN_F_NONE                      0x0000
 245 #define VBVA_SCREEN_F_ACTIVE                    0x0001
 246 /*
 247  * The virtual monitor has been disabled by the guest and should be removed
 248  * by the host and ignored for purposes of pointer position calculation.
 249  */
 250 #define VBVA_SCREEN_F_DISABLED                  0x0002
 251 /*
 252  * The virtual monitor has been blanked by the guest and should be blacked
 253  * out by the host using width, height, etc values from the vbva_infoscreen
 254  * request.
 255  */
 256 #define VBVA_SCREEN_F_BLANK                     0x0004
 257 /*
 258  * The virtual monitor has been blanked by the guest and should be blacked
 259  * out by the host using the previous mode values for width. height, etc.
 260  */
 261 #define VBVA_SCREEN_F_BLANK2                    0x0008
 262
 263 struct vbva_infoscreen {
 264         /* Which view contains the screen. */
 265         u32 view_index;
 266
 267         /* Physical X origin relative to the primary screen. */
 268         s32 origin_x;
 269
 270         /* Physical Y origin relative to the primary screen. */
 271         s32 origin_y;
 272
 273         /* Offset of visible framebuffer relative to the framebuffer start. */
 274         u32 start_offset;
 275
 276         /* The scan line size in bytes. */
 277         u32 line_size;
 278
 279         /* Width of the screen. */
 280         u32 width;
 281
 282         /* Height of the screen. */
 283         u32 height;
 284
 285         /* Color depth. */
 286         u16 bits_per_pixel;
 287
 288         /* VBVA_SCREEN_F_* */
 289         u16 flags;
 290 } __packed;
 291
 292 /* vbva_enable.flags */
 293 #define VBVA_F_NONE                             0x00000000
 294 #define VBVA_F_ENABLE                           0x00000001
 295 #define VBVA_F_DISABLE                          0x00000002
 296 /* extended VBVA to be used with WDDM */
 297 #define VBVA_F_EXTENDED                         0x00000004
 298 /* vbva offset is absolute VRAM offset */
 299 #define VBVA_F_ABSOFFSET                        0x00000008
 300
 301 struct vbva_enable {
 302         u32 flags;
 303         u32 offset;
 304         s32 result;
 305 } __packed;
 306
 307 struct vbva_enable_ex {
 308         struct vbva_enable base;
 309         u32 screen_id;
 310 } __packed;
 311
 312 struct vbva_mouse_pointer_shape {
 313         /* The host result. */
 314         s32 result;
 315
 316         /* VBOX_MOUSE_POINTER_* bit flags. */
 317         u32 flags;
 318
 319         /* X coordinate of the hot spot. */
 320         u32 hot_X;
 321
 322         /* Y coordinate of the hot spot. */
 323         u32 hot_y;
 324
 325         /* Width of the pointer in pixels. */
 326         u32 width;
 327
 328         /* Height of the pointer in scanlines. */
 329         u32 height;
 330
 331         /* Pointer data.
 332          *
 333          * The data consists of 1 bpp AND mask followed by 32 bpp XOR (color)
 334          * mask.
 335          *
 336          * For pointers without alpha channel the XOR mask pixels are 32 bit
 337          * values: (lsb)BGR0(msb). For pointers with alpha channel the XOR mask
 338          * consists of (lsb)BGRA(msb) 32 bit values.
 339          *
 340          * Guest driver must create the AND mask for pointers with alpha chan.,
 341          * so if host does not support alpha, the pointer could be displayed as
 342          * a normal color pointer. The AND mask can be constructed from alpha
 343          * values. For example alpha value >= 0xf0 means bit 0 in the AND mask.
 344          *
 345          * The AND mask is 1 bpp bitmap with byte aligned scanlines. Size of AND
 346          * mask, therefore, is and_len = (width + 7) / 8 * height. The padding
 347          * bits at the end of any scanline are undefined.
 348          *
 349          * The XOR mask follows the AND mask on the next 4 bytes aligned offset:
 350          * u8 *xor = and + (and_len + 3) & ~3
 351          * Bytes in the gap between the AND and the XOR mask are undefined.
 352          * XOR mask scanlines have no gap between them and size of XOR mask is:
 353          * xor_len = width * 4 * height.
 354          *
 355          * Preallocate 4 bytes for accessing actual data as p->data.
 356          */
 357         u8 data[4];
 358 } __packed;
 359
 360 /* pointer is visible */
 361 #define VBOX_MOUSE_POINTER_VISIBLE              0x0001
 362 /* pointer has alpha channel */
 363 #define VBOX_MOUSE_POINTER_ALPHA                0x0002
 364 /* pointerData contains new pointer shape */
 365 #define VBOX_MOUSE_POINTER_SHAPE                0x0004
 366
 367 /*
 368  * The guest driver can handle asynch guest cmd completion by reading the
 369  * command offset from io port.
 370  */
 371 #define VBVACAPS_COMPLETEGCMD_BY_IOREAD         0x00000001
 372 /* the guest driver can handle video adapter IRQs */
 373 #define VBVACAPS_IRQ                            0x00000002
 374 /* The guest can read video mode hints sent via VBVA. */
 375 #define VBVACAPS_VIDEO_MODE_HINTS               0x00000004
 376 /* The guest can switch to a software cursor on demand. */
 377 #define VBVACAPS_DISABLE_CURSOR_INTEGRATION     0x00000008
 378 /* The guest does not depend on host handling the VBE registers. */
 379 #define VBVACAPS_USE_VBVA_ONLY                  0x00000010
 380
 381 struct vbva_caps {
 382         s32 rc;
 383         u32 caps;
 384 } __packed;
 385
 386 /* Query the most recent mode hints received from the host. */
 387 struct vbva_query_mode_hints {
 388         /* The maximum number of screens to return hints for. */
 389         u16 hints_queried_count;
 390         /* The size of the mode hint structures directly following this one. */
 391         u16 hint_structure_guest_size;
 392         /* Return code for the operation. Initialise to VERR_NOT_SUPPORTED. */
 393         s32 rc;
 394 } __packed;
 395
 396 /*
 397  * Structure in which a mode hint is returned. The guest allocates an array
 398  * of these immediately after the vbva_query_mode_hints structure.
 399  * To accommodate future extensions, the vbva_query_mode_hints structure
 400  * specifies the size of the vbva_modehint structures allocated by the guest,
 401  * and the host only fills out structure elements which fit into that size. The
 402  * host should fill any unused members (e.g. dx, dy) or structure space on the
 403  * end with ~0. The whole structure can legally be set to ~0 to skip a screen.
 404  */
 405 struct vbva_modehint {
 406         u32 magic;
 407         u32 cx;
 408         u32 cy;
 409         u32 bpp;                /* Which has never been used... */
 410         u32 display;
 411         u32 dx;                 /* X offset into the virtual frame-buffer. */
 412         u32 dy;                 /* Y offset into the virtual frame-buffer. */
 413         u32 enabled;            /* Not flags. Add new members for new flags. */
 414 } __packed;
 415
 416 #define VBVAMODEHINT_MAGIC 0x0801add9u
 417
 418 /*
 419  * Report the rectangle relative to which absolute pointer events should be
 420  * expressed. This information remains valid until the next VBVA resize event
 421  * for any screen, at which time it is reset to the bounding rectangle of all
 422  * virtual screens and must be re-set.
 423  */
 424 struct vbva_report_input_mapping {
 425         s32 x;  /* Upper left X co-ordinate relative to the first screen. */
 426         s32 y;  /* Upper left Y co-ordinate relative to the first screen. */
 427         u32 cx; /* Rectangle width. */
 428         u32 cy; /* Rectangle height. */
 429 } __packed;
 430
 431 /*
 432  * Report the guest cursor position and query the host one. The host may wish
 433  * to use the guest information to re-position its own cursor (though this is
 434  * currently unlikely).
 435  */
 436 struct vbva_cursor_position {
 437         u32 report_position;    /* Are we reporting a position? */
 438         u32 x;                  /* Guest cursor X position */
 439         u32 y;                  /* Guest cursor Y position */
 440 } __packed;
 441
 442 #endif