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 |
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[]; |
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 |
443 | |